#!BPY

 # -*- coding: utf-8 -*-

 # coding=utf-8

 """Registration info for Blender menus:

 Name: 'LuxBlend v0.6 Exporter'

 Blender: 248

 Group: 'Render'

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

 """

 __author__ = "radiance, zuegs, ideasman42, luxblender, dougal2"

 __version__ = "0.6"

 __url__ = [

 	"http://www.luxrender.net/",

 	"http://www.luxrender.net/forum/viewforum.php?f=11",

 	"http://www.luxrender.net/wiki/index.php/Tutorial_1:_Your_first_scene_%26_render"

 ]

 __bpydoc__ = """\

 LuxRender is an open-source rendering system for physically correct, unbiased image synthesis.

 This is the Luxrender Blender Export Script.

 Useful links:

 - For updates: http://www.luxrender.net/forum/viewforum.php?f=11

 - For Blender Tutorial: http://www.luxrender.net/wiki/index.php/Tutorial_1:_Your_first_scene_%26_render

 Usage: 

 - Run the script from the render menu.

 - Set the default location of the Luxrender.exe.

 Please check the lux tutorials & forums for more information.

 """

 #

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

 #

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

 # LuxBlend v0.6 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]

     slots = [m for m in mats if m]

     if m==0 or not slots:

         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]

         usedmats = [f.mat for f in mesh.faces]

         for matIndex in range(len(mats)):

             if not matIndex in usedmats:

                 continue

             if not(portal):

                 mat = mats[matIndex]

                 if not mat:

                    mat = dummyMat

                 self.exportMaterialLink(file, mat)

             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],\

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

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

                 file.write("\t\tCoordinateSystem \"%s\"\n"%(obj.getName()+"_motion"))

                 file.write("\tTransformEnd\n")

             if mesh_name in self.meshes:

                 mesh.getFromObject(obj, 0, 1)

                 mats = getMaterials(obj)

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

                 if (mesh_optimizing):

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

                 else:

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

             else:

                 print("  instance %s"%(mesh_name))

                 if motion:

                     file.write("\tMotionInstance \"%s\" 0.0 1.0 \"%s\"\n"%(mesh_name, obj.getName()+"_motion"))

                 else:

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

             file.write("AttributeEnd\n\n")

         mesh.verts = None

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

     # exportPortals(self, file)

     # exports portals objects to the file

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

     def exportPortals(self, file):

         scn = Scene.GetCurrent()

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

         mesh = Mesh.New('')

         for [obj, matrix] in self.portals:

             print("portal: %s"%(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]))

             mesh_name = obj.getData(name_only=True)

             mesh.getFromObject(obj, 0, 1)

             mats = getMaterials(obj) # mats = obj.getData().getMaterials()

             if (mesh_optimizing):

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

             else:

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

         mesh.verts = None

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

     # exportLights(self, file)

     # exports lights to the file

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

     def exportLights(self, file):

         for [obj, matrix] in self.lights:

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

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

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

                 if ltype == Lamp.Types["Area"]:

                     (str, link) = luxLight("", "", obj, None, 0)

                     file.write(str)

                 if ltype == Lamp.Types["Area"]: file.write("AttributeBegin # %s\n"%obj.getName())

                 else: file.write("TransformBegin # %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]))

                 col = obj.getData(mesh=1).col # data

                 energy = obj.getData(mesh=1).energy # data

                 if ltype == Lamp.Types["Lamp"]:

                     lightgroup = luxProp(obj, "light.lightgroup", "default")

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

                         file.write("LightGroup \"%s\"\n"%lightgroup.get())

                     (str, link) = luxLamp("", "", obj, None, 0)

                     file.write(str+"LightSource \"point\""+link+"\n")

                 if ltype == Lamp.Types["Spot"]:

                     (str, link) = luxSpot("", "", obj, None, 0)

                     file.write(str)

                     proj = luxProp(obj, "light.usetexproj", "false")

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

                         lightgroup = luxProp(obj, "light.lightgroup", "default")

                         file.write("LightGroup \"%s\"\n"%lightgroup.get())

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

                         file.write("Rotate 180 0 1 0\n")

                         file.write("LightSource \"projection\" \"float fov\" [%f]"%(obj.getData(mesh=1).spotSize))

                     else:

                         file.write("LightSource \"spot\" \"point from\" [0 0 0] \"point to\" [0 0 -1] \"float coneangle\" [%f] \"float conedeltaangle\" [%f]"\

                             %(obj.getData(mesh=1).spotSize*0.5, obj.getData(mesh=1).spotSize*0.5*obj.getData(mesh=1).spotBlend)) # data

                     file.write(link+"\n")

                 if ltype == Lamp.Types["Area"]:

                     lightgroup = luxProp(obj, "light.lightgroup", "default")

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

                         file.write("LightGroup \"%s\"\n"%lightgroup.get())

                     file.write("\tAreaLightSource \"area\"")

                     file.write(link)

 #                    file.write(luxLight("", "", obj, None, 0))

                     file.write("\n")

                     areax = obj.getData(mesh=1).getAreaSizeX()

                     # lamps "getAreaShape()" not implemented yet - so we can't detect shape! Using square as default

                     # todo: ideasman42

                     if (True): areay = areax

                     else: areay = obj.getData(mesh=1).getAreaSizeY()

                     file.write('\tShape "trianglemesh" "integer indices" [0 1 2 0 2 3] "point P" [-%(x)f %(y)f 0.0 %(x)f %(y)f 0.0 %(x)f -%(y)f 0.0 -%(x)f -%(y)f 0.0]\n'%{"x":areax/2, "y":areay/2})

                 if ltype == Lamp.Types["Area"]: file.write("AttributeEnd # %s\n"%obj.getName())

                 else: file.write("TransformEnd # %s\n"%obj.getName())

                 file.write("\n")

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

     # exportVolumes(self, file)

     # exports volumes to the file

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

     def exportVolumes(self, file):

         for [obj, matrix] in self.volumes:

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

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

             # trickery to obtain objectspace boundingbox AABB

             mat = obj.matrixWorld.copy().invert()

             bb = [vec * mat for vec in obj.getBoundBox()]

             minx = miny = minz = 100000000000000.0

             maxx = maxy = maxz = -100000000000000.0

             for vec in bb:

                 if (vec[0] < minx): minx = vec[0]

                 if (vec[1] < miny): miny = vec[1]

                 if (vec[2] < minz): minz = vec[2]

                 if (vec[0] > maxx): maxx = vec[0]

                 if (vec[1] > maxy): maxy = vec[1]

                 if (vec[2] > maxz): maxz = vec[2]

             file.write("Transform [%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]))

             str_opt = (" \"point p0\" [%f %f %f] \"point p1\" [%f %f %f]"%(minx, miny, minz, maxx, maxy, maxz))

             mats = getMaterials(obj)

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

                 mat = mats[0]

                 (str, link) = luxMaterialBlock("", "", "", mat, None, 0, str_opt)

                 file.write("%s"%link)

                 file.write("\n\n")

 # Note - radiance - this is a work in progress

 def luxFlashBlock(camObj):

     str = ""

     str += "CoordSysTransform \"camera\"\n"

     str += "Texture \"camflashtex\" \"color\" \"blackbody\" \"float temperature\" [5500.0]"

     str += "AreaLightSource \"area\" \"texture L\" [\"camflashtex\"] \"float power\" [100.000000] \"float efficacy\" [17.000000] \"float gain\" [1.000000]\n"

     up = 10.0

     str += "Shape \"trianglemesh\" \"integer indices\" [ 0 1 2 0 2 3 ] \"point P\" [ 0.014 0.012 0.0   0.006 0.012 0.0   0.006 0.008 0.0   0.014 0.008 0.0 ]\n"

     return str

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

 # EXPORT

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

 def save_lux(filename, unindexedname):

     export_total_steps = 12.0

     global meshlist, matnames, lxs_filename, geom_filename, geom_pfilename, mat_filename, mat_pfilename, vol_filename, vol_pfilename, LuxIsGUI

     global render_status_text

     global render_status

     render_status_text = 'Exporting...'

     render_status = True

     print("Lux Render Export started...\n")

     time1 = Blender.sys.time()

     scn = Scene.GetCurrent()

     filepath = os.path.dirname(filename)

     filebase = os.path.splitext(os.path.basename(filename))[0]

     lxs_filename = filename

     geom_filename = os.path.join(filepath, filebase + "-geom.lxo")