#!BPY

# coding=utf-8

"""Registration info for Blender menus:

Name: 'LuxBlend v0.6RC5 Exporter'

Blender: 248

Group: 'Render'

Tooltip: 'Export/Render to LuxRender v0.6RC5 scene format (.lxs)'

"""

#

# ***** BEGIN GPL LICENSE BLOCK *****

#

# --------------------------------------------------------------------------

# LuxBlend v0.6RC5 exporter

# --------------------------------------------------------------------------

#

# Authors:

# radiance, zuegs, ideasman42, luxblender, dougal2

#

# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#

# ***** END GPL LICENCE BLOCK *****

# --------------------------------------------------------------------------

######################################################

# Importing modules

######################################################

import math

import time

import os

import sys as osys

import types

import subprocess

import Blender

from Blender import Mesh, Scene, Object, Material, Texture, Window, sys, Draw, BGL, Mathutils, Lamp, Image

######################################################

# Functions

######################################################

# New name based on old with a different extension

def newFName(ext):

    return Blender.Get('filename')[: -len(Blender.Get('filename').split('.', -1)[-1]) ] + ext

# some helpers

def luxstr(str):

    return str.replace("\\", "\\\\")

### relpath ##########################

def relpath(base, target):

    if target[0:2] == "\\\\" or target[0:2] == "//":

        return target[2:len(target)]

    if not os.path.isabs(base):

        base = os.path.abspath(base)

    if not os.path.isabs(target):

        target = os.path.abspath(target)

    if os.sep == "\\":

        base = os.path.normcase(base)

        target = os.path.normcase(target)

    if base == os.sep:

        return '.' + target

    baselist = base.split(os.sep)

    if baselist[-1] == "":

        baselist = baselist[:-1]

    targetlist = target.split(os.sep)

    i = 0

    top = min([len(baselist), len(targetlist)])

    while i < top and baselist[i] == targetlist[i]:

        i+=1

    if i == 0:

        return os.sep.join(targetlist)

    if i == len(baselist):

        return os.sep.join(targetlist[i:])

    else:

        return ('..' + os.sep) * (len(baselist) - i) + os.sep.join(targetlist[i:])

### luxFilePath #####################

lxs_filename = ""

previewing = False

def luxFilePath(filename):

    global lxs_filename, previewing

    scn = Scene.GetCurrent()

    pm = luxProp(scn, "pathmode", "absolute").get()

    if (pm=="absolute") or previewing: # absolute paths (the old / default mode)

        return filename

    elif pm=="relative": # relative paths

        base = os.path.dirname(lxs_filename)

        return relpath(base, filename)

    elif pm=="flat": # flat mode - only filename

        return os.path.basename(filename)

###### RGC ##########################

def rg(col):

    scn = Scene.GetCurrent()

    if luxProp(scn, "RGC", "true").get()=="true":

        gamma = luxProp(scn, "film.gamma", 2.2).get()

    else:

        gamma = 1.0

    ncol = col**gamma

    if luxProp(scn, "colorclamp", "false").get()=="true":

        ncol = ncol * 0.9

        if ncol > 0.9:

            ncol = 0.9

        if ncol < 0.0:

            ncol = 0.0

    return ncol

def texturegamma():

    scn = Scene.GetCurrent()

    if luxProp(scn, "RGC", "true").get()=="true":

        return luxProp(scn, "film.gamma", 2.2).get()

    else:

        return 1.0

def exportMaterial(mat):

    str = "# Material '%s'\n" %mat.name

    return str+luxMaterial(mat)+"\n"

def exportMaterialGeomTag(mat):

    return "%s\n"%(luxProp(mat, "link", "").get())

################################################################

dummyMat = 2394723948 # random identifier for dummy material

clayMat = None

#-------------------------------------------------

# getMaterials(obj)

# helper function to get the material list of an object in respect of obj.colbits

#-------------------------------------------------

