1 #include "TinyRenderer.h"
2
3 #include <cmath>
4 #include <iostream>
5 #include <limits>
6 #include <vector>
7 #include "../CommonInterfaces/CommonFileIOInterface.h"
8 #include "../OpenGLWindow/ShapeData.h"
9 #include "../Utils/b3BulletDefaultFileIO.h"
10 #include "../Utils/b3ResourcePath.h"
11 #include "Bullet3Common/b3Logging.h"
12 #include "Bullet3Common/b3MinMax.h"
13 #include "LinearMath/btAlignedObjectArray.h"
14 #include "LinearMath/btVector3.h"
15 #include "geometry.h"
16 #include "model.h"
17 #include "our_gl.h"
18 #include "tgaimage.h"
19
20 using namespace TinyRender;
21
22 struct DepthShader : public IShader
23 {
24 Model* m_model;
25 Matrix& m_modelMat;
26 Matrix m_invModelMat;
27
28 Matrix& m_projectionMat;
29 Vec3f m_localScaling;
30 Matrix& m_lightModelView;
31 float m_lightDistance;
32
33 mat<2, 3, float> varying_uv; // triangle uv coordinates, written by the vertex shader, read by the fragment shader
34 mat<4, 3, float> varying_tri; // triangle coordinates (clip coordinates), written by VS, read by FS
35
36 mat<3, 3, float> varying_nrm; // normal per vertex to be interpolated by FS
37
DepthShaderDepthShader38 DepthShader(Model* model, Matrix& lightModelView, Matrix& projectionMat, Matrix& modelMat, Vec3f localScaling, float lightDistance)
39 : m_model(model),
40 m_modelMat(modelMat),
41 m_projectionMat(projectionMat),
42 m_localScaling(localScaling),
43 m_lightModelView(lightModelView),
44 m_lightDistance(lightDistance)
45 {
46 m_nearPlane = m_projectionMat.col(3)[2] / (m_projectionMat.col(2)[2] - 1);
47 m_farPlane = m_projectionMat.col(3)[2] / (m_projectionMat.col(2)[2] + 1);
48
49 m_invModelMat = m_modelMat.invert_transpose();
50 }
vertexDepthShader51 virtual Vec4f vertex(int iface, int nthvert)
52 {
53 Vec2f uv = m_model->uv(iface, nthvert);
54 varying_uv.set_col(nthvert, uv);
55 varying_nrm.set_col(nthvert, proj<3>(m_invModelMat * embed<4>(m_model->normal(iface, nthvert), 0.f)));
56 Vec3f unScaledVert = m_model->vert(iface, nthvert);
57 Vec3f scaledVert = Vec3f(unScaledVert[0] * m_localScaling[0],
58 unScaledVert[1] * m_localScaling[1],
59 unScaledVert[2] * m_localScaling[2]);
60 Vec4f gl_Vertex = m_projectionMat * m_lightModelView * embed<4>(scaledVert);
61 varying_tri.set_col(nthvert, gl_Vertex);
62 return gl_Vertex;
63 }
64
fragmentDepthShader65 virtual bool fragment(Vec3f bar, TGAColor& color)
66 {
67 Vec4f p = varying_tri * bar;
68 color = TGAColor(255, 255, 255) * (p[2] / m_lightDistance);
69 return false;
70 }
71 };
72
73 struct Shader : public IShader
74 {
75 Model* m_model;
76 Vec3f m_light_dir_local;
77 Vec3f m_light_color;
78 Matrix& m_modelMat;
79 Matrix m_invModelMat;
80 Matrix& m_modelView1;
81 Matrix& m_projectionMat;
82 Vec3f m_localScaling;
83 Matrix& m_lightModelView;
84 Vec4f m_colorRGBA;
85 Matrix& m_viewportMat;
86 Matrix m_projectionModelViewMat;
87 Matrix m_projectionLightViewMat;
88 float m_ambient_coefficient;
89 float m_diffuse_coefficient;
90 float m_specular_coefficient;
91
92 b3AlignedObjectArray<float>* m_shadowBuffer;
93
94 int m_width;
95 int m_height;
96
97 int m_index;
98
99 mat<2, 3, float> varying_uv; // triangle uv coordinates, written by the vertex shader, read by the fragment shader
100 mat<4, 3, float> varying_tri; // triangle coordinates (clip coordinates), written by VS, read by FS
101 mat<4, 3, float> varying_tri_light_view;
102 mat<3, 3, float> varying_nrm; // normal per vertex to be interpolated by FS
103 mat<4, 3, float> world_tri; // model triangle coordinates in the world space used for backface culling, written by VS
104
ShaderShader105 Shader(Model* model, Vec3f light_dir_local, Vec3f light_color, Matrix& modelView, Matrix& lightModelView, Matrix& projectionMat, Matrix& modelMat, Matrix& viewportMat, Vec3f localScaling, const Vec4f& colorRGBA, int width, int height, b3AlignedObjectArray<float>* shadowBuffer, float ambient_coefficient = 0.6, float diffuse_coefficient = 0.35, float specular_coefficient = 0.05)
106 : m_model(model),
107 m_light_dir_local(light_dir_local),
108 m_light_color(light_color),
109 m_modelMat(modelMat),
110 m_modelView1(modelView),
111 m_projectionMat(projectionMat),
112 m_localScaling(localScaling),
113 m_lightModelView(lightModelView),
114 m_colorRGBA(colorRGBA),
115 m_viewportMat(viewportMat),
116 m_ambient_coefficient(ambient_coefficient),
117 m_diffuse_coefficient(diffuse_coefficient),
118 m_specular_coefficient(specular_coefficient),
119
120 m_shadowBuffer(shadowBuffer),
121 m_width(width),
122 m_height(height)
123
124 {
125 m_nearPlane = m_projectionMat.col(3)[2] / (m_projectionMat.col(2)[2] - 1);
126 m_farPlane = m_projectionMat.col(3)[2] / (m_projectionMat.col(2)[2] + 1);
127 //printf("near=%f, far=%f\n", m_nearPlane, m_farPlane);
128 m_invModelMat = m_modelMat.invert_transpose();
129 m_projectionModelViewMat = m_projectionMat * m_modelView1;
130 m_projectionLightViewMat = m_projectionMat * m_lightModelView;
131 }
vertexShader132 virtual Vec4f vertex(int iface, int nthvert)
133 {
134 //B3_PROFILE("vertex");
135 Vec2f uv = m_model->uv(iface, nthvert);
136 varying_uv.set_col(nthvert, uv);
137 varying_nrm.set_col(nthvert, proj<3>(m_invModelMat * embed<4>(m_model->normal(iface, nthvert), 0.f)));
138 Vec3f unScaledVert = m_model->vert(iface, nthvert);
139 Vec3f scaledVert = Vec3f(unScaledVert[0] * m_localScaling[0],
140 unScaledVert[1] * m_localScaling[1],
141 unScaledVert[2] * m_localScaling[2]);
142 Vec4f gl_Vertex = m_projectionModelViewMat * embed<4>(scaledVert);
143 varying_tri.set_col(nthvert, gl_Vertex);
144 Vec4f world_Vertex = m_modelMat * embed<4>(scaledVert);
145 world_tri.set_col(nthvert, world_Vertex);
146 Vec4f gl_VertexLightView = m_projectionLightViewMat * embed<4>(scaledVert);
147 varying_tri_light_view.set_col(nthvert, gl_VertexLightView);
148 return gl_Vertex;
149 }
150
fragmentShader151 virtual bool fragment(Vec3f bar, TGAColor& color)
152 {
153 //B3_PROFILE("fragment");
154 Vec4f p = m_viewportMat * (varying_tri_light_view * bar);
155 float depth = p[2];
156 p = p / p[3];
157
158 float index_x = b3Max(float(0.0), b3Min(float(m_width - 1), p[0]));
159 float index_y = b3Max(float(0.0), b3Min(float(m_height - 1), p[1]));
160 int idx = int(index_x) + int(index_y) * m_width; // index in the shadowbuffer array
161 float shadow = 1.0;
162 if (m_shadowBuffer && idx >=0 && idx <m_shadowBuffer->size())
163 {
164 shadow = 0.8 + 0.2 * (m_shadowBuffer->at(idx) < -depth + 0.05); // magic coeff to avoid z-fighting
165 }
166 Vec3f bn = (varying_nrm * bar).normalize();
167 Vec2f uv = varying_uv * bar;
168
169 Vec3f reflection_direction = (bn * (bn * m_light_dir_local * 2.f) - m_light_dir_local).normalize();
170 float specular = std::pow(b3Max(reflection_direction.z, 0.f),
171 m_model->specular(uv));
172 float diffuse = b3Max(0.f, bn * m_light_dir_local);
173
174 color = m_model->diffuse(uv);
175 color[0] *= m_colorRGBA[0];
176 color[1] *= m_colorRGBA[1];
177 color[2] *= m_colorRGBA[2];
178 color[3] *= m_colorRGBA[3];
179
180 for (int i = 0; i < 3; ++i)
181 {
182 int orgColor = 0;
183 float floatColor = (m_ambient_coefficient * color[i] + shadow * (m_diffuse_coefficient * diffuse + m_specular_coefficient * specular) * color[i] * m_light_color[i]);
184 if (floatColor==floatColor)
185 {
186 orgColor=int(floatColor);
187 }
188 color[i] = b3Min(orgColor, 255);
189 }
190
191 return false;
192 }
193 };
194
TinyRenderObjectData(TGAImage & rgbColorBuffer,b3AlignedObjectArray<float> & depthBuffer,b3AlignedObjectArray<float> * shadowBuffer)195 TinyRenderObjectData::TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<float>* shadowBuffer)
196 : m_model(0),
197 m_rgbColorBuffer(rgbColorBuffer),
198 m_depthBuffer(depthBuffer),
199 m_shadowBuffer(shadowBuffer),
200 m_segmentationMaskBufferPtr(0),
201 m_userData(0),
202 m_userIndex(-1),
203 m_objectIndex(-1),
204 m_doubleSided(false)
205 {
206 Vec3f eye(1, 1, 3);
207 Vec3f center(0, 0, 0);
208 Vec3f up(0, 0, 1);
209 m_lightDirWorld.setValue(0, 0, 0);
210 m_lightColor.setValue(1, 1, 1);
211 m_localScaling.setValue(1, 1, 1);
212 m_modelMatrix = Matrix::identity();
213 m_lightAmbientCoeff = 0.6;
214 m_lightDiffuseCoeff = 0.35;
215 m_lightSpecularCoeff = 0.05;
216
217 }
218
TinyRenderObjectData(TGAImage & rgbColorBuffer,b3AlignedObjectArray<float> & depthBuffer,b3AlignedObjectArray<float> * shadowBuffer,b3AlignedObjectArray<int> * segmentationMaskBuffer,int objectIndex,int linkIndex)219 TinyRenderObjectData::TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<float>* shadowBuffer, b3AlignedObjectArray<int>* segmentationMaskBuffer, int objectIndex, int linkIndex)
220 : m_model(0),
221 m_rgbColorBuffer(rgbColorBuffer),
222 m_depthBuffer(depthBuffer),
223 m_shadowBuffer(shadowBuffer),
224 m_segmentationMaskBufferPtr(segmentationMaskBuffer),
225 m_userData(0),
226 m_userIndex(-1),
227 m_objectIndex(objectIndex),
228 m_linkIndex(linkIndex),
229 m_doubleSided(false)
230 {
231 Vec3f eye(1, 1, 3);
232 Vec3f center(0, 0, 0);
233 Vec3f up(0, 0, 1);
234 m_lightDirWorld.setValue(0, 0, 0);
235 m_lightColor.setValue(1, 1, 1);
236 m_localScaling.setValue(1, 1, 1);
237 m_modelMatrix = Matrix::identity();
238 m_lightAmbientCoeff = 0.6;
239 m_lightDiffuseCoeff = 0.35;
240 m_lightSpecularCoeff = 0.05;
241 }
242
TinyRenderObjectData(TGAImage & rgbColorBuffer,b3AlignedObjectArray<float> & depthBuffer)243 TinyRenderObjectData::TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer)
244 : m_model(0),
245 m_rgbColorBuffer(rgbColorBuffer),
246 m_depthBuffer(depthBuffer),
247 m_shadowBuffer(0),
248 m_segmentationMaskBufferPtr(0),
249 m_userData(0),
250 m_userIndex(-1),
251 m_objectIndex(-1),
252 m_doubleSided(false)
253 {
254 Vec3f eye(1, 1, 3);
255 Vec3f center(0, 0, 0);
256 Vec3f up(0, 0, 1);
257 m_lightDirWorld.setValue(0, 0, 0);
258 m_lightDistance = 10;
259 m_lightColor.setValue(1, 1, 1);
260 m_localScaling.setValue(1, 1, 1);
261 m_modelMatrix = Matrix::identity();
262 m_lightAmbientCoeff = 0.6;
263 m_lightDiffuseCoeff = 0.35;
264 m_lightSpecularCoeff = 0.05;
265 }
266
TinyRenderObjectData(TGAImage & rgbColorBuffer,b3AlignedObjectArray<float> & depthBuffer,b3AlignedObjectArray<int> * segmentationMaskBuffer,int objectIndex)267 TinyRenderObjectData::TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<int>* segmentationMaskBuffer, int objectIndex)
268 : m_model(0),
269 m_rgbColorBuffer(rgbColorBuffer),
270 m_depthBuffer(depthBuffer),
271 m_shadowBuffer(0),
272 m_segmentationMaskBufferPtr(segmentationMaskBuffer),
273 m_userData(0),
274 m_userIndex(-1),
275 m_objectIndex(objectIndex),
276 m_doubleSided(false)
277 {
278 Vec3f eye(1, 1, 3);
279 Vec3f center(0, 0, 0);
280 Vec3f up(0, 0, 1);
281 m_lightDirWorld.setValue(0, 0, 0);
282 m_lightColor.setValue(1, 1, 1);
283 m_localScaling.setValue(1, 1, 1);
284 m_modelMatrix = Matrix::identity();
285 m_lightAmbientCoeff = 0.6;
286 m_lightDiffuseCoeff = 0.35;
287 m_lightSpecularCoeff = 0.05;
288 }
289
loadModel(const char * fileName,CommonFileIOInterface * fileIO)290 void TinyRenderObjectData::loadModel(const char* fileName, CommonFileIOInterface* fileIO)
291 {
292 //todo(erwincoumans) move the file loading out of here
293 char relativeFileName[1024];
294 if (!fileIO->findResourcePath(fileName, relativeFileName, 1024))
295 {
296 printf("Cannot find file %s\n", fileName);
297 }
298 else
299 {
300 m_model = new Model(relativeFileName);
301 }
302 }
303
registerMeshShape(const float * vertices,int numVertices,const int * indices,int numIndices,const float rgbaColor[4],unsigned char * textureImage,int textureWidth,int textureHeight)304 void TinyRenderObjectData::registerMeshShape(const float* vertices, int numVertices, const int* indices, int numIndices, const float rgbaColor[4],
305 unsigned char* textureImage, int textureWidth, int textureHeight)
306 {
307 if (0 == m_model)
308 {
309 {
310 B3_PROFILE("setColorRGBA");
311
312 m_model = new Model();
313 m_model->setColorRGBA(rgbaColor);
314 }
315 if (textureImage)
316 {
317 {
318 B3_PROFILE("setDiffuseTextureFromData");
319 m_model->setDiffuseTextureFromData(textureImage, textureWidth, textureHeight);
320 }
321 }
322 else
323 {
324 /*char relativeFileName[1024];
325 if (b3ResourcePath::findResourcePath("floor_diffuse.tga", relativeFileName, 1024))
326 {
327 m_model->loadDiffuseTexture(relativeFileName);
328 }
329 */
330 }
331 {
332 B3_PROFILE("reserveMemory");
333 m_model->reserveMemory(numVertices, numIndices);
334 }
335 {
336 B3_PROFILE("addVertex");
337 for (int i = 0; i < numVertices; i++)
338 {
339 m_model->addVertex(vertices[i * 9],
340 vertices[i * 9 + 1],
341 vertices[i * 9 + 2],
342 vertices[i * 9 + 4],
343 vertices[i * 9 + 5],
344 vertices[i * 9 + 6],
345 vertices[i * 9 + 7],
346 vertices[i * 9 + 8]);
347 }
348 }
349 {
350 B3_PROFILE("addTriangle");
351 for (int i = 0; i < numIndices; i += 3)
352 {
353 m_model->addTriangle(indices[i], indices[i], indices[i],
354 indices[i + 1], indices[i + 1], indices[i + 1],
355 indices[i + 2], indices[i + 2], indices[i + 2]);
356 }
357 }
358 }
359 }
360
registerMesh2(btAlignedObjectArray<btVector3> & vertices,btAlignedObjectArray<btVector3> & normals,btAlignedObjectArray<int> & indices,CommonFileIOInterface * fileIO)361 void TinyRenderObjectData::registerMesh2(btAlignedObjectArray<btVector3>& vertices, btAlignedObjectArray<btVector3>& normals, btAlignedObjectArray<int>& indices, CommonFileIOInterface* fileIO)
362 {
363 if (0 == m_model)
364 {
365 int numVertices = vertices.size();
366 int numIndices = indices.size();
367
368 m_model = new Model();
369 char relativeFileName[1024];
370 if (fileIO->findResourcePath("floor_diffuse.tga", relativeFileName, 1024))
371 {
372 m_model->loadDiffuseTexture(relativeFileName);
373 }
374
375 for (int i = 0; i < numVertices; i++)
376 {
377 m_model->addVertex(vertices[i].x(),
378 vertices[i].y(),
379 vertices[i].z(),
380 normals[i].x(),
381 normals[i].y(),
382 normals[i].z(),
383 0.5, 0.5);
384 }
385 for (int i = 0; i < numIndices; i += 3)
386 {
387 m_model->addTriangle(indices[i], indices[i], indices[i],
388 indices[i + 1], indices[i + 1], indices[i + 1],
389 indices[i + 2], indices[i + 2], indices[i + 2]);
390 }
391 }
392 }
393
createCube(float halfExtentsX,float halfExtentsY,float halfExtentsZ,CommonFileIOInterface * fileIO)394 void TinyRenderObjectData::createCube(float halfExtentsX, float halfExtentsY, float halfExtentsZ, CommonFileIOInterface* fileIO)
395 {
396 b3BulletDefaultFileIO defaultFileIO;
397
398 if (fileIO==0)
399 {
400 fileIO = &defaultFileIO;
401 }
402 m_model = new Model();
403
404 char relativeFileName[1024];
405 if (fileIO->findResourcePath("floor_diffuse.tga", relativeFileName, 1024))
406 {
407 m_model->loadDiffuseTexture(relativeFileName);
408 }
409
410 int strideInBytes = 9 * sizeof(float);
411 int numVertices = sizeof(cube_vertices_textured) / strideInBytes;
412 int numIndices = sizeof(cube_indices) / sizeof(int);
413
414 for (int i = 0; i < numVertices; i++)
415 {
416 m_model->addVertex(halfExtentsX * cube_vertices_textured[i * 9],
417 halfExtentsY * cube_vertices_textured[i * 9 + 1],
418 halfExtentsZ * cube_vertices_textured[i * 9 + 2],
419 cube_vertices_textured[i * 9 + 4],
420 cube_vertices_textured[i * 9 + 5],
421 cube_vertices_textured[i * 9 + 6],
422 cube_vertices_textured[i * 9 + 7],
423 cube_vertices_textured[i * 9 + 8]);
424 }
425 for (int i = 0; i < numIndices; i += 3)
426 {
427 m_model->addTriangle(cube_indices[i], cube_indices[i], cube_indices[i],
428 cube_indices[i + 1], cube_indices[i + 1], cube_indices[i + 1],
429 cube_indices[i + 2], cube_indices[i + 2], cube_indices[i + 2]);
430 }
431 }
432
~TinyRenderObjectData()433 TinyRenderObjectData::~TinyRenderObjectData()
434 {
435 delete m_model;
436 }
437
equals(const Vec4f & vA,const Vec4f & vB)438 static bool equals(const Vec4f& vA, const Vec4f& vB)
439 {
440 return false;
441 }
442
clipEdge(const mat<4,3,float> & triangleIn,int vertexIndexA,int vertexIndexB,b3AlignedObjectArray<Vec4f> & vertices)443 static void clipEdge(const mat<4, 3, float>& triangleIn, int vertexIndexA, int vertexIndexB, b3AlignedObjectArray<Vec4f>& vertices)
444 {
445 Vec4f v0New = triangleIn.col(vertexIndexA);
446 Vec4f v1New = triangleIn.col(vertexIndexB);
447
448 bool v0Inside = v0New[3] > 0.f && v0New[2] > -v0New[3];
449 bool v1Inside = v1New[3] > 0.f && v1New[2] > -v1New[3];
450
451 if (v0Inside && v1Inside)
452 {
453 }
454 else if (v0Inside || v1Inside)
455 {
456 float d0 = v0New[2] + v0New[3];
457 float d1 = v1New[2] + v1New[3];
458 float factor = 1.0 / (d1 - d0);
459 Vec4f newVertex = (v0New * d1 - v1New * d0) * factor;
460 if (v0Inside)
461 {
462 v1New = newVertex;
463 }
464 else
465 {
466 v0New = newVertex;
467 }
468 }
469 else
470 {
471 return;
472 }
473
474 if (vertices.size() == 0 || !(equals(vertices[vertices.size() - 1], v0New)))
475 {
476 vertices.push_back(v0New);
477 }
478
479 vertices.push_back(v1New);
480 }
481
clipTriangleAgainstNearplane(const mat<4,3,float> & triangleIn,b3AlignedObjectArray<mat<4,3,float>> & clippedTrianglesOut)482 static bool clipTriangleAgainstNearplane(const mat<4, 3, float>& triangleIn, b3AlignedObjectArray<mat<4, 3, float> >& clippedTrianglesOut)
483 {
484 //discard triangle if all vertices are behind near-plane
485 if (triangleIn[3][0] < 0 && triangleIn[3][1] < 0 && triangleIn[3][2] < 0)
486 {
487 return true;
488 }
489
490 //accept triangle if all vertices are in front of the near-plane
491 if (triangleIn[3][0] >= 0 && triangleIn[3][1] >= 0 && triangleIn[3][2] >= 0)
492 {
493 clippedTrianglesOut.push_back(triangleIn);
494 return false;
495 }
496
497 Vec4f vtxCache[5];
498
499 b3AlignedObjectArray<Vec4f> vertices;
500 vertices.initializeFromBuffer(vtxCache, 0, 5);
501 clipEdge(triangleIn, 0, 1, vertices);
502 clipEdge(triangleIn, 1, 2, vertices);
503 clipEdge(triangleIn, 2, 0, vertices);
504
505 if (vertices.size() < 3)
506 return true;
507
508 if (equals(vertices[0], vertices[vertices.size() - 1]))
509 {
510 vertices.pop_back();
511 }
512
513 //create a fan of triangles
514 for (int i = 1; i < vertices.size() - 1; i++)
515 {
516 mat<4, 3, float>& vtx = clippedTrianglesOut.expand();
517 vtx.set_col(0, vertices[0]);
518 vtx.set_col(1, vertices[i]);
519 vtx.set_col(2, vertices[i + 1]);
520 }
521 return true;
522 }
523
renderObject(TinyRenderObjectData & renderData)524 void TinyRenderer::renderObject(TinyRenderObjectData& renderData)
525 {
526 B3_PROFILE("renderObject");
527 int width = renderData.m_rgbColorBuffer.get_width();
528 int height = renderData.m_rgbColorBuffer.get_height();
529
530 Vec3f light_dir_local = Vec3f(renderData.m_lightDirWorld[0], renderData.m_lightDirWorld[1], renderData.m_lightDirWorld[2]);
531 Vec3f light_color = Vec3f(renderData.m_lightColor[0], renderData.m_lightColor[1], renderData.m_lightColor[2]);
532 float light_distance = renderData.m_lightDistance;
533 Model* model = renderData.m_model;
534 if (0 == model)
535 return;
536 //discard invisible objects (zero alpha)
537 if (model->getColorRGBA()[3] == 0)
538 return;
539
540 renderData.m_viewportMatrix = viewport(0, 0, width, height);
541
542 b3AlignedObjectArray<float>& zbuffer = renderData.m_depthBuffer;
543 b3AlignedObjectArray<float>* shadowBufferPtr = renderData.m_shadowBuffer;
544 int* segmentationMaskBufferPtr = (renderData.m_segmentationMaskBufferPtr && renderData.m_segmentationMaskBufferPtr->size()) ? &renderData.m_segmentationMaskBufferPtr->at(0) : 0;
545
546 TGAImage& frame = renderData.m_rgbColorBuffer;
547
548 {
549 // light target is set to be the origin, and the up direction is set to be vertical up.
550 Matrix lightViewMatrix = lookat(light_dir_local * light_distance, Vec3f(0.0, 0.0, 0.0), Vec3f(0.0, 0.0, 1.0));
551 Matrix lightModelViewMatrix = lightViewMatrix * renderData.m_modelMatrix;
552 Matrix modelViewMatrix = renderData.m_viewMatrix * renderData.m_modelMatrix;
553 Vec3f localScaling(renderData.m_localScaling[0], renderData.m_localScaling[1], renderData.m_localScaling[2]);
554 Matrix viewMatrixInv = renderData.m_viewMatrix.invert();
555 btVector3 P(viewMatrixInv[0][3], viewMatrixInv[1][3], viewMatrixInv[2][3]);
556
557 Shader shader(model, light_dir_local, light_color, modelViewMatrix, lightModelViewMatrix, renderData.m_projectionMatrix, renderData.m_modelMatrix, renderData.m_viewportMatrix, localScaling, model->getColorRGBA(), width, height, shadowBufferPtr, renderData.m_lightAmbientCoeff, renderData.m_lightDiffuseCoeff, renderData.m_lightSpecularCoeff);
558
559 {
560 B3_PROFILE("face");
561
562 for (int i = 0; i < model->nfaces(); i++)
563 {
564 for (int j = 0; j < 3; j++)
565 {
566 shader.vertex(i, j);
567 }
568
569 if (!renderData.m_doubleSided)
570 {
571 // backface culling
572 btVector3 v0(shader.world_tri.col(0)[0], shader.world_tri.col(0)[1], shader.world_tri.col(0)[2]);
573 btVector3 v1(shader.world_tri.col(1)[0], shader.world_tri.col(1)[1], shader.world_tri.col(1)[2]);
574 btVector3 v2(shader.world_tri.col(2)[0], shader.world_tri.col(2)[1], shader.world_tri.col(2)[2]);
575 btVector3 N = (v1 - v0).cross(v2 - v0);
576 if ((v0 - P).dot(N) >= 0)
577 continue;
578 }
579
580 mat<4, 3, float> stackTris[3];
581
582 b3AlignedObjectArray<mat<4, 3, float> > clippedTriangles;
583 clippedTriangles.initializeFromBuffer(stackTris, 0, 3);
584
585 bool hasClipped = clipTriangleAgainstNearplane(shader.varying_tri, clippedTriangles);
586
587 if (hasClipped)
588 {
589 for (int t = 0; t < clippedTriangles.size(); t++)
590 {
591 triangleClipped(clippedTriangles[t], shader.varying_tri, shader, frame, &zbuffer[0], segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex + ((renderData.m_linkIndex + 1) << 24));
592 }
593 }
594 else
595 {
596 triangle(shader.varying_tri, shader, frame, &zbuffer[0], segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex + ((renderData.m_linkIndex + 1) << 24));
597 }
598 }
599 }
600 }
601 }
602
renderObjectDepth(TinyRenderObjectData & renderData)603 void TinyRenderer::renderObjectDepth(TinyRenderObjectData& renderData)
604 {
605 int width = renderData.m_rgbColorBuffer.get_width();
606 int height = renderData.m_rgbColorBuffer.get_height();
607
608 Vec3f light_dir_local = Vec3f(renderData.m_lightDirWorld[0], renderData.m_lightDirWorld[1], renderData.m_lightDirWorld[2]);
609 float light_distance = renderData.m_lightDistance;
610 Model* model = renderData.m_model;
611 if (0 == model)
612 return;
613
614 renderData.m_viewportMatrix = viewport(0, 0, width, height);
615
616 float* shadowBufferPtr = (renderData.m_shadowBuffer && renderData.m_shadowBuffer->size()) ? &renderData.m_shadowBuffer->at(0) : 0;
617 int* segmentationMaskBufferPtr = 0;
618
619 TGAImage depthFrame(width, height, TGAImage::RGB);
620
621 {
622 // light target is set to be the origin, and the up direction is set to be vertical up.
623 Matrix lightViewMatrix = lookat(light_dir_local * light_distance, Vec3f(0.0, 0.0, 0.0), Vec3f(0.0, 0.0, 1.0));
624 Matrix lightModelViewMatrix = lightViewMatrix * renderData.m_modelMatrix;
625 Matrix lightViewProjectionMatrix = renderData.m_projectionMatrix;
626 Vec3f localScaling(renderData.m_localScaling[0], renderData.m_localScaling[1], renderData.m_localScaling[2]);
627
628 DepthShader shader(model, lightModelViewMatrix, lightViewProjectionMatrix, renderData.m_modelMatrix, localScaling, light_distance);
629 for (int i = 0; i < model->nfaces(); i++)
630 {
631 for (int j = 0; j < 3; j++)
632 {
633 shader.vertex(i, j);
634 }
635
636 mat<4, 3, float> stackTris[3];
637
638 b3AlignedObjectArray<mat<4, 3, float> > clippedTriangles;
639 clippedTriangles.initializeFromBuffer(stackTris, 0, 3);
640
641 bool hasClipped = clipTriangleAgainstNearplane(shader.varying_tri, clippedTriangles);
642
643 if (hasClipped)
644 {
645 for (int t = 0; t < clippedTriangles.size(); t++)
646 {
647 triangleClipped(clippedTriangles[t], shader.varying_tri, shader, depthFrame, shadowBufferPtr, segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex);
648 }
649 }
650 else
651 {
652 triangle(shader.varying_tri, shader, depthFrame, shadowBufferPtr, segmentationMaskBufferPtr, renderData.m_viewportMatrix, renderData.m_objectIndex);
653 }
654 }
655 }
656 }
657