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

                       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

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

     geom_pfilename = filebase + "-geom.lxo"

     mat_filename = os.path.join(filepath, filebase + "-mat.lxm")

     mat_pfilename = filebase + "-mat.lxm"

     vol_filename = os.path.join(filepath, filebase + "-vol.lxv")

     vol_pfilename = filebase + "-vol.lxv"

     ### Zuegs: initialization for export class

     export = luxExport(Blender.Scene.GetCurrent())

     # check if a light is present

     envtype = luxProp(scn, "env.type", "infinite").get()

     if envtype == "sunsky":

         sun = None

         for obj in scn.objects:

             if (obj.getType() == "Lamp") and ((obj.Layers & scn.Layers) > 0):

                 if obj.getData(mesh=1).getType() == 1: # sun object # data

                     sun = obj

     if not(export.analyseScene()) and not(envtype == "infinite") and not((envtype == "sunsky") and (sun != None)):