X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/2bfb6873ab89019125b7e6602eac6ca8fef7940c..3761107280d20fdc779f71b8a60358c3639a074f:/vrm.py?ds=inline diff --git a/vrm.py b/vrm.py index bbff105..bd61a58 100755 --- a/vrm.py +++ b/vrm.py @@ -1,25 +1,133 @@ #!BPY - """ Name: 'VRM' -Blender: 237 +Blender: 241 Group: 'Export' -Tooltip: 'Vector Rendering Method Export Script' +Tooltip: 'Vector Rendering Method Export Script 0.3' """ +# --------------------------------------------------------------------- +# Copyright (c) 2006 Antonio Ospite +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +# +# --------------------------------------------------------------------- +# +# NOTE: I do not know who is the original author of 'vrm'. +# The present code is almost entirely rewritten from scratch, +# but if I have to give credits to anyone, please let me know, +# so I can update the copyright. +# +# --------------------------------------------------------------------- +# +# Additional credits: +# Thanks to Emilio Aguirre for S2flender from which I took inspirations :) +# Thanks to Anthony C. D'Agostino for the backface.py script +# +# --------------------------------------------------------------------- import Blender -from Blender import Scene, Object, Lamp, Camera +from Blender import Scene, Object, NMesh, Lamp, Camera +from Blender.Mathutils import * from math import * -from Blender.Window import * -from Blender.Scene import Render - -def init(): - print "Init\n" - renderDir = context.getRenderPath() +# --------------------------------------------------------------------- +# +## Projections classes +# +# --------------------------------------------------------------------- + +class Projection: + def __init__(self): + print "New projection" + +class PerspectiveProjection(Projection): + def __init___(self): + Projection.__init__(self) + print "Perspective" + + def doProjection(): + print "do a perspective projection!!" + +def Perspective(fovy, aspect, near, far): + top = near * tan(fovy * pi / 360.0) + bottom = -top + left = bottom*aspect + right= top*aspect + x = (2.0 * near) / (right-left) + y = (2.0 * near) / (top-bottom) + a = (right+left) / (right-left) + b = (top+bottom) / (top - bottom) + c = - ((far+near) / (far-near)) + d = - ((2*far*near)/(far-near)) + return Matrix([x,0.0,a,0.0],[0.0,y,b,0.0],[0.0,0.0,c,d],[0.0,0.0,-1.0,0.0]) + +def flatten_new(v, cameraObj, canvasSize, obMesh): + + cam = cameraObj.getInverseMatrix() + cam.transpose() + + # Changing the view mode + cmra = cameraObj.getData() + + #if cmra.type: + # print "Ortho" + #m2 = Ortho(fovy,float(w*ax)/float(h*ay),cmra.clipStart, cmra.clipEnd,17) #cmra.scale) + #else: + # print "Perspective" + + #Create Frustum + #frustum = _Frustum(cam,m2) + + m1 = Matrix() + mP = Matrix() + + fovy = atan(0.5/(float(canvasSize[0])/float(canvasSize[1]))/(cmra.lens/32)) + fovy = fovy * 360/pi + + m2 = Perspective(fovy,float(canvasSize[0])/float(canvasSize[1]),cmra.clipStart, cmra.clipEnd) + + m1 = obMesh.matrixWorld #mat + m1.transpose() + mP = cam * m1 + mP = m2 * mP + + #Transform the vertices to global coordinates + p = mP*Vector([v.co[0],v.co[1],v.co[2],1.0]) + #tf.append(p) + #p = m1*Vector([v.co[0],v.co[1],v.co[2],1.0]) + #t2.append([p[0],p[1],p[2]]) + + mW = canvasSize[0]/2 + mH = canvasSize[1]/2 + + if p[3]<=0: + p[0] = int(p[0]*mW)+mW + p[1] = int(p[1]*mH)+mH + else: + p[0] = int((p[0]/p[3])*mW)+mW + p[1] = int((p[1]/p[3])*mH)+mH + + # Mirror and translate along y + p[1] *= -1 + p[1] += canvasSize[1] + return p + + # distance from camera Z' def Distance(PX,PY,PZ): @@ -27,10 +135,6 @@ def Distance(PX,PY,PZ): dist = sqrt(PX*PX+PY*PY+PZ*PZ) return dist -def Dodaj(x,y,z): - - print "" - def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ): NewPoint = [] @@ -52,199 +156,346 @@ def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ): NewPoint.append(NewZ) return NewPoint -def flatern(vertx, verty, vertz): - - cam = Camera.get() # Get the cameras in scene - Lens = cam[0].getLens() # The First Blender camera lens +def flatten(vertx, verty, vertz, cameraObj, canvasSize): - camTyp = cam[0].getType() + camera = cameraObj.getData() + Lens = camera.getLens() # The Camera lens - msize = (context.imageSizeX(), context.imageSizeY()) - xres = msize[0] # X res for output - yres = msize[1] # Y res for output + xres = canvasSize[0] # X res for output + yres = canvasSize[1] # Y res for output ratio = xres/yres - screenxy=[0,0] + fov = atan(ratio * 16.0 / Lens) # Get fov stuff + + dist = xres/2*tan(fov) # Calculate dist from pinhole camera to image plane + + screenxy=[0,0,vertz] x=-vertx y=verty z=vertz - fov = atan(ratio * 16.0 / Lens) # Get fov stuff - dist = xres/2*tan(fov) # Calculate dist from pinhole camera to image plane -#---------------------------- -# calculate x'=dist*x/z & y'=dist*x/z -#---------------------------- - screenxy[0]=int(xres/2+4*x*dist/z) - screenxy[1]=int(yres/2+4*y*dist/z) + #---------------------------- + # calculate x'=dist*x/z & y'=dist*x/z + #---------------------------- + screenxy[0]=int(xres/2.0+4*x*dist/z) + screenxy[1]=int(yres/2.0+4*y*dist/z) return screenxy -def writesvg(ob): +## Backface culling routine +# + +def isFaceVisible(face, obj, cameraObj): + """ + Determine if the face is visible from the current camera. + """ + numvert = len(face) + # backface culling + a = [] + a.append(face[0][0]) + a.append(face[0][1]) + a.append(face[0][2]) + a = RotatePoint(a[0], a[1], a[2], obj.RotX, obj.RotY, obj.RotZ) + a[0] += obj.LocX - cameraObj.LocX + a[1] += obj.LocY - cameraObj.LocY + a[2] += obj.LocZ - cameraObj.LocZ + b = [] + b.append(face[1][0]) + b.append(face[1][1]) + b.append(face[1][2]) + b = RotatePoint(b[0], b[1], b[2], obj.RotX, obj.RotY, obj.RotZ) + b[0] += obj.LocX - cameraObj.LocX + b[1] += obj.LocY - cameraObj.LocY + b[2] += obj.LocZ - cameraObj.LocZ + c = [] + c.append(face[numvert-1][0]) + c.append(face[numvert-1][1]) + c.append(face[numvert-1][2]) + c = RotatePoint(c[0], c[1], c[2], obj.RotX, obj.RotY, obj.RotZ) + c[0] += obj.LocX - cameraObj.LocX + c[1] += obj.LocY - cameraObj.LocY + c[2] += obj.LocZ - cameraObj.LocZ + + norm = [0,0,0] + norm[0] = (b[1] - a[1])*(c[2] - a[2]) - (c[1] - a[1])*(b[2] - a[2]) + norm[1] = -((b[0] - a[0])*(c[2] - a[2]) - (c[0] - a[0])*(b[2] - a[2])) + norm[2] = (b[0] - a[0])*(c[1] - a[1]) - (c[0] - a[0])*(b[1] - a[1]) + + d = norm[0]*a[0] + norm[1]*a[1] + norm[2]*a[2] + return (d<0) + + +# --------------------------------------------------------------------- +# +## Mesh representation class +# +# --------------------------------------------------------------------- + +# TODO: a class to represent the needed properties of a 2D vector image + + +# --------------------------------------------------------------------- +# +## Vector Drawing Classes +# +# --------------------------------------------------------------------- + +## A generic Writer + +class VectorWriter: + """ + A class for printing output in a vectorial format. + + Given a 2D representation of the 3D scene the class is responsible to + write it is a vector format. + + Every subclasses of VectorWriter must have at last the following public + methods: + - printCanvas(mesh) --- where mesh is as specified before. + """ + + def __init__(self, fileName, canvasSize): + """Open the file named #fileName# and set the canvas size.""" + + self.file = open(fileName, "w") + print "Outputting to: ", fileName + + self.canvasSize = canvasSize + + + # Public Methods + # + + def printCanvas(mesh): + return + + + # Private Methods + # + + def _printHeader(): + return - for i in range(0, ob[0]+1): - print ob[i], "\n" - print "WriteSVG\n" + def _printFooter(): + return -######## -# Main # -######## -scena = Scene.GetCurrent() -context = scena.getRenderingContext() +## SVG Writer -#print dir(context) +class SVGVectorWriter(VectorWriter): + """A concrete class for writing SVG output. -init() + The class does not support animations, yet. + Sorry. + """ -tacka = [0,0,0] -lice = [3,tacka,tacka,tacka,tacka] + def __init__(self, file, canvasSize): + """Simply call the parent Contructor.""" + VectorWriter.__init__(self, file, canvasSize) -msize = (context.imageSizeX(), context.imageSizeY()) -print msize -file=open("proba.svg","w") + # Public Methods + # + + def printCanvas(self, mesh): + """Convert the mesh representation to SVG.""" -file.write("\n") -#file.write("\n") + self._printHeader() + + for obj in mesh: + for face in obj: + self._printPolygon(face) + + self._printFooter() + + + # Private Methods + # + + def _printHeader(self): + """Print SVG header.""" -Objects = Blender.Object.Get() -NUMobjects = len(Objects) + self.file.write("\n") + self.file.write("\n\n" % + self.canvasSize) -startFrm = context.startFrame() -endFrm = startFrm -#endFrm = context.endFrame() -camera = scena.getCurrentCamera() # Get the current camera + def _printFooter(self): + """Print the SVG footer.""" -for f in range(startFrm, endFrm+1): - #scena.currentFrame(f) - Blender.Set('curframe', f) + self.file.write("\n\n") + self.file.close() - DrawProgressBar (f/(endFrm+1-startFrm),"Rendering ..." + str(context.currentFrame())) + def _printPolygon(self, face): + """Print our primitive, finally. - print "Frame: ", f, "\n" - if startFrm <> endFrm: file.write("\n") - for o in range(NUMobjects): + There is no color Handling for now, *FIX!* + """ - if Objects[o].getType() == "Mesh": + intensity = 128 + stroke_width=1 + + self.file.write("\n") - OBJmesh = obj.getData() # Get the mesh data for the object - numfaces=len(OBJmesh.faces) # The number of faces in the object - numEachVert=len(OBJmesh.faces[0]) # The number of verts in each face - #------------ - # Get the Material Colors - #------------ -# MATinfo = OBJmesh.getMaterials() -# -# if len(MATinfo) > 0: -# RGB=MATinfo[0].rgbCol -# R=int(RGB[0]*255) -# G=int(RGB[1]*255) -# B=int(RGB[2]*255) -# color=`R`+"."+`G`+"."+`B` -# print color -# else: -# color="100.100.100" +# --------------------------------------------------------------------- +# +## Rendering Classes +# +# --------------------------------------------------------------------- - objekat = [] +class Renderer: + """Render a scene viewed from a given camera. + + This class is responsible of the rendering process, hence transormation + and projection of the ojects in the scene are invoked by the renderer. - objekat.append(0) + The user can optionally provide a specific camera for the rendering, see + the #doRendering# method for more informations. + """ - for face in range(numfaces): - numvert = len(OBJmesh.faces[face]) - objekat.append(numvert) - objekat[0] += 1 + def __init__(self): + """Set the canvas size to a defaulr value. -# backface cutting - a = [] - a.append(OBJmesh.faces[face][0][0]) - a.append(OBJmesh.faces[face][0][1]) - a.append(OBJmesh.faces[face][0][2]) - a = RotatePoint(a[0], a[1], a[2], obj.RotX, obj.RotY, obj.RotZ) - a[0] += obj.LocX - camera.LocX - a[1] += obj.LocY - camera.LocY - a[2] += obj.LocZ - camera.LocZ - b = [] - b.append(OBJmesh.faces[face][1][0]) - b.append(OBJmesh.faces[face][1][1]) - b.append(OBJmesh.faces[face][1][2]) - b = RotatePoint(b[0], b[1], b[2], obj.RotX, obj.RotY, obj.RotZ) - b[0] += obj.LocX - camera.LocX - b[1] += obj.LocY - camera.LocY - b[2] += obj.LocZ - camera.LocZ - c = [] - c.append(OBJmesh.faces[face][numvert-1][0]) - c.append(OBJmesh.faces[face][numvert-1][1]) - c.append(OBJmesh.faces[face][numvert-1][2]) - c = RotatePoint(c[0], c[1], c[2], obj.RotX, obj.RotY, obj.RotZ) - c[0] += obj.LocX - camera.LocX - c[1] += obj.LocY - camera.LocY - c[2] += obj.LocZ - camera.LocZ - - norm = [0,0,0] - norm[0] = (b[1] - a[1])*(c[2] - a[2]) - (c[1] - a[1])*(b[2] - a[2]) - norm[1] = -((b[0] - a[0])*(c[2] - a[2]) - (c[0] - a[0])*(b[2] - a[2])) - norm[2] = (b[0] - a[0])*(c[1] - a[1]) - (c[0] - a[0])*(b[1] - a[1]) - - d = norm[0]*a[0] + norm[1]*a[1] + norm[2]*a[2] - - if d < 0: - file.write("\n") - if startFrm <> endFrm: - file.write("\n") - file.write("\n") - file.write("\n") - -#flatern() -#writesvg(objekat) -file.write("") -file.close() -print file -DrawProgressBar (1.0,"Finished.") -print "Finished\n" + The only instance attribute here is the canvas size, which can be + queryed to the renderer by other entities. + """ + self.canvasSize = (0.0, 0.0) + + + # Public Methods + # + + def getCanvasSize(self): + """Return the current canvas size read from Blender rendering context""" + return self.canvasSize + + def doRendering(self, scene, cameraObj=None): + """Control the rendering process. + + Here we control the entire rendering process invoking the operation + needed to transforma project the 3D scene in two dimensions. + + Parameters: + scene --- the Blender Scene to render + cameraObj --- the camera object to use for the viewing processing + """ + + if cameraObj == None: + cameraObj = scene.getCurrentCamera() + + # TODO: given the camera get the Wold-to-camera transform and the + # projection matrix + + context = scene.getRenderingContext() + self.canvasSize = (context.imageSizeX(), context.imageSizeY()) + + Objects = scene.getChildren() + + # A mesh to store the transformed geometrical structure + mesh = [] + + for obj in Objects: + + if (obj.getType() != "Mesh"): + print "Type:", obj.getType(), "\tSorry, only mesh Object supported!" + continue + + OBJmesh = obj.getData() # Get the mesh data for the object + meshfaces = OBJmesh.faces # The number of faces in the object + + transformed_object = [] + + for face in meshfaces: + + # TODO: per face color calculation + # TODO: add/sorting in Z' direction (per face??) + + # if the face is visible flatten it on the "picture plane" + if isFaceVisible(face, obj, cameraObj): + + # Store transformed face + transformed_face = [] + + for vert in face: + + vertxyz = list(vert) + + p1 = flatten_new(vert, cameraObj, self.canvasSize, + obj) + transformed_face.append(p1) + continue + + # rotate camera + vertxyz = RotatePoint(vertxyz[0], vertxyz[1], vertxyz[2], + cameraObj.RotX, cameraObj.RotY, cameraObj.RotZ) + #-cameraObj.RotX, -cameraObj.RotY, -cameraObj.RotZ) + + + # original setting for translate + vertxyz[0] -= (obj.LocX - cameraObj.LocX) + vertxyz[1] -= (obj.LocY - cameraObj.LocY) + vertxyz[2] -= (obj.LocZ - cameraObj.LocZ) + + + # rotate object + vertxyz = RotatePoint(vertxyz[0], vertxyz[1], vertxyz[2], obj.RotX, obj.RotY, obj.RotZ) + + + + p1 = flatten(vertxyz[0], vertxyz[1], vertxyz[2], + cameraObj, self.canvasSize) + + transformed_face.append(p1) + + # just some fake lighting... + + transformed_object.append(transformed_face) + + # at the end of the loop on obj + mesh.append(transformed_object) + return mesh + + + # Private Methods + # + + def _removehiddenFaces(obj): + return + + def _testClipping(face): + return + + +# --------------------------------------------------------------------- +# +## Main Program +# +# --------------------------------------------------------------------- + + +scene = Scene.GetCurrent() +renderer = Renderer() + +projectedMesh = renderer.doRendering(scene) +canvasSize = renderer.getCanvasSize() + +# hackish sorting of faces according to the max z value of a vertex +for o in projectedMesh: + o.sort(lambda f1, f2: + cmp(sum([v[2] for v in f1])/len(f1), sum([v[2] for v in f2])/len(f2))) + o.reverse() + +writer = SVGVectorWriter("proba.svg", canvasSize) +writer.printCanvas(projectedMesh)