#!BPY

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

 # coding=utf-8

 """Registration info for Blender menus:

 Name: 'LuxBlend v0.7 Exporter'

 Blender: 248

 Group: 'Render'

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

 """

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

 __version__ = "0.7"

 __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.7 exporter

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

 #

 # Authors:

 # radiance, zuegs, ideasman42, luxblender, dougal2, SATtva

 #

 # 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, Modifier, Texture, Window, sys, Draw, BGL, Mathutils, Lamp, Image, Particle, Curve

 # critical export function profiling

 if False:

     import hotshot, hotshot.stats 

     def profileit(printlines=1):

         def _my(func):

             def _func(*args, **kargs):

                 prof = hotshot.Profile("profiling.data")

                 res = prof.runcall(func, *args, **kargs)

                 prof.close()

                 stats = hotshot.stats.load("profiling.data")

                 stats.strip_dirs()

                 stats.sort_stats('time', 'calls')

                 print ">>>---- Begin profiling print for %s" % func.__name__

                 stats.print_stats(printlines)

                 print ">>>---- End profiling print"

                 return res

             return _func

         return _my

 else:

     def profileit(arg=None):

         def _my(func):

             return func

         return _my

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

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

 # generate and attach a permanent UID to the scene if there isn't any

 def luxGenUID(scn):

     global luxUID

     guid = luxProp(scn, 'UID', '')

     g = guid.get()

     if (not Blender.Get('filename') and not luxUID) or not g:

         print 'Lux scene UID is missing. Generating a new one...'

         try:

             import hashlib

             h = hashlib.sha1

         except ImportError:

             try:

                 import sha

                 h = sha.new

             except ImportError:

                 h = hash

         try:

             r = os.urandom(20)

         except NotImplementedError:

             import random

             r = str(random.getrandbits(160))

         g = h(str(sys.time())+'|'+r)

         try: g = g.hexdigest()

         except: g = hex(g)[2:]

         print 'Generated UID:', g, "\n"

         guid.set(g)

     return g

 def bitmask(n, max=20):

     bits = []

     for i in range(max-1, -1, -1):

         v = pow(2, i)

         if n < v:

             continue

         else:

             n = n - v

             bits.insert(0, i+1)

     return bits

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

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

     if not obj.type in ['Mesh', 'Curve', 'Surf', 'Text', 'MBall']:

     	return []

     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:

             try:

                 dataMats = Curve.Get(obj.getData().getName()).getMaterials()

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

             resetMatTex(clayMat)

             # resetting clay material to diffuse 0.6

             luxProp(clayMat, 'type', '').set('matte')

             luxProp(clayMat, ':Kd', '').set(' '.join([str(rg(0.6))]*3))

         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

         if not mats and clayMat is not None: mats.append(clayMat)

     return mats

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

 # getModifiers(obj)

 # returns modifiers stack and modifiers settings of an object

 # (modifier rendering parameter is honored)

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

 def getModifiers(obj):

     stack = []

     s = []

     for mod in obj.modifiers:

         if not mod[Modifier.Settings.RENDER]: continue

         for k in Modifier.Settings.keys():

             try:

                 v = mod[getattr(Modifier.Settings, k)]

                 s.append(k+'='+str(v))

             except KeyError:

                 pass

         stack.append([mod.type, s])

     return str(stack) if len(stack) else ''

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

 # luxExport class

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

 class luxExport:

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

     # __init__

     # initializes the exporter object

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

     def __init__(self, scene, master_progress):

         self.scene = scene

         self.camera = scene.objects.camera

         self.objects = []

         self.portals = []

         self.volumes = []

         self.namedVolumes = []

         self.hair = {'obj':{}, 'motion':{}}

         self.meshes = {}

         self.instances = {}  # only for instances with quirks: redefined materials and modifiers

         self.groups = {}

         self.materials = []

         self.lights = []

         self.duplis = set()

         self.mpb = master_progress

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

     # 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

         export_emitter = False

         export_emitter_mats = False

         if (obj.users > 0):

             obj_type = obj.getType()

             psystems = obj.getParticleSystems()

             for psys in psystems:

                 if ( (psys.type == Particle.TYPE['EMITTER'] or psys.type == Particle.TYPE['REACTOR']) and psys.drawAs == Particle.DRAWAS['OBJECT']):

                     if psys.renderEmitter: export_emitter = True

                     dup_obj = psys.duplicateObject

                     self.duplis.add(dup_obj)

                     obj_matrix = dup_obj.getMatrix()

                     obj_translation_vec = obj_matrix.translationPart()

                     obj_rotation_scale_mat = obj_matrix.rotationPart()  # This gets a 3D submatrix with the rotation AND scale parts.

                     locs = psys.getLoc()

                     scales = psys.getSize()

                     rots = psys.getRot()

                     if(len(locs) != len(scales) or len(locs) != len(rots)):

                         print("ERROR: Please bake particle systems before rendering")

                         Draw.PupMenu("ERROR: Please bake particle systems before rendering%t|OK%x1")

                         break

                     for i in range(len(locs)) :

                         part_rotation_quat = Mathutils.Quaternion(rots[i])

                         part_rotation_mat = part_rotation_quat.toMatrix()

                         rotation_scale_mat =  obj_rotation_scale_mat * part_rotation_mat * scales[i]

                         # If dup_obj is translated, the particles are translated by the same amount but

                         # the direction is rotated by the particle rotation. If dup_obj is rotated, that rotation

                         # does not affect the translation. I know it's a bit odd, but that's the way Blender does it

                         # and so that's why the order of the matrix multiplications is like this.

                         translation_vec = Mathutils.Vector(locs[i]) + part_rotation_quat*obj_translation_vec

                         translation_mat = Mathutils.TranslationMatrix(translation_vec)

                         rotation_scale_mat.resize4x4()

                         # Translation must be last because of the way the rotations and translations are encoded in 4D matrices.

                         #combined_matrix = scale_matrix*rotation_mat*translation_mat

                         combined_matrix = rotation_scale_mat*translation_mat

                         #print "combined_matrix = ", combined_matrix

                         self.analyseObject(dup_obj, combined_matrix, "%s.%s"%(obj.getName(), dup_obj.getName()), False, True)

                         #if self.analyseObject(dup_obj, combined_matrix, "%s.%s"%(obj.getName(), dup_obj.getName()), True, True): light = True

                 elif psys.type == Particle.TYPE['HAIR'] and psys.drawAs == Particle.DRAWAS['PATH']:

                     if psys.renderEmitter: export_emitter = True

                     if not obj in self.hair['obj']: self.hair['obj'][obj] = []

                     try:

                         if not psys.getName() in self.hair['obj'][obj]: self.hair['obj'][obj].append(psys.getName())

                     except AttributeError:

                         print 'ERROR: Installed version of Blender does not properly supports hair particles'

                         print '       export. Please use this version of LuxBlend with Blender 2.49b only.'

                         if osys.platform == 'win32':

                             print '       Important note for users of Blender 2.49b on Windows systems: if you'

                             print '       received this message, then you\'re using an inappropriate build of'

                             print '       Blender program. You can find the correct version build in blender.org'

                             print '       download section in a *zip archive* (not in an installer!).'

                         print

                         Draw.PupMenu('ERROR: Blender version does not properly supports hair export (see console for details)%t|OK%x1')

                         break

                     if not psys.renderEmitter:

                         export_emitter_mats = True

                 elif psys.drawAs == Particle.DRAWAS['GROUP']:

                     grpObjs =  obj.DupObjects

                     grpObjName = obj.name

                     for i in grpObjs:

                         o = i[0]

                         m = i[1]

                         # Prefix the name of all particle objects with "luxGroupParticle".

                         self.analyseObject(o, m, "%s.%s"%("luxGroupParticle", grpObjName), False, True)

                 else:

                     print "Unknown particle type for particle system [" + obj.name + "]."

             if (obj.enableDupFrames and isOriginal):

                 for o, m in obj.DupObjects:

                     light = 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:

                     if not o.restrictRender and not isDupli:

                         if obj.enableDupGroup:

                             objGroups = []

                             for g in Blender.Group.Get():

                                 if o in g.objects: objGroups.append(g)

                             if not objGroups or not True in [ l in o.layers for l in self.groups[g] for g in objGroups ]:

                                 continue

                         light = 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"))):

                 if (len(psystems) == 0) or export_emitter or export_emitter_mats:

                     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)

                                 # collect used named volumes ids

                                 for volume_prop in ['Exterior', 'Interior']:

                                     if luxProp(mat, '%s_vol_used'%(volume_prop), 'false').get() == 'true':

                                         volumeId = luxProp(mat, '%s_vol_id' % (volume_prop), 0).get()

                                         if volumeId not in self.namedVolumes:

                                             self.namedVolumes.append(volumeId)

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

                              and luxProp(Scene.GetCurrent(), "lightgroup.disable."+luxProp(mat, "light.lightgroup", "default").get(), "false").get() != "true":

                                 light = True

                         if len(psystems) == 0 or export_emitter:

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

                     if luxProp(Scene.GetCurrent(), "lightgroup.disable."+luxProp(obj, "light.lightgroup", "default").get(), "false").get() != "true":

                         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 g in Blender.Group.Get():

             # caching groups layers

             self.groups[g] = bitmask(g.layers)

         for obj in self.scene.objects:

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

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

         return light

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

     # exportInstanceObjName(self, mesh_name, matId, shapeId)

     # format instanced material-separated mesh name

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

     def exportInstanceObjName(self, mesh_name, matId=None, shapeId=None):

         s = mesh_name

         if matId is None and shapeId is None:

             return s

         s += ':luxInstancedObj'

         if matId is not None: s += ':matId%s' % matId

         if shapeId is not None: s += ':shapeId%s' % shapeId

         return s

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

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

         #pb = exportProgressBar(len(self.materials), self.mpb)

         for mat in self.materials:

             #pb.counter('Exporting Materials')

             self.exportMaterial(file, mat)

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

     # exportNamedVolumes(self, file)

     # exports named volumes to the file

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

     def exportNamedVolumes(self, file):

         #pb = exportProgressBar(len(self.namedVolumes), self.mpb)

         output = ''

         volumes = listNamedVolumes()

         for linked, new in importedVolumeIdsTranslation.items():

             if linked in self.namedVolumes:

                 self.namedVolumes.remove(linked)

                 self.namedVolumes.append(new)

         for volume in volumes.values():

             if volume in self.namedVolumes:

                 #pb.counter('Exporting Mediums Definitions')

                 data = getNamedVolume(volume)

                 output = "\t# Volume '%s'\n" % data['name']

                 tex = luxNamedVolumeTexture(volume)

                 output += "%s\nMakeNamedVolume \"%s\" %s" % (tex[0], data['name'], tex[1])

                 output += "\n\n"

                 file.write(output)

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

     # exportHairSystems(self, file)

     # collects hair particles and exports hair systems

     # primitives to the file

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

     def exportHairSystems(self, file):

         #pb = exportProgressBar(len(self.hair), self.mpb)

         clay_export = (luxProp(self.scene, 'clay', 'false').get() != 'true')

         ob_moblur = (luxProp(self.camera.data, 'objectmblur', 'true').get() == 'true' and luxProp(self.camera.data, 'usemblur', 'false').get() == 'true')

         frame = Blender.Get('curframe')

         for obj, obj_psystems in self.hair['obj'].items():

             #pb.counter('Exporting Hair Particles')

             for psys in obj.getParticleSystems():

                 psysname = psys.getName()

                 if not psysname in obj_psystems: continue

                 if clay_export:

                     mat = psys.getMat() or dummyMat

                 else:

                     mat = getMaterials(obj, True)[0]

                 size = luxProp(mat, 'hair_thickness', 0.5).get() * luxScaleUnits('hair_thickness', 'mm', mat)

                 legname = '%s:%s:luxHairPrimitive:leg' % (obj.name, psysname)

                 jointname = '%s:%s:luxHairPrimitive:joint' % (obj.name, psysname)

                 primitives = {

                   legname: "\tShape \"cylinder\" \"float radius\" %f \"float zmin\" 0.0 \"float zmax\" 1.0\n" % (0.5*size),

                   jointname: "\tShape \"sphere\" \"float radius\" %f\n" % (0.5*size)

                 }

                 # exporting primitive objects

                 for name, shape in primitives.items():

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

                     self.exportMaterialLink(file, mat)

                     file.write(shape)

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

                 # collecting segment objects (instanced)

                 self.luxCollectHairObjs(psys, jointname, legname, size)

                 if ob_moblur:

                     # to make motion blur work we must also get transform matrices from the following frame

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

                     self.luxCollectHairObjs(psys, jointname, legname, size, True)

                     Blender.Set('curframe', frame)

                 # removing psys from the list to avoid multiple exports

                 self.hair['obj'][obj].remove(psysname)

     # collect hair strand segment objects/matrices pairs

     def luxCollectHairObjs(self, psys, jointname, legname, size, motion=False):

         # matrix check helper function

         def matrixHasNaN(m):

             for i in range(len(m)):

                 for v in m[i]:

                     if type(v) is not float and matrixHasNaN(v): return True

                     elif str(v) == 'nan': return True

             return False

         # it seams to be a bug in Blender Python API here -- if an object

         # has more than one particle system, then beginning from the

         # second system the call to Particles.getLoc() results in an empty

         # list for the first time

         segmentsLoc = psys.getLoc()

         segmentsLoc = psys.getLoc()  # sic

         for i, strand in enumerate(segmentsLoc):

             for j in range(0, len(strand)*2-1):

             	j_over_2 = j/2

                 if j%2 == 0:

                     name = jointname

                     matrix = Mathutils.Matrix([1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [strand[j_over_2][0], strand[j_over_2][1], strand[j_over_2][2], 1.0])

                 else:

                     name = legname

                     m = self.getHairSegmentTransform(strand[j_over_2], strand[j_over_2+1])

                     matrix = Mathutils.Matrix(m[0], m[1], m[2], m[3])

                 # check to cull out point-sized strands

                 if j == 1 and not motion and matrixHasNaN(matrix[:3]) is True:

                     self.objects.pop()

                     break

                 obj = self.luxHair('%s_strand%s_segment%s' % (name,i,j), name)

                 if not motion:

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

                     try:

                         self.instances[name]['obj_mods'][''] = ['luxHair']

                     except KeyError:

                         self.instances[name] = {'obj_mods': {'': ['luxHair']}}

                 else:

                     self.hair['motion'][obj] = matrix

     # minimalistic Blender-like object for holding strand obj properties

     class luxHair:

         def __init__(self, objName, parentName):

             self.objName = objName

             self.parentName = parentName

         def __cmp__(self, other):

             return cmp(self.__repr__(), other.__repr__())

         def __hash__(self):

             return hash(self.__repr__())

         def __repr__(self):

             return '[Object "%s"]' % self.objName

         def __str__(self):

             return self.__repr__()

         def getData(self, **args):

             return self.parentName

         def getName(self):

             return self.objName

     # hair export helper function (by e_jackson)

     def getHairSegmentTransform(self, p1, p2):

         """

         This function selects an orthogonal basis V_1 = (p2-p1), V_2, V_3 such that V_2 and V_3

         have unit length and calculates a transformation matrix from standard orthnormal basis

         to the selected one.

         Arguments:

             p1, p2 == coordinate triples of beginning and end points of a vector

         Returns:

             string which represents transformation matrix in a format compatible with Luxrender SDL

         """

         # standard orthonormal basis

         Standard_basis = [Mathutils.Vector(1.0, 0.0, 0.0), Mathutils.Vector(0.0, 1.0, 0.0), Mathutils.Vector(0.0, 0.0, 1.0)]

         V = [(), (), ()]

         V[2] = Mathutils.Vector(p2) - Mathutils.Vector(p1)

         # we choose an ort which corresponds to the smallest absolute value of coordinate in V[0]

         W = Standard_basis[0]

         Length = abs(V[2].x)

         for Node in zip([1, 2], [abs(V[2].y), abs(V[2].z)]) :

             if Node[1] < Length :

                 Length = Node[1]

                 W = Standard_basis[Node[0]]

         V[1] = V[2].cross(W)

         V[1].normalize()

         V[0] = V[1].cross(V[2])

         V[0].normalize()

         # transition matrix from standard basis to V

         M = Mathutils.Matrix(V[0], V[1], V[2])

         Result = []

         for Count in range(3) :

             Result.append([M[Count][0], M[Count][1], M[Count][2], 0.0])

         Result.append([p1[0], p1[1], p1[2], 1.0])

         return Result

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

     # getMeshType(self, vertcount, mat, instancedMats)

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

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

     def getMeshType(self, vertcount, mat, instancedMats=None):

         scn = Scene.GetCurrent()

         if mat != dummyMat and not instancedMats:

             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, instancedMats, instancedShapes)

     # exports mesh to the file without any optimization

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

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

         #print("    exporting mesh")

         if mats == []:

             mats = [dummyMat]

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

         i = 0

         for matIndex in range(len(mats)):

             if not matIndex in usedmats:

                 continue

             if not(portal):

                 mat = mats[matIndex]

                 if not mat:

                    mat = dummyMat

                 if instancedMats:

                     file.write("ObjectBegin \"%s\"\n" % self.exportInstanceObjName(instancedMats, i, instancedShapes))

                 self.exportMaterialLink(file, mat)

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

             if not(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")

                 # Check if there is a render specific UV layer and make it active for export.

                 activeUVLayer_orig = mesh.activeUVLayer

                 renderUVLayer = mesh.renderUVLayer

                 if renderUVLayer != activeUVLayer_orig:

                     mesh.activeUVLayer = renderUVLayer

                 for face in ffaces:

                     for uv in face.uv:

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

                 # If we changed the active UV layer: reset it to the original.

                 if renderUVLayer != activeUVLayer_orig:

                     mesh.activeUVLayer = activeUVLayer_orig 

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

             if instancedMats:

                 file.write("ObjectEnd # %s\n\n" % self.exportInstanceObjName(instancedMats, i, instancedShapes))

             i += 1

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

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

     # 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, instancedMats=None, instancedShapes=None):

         #print("    exporting optimized mesh")

         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]

         i = 0

         # Check if there is a render specific UV layer and make it active for export.

         activeUVLayer_orig = mesh.activeUVLayer

         renderUVLayer = mesh.renderUVLayer

         if renderUVLayer != activeUVLayer_orig:

             mesh.activeUVLayer = renderUVLayer

         for matIndex in range(len(mats)):

             if not matIndex in usedmats:

                 continue

             if not(portal):

                 mat = mats[matIndex]

                 if not mat:

                    mat = dummyMat

                 if instancedMats:

                     file.write("ObjectBegin \"%s\"\n" % self.exportInstanceObjName(instancedMats, i, instancedShapes))

                 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], instancedMats)

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