+ mesh.transform(matrix, True)
+
+ def _doObjectDepthSorting(self, mesh):
+ """Sort faces in an object.
+
+ The faces in the object are sorted following the distance of the
+ vertices from the camera position.
+ """
+ c = self._cameraWorldPosition()
+
+ # hackish sorting of faces
+ mesh.faces.sort(
+ lambda f1, f2:
+ # Sort faces according to the min distance from the camera
+ #cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
+ # min([(Vector(v.co)-Vector(c)).length for v in f2])))
+
+ # Sort faces according to the max distance from the camera
+ cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
+ max([(Vector(v.co)-Vector(c)).length for v in f2])))
+
+ # Sort faces according to the avg distance from the camera
+ #cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
+ # sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
+
+ mesh.faces.reverse()
+
+ def _doBackFaceCulling(self, mesh):
+ """Simple Backface Culling routine.
+
+ At this level we simply do a visibility test face by face and then
+ select the vertices belonging to visible faces.
+ """
+
+ # Select all vertices, so edges without faces can be displayed
+ for v in mesh.verts:
+ v.sel = 1
+
+ Mesh.Mode(Mesh.SelectModes['FACE'])
+ # Loop on faces
+ for f in mesh.faces:
+ f.sel = 0
+ if self._isFaceVisible(f):
+ f.sel = 1
+
+ # Is this the correct way to propagate the face selection info to the
+ # vertices belonging to a face ??
+ # TODO: Using the Mesh class this should come for free. Right?
+ Mesh.Mode(Mesh.SelectModes['VERTEX'])
+ for f in mesh.faces:
+ if not f.sel:
+ for v in f:
+ v.sel = 0
+
+ for f in mesh.faces:
+ if f.sel:
+ for v in f:
+ v.sel = 1
+
+ def _doColorAndLighting(self, mesh):
+ """Apply an Illumination model to the object.
+
+ The Illumination model used is the Phong one, it may be inefficient,
+ but I'm just learning about rendering and starting from Phong seemed
+ the most natural way.
+ """
+
+ # If the mesh has vertex colors already, use them,
+ # otherwise turn them on and do some calculations
+ if mesh.hasVertexColours():
+ return
+ mesh.hasVertexColours(True)
+
+ materials = mesh.materials
+
+ # TODO: use multiple lighting sources
+ light_obj = self.lights[0]
+ light_pos = self._worldPosition(light_obj)
+ light = light_obj.data
+
+ camPos = self._cameraWorldPosition()
+
+ # We do per-face color calculation (FLAT Shading), we can easily turn
+ # to a per-vertex calculation if we want to implement some shading
+ # technique. For an example see:
+ # http://www.miralab.unige.ch/papers/368.pdf
+ for f in mesh.faces:
+ if not f.sel:
+ continue
+
+ mat = None
+ if materials:
+ mat = materials[f.mat]
+
+ # A new default material
+ if not mat:
+ mat = Material.New('defMat')
+
+ L = Vector(light_pos).normalize()