def getMaterials(obj, compress=False):

    global clayMat

    mats = [None]*16

    colbits = obj.colbits

    objMats = obj.getMaterials(1)

    data = obj.getData(mesh=1)

    try:

        dataMats = data.materials

    except:

        try:

            dataMats = data.getMaterials(1)

        except:

            dataMats = []

            colbits = 0xffff

    m = max(len(objMats), len(dataMats))

    if m>0:

        objMats.extend([None]*16)

        dataMats.extend([None]*16)

        for i in range(m):

            if (colbits & (1<<i) > 0):

                mats[i] = objMats[i]

            else:

                mats[i] = dataMats[i]

        if compress:

            mats = [m for m in mats if m]

    else:

        print "Warning: object %s has no material assigned"%(obj.getName())

        mats = []

    # clay option

    if luxProp(Scene.GetCurrent(), "clay", "false").get()=="true":

        if clayMat==None: clayMat = Material.New("lux_clayMat")

        for i in range(len(mats)):

            if mats[i]:

                mattype = luxProp(mats[i], "type", "").get()

                if (mattype not in ["portal","light","boundvolume"]): mats[i] = clayMat

    return mats

######################################################

# luxExport class

######################################################

class luxExport:

    #-------------------------------------------------

    # __init__

    # initializes the exporter object

    #-------------------------------------------------

    def __init__(self, scene):

        self.scene = scene

        self.camera = scene.objects.camera

        self.objects = []

        self.portals = []

        self.volumes = []

        self.meshes = {}

        self.materials = []

        self.lights = []

        self.duplis = set()

    #-------------------------------------------------

    # analyseObject(self, obj, matrix, name)

    # called by analyseScene to build the lists before export

    #-------------------------------------------------

    def analyseObject(self, obj, matrix, name, isOriginal=True, isDupli=False):

        light = False

        if (obj.users > 0):

            obj_type = obj.getType()

            if (obj.enableDupFrames and isOriginal):

                for o, m in obj.DupObjects:

                    self.analyseObject(o, m, "%s.%s"%(name, o.getName()), False)    

            if (obj.enableDupGroup or obj.enableDupVerts or obj.enableDupFaces):

                self.duplis.add(obj)

                for o, m in obj.DupObjects:

                    self.analyseObject(o, m, "%s.%s"%(name, o.getName()), True, True)    

            elif ((isDupli or (not obj.getParent() in self.duplis)) and ((obj_type == "Mesh") or (obj_type == "Surf") or (obj_type == "Curve") or (obj_type == "Text"))):

                mats = getMaterials(obj)

                if (len(mats)>0) and (mats[0]!=None) and ((mats[0].name=="PORTAL") or (luxProp(mats[0], "type", "").get()=="portal")):

                    self.portals.append([obj, matrix])

                elif (len(mats)>0) and (luxProp(mats[0], "type", "").get()=="boundvolume"):

                    self.volumes.append([obj, matrix])

                else:

                    for mat in mats:

                        if (mat!=None) and (mat not in self.materials):

                            self.materials.append(mat)

                        if (mat!=None) and ((luxProp(mat, "type", "").get()=="light") or (luxProp(mat, "emission", "false").get()=="true")):

                            light = True

                    mesh_name = obj.getData(name_only=True)

                    try:

                        self.meshes[mesh_name] += [obj]

                    except KeyError:

                        self.meshes[mesh_name] = [obj]                

                    self.objects.append([obj, matrix])

            elif (obj_type == "Lamp"):

                ltype = obj.getData(mesh=1).getType() # data

                if (ltype == Lamp.Types["Lamp"]) or (ltype == Lamp.Types["Spot"]) or (ltype == Lamp.Types["Area"]):

                    self.lights.append([obj, matrix])

                    light = True

        return light

    #-------------------------------------------------

    # analyseScene(self)

    # this function builds the lists of object, lights, meshes and materials before export

    #-------------------------------------------------

    def analyseScene(self):

        light = False

        for obj in self.scene.objects:

            if ((obj.Layers & self.scene.Layers) > 0):

                if self.analyseObject(obj, obj.getMatrix(), obj.getName()): light = True

        return light

    #-------------------------------------------------

    # exportMaterialLink(self, file, mat)

    # exports material link. LuxRender "Material" 

    #-------------------------------------------------

    def exportMaterialLink(self, file, mat):

        if mat == dummyMat:

            file.write("\tMaterial \"matte\" # dummy material\n")

        else:

            file.write("\t%s"%exportMaterialGeomTag(mat)) # use original methode

    #-------------------------------------------------

    # exportMaterial(self, file, mat)

    # exports material. LuxRender "Texture" 

    #-------------------------------------------------

    def exportMaterial(self, file, mat):

        print "material %s"%(mat.getName())

        file.write("\t%s"%exportMaterial(mat)) # use original methode        

    #-------------------------------------------------

    # exportMaterials(self, file)

    # exports materials to the file

    #-------------------------------------------------

    def exportMaterials(self, file):

        for mat in self.materials:

            self.exportMaterial(file, mat)

    #-------------------------------------------------

    # getMeshType(self, vertcount, mat)

    # returns type of mesh as string to use depending on thresholds

    #-------------------------------------------------

    def getMeshType(self, vertcount, mat):

        scn = Scene.GetCurrent()

        if mat != dummyMat:

            usesubdiv = luxProp(mat, "subdiv", "false")

            usedisp = luxProp(mat, "dispmap", "false")

            sharpbound = luxProp(mat, "sharpbound", "false")

            nsmooth = luxProp(mat, "nsmooth", "true")

            sdoffset = luxProp(mat, "sdoffset", 0.0)

            dstr = ""

            if usesubdiv.get() == "true":

                nlevels = luxProp(mat, "sublevels", 1)

                dstr += "\"loopsubdiv\" \"integer nlevels\" [%i] \"bool dmnormalsmooth\" [\"%s\"] \"bool dmsharpboundary\" [\"%s\"]"% (nlevels.get(), nsmooth.get(), sharpbound.get())

            if usedisp.get() == "true":

                dstr += " \"string displacementmap\" [\"%s::dispmap.scale\"] \"float dmscale\" [-1.0] \"float dmoffset\" [%f]"%(mat.getName(), sdoffset.get()) # scale is scaled in texture

            if dstr != "": return dstr

        return "\"trianglemesh\""

    #-------------------------------------------------

    # exportMesh(self, file, mesh, mats, name, portal)

    # exports mesh to the file without any optimization

    #-------------------------------------------------

    def exportMesh(self, file, mesh, mats, name, portal=False):

        if mats == []:

            mats = [dummyMat]

        for matIndex in range(len(mats)):

            if (mats[matIndex] != None):

                mesh_str = getMeshType(len(mesh.verts), mats[matIndex])

                if (portal):

                    file.write("\tShape %s \"integer indices\" [\n"% mesh_str)

                else:

                    self.exportMaterialLink(file, mats[matIndex])

                    file.write("\tPortalShape %s \"integer indices\" [\n"% mesh_str)

                index = 0

                ffaces = [f for f in mesh.faces if f.mat == matIndex]

                for face in ffaces:

                    file.write("%d %d %d\n"%(index, index+1, index+2))

                    if (len(face)==4):

                        file.write("%d %d %d\n"%(index, index+2, index+3))

                    index += len(face.verts)

                file.write("\t] \"point P\" [\n");

                for face in ffaces:

                    for vertex in face:

                        file.write("%f %f %f\n"% tuple(vertex.co))

                file.write("\t] \"normal N\" [\n")

                for face in ffaces:

                    normal = face.no

                    for vertex in face:

                        if (face.smooth):

                            normal = vertex.no

                        file.write("%f %f %f\n"% tuple(normal))

                if (mesh.faceUV):

                    file.write("\t] \"float uv\" [\n")

                    for face in ffaces:

                        for uv in face.uv:

                            file.write("%f %f\n"% tuple(uv))

                file.write("\t]\n")

    #-------------------------------------------------

    # exportMeshOpt(self, file, mesh, mats, name, portal, optNormals)

    # exports mesh to the file with optimization.

    # portal: export without normals and UVs

    # optNormals: speed and filesize optimization, flat faces get exported without normals

    #-------------------------------------------------

    def exportMeshOpt(self, file, mesh, mats, name, portal=False, optNormals=True):

        shapeList, smoothFltr, shapeText = [0], [[0,1]], [""]

        if portal:

            normalFltr, uvFltr, shapeText = [0], [0], ["portal"] # portal, no normals, no UVs

        else:

            uvFltr, normalFltr, shapeText = [1], [1], ["mixed with normals"] # normals and UVs

            if optNormals: # one pass for flat faces without normals and another pass for smoothed faces with normals, all with UVs

                shapeList, smoothFltr, normalFltr, uvFltr, shapeText = [0,1], [[0],[1]], [0,1], [1,1], ["flat w/o normals", "smoothed with normals"]

        if mats == []:

            mats = [dummyMat]

        for matIndex in range(len(mats)):

            if (mats[matIndex] != None):

                if not(portal):

                    self.exportMaterialLink(file, mats[matIndex])

                for shape in shapeList:

                    blenderExportVertexMap = []

                    exportVerts = []

                    exportFaces = []

                    ffaces = [f for f in mesh.faces if (f.mat == matIndex) and (f.smooth in smoothFltr[shape])]

                    for face in ffaces:

                        exportVIndices = []

                        index = 0

                        for vertex in face:

