"""
__author__ = "Antonio Ospite"
-__url__ = ["http://vrm.projects.blender.org"]
-__version__ = "0.3"
+__url__ = ["http://projects.blender.org/projects/vrm"]
+__version__ = "0.3.beta"
__bpydoc__ = """\
Render the scene and save the result in vector format.
# ---------------------------------------------------------------------
#
# Things TODO for a next release:
-# - Switch to the Mesh structure, should be considerably faster
-# (partially done, but with Mesh we cannot sort faces, yet)
+# - FIX the issue with negative scales in object tranformations!
# - Use a better depth sorting algorithm
+# - Implement clipping of primitives and do handle object intersections.
+# (for now only clipping away whole objects is supported).
# - Review how selections are made (this script uses selection states of
# primitives to represent visibility infos)
-# - Implement clipping of primitives and do handle object intersections.
-# (for now only clipping for whole objects is supported).
-# - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
-# - Use multiple lighting sources in color calculation
-# - Implement Shading Styles? (for now we use Flat Shading).
# - Use a data structure other than Mesh to represent the 2D image?
-# Think to a way to merge adjacent polygons that have the same color.
+# Think to a way to merge (adjacent) polygons that have the same color.
# Or a way to use paths for silhouettes and contours.
-# - Add Vector Writers other that SVG.
# - Consider SMIL for animation handling instead of ECMA Script? (Firefox do
# not support SMIL for animations)
-# - FIX the issue with negative scales in object tranformations!
+# - Switch to the Mesh structure, should be considerably faster
+# (partially done, but with Mesh we cannot sort faces, yet)
+# - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
+# - Implement Shading Styles? (partially done, to make more flexible).
+# - Add Vector Writers other than SVG.
+# - Check memory use!!
+# - Support Indexed palettes!! (Useful for ILDA FILES, for example,
+# see http://www.linux-laser.org/download/autotrace/ilda-output.patch)
#
# ---------------------------------------------------------------------
#
# Changelog:
#
-# vrm-0.3.py - 2006-05-19
-# * First release after code restucturing.
-# Now the script offers a useful set of functionalities
-# and it can render animations, too.
+# vrm-0.3.py - ...
+# * First release after code restucturing.
+# Now the script offers a useful set of functionalities
+# and it can render animations, too.
+# * Optimization in Renderer.doEdgeStyle(), build a topology cache
+# so to speed up the lookup of adjacent faces of an edge.
+# Thanks ideasman42.
+# * The SVG output is now SVG 1.0 valid.
+# Checked with: http://jiggles.w3.org/svgvalidator/ValidatorURI.html
+# * Progress indicator during HSR.
#
# ---------------------------------------------------------------------
import Blender
-from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera
+from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window
from Blender.Mathutils import *
from math import *
+import sys, time
# Some global settings
class config:
polygons = dict()
polygons['SHOW'] = True
- polygons['SHADING'] = 'TOON'
+ polygons['SHADING'] = 'FLAT'
+ polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
+ #polygons['HSR'] = 'NEWELL'
# Hidden to the user for now
polygons['EXPANSION_TRICK'] = True
+ polygons['TOON_LEVELS'] = 2
+
edges = dict()
- edges['SHOW'] = True
+ edges['SHOW'] = False
edges['SHOW_HIDDEN'] = False
- edges['STYLE'] = 'SILHOUETTE'
+ edges['STYLE'] = 'MESH'
edges['WIDTH'] = 2
edges['COLOR'] = [0, 0, 0]
+# Debug utility function
+print_debug = False
+def debug(msg):
+ if print_debug:
+ sys.stderr.write(msg)
+
+
# ---------------------------------------------------------------------
#
-## Utility Mesh class
+## Mesh Utility class
#
# ---------------------------------------------------------------------
class MeshUtils:
- def getEdgeAdjacentFaces(edge, mesh):
- """Get the faces adjacent to a given edge.
-
- There can be 0, 1 or more (usually 2) faces adjacent to an edge.
- """
- adjface_list = []
-
- for f in mesh.faces:
- if (edge.v1 in f.v) and (edge.v2 in f.v):
- adjface_list.append(f)
-
- return adjface_list
+ def buildEdgeFaceUsersCache(me):
+ '''
+ Takes a mesh and returns a list aligned with the meshes edges.
+ Each item is a list of the faces that use the edge
+ would be the equiv for having ed.face_users as a property
+
+ Taken from .blender/scripts/bpymodules/BPyMesh.py,
+ thanks to ideasman_42.
+ '''
+
+ def sorted_edge_indicies(ed):
+ i1= ed.v1.index
+ i2= ed.v2.index
+ if i1>i2:
+ i1,i2= i2,i1
+ return i1, i2
+
+
+ face_edges_dict= dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges])
+ for f in me.faces:
+ fvi= [v.index for v in f.v]# face vert idx's
+ for i in xrange(len(f)):
+ i1= fvi[i]
+ i2= fvi[i-1]
+
+ if i1>i2:
+ i1,i2= i2,i1
+
+ face_edges_dict[i1,i2][1].append(f)
+
+ face_edges= [None] * len(me.edges)
+ for ed_index, ed_faces in face_edges_dict.itervalues():
+ face_edges[ed_index]= ed_faces
+
+ return face_edges
- def isMeshEdge(e, mesh):
+ def isMeshEdge(adjacent_faces):
"""Mesh edge rule.
- A mesh edge is visible if _any_ of its adjacent faces is selected.
+ A mesh edge is visible if _at_least_one_ of its adjacent faces is selected.
Note: if the edge has no adjacent faces we want to show it as well,
useful for "edge only" portion of objects.
"""
- adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
-
if len(adjacent_faces) == 0:
return True
else:
return False
- def isSilhouetteEdge(e, mesh):
+ def isSilhouetteEdge(adjacent_faces):
"""Silhuette selection rule.
An edge is a silhuette edge if it is shared by two faces with
face.
"""
- adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
-
if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
(len(adjacent_faces) == 2 and
adjacent_faces[0].sel != adjacent_faces[1].sel)
return True
else:
return False
-
- def toonShading(u):
- levels = 2
+ buildEdgeFaceUsersCache = staticmethod(buildEdgeFaceUsersCache)
+ isMeshEdge = staticmethod(isMeshEdge)
+ isSilhouetteEdge = staticmethod(isSilhouetteEdge)
+
+
+# ---------------------------------------------------------------------
+#
+## Shading Utility class
+#
+# ---------------------------------------------------------------------
+class ShadingUtils:
+
+ shademap = None
+
+ def toonShadingMapSetup():
+ levels = config.polygons['TOON_LEVELS']
+
texels = 2*levels - 1
- map = [0.0] + [(i)/float(texels-1) for i in range(1, texels-1) ] + [1.0]
-
+ tmp_shademap = [0.0] + [(i)/float(texels-1) for i in xrange(1, texels-1) ] + [1.0]
+
+ return tmp_shademap
+
+ def toonShading(u):
+
+ shademap = ShadingUtils.shademap
+
+ if not shademap:
+ shademap = ShadingUtils.toonShadingMapSetup()
+
v = 1.0
- for i in range(0, len(map)-1):
- pivot = (map[i]+map[i+1])/2.0
+ for i in xrange(0, len(shademap)-1):
+ pivot = (shademap[i]+shademap[i+1])/2.0
j = int(u>pivot)
- v = map[i+j]
+ v = shademap[i+j]
- if v<map[i+1]:
+ if v < shademap[i+1]:
return v
return v
-
- getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
- isMeshEdge = staticmethod(isMeshEdge)
- isSilhouetteEdge = staticmethod(isSilhouetteEdge)
+ toonShadingMapSetup = staticmethod(toonShadingMapSetup)
toonShading = staticmethod(toonShading)
-
# ---------------------------------------------------------------------
#
## Projections classes
fovy = fovy * 360.0/pi
# What projection do we want?
- if camera.type:
- #mP = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale)
- mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale)
- else:
+ if camera.type == 0:
mP = self._calcPerspectiveMatrix(fovy, aspect, near, far)
+ elif camera.type == 1:
+ mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale)
# View transformation
cam = Matrix(cameraObj.getInverseMatrix())
"""
# Note that we have to work on the vertex using homogeneous coordinates
+ # From blender 2.42+ we don't need to resize the vector to be 4d
+ # when applying a 4x4 matrix, but we do that anyway since we need the
+ # 4th coordinate later
p = self.projectionMatrix * Vector(v).resize4D()
-
- if p[3]>0:
+
+ # Perspective division
+ if p[3] != 0:
p[0] = p[0]/p[3]
p[1] = p[1]/p[3]
+ p[2] = p[2]/p[3]
# restore the size
p[3] = 1.0
return m
+# ---------------------------------------------------------------------
+#
+## Progress Indicator
+#
+# ---------------------------------------------------------------------
+
+class Progress:
+ """A model for a progress indicator.
+
+ Do the progress calculation calculation and
+ the view independent stuff of a progress indicator.
+ """
+ def __init__(self, steps=0):
+ self.name = ""
+ self.steps = steps
+ self.completed = 0
+ self.progress = 0
+
+ def setSteps(self, steps):
+ """Set the number of steps of the activity wich we want to track.
+ """
+ self.steps = steps
+
+ def getSteps(self):
+ return self.steps
+
+ def setName(self, name):
+ """Set the name of the activity wich we want to track.
+ """
+ self.name = name
+
+ def getName(self):
+ return self.name
+
+ def getProgress(self):
+ return self.progress
+
+ def reset(self):
+ self.completed = 0
+ self.progress = 0
+
+ def update(self):
+ """Update the model, call this method when one step is completed.
+ """
+ if self.progress == 100:
+ return False
+
+ self.completed += 1
+ self.progress = ( float(self.completed) / float(self.steps) ) * 100
+ self.progress = int(self.progress)
+
+ return True
+
+
+class ProgressIndicator:
+ """An abstraction of a View for the Progress Model
+ """
+ def __init__(self):
+
+ # Use a refresh rate so we do not show the progress at
+ # every update, but every 'self.refresh_rate' times.
+ self.refresh_rate = 10
+ self.shows_counter = 0
+
+ self.progressModel = None
+
+ def setActivity(self, name, steps):
+ """Initialize the Model.
+
+ In a future version (with subactivities-progress support) this method
+ could only set the current activity.
+ """
+ self.progressModel = Progress()
+ self.progressModel.setName(name)
+ self.progressModel.setSteps(steps)
+
+ def getActivity(self):
+ return self.progressModel
+
+ def update(self):
+ """Update the model and show the actual progress.
+ """
+ assert(self.progressModel)
+
+ if self.progressModel.update():
+ self.show(self.progressModel.getProgress(),
+ self.progressModel.getName())
+
+ # We return always True here so we can call the update() method also
+ # from lambda funcs (putting the call in logical AND with other ops)
+ return True
+
+ def show(self, progress, name=""):
+ self.shows_counter = (self.shows_counter + 1) % self.refresh_rate
+ if self.shows_counter != 0:
+ return
+
+ if progress == 100:
+ self.shows_counter = -1
+
+
+class ConsoleProgressIndicator(ProgressIndicator):
+ """Show a progress bar on stderr, a la wget.
+ """
+ def __init__(self):
+ ProgressIndicator.__init__(self)
+
+ self.swirl_chars = ["-", "\\", "|", "/"]
+ self.swirl_count = -1
+
+ def show(self, progress, name):
+ ProgressIndicator.show(self, progress, name)
+
+ bar_length = 70
+ bar_progress = int( (progress/100.0) * bar_length )
+ bar = ("=" * bar_progress).ljust(bar_length)
+
+ self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+ swirl_char = self.swirl_chars[self.swirl_count]
+
+ progress_bar = "%s |%s| %c %3d%%" % (name, bar, swirl_char, progress)
+
+ sys.stderr.write(progress_bar+"\r")
+ if progress == 100:
+ sys.stderr.write("\n")
+
+
+class GraphicalProgressIndicator(ProgressIndicator):
+ """Interface to the Blender.Window.DrawProgressBar() method.
+ """
+ def __init__(self):
+ ProgressIndicator.__init__(self)
+
+ #self.swirl_chars = ["-", "\\", "|", "/"]
+ # We have to use letters with the same width, for now!
+ # Blender progress bar considers the font widths when
+ # calculating the progress bar width.
+ self.swirl_chars = ["\\", "/"]
+ self.swirl_count = -1
+
+ def show(self, progress, name):
+ ProgressIndicator.show(self, progress)
+
+ self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+ swirl_char = self.swirl_chars[self.swirl_count]
+
+ progress_text = "%s - %c %3d%%" % (name, swirl_char, progress)
+
+ # Finally draw the Progress Bar
+ Window.WaitCursor(1) # Maybe we can move that call in the constructor?
+ Window.DrawProgressBar(progress/100.0, progress_text)
+
+ if progress == 100:
+ Window.DrawProgressBar(1, progress_text)
+ Window.WaitCursor(0)
+
+
# ---------------------------------------------------------------------
#
"""Print SVG header."""
self.file.write("<?xml version=\"1.0\"?>\n")
- self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n")
- self.file.write("\t\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
- self.file.write("<svg version=\"1.1\"\n")
+ self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\"\n")
+ self.file.write("\t\"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n")
+ self.file.write("<svg version=\"1.0\"\n")
self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
- self.file.write("\twidth=\"%d\" height=\"%d\" streamable=\"true\">\n\n" %
+ self.file.write("\twidth=\"%d\" height=\"%d\">\n\n" %
self.canvasSize)
if self.animation:
- self.file.write("""\n<script><![CDATA[
+ self.file.write("""\n<script type="text/javascript"><![CDATA[
globalStartFrame=%d;
globalEndFrame=%d;
if not face.sel:
continue
- self.file.write("<polygon points=\"")
+ self.file.write("<path d=\"")
+
+ p = self._calcCanvasCoord(face.verts[0])
+ self.file.write("M %g,%g L " % (p[0], p[1]))
- for v in face:
+ for v in face.verts[1:]:
p = self._calcCanvasCoord(v)
self.file.write("%g,%g " % (p[0], p[1]))
# get rid of the last blank space, just cosmetics here.
self.file.seek(-1, 1)
- self.file.write("\"\n")
+ self.file.write(" z\"\n")
# take as face color the first vertex color
- # TODO: the average of vetrex colors?
if face.col:
fcol = face.col[0]
color = [fcol.r, fcol.g, fcol.b, fcol.a]
# Convert the color to the #RRGGBB form
str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
- # use the stroke property to alleviate the "adjacent edges" problem,
- # we simulate polygon expansion using borders,
- # see http://www.antigrain.com/svg/index.html for more info
- stroke_width = 0.5
-
# Handle transparent polygons
opacity_string = ""
if color[3] != 255:
self.file.write("\tstyle=\"fill:" + str_col + ";")
self.file.write(opacity_string)
+
+ # use the stroke property to alleviate the "adjacent edges" problem,
+ # we simulate polygon expansion using borders,
+ # see http://www.antigrain.com/svg/index.html for more info
+ stroke_width = 1.0
+
if config.polygons['EXPANSION_TRICK']:
- self.file.write(" stroke:" + str_col + ";")
+ self.file.write(" stroke:%s;\n" % str_col)
self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
self.file.write(" stroke-linecap:round;stroke-linejoin:round")
+
self.file.write("\"/>\n")
self.file.write("</g>\n")
self.file.write("</g>\n")
-
# ---------------------------------------------------------------------
#
## Rendering Classes
class Renderer:
- """Render a scene viewed from a given camera.
+ """Render a scene viewed from the active camera.
This class is responsible of the rendering process, transformation and
projection of the objects in the scene are invoked by the renderer.
def __init__(self):
"""Make the rendering process only for the current scene by default.
- We will work on a copy of the scene, be sure that the current scene do
+ We will work on a copy of the scene, to be sure that the current scene do
not get modified in any way.
"""
outputWriter.open(startFrame, endFrame)
# Do the rendering process frame by frame
- print "Start Rendering!"
- for f in range(startFrame, endFrame+1):
+ print "Start Rendering of %d frames" % (endFrame-startFrame)
+ for f in xrange(startFrame, endFrame+1):
+ print "\n\nFrame: %d" % f
context.currentFrame(f)
# Use some temporary workspace, a full copy of the scene
inputScene = self._SCENE.copy(2)
+ # And Set our camera accordingly
+ self.cameraObj = inputScene.getCurrentCamera()
try:
renderedScene = self.doRenderScene(inputScene)
doPrintEdges = config.edges['SHOW'],
showHiddenEdges = config.edges['SHOW_HIDDEN'])
- # clear the rendered scene
+ # delete the rendered scene
self._SCENE.makeCurrent()
Scene.unlink(renderedScene)
del renderedScene
# global processing of the scene
- self._doConvertGeometricObjToMesh(workScene)
+ self._doSceneClipping(workScene)
- #self._doSceneClipping(workScene)
+ self._doConvertGeometricObjsToMesh(workScene)
if config.output['JOIN_OBJECTS']:
self._joinMeshObjectsInScene(workScene)
# Per object activities
Objects = workScene.getChildren()
- for obj in Objects:
+ print "Total Objects: %d" % len(Objects)
+ for i,obj in enumerate(Objects):
+ print "Rendering Object: %d" % i
-
if obj.getType() != 'Mesh':
print "Only Mesh supported! - Skipping type:", obj.getType()
continue
mesh = obj.getData(mesh=1)
- self._doModelToWorldCoordinates(mesh, obj.matrix)
+ self._doModelingTransformation(mesh, obj.matrix)
self._doBackFaceCulling(mesh)
-
- self._doObjectDepthSorting(mesh)
-
- self._doColorAndLighting(mesh)
- self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
+ self._doLighting(mesh)
+ # Do "projection" now so we perform further processing
+ # in Normalized View Coordinates
self._doProjection(mesh, self.proj)
+
+ self._doViewFrustumClipping(mesh)
+
+ self._doHiddenSurfaceRemoval(mesh)
+
+ self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
+
# Update the object data, important! :)
mesh.update()
"""
return obj.matrix.translationPart()
- def _cameraViewDirection(self):
+ def _cameraViewVector(self):
"""Get the View Direction form the camera matrix.
"""
return Vector(self.cameraObj.matrix[2]).resize3D()
# View Vector in orthographics projections is the view Direction of
# the camera
if self.cameraObj.data.getType() == 1:
- view_vect = self._cameraViewDirection()
+ view_vect = self._cameraViewVector()
# View vector in perspective projections can be considered as
# the difference between the camera position and one point of
vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
view_vect = vv[1]
+
# if d > 0 the face is visible from the camera
d = view_vect * normal
# Scene methods
- def _doConvertGeometricObjToMesh(self, scene):
- """Convert all "geometric" objects to mesh ones.
- """
- geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
-
- Objects = scene.getChildren()
- objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
- for obj in objList:
- old_obj = obj
- obj = self._convertToRawMeshObj(obj)
- scene.link(obj)
- scene.unlink(old_obj)
-
-
- # XXX Workaround for Text and Curve which have some normals
- # inverted when they are converted to Mesh, REMOVE that when
- # blender will fix that!!
- if old_obj.getType() in ['Curve', 'Text']:
- me = obj.getData(mesh=1)
- for f in me.faces: f.sel = 1;
- for v in me.verts: v.sel = 1;
- me.remDoubles(0)
- me.triangleToQuad()
- me.recalcNormals()
- me.update()
-
def _doSceneClipping(self, scene):
- """Clip objects against the View Frustum.
+ """Clip whole objects against the View Frustum.
For now clip away only objects according to their center position.
"""
cpos = self._getObjPosition(self.cameraObj)
- view_vect = self._cameraViewDirection()
+ view_vect = self._cameraViewVector()
near = self.cameraObj.data.clipStart
far = self.cameraObj.data.clipEnd
if (d < near) or (d > far) or (theta > fovy):
scene.unlink(o)
+ def _doConvertGeometricObjsToMesh(self, scene):
+ """Convert all "geometric" objects to mesh ones.
+ """
+ geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+
+ Objects = scene.getChildren()
+ objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
+ for obj in objList:
+ old_obj = obj
+ obj = self._convertToRawMeshObj(obj)
+ scene.link(obj)
+ scene.unlink(old_obj)
+
+
+ # XXX Workaround for Text and Curve which have some normals
+ # inverted when they are converted to Mesh, REMOVE that when
+ # blender will fix that!!
+ if old_obj.getType() in ['Curve', 'Text']:
+ me = obj.getData(mesh=1)
+ for f in me.faces: f.sel = 1;
+ for v in me.verts: v.sel = 1;
+ me.remDoubles(0)
+ me.triangleToQuad()
+ me.recalcNormals()
+ me.update()
+
+
def _doSceneDepthSorting(self, scene):
"""Sort objects in the scene.
"""Merge all the Mesh Objects in a scene into a single Mesh Object.
"""
- if Blender.mode == 'background':
- print "\nWARNING! Joining objects not supported in background mode!\n"
- return
-
oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
# FIXME: Object.join() do not work if the list contains 1 object
try:
bigObj.join(oList)
except RuntimeError:
- print "Can't Join Objects"
+ print "\nWarning! - Can't Join Objects\n"
scene.unlink(bigObj)
return
except TypeError:
scene.update()
- # Per object methods
+ # Per object/mesh methods
def _convertToRawMeshObj(self, object):
"""Convert geometry based object to a mesh object.
return newObject
- def _doModelToWorldCoordinates(self, mesh, matrix):
+ def _doModelingTransformation(self, mesh, matrix):
"""Transform object coordinates to world coordinates.
This step is done simply applying to the object its tranformation
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.
- """
- if len(mesh.faces) == 0:
- return
-
- c = self._getObjPosition(self.cameraObj)
-
- # hackish sorting of faces
-
- # Sort faces according to the max distance from the camera
- by_max_vert_dist = (lambda f1, f2:
- 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 min distance from the camera
- by_min_vert_dist = (lambda f1, f2:
- 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 avg distance from the camera
- by_avg_vert_dist = (lambda f1, f2:
- 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)))
-
-
- # FIXME: using NMesh to sort faces. We should avoid that!
- nmesh = NMesh.GetRaw(mesh.name)
- nmesh.faces.sort(by_max_vert_dist)
- nmesh.faces.reverse()
-
- # Get visible faces
- #vf = nmesh.faces
- #while len(vf)>1:
- # p1 = vf[0]
- # insideList =
-
-
- mesh.faces.delete(1, range(0, len(mesh.faces)))
-
- for i,f in enumerate(nmesh.faces):
- fv = [v.index for v in f.v]
- mesh.faces.extend(fv)
- mesh.faces[i].mat = f.mat
- mesh.faces[i].sel = f.sel
-
-
def _doBackFaceCulling(self, mesh):
"""Simple Backface Culling routine.
if self._isFaceVisible(f):
f.sel = 1
- def _doColorAndLighting(self, mesh):
- """Apply an Illumination ans shading model to the object.
+ def _doLighting(self, mesh):
+ """Apply an Illumination and shading model to the object.
The model used is the Phong one, it may be inefficient,
but I'm just learning about rendering and starting from Phong seemed
mesh.vertexColors = 1
materials = mesh.materials
-
- # TODO: use multiple lighting sources
- light_obj = self.lights[0]
- light_pos = self._getObjPosition(light_obj)
- light = light_obj.data
camPos = self._getObjPosition(self.cameraObj)
-
+
# 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:
mat = None
if materials:
mat = materials[f.mat]
+ # Check if it is a shadeless material
+ if mat.getMode() & Material.Modes['SHADELESS']:
+ I = mat.getRGBCol()
+ # Convert to a value between 0 and 255
+ tmp_col = [ int(c * 255.0) for c in I]
+
+ for c in f.col:
+ c.r = tmp_col[0]
+ c.g = tmp_col[1]
+ c.b = tmp_col[2]
+ #c.a = tmp_col[3]
+
+ continue
+
+
# A new default material
if mat == None:
mat = Material.New('defMat')
+
+ # do vertex color calculation
+
+ TotDiffSpec = Vector([0.0, 0.0, 0.0])
+
+ for l in self.lights:
+ light_obj = l
+ light_pos = self._getObjPosition(l)
+ light = light_obj.data
- L = Vector(light_pos).normalize()
+ L = Vector(light_pos).normalize()
- V = (Vector(camPos) - Vector(f.cent)).normalize()
+ V = (Vector(camPos) - Vector(f.cent)).normalize()
- N = Vector(f.no).normalize()
+ N = Vector(f.no).normalize()
- R = 2 * (N*L) * N - L
+ if config.polygons['SHADING'] == 'TOON':
+ NL = ShadingUtils.toonShading(N*L)
+ else:
+ NL = (N*L)
- # TODO: Attenuation factor (not used for now)
- a0 = 1.0; a1 = 0.0; a2 = 1.0
- d = (Vector(f.v[0].co) - Vector(light_pos)).length
- fd = min(1, 1.0/(a0 + a1*d + a2*(d*d)))
+ # Should we use NL instead of (N*L) here?
+ R = 2 * (N*L) * N - L
- # Ambient component
- Ia = 1.0
- ka = mat.getAmb() * Vector([0.1, 0.1, 0.1])
- Iamb = Ia * ka
-
- # Diffuse component (add light.col for kd)
- kd = mat.getRef() * Vector(mat.getRGBCol())
- Ip = light.getEnergy()
-
- if config.polygons['SHADING'] == 'FLAT':
- Idiff = Ip * kd * (N*L)
- elif config.polygons['SHADING'] == 'TOON':
- Idiff = Ip * kd * MeshUtils.toonShading(N*L)
+ Ip = light.getEnergy()
+
+ # Diffuse co-efficient
+ kd = mat.getRef() * Vector(mat.getRGBCol())
+ for i in [0, 1, 2]:
+ kd[i] *= light.col[i]
+
+ Idiff = Ip * kd * max(0, NL)
+
+
+ # Specular component
+ ks = mat.getSpec() * Vector(mat.getSpecCol())
+ ns = mat.getHardness()
+ Ispec = Ip * ks * pow(max(0, (V*R)), ns)
+
+ TotDiffSpec += (Idiff+Ispec)
- # Specular component
- ks = mat.getSpec() * Vector(mat.getSpecCol())
- ns = mat.getHardness()
- Ispec = Ip * ks * pow((V*R), ns)
- # Emissive component
+ # Ambient component
+ Iamb = Vector(Blender.World.Get()[0].getAmb())
+ ka = mat.getAmb()
+
+ # Emissive component (convert to a triplet)
ki = Vector([mat.getEmit()]*3)
- I = ki + Iamb + (Idiff + Ispec)
+ #I = ki + Iamb + (Idiff + Ispec)
+ I = ki + (ka * Iamb) + TotDiffSpec
# Set Alpha component
c.b = tmp_col[2]
c.a = tmp_col[3]
+ def _doProjection(self, mesh, projector):
+ """Apply Viewing and Projection tranformations.
+ """
+
+ for v in mesh.verts:
+ p = projector.doProjection(v.co[:])
+ v.co[0] = p[0]
+ v.co[1] = p[1]
+ v.co[2] = p[2]
+
+ #mesh.recalcNormals()
+ #mesh.update()
+
+ # We could reeset Camera matrix, since now
+ # we are in Normalized Viewing Coordinates,
+ # but doung that would affect World Coordinate
+ # processing for other objects
+
+ #self.cameraObj.data.type = 1
+ #self.cameraObj.data.scale = 2.0
+ #m = Matrix().identity()
+ #self.cameraObj.setMatrix(m)
+
+ def _doViewFrustumClipping(self, mesh):
+ """Clip faces against the View Frustum.
+ """
+
+ # HSR routines
+ def __simpleDepthSort(self, mesh):
+ """Sort faces by the furthest vertex.
+
+ This simple mesthod is known also as the painter algorithm, and it
+ solves HSR correctly only for convex meshes.
+ """
+
+ global progress
+ # The sorting requires circa n*log(n) steps
+ n = len(mesh.faces)
+ progress.setActivity("HSR: Painter", n*log(n))
+
+
+ by_furthest_z = (lambda f1, f2: progress.update() and
+ cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+ )
+
+ # FIXME: using NMesh to sort faces. We should avoid that!
+ nmesh = NMesh.GetRaw(mesh.name)
+
+ # remember that _higher_ z values mean further points
+ nmesh.faces.sort(by_furthest_z)
+ nmesh.faces.reverse()
+
+ nmesh.update()
+
+ def __topologicalDepthSort(self, mesh):
+ """Occlusion based on topological occlusion.
+
+ Build the occlusion graph of the mesh,
+ and then do topological sort on that graph
+ """
+ return
+
+ def __newellDepthSort(self, mesh):
+ """Newell's depth sorting.
+
+ """
+ by_furthest_z = (lambda f1, f2:
+ cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+ )
+
+ def Distance(point, face):
+ """ Calculate the distance between a point and a face.
+
+ An alternative but more expensive method can be:
+
+ ip = Intersect(Vector(face[0]), Vector(face[1]), Vector(face[2]),
+ Vector(face.no), Vector(point), 0)
+
+ d = Vector(ip - point).length
+ """
+
+ plNormal = Vector(face.no)
+ plVert0 = Vector(face[0])
+
+ #d = abs( (point * plNormal ) - (plVert0 * plNormal) )
+ d = (point * plNormal ) - (plVert0 * plNormal)
+ debug("d: "+ str(d) + "\n")
+
+ return d
+
+
+ # FIXME: using NMesh to sort faces. We should avoid that!
+ nmesh = NMesh.GetRaw(mesh.name)
+
+ # remember that _higher_ z values mean further points
+ nmesh.faces.sort(by_furthest_z)
+ nmesh.faces.reverse()
+
+
+ # Begin depth sort tests
+
+ # use the smooth flag to set marked faces
+ for f in nmesh.faces:
+ f.smooth = 0
+
+ facelist = nmesh.faces[:]
+ maplist = []
+
+ EPS = 10e-7
+
+ global progress
+ progress.setActivity("HSR: Newell", len(facelist))
+
+ while len(facelist):
+ P = facelist[0]
+
+ pSign = 1
+ if P.sel == 0:
+ pSign = -1
+
+ for Q in facelist[1:]:
+
+ debug("P.smooth: " + str(P.smooth) + "\n")
+ debug("Q.smooth: " + str(Q.smooth) + "\n")
+ debug("\n")
+
+ qSign = 1
+ if Q.sel == 0:
+ qSign = -1
+
+ # We need to test only those Qs whose furthest vertex
+ # is closer to the observer than the closest vertex of P.
+
+ zP = [v.co[2] for v in P.v]
+ zQ = [v.co[2] for v in Q.v]
+ ZOverlap = min(zP) < max(zQ)
+
+ if not ZOverlap:
+ if not Q.smooth:
+ # We can safely print P
+ break
+ else:
+ continue
+
+ # Test 1: X extent overlapping
+ xP = [v.co[0] for v in P.v]
+ xQ = [v.co[0] for v in Q.v]
+ notXOverlap = (max(xP) < min(xQ)) or (max(xQ) < min(xP))
+
+ if notXOverlap:
+ continue
+
+ # Test 2: Y extent Overlapping
+ yP = [v.co[1] for v in P.v]
+ yQ = [v.co[1] for v in Q.v]
+ notYOverlap = (max(yP) < min(yQ)) or (max(yQ) < min(yP))
+
+ if notYOverlap:
+ continue
+
+
+ # Test 3: P vertices are all behind the plane of Q
+ n = 0
+ for Pi in P:
+ d = qSign * Distance(Vector(Pi), Q)
+ if d < EPS:
+ n += 1
+ pVerticesBehindPlaneQ = (n == len(P))
+
+ if pVerticesBehindPlaneQ:
+ debug("\nTest 3\n")
+ debug("P BEHIND Q!\n")
+ continue
+
+
+ # Test 4: Q vertices in front of the plane of P
+ n = 0
+ for Qi in Q:
+ d = pSign * Distance(Vector(Qi), P)
+ if d >= EPS:
+ n += 1
+ qVerticesInFrontPlaneP = (n == len(Q))
+
+ if qVerticesInFrontPlaneP:
+ debug("\nTest 4\n")
+ debug("Q IN FRONT OF P!\n")
+ continue
+
+ # Test 5: Line Intersections... TODO
+
+
+ # We do not know if P obscures Q.
+ if Q.smooth == 1:
+ # Split P or Q, TODO
+ debug("Split here!!\n")
+ continue
+
+
+ # The question now is: Does Q obscure P?
+
+ # Test 3bis: Q vertices are all behind the plane of P
+ n = 0
+ for Qi in Q:
+ d = pSign * Distance(Vector(Qi), P)
+ if d < EPS:
+ n += 1
+ qVerticesBehindPlaneP = (n == len(Q))
+
+
+ # Test 4bis: P vertices in front of the plane of Q
+ n = 0
+ for Pi in P:
+ d = qSign * Distance(Vector(Pi), Q)
+ if d >= EPS:
+ n += 1
+ pVerticesInFrontPlaneQ = (n == len(P))
+
+
+ """
+ import intersection
+
+ if not qVerticesBehindPlaneP and not pVerticesInFrontPlaneQ:
+ # Split P or Q, TODO
+ print "Test 3bis or 4bis failed"
+ print "Split here!!2\n"
+
+ newfaces = intersection.splitOn(nmesh, P, Q, 0)
+ facelist.remove(Q)
+ for nf in newfaces:
+ if nf:
+ nf.col = Q.col
+ facelist.append(nf)
+
+ break
+
+ # We do not know
+ if Q.smooth:
+ # split P or Q
+ print "Split here!!\n"
+ newfaces = intersection.splitOn(nmesh, P, Q, 0)
+ facelist.remove(Q)
+ for nf in newfaces:
+ if nf:
+ nf.col = Q.col
+ facelist.append(nf)
+
+ break
+ """
+
+ Q.smooth = 1
+ facelist.remove(Q)
+ facelist.insert(0, Q)
+
+ # Write P!
+ facelist.remove(P)
+ maplist.append(P)
+
+ progress.update()
+
+
+ nmesh.faces = maplist
+
+ for f in nmesh.faces:
+ f.sel = 1
+ nmesh.update()
+
+ def _doHiddenSurfaceRemoval(self, mesh):
+ """Do HSR for the given mesh.
+ """
+ if len(mesh.faces) == 0:
+ return
+
+ if config.polygons['HSR'] == 'PAINTER':
+ print "\n\nUsing the Painter algorithm for HSR.\n"
+ self.__simpleDepthSort(mesh)
+
+ elif config.polygons['HSR'] == 'NEWELL':
+ print "\n\nUsing the Newell's algorithm for HSR.\n"
+ self.__newellDepthSort(mesh)
+
+
def _doEdgesStyle(self, mesh, edgestyleSelect):
"""Process Mesh Edges accroding to a given selection style.
Mesh.Mode(Mesh.SelectModes['EDGE'])
+ edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh)
+
+ for i,edge_faces in enumerate(edge_cache):
+ mesh.edges[i].sel = 0
+ if edgestyleSelect(edge_faces):
+ mesh.edges[i].sel = 1
+
+ """
for e in mesh.edges:
e.sel = 0
if edgestyleSelect(e, mesh):
e.sel = 1
-
- def _doProjection(self, mesh, projector):
- """Calculate the Projection for the object.
"""
- # TODO: maybe using the object.transform() can be faster?
-
- for v in mesh.verts:
- p = projector.doProjection(v.co)
- v.co[0] = p[0]
- v.co[1] = p[1]
- v.co[2] = p[2]
-
+
# ---------------------------------------------------------------------
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(0.0, 0.0, 0.0)
glRasterPos2i(10, 350)
- Draw.Text("VRM: Vector Rendering Method script.")
+ Draw.Text("VRM: Vector Rendering Method script. Version %s." %
+ __version__)
glRasterPos2i(10, 335)
Draw.Text("Press Q or ESC to quit.")
"Render hidden edges as dashed lines")
glRasterPos2i(10, 160)
- Draw.Text("Antonio Ospite (c) 2006")
+ Draw.Text("%s (c) 2006" % __author__)
def event(evt, val):
config.output['FORMAT']= outputWriters.keys()[i]
elif evt == GUI.evtAnimToggle:
- config.outpur['ANIMATION'] = bool(GUI.animToggle.val)
+ config.output['ANIMATION'] = bool(GUI.animToggle.val)
elif evt == GUI.evtJoinObjsToggle:
config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val)
if evt:
Draw.Redraw(1)
- GUI.conf_debug()
+ #GUI.conf_debug()
def conf_debug():
from pprint import pprint
if editmode: Window.EditMode(1)
+# We use a global progress Indicator Object
+progress = None
# Here the main
if __name__ == "__main__":
-
+
+ global progress
+
outputfile = ""
basename = Blender.sys.basename(Blender.Get('filename'))
if basename != "":
outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()
if Blender.mode == 'background':
+ progress = ConsoleProgressIndicator()
vectorize(outputfile)
else:
+ progress = GraphicalProgressIndicator()
Draw.Register(GUI.draw, GUI.event, GUI.button_event)
projects / vrm.git / blobdiff