871131ee490a89b537ea87f6bf7e15fa1f2cec91
[vrm.git] / vrm.py
1 #!BPY
2 """
3 Name: 'VRM'
4 Blender: 241
5 Group: 'Export'
6 Tooltip: 'Vector Rendering Method Export Script 0.3'
7 """
8
9 # ---------------------------------------------------------------------
10 #    Copyright (c) 2006 Antonio Ospite
11 #
12 #    This program is free software; you can redistribute it and/or modify
13 #    it under the terms of the GNU General Public License as published by
14 #    the Free Software Foundation; either version 2 of the License, or
15 #    (at your option) any later version.
16 #
17 #    This program is distributed in the hope that it will be useful,
18 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
19 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 #    GNU General Public License for more details.
21 #
22 #    You should have received a copy of the GNU General Public License
23 #    along with this program; if not, write to the Free Software
24 #    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
25 #
26 # ---------------------------------------------------------------------
27 #
28 #    NOTE: I do not know who is the original author of 'vrm'.
29 #    The present code is almost entirely rewritten from scratch,
30 #    but if I have to give credits to anyone, please let me know,
31 #    so I can update the copyright.
32 #
33 # ---------------------------------------------------------------------
34 #
35 # Additional credits:
36 #   Thanks to Emilio Aguirre for S2flender from which I took inspirations :)
37 #   Thanks to Anthony C. D'Agostino for the backface.py script   
38 #
39 # ---------------------------------------------------------------------
40
41 import Blender
42 from Blender import Scene, Object, NMesh, Lamp, Camera
43 from Blender.Mathutils import *
44 from math import *
45
46
47 # ---------------------------------------------------------------------
48 #
49 ## Projections classes
50 #
51 # ---------------------------------------------------------------------
52
53 class Projector:
54     """Calculate the projection of an object given the camera.
55     
56     A projector is useful to so some per-object transformation to obtain the
57     projection of an object given the camera.
58     
59     The main method is #doProjection# see the method description for the
60     parameter list.
61     """
62
63     def __init__(self, cameraObj, obMesh, canvasSize):
64         """Calculate the projection matrix.
65
66         The projection matrix depends, in this case, on the camera settings,
67         and also on object transformation matrix.
68         """
69
70         self.size = canvasSize
71
72         camera = cameraObj.getData()
73
74         aspect = float(canvasSize[0])/float(canvasSize[1])
75         near = camera.clipStart
76         far = camera.clipEnd
77
78         fovy = atan(0.5/aspect/(camera.lens/32))
79         fovy = fovy * 360/pi
80         
81         # What projection do we want?
82         if camera.type:
83             m2 = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale) 
84         else:
85             m2 = self._calcPerspectiveMatrix(fovy, aspect, near, far) 
86         
87         m1 = Matrix()
88         mP = Matrix()
89
90         # View transformation
91         cam = cameraObj.getInverseMatrix()
92         cam.transpose() 
93
94         m1 = obMesh.getMatrix()
95         m1.transpose()
96         
97         mP = cam * m1
98         mP = m2  * mP
99
100         self.projectionMatrix = mP
101
102     ##
103     # Public methods
104     #
105
106     def doProjection(self, v):
107         """Project the point on the view plane.
108
109         Given a vertex calculate the projection using the current projection
110         matrix.
111         """
112         
113         # Note that we need the vertex expressed using homogeneous coordinates
114         p = self.projectionMatrix * Vector([v[0], v[1], v[2], 1.0])
115         
116         mW = self.size[0]/2
117         mH = self.size[1]/2
118         
119         if p[3]<=0:
120             p[0] = int(p[0]*mW)+mW
121             p[1] = int(p[1]*mH)+mH
122         else:
123             p[0] = int((p[0]/p[3])*mW)+mW
124             p[1] = int((p[1]/p[3])*mH)+mH
125             
126         # For now we want (0,0) in the top-left corner of the canvas
127         # Mirror and translate along y
128         p[1] *= -1
129         p[1] += self.size[1]
130     
131         return p
132
133     ##
134     # Private methods
135     #
136     
137     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
138         """Return a perspective projection matrix."""
139         
140         top = near * tan(fovy * pi / 360.0)
141         bottom = -top
142         left = bottom*aspect
143         right= top*aspect
144         x = (2.0 * near) / (right-left)
145         y = (2.0 * near) / (top-bottom)
146         a = (right+left) / (right-left)
147         b = (top+bottom) / (top - bottom)
148         c = - ((far+near) / (far-near))
149         d = - ((2*far*near)/(far-near))
150         
151         m = Matrix(
152                 [x,   0.0,    a,    0.0],
153                 [0.0,   y,    b,    0.0],
154                 [0.0, 0.0,    c,      d],
155                 [0.0, 0.0, -1.0,    0.0])
156
157         return m
158
159     def _calcOrthoMatrix(self, fovy, aspect , near, far, scale):
160         """Return an orthogonal projection matrix."""
161         
162         top = near * tan(fovy * pi / 360.0) * (scale * 10)
163         bottom = -top 
164         left = bottom * aspect
165         right= top * aspect
166         rl = right-left
167         tb = top-bottom
168         fn = near-far 
169         tx = -((right+left)/rl)
170         ty = -((top+bottom)/tb)
171         tz = ((far+near)/fn)
172
173         m = Matrix(
174                 [2.0/rl, 0.0,    0.0,     tx],
175                 [0.0,    2.0/tb, 0.0,     ty],
176                 [0.0,    0.0,    2.0/fn,  tz],
177                 [0.0,    0.0,    0.0,    1.0])
178         
179         return m
180
181
182 # ---------------------------------------------------------------------
183 #
184 ## Mesh representation class
185 #
186 # ---------------------------------------------------------------------
187
188 # TODO: a class to represent the needed properties of a 2D vector image
189 # Just use a NMesh structure?
190
191
192 # ---------------------------------------------------------------------
193 #
194 ## Vector Drawing Classes
195 #
196 # ---------------------------------------------------------------------
197
198 ## A generic Writer
199
200 class VectorWriter:
201     """
202     A class for printing output in a vectorial format.
203
204     Given a 2D representation of the 3D scene the class is responsible to
205     write it is a vector format.
206
207     Every subclasses of VectorWriter must have at last the following public
208     methods:
209         - printCanvas(mesh) --- where mesh is as specified before.
210     """
211     
212     def __init__(self, fileName, canvasSize):
213         """Open the file named #fileName# and set the canvas size."""
214         
215         self.file = open(fileName, "w")
216         print "Outputting to: ", fileName
217
218         self.canvasSize = canvasSize
219     
220
221     ##
222     # Public Methods
223     #
224     
225     def printCanvas(mesh):
226         return
227         
228     ##
229     # Private Methods
230     #
231     
232     def _printHeader():
233         return
234
235     def _printFooter():
236         return
237
238
239 ## SVG Writer
240
241 class SVGVectorWriter(VectorWriter):
242     """A concrete class for writing SVG output.
243
244     The class does not support animations, yet.
245     Sorry.
246     """
247
248     def __init__(self, file, canvasSize):
249         """Simply call the parent Contructor."""
250         VectorWriter.__init__(self, file, canvasSize)
251
252
253     ##
254     # Public Methods
255     #
256     
257     def printCanvas(self, scene):
258         """Convert the scene representation to SVG."""
259
260         self._printHeader()
261         
262         for obj in scene:
263             self.file.write("<g>\n")
264             
265             for face in obj.faces:
266                 self._printPolygon(face)
267
268             self.file.write("</g>\n")
269         
270         self._printFooter()
271     
272     ##  
273     # Private Methods
274     #
275     
276     def _printHeader(self):
277         """Print SVG header."""
278
279         self.file.write("<?xml version=\"1.0\"?>\n")
280         self.file.write("<svg version=\"1.2\"\n")
281         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
282         self.file.write("\twidth=\"%d\" height=\"%d\" streamable=\"true\">\n\n" %
283                 self.canvasSize)
284
285     def _printFooter(self):
286         """Print the SVG footer."""
287
288         self.file.write("\n</svg>\n")
289         self.file.close()
290
291     def _printPolygon(self, face):
292         """Print our primitive, finally.
293
294         There is no color Handling for now, *FIX!*
295         """
296
297         stroke_width=1
298         
299         self.file.write("<polygon points=\"")
300
301         i = 0
302         for v in face:
303             if i != 0:
304                 self.file.write(", ")
305
306             i+=1
307             
308             self.file.write("%g, %g" % (v[0], v[1]))
309         
310         color = [ int(c*255) for c in face.col]
311
312         self.file.write("\"\n")
313         self.file.write("\tstyle=\"fill:rgb("+str(color[0])+","+str(color[1])+","+str(color[2])+");")
314         self.file.write(" stroke:rgb(0,0,0);")
315         self.file.write(" stroke-width:"+str(stroke_width)+";\n")
316         self.file.write(" stroke-linecap:round;stroke-linejoin:round\"/>\n")
317
318
319 # ---------------------------------------------------------------------
320 #
321 ## Rendering Classes
322 #
323 # ---------------------------------------------------------------------
324
325 def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ):
326     
327     NewPoint = []
328     # Rotate X
329     NewY = (PY * cos(AngleX))-(PZ * sin(AngleX))
330     NewZ = (PZ * cos(AngleX))+(PY * sin(AngleX))
331     # Rotate Y
332     PZ = NewZ
333     PY = NewY
334     NewZ = (PZ * cos(AngleY))-(PX * sin(AngleY))
335     NewX = (PX * cos(AngleY))+(PZ * sin(AngleY))
336     PX = NewX
337     PZ = NewZ
338     # Rotate Z
339     NewX = (PX * cos(AngleZ))-(PY * sin(AngleZ))
340     NewY = (PY * cos(AngleZ))+(PX * sin(AngleZ))
341     NewPoint.append(NewX)
342     NewPoint.append(NewY)
343     NewPoint.append(NewZ)
344     return NewPoint
345
346 class Renderer:
347     """Render a scene viewed from a given camera.
348     
349     This class is responsible of the rendering process, hence transormation
350     and projection of the ojects in the scene are invoked by the renderer.
351
352     The user can optionally provide a specific camera for the rendering, see
353     the #doRendering# method for more informations.
354     """
355
356     def __init__(self):
357         """Set the canvas size to a defaulr value.
358         
359         The only instance attribute here is the canvas size, which can be
360         queryed to the renderer by other entities.
361         """
362         self.canvasSize = (0.0, 0.0)
363
364
365     ##
366     # Public Methods
367     #
368
369     def getCanvasSize(self):
370         """Return the current canvas size read from Blender rendering context"""
371         return self.canvasSize
372         
373     def doRendering(self, scene, cameraObj=None):
374         """Control the rendering process.
375         
376         Here we control the entire rendering process invoking the operation
377         needed to transforma project the 3D scene in two dimensions.
378
379         Parameters:
380         scene --- the Blender Scene to render
381         cameraObj --- the camera object to use for the viewing processing
382         """
383
384         if cameraObj == None:
385             cameraObj = scene.getCurrentCamera()
386         
387         context = scene.getRenderingContext()
388         self.canvasSize = (context.imageSizeX(), context.imageSizeY())
389         
390         Objects = scene.getChildren()
391         
392         # A structure to store the transformed scene
393         newscene = []
394         
395         for obj in Objects:
396             
397             if (obj.getType() != "Mesh"):
398                 print "Type:", obj.getType(), "\tSorry, only mesh Object supported!"
399                 continue
400
401             # Get a projector for this object
402             proj = Projector(cameraObj, obj, self.canvasSize)
403
404             # Let's store the transformed data
405             transformed_mesh = NMesh.New(obj.name)
406
407             # Store the materials
408             materials = obj.getData().getMaterials()
409
410             meshfaces = obj.getData().faces
411
412             for face in meshfaces:
413
414                 # if the face is visible flatten it on the "picture plane"
415                 if self._isFaceVisible(face, obj, cameraObj):
416                     
417                     # Store transformed face
418                     transformed_face = []
419
420                     for vert in face:
421
422                         p = proj.doProjection(vert.co)
423
424                         transformed_vert = NMesh.Vert(p[0], p[1], p[2])
425                         transformed_face.append(transformed_vert)
426
427                     newface = NMesh.Face(transformed_face)
428                     
429                     # Per-face color calculation
430                     # code taken mostly from the original vrm script
431                     # TODO: understand the code and rewrite it clearly
432                     ambient = -250
433                     fakelight = [10, 10, 15]
434                     norm = face.normal
435                     vektori = (norm[0]*fakelight[0]+norm[1]*fakelight[1]+norm[2]*fakelight[2])
436                     vduzine = fabs(sqrt(pow(norm[0],2)+pow(norm[1],2)+pow(norm[2],2))*sqrt(pow(fakelight[0],2)+pow(fakelight[1],2)+pow(fakelight[2],2)))
437                     intensity = floor(ambient + 200*acos(vektori/vduzine))/200
438                     if intensity < 0:
439                         intensity = 0
440
441                     if materials:
442                         newface.col = materials[face.mat].getRGBCol()
443                     else:
444                         newface.col = [0.5, 0.5, 0.5]
445                         
446                     newface.col = [ (c>0) and (c-intensity) for c in newface.col]
447                     
448                     transformed_mesh.addFace(newface)
449
450             # at the end of the loop on obj
451             
452             #transformed_object = NMesh.PutRaw(transformed_mesh)
453             newscene.append(transformed_mesh)
454
455         # reverse the order (TODO: See how is the object order in NMesh)
456         #newscene.reverse()
457         
458         return newscene
459
460
461     ##
462     # Private Methods
463     #
464
465     def _isFaceVisible(self, face, obj, cameraObj):
466         """Determine if the face is visible from the current camera.
467
468         The following code is taken basicly from the original vrm script.
469         """
470
471         camera = cameraObj
472
473         numvert = len(face)
474
475         # backface culling
476
477         # translate and rotate according to the object matrix
478         # and then translate according to the camera position
479         #m = obj.getMatrix()
480         #m.transpose()
481         
482         #a = m*Vector(face[0]) - Vector(cameraObj.loc)
483         #b = m*Vector(face[1]) - Vector(cameraObj.loc)
484         #c = m*Vector(face[numvert-1]) - Vector(cameraObj.loc)
485         
486         a = []
487         a.append(face[0][0])
488         a.append(face[0][1])
489         a.append(face[0][2])
490         a = RotatePoint(a[0], a[1], a[2], obj.RotX, obj.RotY, obj.RotZ)
491         a[0] += obj.LocX - camera.LocX
492         a[1] += obj.LocY - camera.LocY
493         a[2] += obj.LocZ - camera.LocZ
494         b = []
495         b.append(face[1][0])
496         b.append(face[1][1])
497         b.append(face[1][2])
498         b = RotatePoint(b[0], b[1], b[2], obj.RotX, obj.RotY, obj.RotZ)
499         b[0] += obj.LocX - camera.LocX
500         b[1] += obj.LocY - camera.LocY
501         b[2] += obj.LocZ - camera.LocZ
502         c = []
503         c.append(face[numvert-1][0])
504         c.append(face[numvert-1][1])
505         c.append(face[numvert-1][2])
506         c = RotatePoint(c[0], c[1], c[2], obj.RotX, obj.RotY, obj.RotZ)
507         c[0] += obj.LocX - camera.LocX
508         c[1] += obj.LocY - camera.LocY
509         c[2] += obj.LocZ - camera.LocZ
510
511         norm = Vector([0,0,0])
512         norm[0] = (b[1] - a[1])*(c[2] - a[2]) - (c[1] - a[1])*(b[2] - a[2])
513         norm[1] = -((b[0] - a[0])*(c[2] - a[2]) - (c[0] - a[0])*(b[2] - a[2]))
514         norm[2] = (b[0] - a[0])*(c[1] - a[1]) - (c[0] - a[0])*(b[1] - a[1])
515
516         d = norm[0]*a[0] + norm[1]*a[1] + norm[2]*a[2]
517         # d = DotVecs(norm, Vector(a))
518
519         return (d<0)
520
521     def _doClipping(face):
522         return
523
524
525 # ---------------------------------------------------------------------
526 #
527 ## Main Program
528 #
529 # ---------------------------------------------------------------------
530
531
532 # hackish sorting of faces according to the max z value of a vertex
533 def zSorting(scene):
534     for o in scene:
535         o.faces.sort(lambda f1, f2:
536                 # Sort faces according to the min z coordinate in a face
537                 #cmp(min([v[2] for v in f1]), min([v[2] for v in f2])))
538
539                 # Sort faces according to the max z coordinate in a face
540                 cmp(max([v[2] for v in f1]), max([v[2] for v in f2])))
541                 
542                 # Sort faces according to the avg z coordinate in a face
543                 #cmp(sum([v[2] for v in f1])/len(f1), sum([v[2] for v in f2])/len(f2)))
544         o.faces.reverse()
545     
546 from Blender import sys
547 def vectorize(filename):
548
549     print "Filename: %s" % filename
550     print
551     filename = filename.replace('/', sys.sep)
552     print filename
553     print
554     
555     scene   = Scene.GetCurrent()
556     renderer = Renderer()
557
558     flatScene = renderer.doRendering(scene)
559     canvasSize = renderer.getCanvasSize()
560
561     zSorting(flatScene)
562
563     writer = SVGVectorWriter(filename, canvasSize)
564     writer.printCanvas(flatScene)
565     
566 try:
567     Blender.Window.FileSelector (vectorize, 'Save SVG', "proba.svg")
568 except:
569     vectorize("proba.svg")
570