#                            v = [vertex.co[0], vertex.co[1], vertex.co[2]]

                            v = [vertex.co]

                            if normalFltr[shape]:

                                if (face.smooth):

#                                    v.extend(vertex.no)

                                    v.append(vertex.no)

                                else:

#                                    v.extend(face.no)

                                    v.append(face.no)

                            if (uvFltr[shape]) and (mesh.faceUV):

#                                v.extend(face.uv[index])

                                v.append(face.uv[index])

                            blenderVIndex = vertex.index

                            newExportVIndex = -1

                            length = len(v)

                            if (blenderVIndex < len(blenderExportVertexMap)):

                                for exportVIndex in blenderExportVertexMap[blenderVIndex]:

                                    v2 = exportVerts[exportVIndex]

                                    if (length==len(v2)) and (v == v2):

                                        newExportVIndex = exportVIndex

                                        break

                            if (newExportVIndex < 0):

                                newExportVIndex = len(exportVerts)

                                exportVerts.append(v)

                                while blenderVIndex >= len(blenderExportVertexMap):

                                    blenderExportVertexMap.append([])

                                blenderExportVertexMap[blenderVIndex].append(newExportVIndex)

                            exportVIndices.append(newExportVIndex)

                            index += 1

                        exportFaces.append(exportVIndices)

                    if (len(exportVerts)>0):

                        mesh_str = self.getMeshType(len(exportVerts), mats[matIndex])

                        if (portal):

                            file.write("\tPortalShape %s \"integer indices\" [\n"% mesh_str)

                        else:

                            file.write("\tShape %s \"integer indices\" [\n"% mesh_str)

                        for face in exportFaces:

                            file.write("%d %d %d\n"%(face[0], face[1], face[2]))

                            if (len(face)==4):

                                file.write("%d %d %d\n"%(face[0], face[2], face[3]))

                        file.write("\t] \"point P\" [\n");

