#!BPY

"""
Name: 'VRM'
Blender: 237
Group: 'Export'
Tooltip: 'Vector Rendering Method Export Script'
"""

import Blender
from Blender import Scene, Object, Lamp, Camera
from math import *
from Blender.Window import *
from Blender.Scene import Render


# distance from camera Z'
def Distance(PX,PY,PZ):
    
    dist = sqrt(PX*PX+PY*PY+PZ*PZ)
    return dist

def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ):
    
    NewPoint = []
    # Rotate X
    NewY = (PY * cos(AngleX))-(PZ * sin(AngleX))
    NewZ = (PZ * cos(AngleX))+(PY * sin(AngleX))
    # Rotate Y
    PZ = NewZ
    PY = NewY
    NewZ = (PZ * cos(AngleY))-(PX * sin(AngleY))
    NewX = (PX * cos(AngleY))+(PZ * sin(AngleY))
    PX = NewX
    PZ = NewZ
    # Rotate Z
    NewX = (PX * cos(AngleZ))-(PY * sin(AngleZ))
    NewY = (PY * cos(AngleZ))+(PX * sin(AngleZ))
    NewPoint.append(NewX)
    NewPoint.append(NewY)
    NewPoint.append(NewZ)
    return NewPoint

def vetmatmult(v, M):
    
    v2 = [0, 0, 0, 0]
    
    for i in range(0, 3):
        for j in range(0, 3):
            v2[i] += (v[i]*M[i][j])

    return v2

def flatern(vertx, verty, vertz):

    cam = Camera.get()            # Get the cameras in scene
    Lens = cam[0].getLens()       # The First Blender camera lens

    camTyp = cam[0].getType()

    msize = (context.imageSizeX(), context.imageSizeY())
    xres = msize[0]             # X res for output
    yres = msize[1]                # Y res for output
    ratio = xres/yres

    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]
    x=-vertx
    y=verty
    z=vertz

    #----------------------------        
    # 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


########
# Main #
########

scena = Scene.GetCurrent()
context = scena.getRenderingContext()
renderDir = context.getRenderPath()

msize = (context.imageSizeX(), context.imageSizeY())

file=open("proba.svg","w")

file.write("<?xml version=\"1.0\"?>\n")
file.write("<svg width=\"" + `msize[0]` + "\" height=\"" + `msize[1]` + "\"\n")
file.write("\txmlns=\"http://www.w3.org/2000/svg\" version=\"1.2\" streamable=\"true\">\n")
#file.write("<pageSet>\n")

Objects = Blender.Object.Get()
NUMobjects = len(Objects)

startFrm = context.startFrame()
endFrm = startFrm
#endFrm = context.endFrame()
frames = range(startFrm, endFrm+1)

# are we rendering an animation ?
animation = (len(frames) > 1)

camera = scena.getCurrentCamera() # Get the current camera

for f in frames:
    context.currentFrame(f)
    Blender.Set('curframe', f)

    DrawProgressBar (f/len(frames),"Rendering ..." + str(f))

    print "Frame: ", f, "\n"
    if animation :
        file.write("<g id=\"Frame" + str(f) + "\" style=\"visibility:hidden\">\n")

    for o in Objects:

        if o.getType() == "Mesh":

            obj = o                  # Get the first selected object
            objname = obj.name                # The object name


            OBJmesh = obj.getData()           # Get the mesh data for the object
            meshfaces = OBJmesh.faces        # The number of faces in the object

            #------------
            # 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"


            for face in range(0, len(meshfaces)):
                numvert = len(OBJmesh.faces[face])
                
                #if (isVisible(face)):
                #    print "face visible"

                # backface culling
                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 the face is visible flatten it on the "picture plane"
                if d < 0:
                    file.write("<polygon points=\"")
                    for vert in range(numvert):

                        vertxyz = []

                        if vert != 0: file.write(", ")

                        vertxyz.append(OBJmesh.faces[face][vert][0])
                        vertxyz.append(OBJmesh.faces[face][vert][1])
                        vertxyz.append(OBJmesh.faces[face][vert][2])

                        # rotate object
                        vertxyz = RotatePoint(vertxyz[0], vertxyz[1], vertxyz[2], obj.RotX, obj.RotY, obj.RotZ)

                        # original setting for translate
                        vertxyz[0] += (obj.LocX - camera.LocX)
                        vertxyz[1] += (obj.LocY - camera.LocY)
                        vertxyz[2] += (obj.LocZ - camera.LocZ)

                        # rotate camera
                        vertxyz = RotatePoint(vertxyz[0], vertxyz[1], vertxyz[2], -camera.RotX, -camera.RotY, -camera.RotZ)

                        #dist = Distance(vertxyz[0], vertxyz[1], vertxyz[2])
                        xy = flatern(vertxyz[0], vertxyz[1], vertxyz[2])
                        px = int(xy[0])
                        py = int(xy[1])
                        # add/sorting in Z' direction
                        #Dodaj(px,py,Distance(vertxyz[0], vertxyz[1], vertxyz[2]))
                        file.write(`px` + ", " + `py`)

                    # per face color calculation
                    ambient = -200
                    #svetlo = [1, 1, -1] #original
                    svetlo = [1, 1, -0.3]
                    vektori = (norm[0]*svetlo[0]+norm[1]*svetlo[1]+norm[2]*svetlo[2])
                    vduzine = fabs(sqrt(pow(norm[0],2)+pow(norm[1],2)+pow(norm[2],2))*sqrt(pow(svetlo[0],2)+pow(svetlo[1],2)+pow(svetlo[2],2)))
                    intensity = floor(ambient + 255 * acos(vektori/vduzine))
                    if intensity < 0:
                        intensity = 0
                    
                    wireframe = True
                    if wireframe:
                        stroke_width=1
                    else: 
                        stroke_width=0
                    file.write("\"\n style=\"fill:rgb("+str(intensity)+","+str(intensity)+","+str(intensity)+");stroke:rgb(0,0,0);stroke-width:"+str(stroke_width)+"\"/>\n")
    if animation:
        file.write("<animate attributeName=\"visibility\" begin=\""+str(f*0.08)+"s\" dur=\"0.08s\" fill=\"remove\" to=\"visible\">\n")
        file.write("</animate>\n")
        file.write("</g>\n")

file.write("</svg>")
file.close()
DrawProgressBar (1.0,"Finished.")
print "Finished\n"