#                        for vertex in exportVerts:

#                            file.write("%f %f %f\n"%(vertex[0], vertex[1], vertex[2]))

                        file.write("".join(["%f %f %f\n"%tuple(vertex[0]) for vertex in exportVerts]))

                        if normalFltr[shape]:

                            file.write("\t] \"normal N\" [\n")

#                            for vertex in exportVerts:

#                                file.write("%f %f %f\n"%(vertex[3], vertex[4], vertex[5]))

                            file.write("".join(["%f %f %f\n"%tuple(vertex[1]) for vertex in exportVerts])) 

                            if (uvFltr[shape]) and (mesh.faceUV):

                                file.write("\t] \"float uv\" [\n")

#                                for vertex in exportVerts:

#                                    file.write("%f %f\n"%(vertex[6], vertex[7]))

                                file.write("".join(["%f %f\n"%tuple(vertex[2]) for vertex in exportVerts])) 

                        else:            

                            if (uvFltr[shape]) and (mesh.faceUV):

                                file.write("\t] \"float uv\" [\n")

#                                for vertex in exportVerts:

#                                    file.write("%f %f\n"%(vertex[3], vertex[4]))

                                file.write("".join(["%f %f\n"%tuple(vertex[1]) for vertex in exportVerts])) 

                        file.write("\t]\n")

                        print "  shape(%s): %d vertices, %d faces"%(shapeText[shape], len(exportVerts), len(exportFaces))

    #-------------------------------------------------

    # exportMeshes(self, file)

    # exports meshes that uses instancing (meshes that are used by at least "instancing_threshold" objects)

    #-------------------------------------------------

    def exportMeshes(self, file):

        scn = Scene.GetCurrent()

        instancing_threshold = luxProp(scn, "instancing_threshold", 2).get()

        mesh_optimizing = luxProp(scn, "mesh_optimizing", True).get()

        mesh = Mesh.New('')

        for (mesh_name, objs) in self.meshes.items():

            allow_instancing = True

            mats = getMaterials(objs[0]) # mats = obj.getData().getMaterials()

            for mat in mats: # don't instance if one of the materials is emissive

                if (mat!=None) and (luxProp(mat, "type", "").get()=="light"):

                    allow_instancing = False

            for obj in objs: # don't instance if the objects with same mesh uses different materials

                ms = getMaterials(obj)

                if ms <> mats:

                    allow_instancing = False

            if obj.modifiers.__len__() > 0:

                allow_instancing = False

            if allow_instancing and (len(objs) > instancing_threshold):

                del self.meshes[mesh_name]

                mesh.getFromObject(objs[0], 0, 1)

                print "blender-mesh: %s (%d vertices, %d faces)"%(mesh_name, len(mesh.verts), len(mesh.faces))

                file.write("ObjectBegin \"%s\"\n"%mesh_name)

                if (mesh_optimizing):

                    self.exportMeshOpt(file, mesh, mats, mesh_name)

                else:

                    self.exportMesh(file, mesh, mats, mesh_name)

                file.write("ObjectEnd # %s\n\n"%mesh_name)

        mesh.verts = None

    #-------------------------------------------------

    # exportObjects(self, file)

    # exports objects to the file

    #-------------------------------------------------

    def exportObjects(self, file):

        scn = Scene.GetCurrent()

        cam = scn.getCurrentCamera().data

        objectmblur = luxProp(cam, "objectmblur", "true")

        usemblur = luxProp(cam, "usemblur", "false")

        mesh_optimizing = luxProp(scn, "mesh_optimizing", True).get()

        mesh = Mesh.New('')

        for [obj, matrix] in self.objects:

            print "object: %s"%(obj.getName())

            mesh_name = obj.getData(name_only=True)

            motion = None

            if(objectmblur.get() == "true" and usemblur.get() == "true"):

                # motion blur

                frame = Blender.Get('curframe')

                Blender.Set('curframe', frame+1)

                m1 = 1.0*matrix # multiply by 1.0 to get a copy of orignal matrix (will be frame-independant) 

                Blender.Set('curframe', frame)

                if m1 != matrix:

                    print "  motion blur"

                    motion = m1

            if motion: # motion-blur only works with instances, so ensure mesh is exported as instance first

                if mesh_name in self.meshes:

                    del self.meshes[mesh_name]

                    mesh.getFromObject(obj, 0, 1)

                    mats = getMaterials(obj)

                    print "  blender-mesh: %s (%d vertices, %d faces)"%(mesh_name, len(mesh.verts), len(mesh.faces))

                    file.write("ObjectBegin \"%s\"\n"%mesh_name)

                    if (mesh_optimizing):

                        self.exportMeshOpt(file, mesh, mats, mesh_name)

                    else:

                        self.exportMesh(file, mesh, mats, mesh_name)

                    file.write("ObjectEnd # %s\n\n"%mesh_name)

            file.write("AttributeBegin # %s\n"%obj.getName())

            file.write("\tTransform [%s %s %s %s  %s %s %s %s  %s %s %s %s  %s %s %s %s]\n"\

                %(matrix[0][0], matrix[0][1], matrix[0][2], matrix[0][3],\

                  matrix[1][0], matrix[1][1], matrix[1][2], matrix[1][3],\

                  matrix[2][0], matrix[2][1], matrix[2][2], matrix[2][3],\

                    matrix[3][0], matrix[3][1], matrix[3][2], matrix[3][3]))

            if motion:

                file.write("\tTransformBegin\n")

                file.write("\t\tIdentity\n")

                file.write("\t\tTransform [%s %s %s %s  %s %s %s %s  %s %s %s %s  %s %s %s %s]\n"\

                    %(motion[0][0], motion[0][1], motion[0][2], motion[0][3],\

                      motion[1][0], motion[1][1], motion[1][2], motion[1][3],\