#!BPY
"""Registration info for Blender menus:
Name: 'LuxBlend-v0.1-alpha9...'
Blender: 240
Group: 'Export'
Tooltip: 'Export to LuxRender v0.1 scene format (.lxs)'
"""
#
# ***** BEGIN GPL LICENSE BLOCK *****
#
# --------------------------------------------------------------------------
# LuxBlend v0.1 alpha9 exporter
# --------------------------------------------------------------------------
#
# Authors:
# Radiance (aka Terrence Vergauwen)
#
# Based on:
# * Lux exporter - Nick Chapman, Gregor Quade, Zuegs, Ewout Fernhout, Leope, psor
#
# 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 os
import Blender
from Blender import Mesh, Scene, Object, Material, Texture, Window, sys, Draw, BGL, Mathutils


######################################################
# Functions
######################################################

# zuegs: added color exponent
def colGamma(value):
	return value**ColExponent.val

def luxMatrix(matrix):
	m0,m1,m2,m3 = matrix
	return "Transform [%s %s %s %s  %s %s %s %s  %s %s %s %s  %s %s %s %s]\n"\
		%(m0[0], m0[1], m0[2], m0[3],\
		  m1[0], m1[1], m1[2], m1[3],\
		  m2[0], m2[1], m2[2], m2[3],\
		  m3[0], m3[1], m3[2], m3[3])

# use this because some data dosnt have both .materials and .getMaterials()
def dataMaterials(data):
	try:		return data.materials
	except:	
		try:	return data.getMaterials()
		except:	return []

#################### Export Material Texture ###

# MATERIAL TYPES enum
# 0 = 'glass'
# 1 = 'translucent'
# 2 = 'mirror'
# 3 = 'plastic'
# 4 = 'shinymetal'
# 5 = 'substrate'
# 6 = 'matte' (Oren-Nayar)
# 7 = 'matte' (Lambertian)

### Determine the type of material ###
def getMaterialType(mat):
	# default to matte (Lambertian)
	mat_type = 7

	# test for emissive material
	if mat.emit:
		### emitter material ###
		mat_type = 100

	# test for Transmissive (transparent) Materials
	elif mat.mode & Material.Modes.RAYTRANSP:
		if mat.translucency < 1.0:
			### 'glass' material ###
			mat_type = 0	
		else:
			### 'translucent' material ###
			mat_type = 1

	# test for Mirror Material
	elif mat.mode & Material.Modes.RAYMIRROR:
		### 'mirror' material ###
		mat_type = 2

	# test for Diffuse / Specular Reflective materials
	else:
		if mat.spec > 0.0001:
			# Reflective 
			if mat.specShader == Material.Shaders.SPEC_BLINN:
				### 'plastic' material ###
				mat_type = 3
			elif mat.specShader == Material.Shaders.SPEC_PHONG:
				### 'shinymetal' material ###
				mat_type = 4
			else:						# CookTor/other
				### 'substrate' material ###
				mat_type = 5
		else:
			### 'matte' material ### 
			if mat.diffuseShader == Material.Shaders.DIFFUSE_ORENNAYAR:
				# oren-nayar sigma
				mat_type = 6
			else:					# Lambertian/other
				# lambertian sigma
				mat_type = 7

	return mat_type


# Determine the type of material / returns filename or 'NONE' 
def getTextureChannel(mat, channel):
	for t in mat.getTextures():
		if (t != None) and (t.texco & Blender.Texture.TexCo.UV) and\
				(t.tex.type == Blender.Texture.Types.IMAGE):
			if t.mapto & Blender.Texture.MapTo[channel]:
				imagefilepath, imagefilename = os.path.split(t.tex.getImage().filename)
				return imagefilename
	return 'NONE'

def getTextureforChannel(mat, channel):
	for t in mat.getTextures():
		if (t != None) and (t.texco & Blender.Texture.TexCo.UV) and\
				(t.tex.type == Blender.Texture.Types.IMAGE):
			if t.mapto & Blender.Texture.MapTo[channel]:
				return t
	return 0

# MATERIAL TYPES enum
# 0 = 'glass'
# 1 = 'translucent'
# 2 = 'mirror'
# 3 = 'plastic'
# 4 = 'shinymetal'
# 5 = 'substrate'
# 6 = 'matte' (Oren-Nayar)
# 7 = 'matte' (Lambertian)
#
# 100 = emissive (area light source / trianglemesh)

def exportMaterial(file, mat):
	file.write("# Material '%s'\n" % mat.name)

	def write_color_constant( chan, name, r, g, b ):
		file.write('Texture "%s-%s" "color" "constant" "color value" [%.3f %.3f %.3f]\n' % (chan, name, r, g, b))

	def write_color_imagemap( chan, name, filename, scaleR, scaleG, scaleB ):
		file.write('Texture "%s-map-%s" "color" "imagemap" "string filename" ["%s"] "float vscale" [-1.0]\n' % (chan, name, filename))
		file.write('Texture "%s-scale-%s" "color" "constant" "color value" [%f %f %f]\n' % (chan, name, scaleR, scaleG, scaleB))
		file.write('Texture "%s-%s" "color" "scale" "texture tex1" ["%s-map-%s"] "texture tex2" ["%s-scale-%s"]\n' % (chan, name, chan, name, chan, name))

	def write_float_constant( chan, name, v ):
		file.write('Texture "%s-%s" "float" "constant" "float value" [%f]\n' % (chan, name, v))

	def write_float_imagemap( chan, name, filename, scale ):
		file.write('Texture "%s-map-%s" "float" "imagemap" "string filename" ["%s"] "float vscale" [-1.0]\n' % (chan, name, filename))
		file.write('Texture "%s-scale-%s" "float" "constant" "float value" [%f]\n' % (chan, name, scale))
		file.write('Texture "%s-%s" "float" "scale" "texture tex1" ["%s-map-%s"] "texture tex2" ["%s-scale-%s"]\n' % (chan, name, chan, name, chan, name))

	def write_color_param( m, param, chan, r, g, b ):
		chan_file = getTextureChannel(m, chan)
		if (chan_file == 'NONE'):
			write_color_constant( param, m.name, r, g, b )
		else:
			tc = getTextureforChannel(m, chan)
			if(tc == 0):
				ss = 1.0
			else:
				ss = tc.colfac
			write_color_imagemap( param, m.name, chan_file, r * ss, g * ss, b * ss )

	def write_float_param( m, param, chan, v ):
		chan_file = getTextureChannel(m, chan)
		if (chan_file == 'NONE'):
			write_float_constant( param, m.name, v )
		else:
			tc = getTextureforChannel(m, chan)
			if (chan == 'NOR'):
				ss = tc.norfac * 0.1
			else:
				ss = v
			write_float_imagemap( param, m.name, chan_file, ss )

	# translates blender mat.hard (range: 1-511) 
	# to lux blinn value (0.0 - 1.0 Reversed)
	def HardtoBlinn(hard):
		blinn = 1.0 / (float(hard) *5)
		if( blinn < 0.00001 ):
			blinn = 0.00001
		if( blinn > 1.0 ):
			blinn = 1.0
		return blinn

	# translates blender mat.hard (range: 1-511) 
	# to lux aniso shinyness value (0.00001 = nearly specular - 1.0 = diffuse)
	def HardtoAniso(hard):
		aniso = 1.0 / (float(hard) *5)
		if( aniso < 0.00001 ):
			aniso = 0.00001
		if( aniso > 1.0 ):
			aniso = 1.0
		return aniso

	mat_type = getMaterialType(mat)

	if (mat_type == 100):
		### emitter material ### COMPLETE
		file.write("# Type: emitter\n# See geometry block.\n\n")

	elif (mat_type == 0):
		### 'glass' material ### COMPLETE
		file.write('# Type: "glass"\n')
		write_color_param( mat, "Kr", 'SPEC', mat.specR, mat.specG, mat.specB )
		write_color_param( mat, "Kt", 'COL', mat.R, mat.G, mat.B )
		write_float_param( mat, "index", 'REF', mat.IOR )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 1):
		### 'translucent' material ###
		file.write('# Type: "translucent"\n')
		write_color_param( mat, "Kd", 'SPEC', mat.specR, mat.specG, mat.specB )
		write_color_param( mat, "Ks", 'COL', mat.R, mat.G, mat.B )
		file.write('Texture "reflect-%s" "float" "constant" "float value" [.5]\n' % (mat.name))
		file.write('Texture "transmit-%s" "float" "constant" "float value" [.5]\n' % (mat.name))
		write_float_param( mat, "roughness", 'HARD', HardtoBlinn(mat.hard) )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 2):
		### 'mirror' material ### COMPLETE
		file.write('# Type: "mirror"\n')
		write_color_param( mat, "Kr", 'COL', mat.R, mat.G, mat.B )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 3):
		### 'plastic' material ### COMPLETE
		file.write('# Type: "plastic"\n')
		write_color_param( mat, "Kd", 'COL', mat.R, mat.G, mat.B )
		write_color_param( mat, "Ks", 'SPEC', mat.specR * mat.spec, mat.specG * mat.spec, mat.specB * mat.spec )
		write_float_param( mat, "roughness", 'HARD', HardtoBlinn(mat.hard) )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 4):
		### 'shinymetal' material ### COMPLETE
		file.write('# Type: "shinymetal"\n')
		write_color_param( mat, "Ks", 'COL', mat.R, mat.G, mat.B )
		write_color_param( mat, "Kr", 'SPEC',mat.specR * mat.spec, mat.specG * mat.spec, mat.specB * mat.spec )
		write_float_param( mat, "roughness", 'HARD', HardtoBlinn(mat.hard) )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 5):
		### 'substrate' material ### COMPLETE
		file.write('# Type: "substrate"\n')
		write_color_param( mat, "Kd", 'COL', mat.R, mat.G, mat.B )
		write_color_param( mat, "Ks", 'SPEC', mat.specR * mat.spec, mat.specG * mat.spec, mat.specB * mat.spec )
		# TODO: add different inputs for both u/v roughenss for aniso effect
		write_float_param( mat, "uroughness", 'HARD', HardtoAniso(mat.hard) )
		write_float_param( mat, "vroughness", 'HARD', HardtoAniso(mat.hard) )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	elif (mat_type == 6):
		### 'matte' (Oren-Nayar) material ###
		# TODO
		file.write('\n')
	else:
		### 'matte' (Lambertian) material ### COMPLETE
		file.write('# Type: "matte" (Lambertian)\n')
		write_color_param( mat, "Kd", 'COL', mat.R, mat.G, mat.B )
		write_float_param( mat, "sigma", 'REF', 0 )
		write_float_param( mat, "bumpmap", 'NOR', 0.0 )

	file.write('#####\n\n')

def exportMaterialGeomTag(mat):
	mat_type = getMaterialType(mat)
	if (mat_type == 100):
		str = 'AreaLightSource "area" "integer nsamples" [1] "color L" [%f %f %f]' % (mat.R * mat.emit, mat.G * mat.emit, mat.B * mat.emit)
	else:

	 	str = "Material "

		if (mat_type == 0):
			### 'glass' material ### COMPLETE
			str += ' "glass" "texture Kr" "Kr-%s' % mat.name
			str += ' "texture Kt" "Kt-%s"' % mat.name
			str += ' "texture index" "index-%s"' % mat.name
			str += ' "texture bumpmap" "bumpmap-%s"'  % mat.name

		elif (mat_type == 1):
			### 'translucent' material ###
			str += ' "translucent" "texture Kd" "Kd-%s"' %mat.name
			str += ' "texture Ks" "Ks-%s"' %mat.name
			str += ' "texture reflect" "reflect-%s"' %mat.name
			str += ' "texture transmit" "transmit-%s"' %mat.name
			str += ' "texture roughness" "roughness-%s"' %mat.name
			str += ' "texture index" "index-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

		elif (mat_type == 2):
			### 'mirror' material ### COMPLETE
			str += ' "mirror" "texture Kr" "Kr-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

		elif (mat_type == 3):
			### 'plastic' material ### COMPLETE
			str += ' "plastic" "texture Kd" "Kd-%s"' %mat.name
			str += ' "texture Ks" "Ks-%s"' %mat.name
			str += ' "texture roughness" "roughness-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

		elif (mat_type == 4):
			### 'shinymetal' material ### COMPLETE
			str += ' "shinymetal" "texture Ks" "Ks-%s"' %mat.name
			str += ' "texture Kr" "Kr-%s"' %mat.name
			str += ' "texture roughness" "roughness-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

		elif (mat_type == 5):
			### 'substrate' material ### COMPLETE
			str += ' "substrate" "texture Kd" "Kd-%s"' %mat.name
			str += ' "texture Ks" "Ks-%s"' %mat.name
			str += ' "texture uroughness" "uroughness-%s"' %mat.name
			str += ' "texture vroughness" "vroughness-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

		elif (mat_type == 6) or (mat_type == 7):
			### 'matte' (Oren-Nayar or Lambertian) material ###
			str += ' "matte" "texture Kd" "Kd-%s"' %mat.name
			str += ' "texture sigma" "sigma-%s"' %mat.name
			str += ' "texture bumpmap" "bumpmap-%s"' %mat.name

	str += "\n"
	return str

# collect Materials
matnames = []
def collectObjectMaterials(obj):
	global matnames
	objectname = obj.name
	objecttype = obj.type
	if (objecttype == "Mesh") or (objecttype == "Curve") or (objecttype == "Text"):
		print("Collecting materials for object: %s" %objectname)
		materials = dataMaterials(obj.getData(mesh=1))
		meshlight = 0
		if len(materials) > 0:
			mat0 = materials[0]
			if mat0.emit > 0:
				meshlight = 1
		if meshlight == 0:
			for mat in materials:
				if mat.name not in matnames:
					matnames.append(mat.name)
	elif (objecttype == "Empty"):
		group = obj.DupGroup
		if group:
			groupname = group.name
			for o, m in obj.DupObjects:
				collectObjectMaterials(o)



################################################################
def exportMesh(mesh, obj, isLight, isPortal):

	mestr = ""
	
	#materials = obj.getData().getMaterials()
	materials = mesh.materials

	def writeMeshData():
		vdata = []
		vlist = []
		flist = []
		def addVertex(bvindex, coord, normal, uv):
			index = -1
			if (bvindex < len(vdata)):
				for ivindex in vdata[bvindex]:
					v = vlist[ivindex]
					if (abs(v[0][0]-coord[0])<0.0001) and \
					(abs(v[0][1]-coord[1])<0.0001) and \
					(abs(v[0][2]-coord[2])<0.0001) and \
					(abs(v[1][0]-normal[0])<0.0001) and \
					(abs(v[1][1]-normal[1])<0.0001) and \
					(abs(v[1][2]-normal[2])<0.0001):
						if ((v[2]==[]) and (uv==[])) or \
						((abs(v[2][0]-uv[0])<0.0001) and \
						(abs(v[2][1]-uv[1])<0.0001)):
							index = ivindex
			if index < 0:
				index = len(vlist)
				vlist.append([coord, normal, uv])
				while bvindex >= len(vdata):
					vdata.append([])
				vdata[bvindex].append(index)
			return index

		def addFace(mindex, index0, index1, index2):
			#while mindex >= len(flist):
			#	flist.append([])
			#flist[mindex].append([index0, index1, index2])
			flist[0].append([index0, index1, index2])

		def getPoints():
			return "".join(map( \
				lambda v: "\t%f %f %f\n" \
				%(v[0][0], v[0][1], v[0][2]), \
				vlist))

		def getNormals():
			return "".join(map( \
				lambda v: "\t%f %f %f\n" \
				%(v[1][0], v[1][1], v[1][2]), \
				vlist))
		def getUVs():
			def getUVStr(uv):
				if uv != []: return "%f %f" %(uv[0], uv[1])
				else: return "0.000000 1.000000"
			return "".join(map( \
				lambda v: "\t%s\n" \
				%(getUVStr(v[2])), vlist))

		def getMaterialName(mindex):
			if mindex < len(mesh.materials): return mesh.materials[mindex].name
			else:
				print "Warning: faces without material"
				return "Default"

		def getMaterialLine(material):
			#if mindex < len(mesh.materials): 
			return exportMaterialGeomTag(material)
			#else:
			#	print "Warning: faces without material"
			#	return "Material \"matte\" \"texture Kd\" \"Kd-Default\""

		def writeGroup(material):
			print "Nr of materials: %i\n" %len(flist)
			if isPortal:
				return "".join(map( \
					lambda fli: 'PortalShape "trianglemesh" "integer indices" [\n' \
						+ ''.join(map(lambda f: "%d %d %d\n"%(f[0], f[1], f[2]), flist[fli])) \
						+ '' , range(len(flist)) )) \
						+ '] "point P" [\n' + getPoints() \
						+ '] "normal N" [\n' + getNormals() \
						+ ']\n\n'		
			if have_uvs:
				return "".join(map( \
					lambda fli: '%s\nShape "trianglemesh" "integer indices" [\n' % (getMaterialLine(material)) \
						+ ''.join(map(lambda f: '%d %d %d\n' % (f[0], f[1], f[2]), flist[fli])) \
						+ '' , range(len(flist)) )) \
						+ '] "point P" [\n' + getPoints() \
						+ '] "normal N" [\n' + getNormals() \
						+ '] "float uv" [\n' + getUVs() \
						+ ']\n\n'
			else:
				return "".join(map( \
					lambda fli: '%s\nShape "trianglemesh" "integer indices" [\n'%(getMaterialLine(material)) \
						+ ''.join(map(lambda f: '%d %d %d\n' % (f[0], f[1], f[2]), flist[fli])) \
						+ '' , range(len(flist)) )) \
						+ '] "point P" [\n' + getPoints() \
						+ '] "normal N" [\n"' + getNormals() \
						+ ']\n\n'

		vdata = []
		vlist = []
		flist = []
		ostr = ""

		emindex = 0
		have_uvs = mesh.faceUV
		materials_names = [material.name for material in materials]
		
		print "obstart\n"
		for material in materials:
		# Construct list of verts/faces
			material_name = material.name
			vdata = []
			vlist = []
			flist = []

			flist.append([])
			have_faces = 0

			for face in mesh.faces:
				iis = [-1, -1, -1, -1]
				if( material_name == materials_names[face.mat] ):	
					if have_uvs:
						face_uv = face.uv
					
					if not face.smooth:
						normal = face.no
					
					for vi, vert in enumerate(face):
						if face.smooth:
							normal = vert.no
						
						if have_uvs:
							uv = face_uv[vi]
						else:
							uv = []
						iis[vi] = addVertex(vert.index, vert.co, normal, uv)
					addFace(0, iis[0], iis[1], iis[2])
					have_faces = 1
					if len(face.v)==4:
						addFace(0, iis[2], iis[3], iis[0])
		
			if have_faces:
				ostr += writeGroup(material)
				
			# clear lists
			vdata[:] = []
			vlist[:] = []
			flist[:] = []
		return ostr


	objectname = obj.name
	meshname = mesh.name
	str = ""

	# write Object header
	if isLight:
		str += "AttributeBegin\n"
		str += luxMatrix(obj.matrixWorld)
		str += "\n"
		str += writeMeshData()

		str += "AttributeEnd\n\n"
	elif isPortal:
		str += "\n"
		str += luxMatrix(obj.matrixWorld)
		str += "\n"
		str += writeMeshData()
	else:
		#str += "ObjectBegin \"%s\"\n\n" %(meshname.replace("<","-").replace(">","-"))
		#str += writeMeshData()
		#str += "ObjectEnd # %s\n\n\n" %(meshname.replace("<","-").replace(">","-"))
		str += """# Object: "%s" Mesh: "%s"\n""" % (objectname, obj.getData(name_only=1))
		str += "AttributeBegin\n"
		str += luxMatrix(obj.matrixWorld)
		str += "\n"
		str += writeMeshData()

		str += "AttributeEnd\n\n"
	return str


# export objext
meshlist = []
def exportObject(obj):
	global meshlist
	str = ""
	gstr = ""
	mstr = {}
	objectname = obj.name
	objecttype = obj.type

	if objecttype in ("Mesh", "Curve", "Text"):
		#mesh = Blender.NMesh.GetRawFromObject(objectname)
		mesh = Mesh.New()
		mesh.getFromObject(obj)
		meshname = obj.getData(name_only=1)

		if (objecttype == "Curve") or (objecttype == "Text"):
			meshname = obj.getData(name_only=1)
			mesh.name = meshname
			for f in mesh.faces:
				f.smooth = 1

		# Not needed anymore, Mesh does this, NMesh didnt
		#if (objecttype == "Curve"):
		#	mesh.setMaterials(obj.getData(mesh=1).getMaterials())

		isLight = 0
		isPortal = 0
		if len(mesh.materials) > 0:
			mat0 = mesh.materials[0]
			if mat0.name == "PORTAL":
				isPortal = 1
			if mat0.emit > 0:
				isLight = 1

		print "processing Object \"%s\" (Mesh \"%s\")..." %(objectname, meshname)

		try:
			meshlist.index(meshname)
		except ValueError:			
			meshlist.append(meshname)

		# export meshlight geometry
		gstr += exportMesh(mesh, obj, isLight, isPortal)

		# TODO FIX FOR INSTANCING
		#if isLight == 0:
		#	# export instance/object
		#	str += "AttributeBegin\n"
		#	matrix = obj.getMatrix()
		#	str += luxMatrix(matrix)
		#	str += "\n"
		#	str += "\tObjectInstance \"%s\"\n" %(meshname.replace("<","-").replace(">","-"))
		#	str += "AttributeEnd\n\n"
				
	mstr[0] = str
	mstr[1] = gstr
	return mstr

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













######################################################
# EXPORT
######################################################

def save_lux(filename, unindexedname):
	global meshlist, matnames, geom_filename, geom_pfilename, mat_filename, mat_pfilename

	print('Lux Render Export started...')
	time1 = Blender.sys.time()

	##### Determine/open files
	print('Exporting scene to "%s"...', filename)
	file = open(filename, 'w')

	filepath = os.path.dirname(filename)
	print filename
	print filepath
	filebase = os.path.basename(filename)

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

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

	print('Exporting materials to "%s"...' % mat_filename)
	print('Exporting geometry to "%s"...' % geom_filename )
	geom_file = open(geom_filename, 'w')
	mat_file = open(mat_filename, 'w')


	##### Write Header ######
	file.write('# Lux Render v0.1 Scene File\n')
	file.write('# Exported by LuxBlend_01_alpha9\n\n')

	##### Write camera ######
	currentscene = Scene.GetCurrent()
	ob_cam = currentscene.objects.camera
	if ob_cam:
		print "processing Camera..."
		matrix = ob_cam.matrixWorld
		pos = matrix.translationPart()
		forwards = -(matrix[2].copy().resize3D())
		target = pos + forwards
		up = matrix[1]
		lens = ob_cam.data.lens 
		context = currentscene.getRenderingContext()
		ratio = float(context.imageSizeY())/float(context.imageSizeX())
		fov = 2*math.atan(ratio*16/lens) * (180 / 3.141592653)
		file.write("LookAt %f %f %f   %f %f %f %f %f %f\n" % ( pos[0], pos[1], pos[2], target[0], target[1], target[2], up[0], up[1], up[2] ))
		file.write("Camera \"perspective\" \"float fov\" [%f] \"float lensradius\" [%f] \"float focaldistance\" [%f] \n" % (fov,LensRadius.val,FocalDistance.val))
	file.write("\n")

	##### Write film ######
	file.write('Film "multiimage"\n') 
	file.write('\t"integer xresolution" [%d] "integer yresolution" [%d]\n' % (context.imageSizeX(), context.imageSizeY()) )
	if(SaveIGI.val == 1):
		file.write('\t"string igi_filename" ["out.igi"]\n')
		file.write('\t\t"integer igi_writeinterval" [%i]\n' %(SaveIGIint.val))
	if(SaveEXR.val == 1):
		file.write('\t"string hdr_filename" ["out.exr"]\n')
		file.write('\t\t"integer hdr_writeinterval" [%i]\n' %(SaveEXRint.val))
	if(SaveTGA.val == 1):
		file.write('\t"string ldr_filename" ["out.tga"]\n')
		file.write('\t\t"integer ldr_writeinterval" [%i]\n' %(SaveTGAint.val))
	file.write('\t\t"integer ldr_displayinterval" [%i]\n' %(Displayint.val))
	file.write('\t\t"string tonemapper" ["reinhard"]\n')
	file.write('\t\t\t"float reinhard_prescale" [%f]\n' %(ToneMapPreScale.val))
	file.write('\t\t\t"float reinhard_postscale" [%f]\n' %(ToneMapPostScale.val))
	file.write('\t\t\t"float reinhard_burn" [%f]\n' %(ToneMapBurn.val))
	file.write('\t\t"float gamma" [%f]\n' %(OutputGamma.val))
	file.write('\t\t"float dither" [%f]\n\n' %(OutputDither.val))
	if(Bloom.val == 1):
		file.write('\t\t"float bloomwidth" [%f]\n' %(BloomWidth.val))
		file.write('\t\t"float bloomradius" [%f]\n' %(BloomRadius.val))

	if(FilterType.val == 1):
		file.write('PixelFilter "mitchell" "float xwidth" [%f] "float ywidth" [%f]\n' %(Filterxwidth.val, Filterywidth.val))
	else:
		file.write('PixelFilter "gaussian" "float xwidth" [%f] "float ywidth" [%f]\n' %(Filterxwidth.val, Filterywidth.val))
	file.write("\n")

	##### Write Pixel Sampler ######
	if(SamplerType.val == 1):
		file.write('Sampler "random" ')
	else:
		file.write('Sampler "lowdiscrepancy" ')

	if(SamplerProgressive.val == 1):
		file.write('"bool progressive" ["true"] ')
	else:
		file.write('"bool progressive" ["false"] ')
	
	file.write('"integer pixelsamples" [%i]\n\n' % (SamplerPixelsamples.val))

	##### Write Integrator ######
	file.write('SurfaceIntegrator "path" "integer maxdepth" [%i] ' % (pathMaxDepth.val))
	if(pathRRforcetransmit.val == 1):
		file.write('"bool rrforcetransmit" ["true"] ')
	else:
		file.write('"bool rrforcetransmit" ["false"] ')

	file.write('"float rrcontinueprob" [%f]\n\n' %(pathRRcontinueprob.val))

	##### Write Acceleration ######
	file.write('Accelerator "kdtree"\n\n')

	##### Get all the objects/materials in this scene #####
	portalstr = ""
	object_list = []
	matnames= []
	for obj in currentscene.objects:
		if obj.Layers & currentscene.Layers:
			objecttype = obj.type
			if (objecttype == "Mesh") and (len(obj.getData(mesh=1).materials) > 0)\
					and (obj.getData(mesh=1).materials[0].name.upper() == "PORTAL"):
						portalstr += exportObject(obj)[1]
			else:
				object_list.append(obj)
				collectObjectMaterials(obj)

	########## BEGIN World
	file.write("\n")
	file.write("WorldBegin\n")
	file.write("\n")
	world = currentscene.world
	##### Write World Background, Sunsky or Env map ######
	if EnvType.val == 0 and world:
		worldcolor = world.getHor()
		file.write("AttributeBegin\n")
		file.write("LightSource \"infinite\" \"color L\" [%g %g %g] \"integer nsamples\" [1]\n" % (worldcolor[0], worldcolor[1], worldcolor[2]))
		file.write("%s" %portalstr)
		file.write("AttributeEnd\n")
	if EnvType.val == 1:
		for obj in object_list:
			if obj.type == "Lamp":
				if obj.data.type == 1: # sun object
					invmatrix = obj.matrixWorld.copy().invert()
					file.write("AttributeBegin\n")
					file.write("LightSource \"sunsky\" \"integer nsamples\" [1]\n")
					file.write("            \"vector sundir\" [%f %f %f]\n" %(invmatrix[0][2], invmatrix[1][2], invmatrix[2][2]))
					file.write("		\"color L\" [%f %f %f]\n" %(SkyGain.val, SkyGain.val, SkyGain.val))
					file.write("		\"float turbidity\" [%f]\n" %(Turbidity.val))
					file.write("%s" %portalstr)
					file.write("AttributeEnd\n")
	if EnvType.val == 2:
		if EnvFile.val != "none" and EnvFile.val != "":
			file.write("AttributeBegin\n")
			file.write("LightSource \"infinite\" \"integer nsamples\" [1]\n")
			file.write("            \"string mapname\" [\"%s\"]\n" %(EnvFile.val) )
			file.write("%s" %portalstr)
			file.write("AttributeEnd\n")
	file.write("\n")


	#### Write material & geometry file includes in scene file
	file.write("Include \"%s\"\n\n" %(mat_pfilename))
	file.write("Include \"%s\"\n\n" %(geom_pfilename))

	##### Write Material file #####
	mat_file.write("")
	mat_file.write("# Dummy Material 'Default'\n")
	mat_file.write("Texture \"Kd-Default\" \"color\" \"constant\" \"color value\" [0.5 0.5 0.5]\n\n")
	materials = Material.Get()
	for mat in materials:
		if mat.name in matnames:
			exportMaterial(mat_file, mat)

	##### Write Geometry file #####
	meshlist = []
	geom_file.write("")
	for obj in object_list:
		global expobj
		expobj = exportObject(obj)
		file.write(expobj[0])
		geom_file.write(expobj[1])

	##### END World & Close files
	geom_file.write("")
	geom_file.close()
	mat_file.write("")
	mat_file.close()
	file.write("WorldEnd\n\n")
	file.close()

	print("Finished.\n")

	time2 = Blender.sys.time()
	print("Processing time: %f\n" %(time2-time1))
	#Draw.Exit()













#########################################################################
###	 LAUNCH LuxRender AND RENDER CURRENT SCENE (WINDOWS ONLY)		 ###
###  psor's first steps to Python(executing Lux per shell script)  ###
#########################################################################

def launchLux(filename):
	# get blenders 'bpydata' directory
	datadir=Blender.Get("datadir")
	
	# open 'LuxWrapper.conf' and read the first line
	f = open(datadir + '/LuxWrapper.conf', 'r+')
	ic=f.readline()
	f.close()
	
	# create 'LuxWrapper.cmd' and write two lines of code into it
	f = open(datadir + "\LuxWrapper.cmd", 'w')
	f.write("cd /d " + ic + "\n")
	f.write("start /b /belownormal Lux.exe %1 -t " + str(Threads.val) + "\n")
	f.close()
	
	# call external shell script to start Lux
	cmd= "\"" + datadir + "\LuxWrapper.cmd " + filename + "\""
	print cmd
	os.system(cmd)


### END OF PSOR ##########################################################




#### SAVE ANIMATION ####	
def save_anim(filename):
	global MatSaved
	
	MatSaved = 0
	startF = Blender.Get('staframe')
	endF = Blender.Get('endframe')

	for i in xrange (startF, endF):
		Blender.Set('curframe', i)
		Blender.Redraw()
		frameindex = "-" + str(i) + ".lxs"
		indexedname = makename(filename, frameindex)
		unindexedname = filename
		save_lux(indexedname, unindexedname)
		MatSaved = 1

#### SAVE STILL (hackish...) ####
def save_still(filename):
	global MatSaved
	
	MatSaved = 0
	unindexedname = filename
	save_lux(filename, unindexedname)
	#if ExecuteLux.val == 1:
	#	launchLux(filename)







######################################################
# Settings GUI
######################################################


###psor's add
ExecuteLux = Draw.Create(1)
DefaultExport = Draw.Create(1)
###END


# Assign event numbers to buttons
evtNoEvt	= 0
evtExport   = 1
evtExportAnim   = 2
openCamera = 6
openEnv = 7
openRSet = 8
openSSet = 9
openTmap = 10
evtloadimg = 11
evtIsNumber = 3
evtFocusS = 4
evtFocusC = 5

# Set initial values of buttons

ColExponent = Draw.Create(2.2)

##  <metropolis>1</metropolis>
MLT = Draw.Create(1)

##  <large_mutation_prob>0.1</large_mutation_prob>
LMP = Draw.Create(0.1)

##  <max_change>0.02</max_change>
MaxChange = Draw.Create(0.02)

##  <max_num_consec_rejections>100</max_num_consec_rejections>
MaxNumConsRej = Draw.Create(100)

##  <russian_roulette_live_prob>0.7</russian_roulette_live_prob>
RRLP = Draw.Create(0.7)

##  <max_depth>1000</max_depth>
MaxDepth = Draw.Create(1000)

##  <bidirectional>true</bidirectional>
Bidirectional = Draw.Create(1)

##  <strata_width>14</strata_width>
StrataWidth = Draw.Create(14)

##Threads
Threads = Draw.Create(1)

##  <logging>0</logging>
Logging = Draw.Create(0)

##  <save_untonemapped_exr>false</save_untonemapped_exr>
SaveUTMExr = Draw.Create(0)

##  <save_tonemapped_exr>false</save_tonemapped_exr>
SaveTMExr = Draw.Create(0)

#HaltTime
HaltTime = Draw.Create(-1)

#Frameup
FrameUp = Draw.Create(20)

#ImageSave
ImageSave = Draw.Create(20)

#ExpotGeom
ExportGeom = Draw.Create(1)
geom_pfilename = ""
##  <sensor_width>0.035</sensor_width>
FilmWidth = Draw.Create(35.0)

##  <lens_radius>0.0</lens_radius>
LensRadius = Draw.Create(0.0)

##  <focus_distance>2.0</focus_distance>
FocalDistance = Draw.Create(2.0)

##  <white_balance>D65</white_balance>
#strWhiteBalance = "White Balance %t | D50 %x50 | D55 %x55 | D65 %x65 | D75 %x75"
strWhiteBalance = "White Balance %t | E %x0 | D50 %x1 | D55 %x2 | D65 %x3 | D75 %x4 "
strWhiteBalance += "| A %x5 | B %x6 | C %x7 | 9300 %x8 | F2 %x9 | F7 %x10 | F11 %x11"
WhiteBalance = Draw.Create(0)
whiteBalanceV = {}
whiteBalanceV[0] = "E"
whiteBalanceV[1] = "D50"
whiteBalanceV[2] = "D55"
whiteBalanceV[3] = "D65"
whiteBalanceV[4] = "D75"
whiteBalanceV[5] = "A"
whiteBalanceV[6] = "B"
whiteBalanceV[7] = "C"
whiteBalanceV[8] = "9300"
whiteBalanceV[9] = "F2"
whiteBalanceV[10] = "F7"
whiteBalanceV[11] = "F11"

##FilmIso
FilmIso = Draw.Create(100)

## Environment Type
strEnvType = "Env Type %t | Background Color %x0 | Physical Sky %x1 | Texture Map %x2 | None %x3"
EnvType = Draw.Create(0)

##  <turbidity>2.0</turbidity>
Turbidity = Draw.Create(2.0)

##  <sky_gain>2.0</sky_gain>
SkyGain = Draw.Create(0.005)

GroundPlane = Draw.Create(0)

## Separate materials
MatFile = Draw.Create(0)

## Environment map
EnvFile = Draw.Create("none")
strEnvMapType = "Map type %t | LatLong %x0"
EnvMapType = Draw.Create(0)
EnvMapTypeV = {}
EnvMapTypeV[0] = "latlong"
EnvGain = Draw.Create(1.0)
EnvWidth = Draw.Create(640)

# filters
strFilterType = "Filter %t | gaussian %x0 | mitchell %x1"
FilterType = Draw.Create(0)
FilterTypeV = {}
FilterTypeV[0] = "gaussian"
FilterTypeV[1] = "mitchell"
Filterxwidth = Draw.Create(2.0)
Filterywidth = Draw.Create(2.0)

# samplers
strSamplerType = "Sampler %t | lowdiscrepancy %x0 | random %x1"
SamplerType = Draw.Create(0)
SamplerTypeV = {}
SamplerTypeV[0] = "lowdiscrepancy"
SamplerTypeV[1] = "random"
SamplerProgressive = Draw.Create(1)
SamplerPixelsamples = Draw.Create(4)

# engine
strIntegratorType = "Integrator %t | path %x0"
IntegratorType = Draw.Create(0)
IntegratorTypeV = {}
IntegratorTypeV[0] = "path"
pathRRforcetransmit = Draw.Create(1)
pathRRcontinueprob = Draw.Create(0.5)
pathMaxDepth = Draw.Create(512)

## Exposure
ToneMapScale = Draw.Create(125)
Autoexp = Draw.Create(0)

## Tonemapping
strToneMapType = "ToneMap type %t | None %x0 | Reinhard %x1"
ToneMapType = Draw.Create(1)
ToneMapPreScale = Draw.Create(1.0)
ToneMapPostScale = Draw.Create(1.0)
ToneMapBurn = Draw.Create(6.0)

# output gamma
OutputGamma = Draw.Create(2.2)

# output dither
OutputDither = Draw.Create(0.0)

# file output
SaveEXR = Draw.Create(0)
SaveEXRint = Draw.Create(120)
SaveIGI = Draw.Create(0)
SaveIGIint = Draw.Create(120)
SaveTGA = Draw.Create(1)
SaveTGAint = Draw.Create(120)
Displayint = Draw.Create(12)

# bloom
Bloom = Draw.Create(0)
BloomWidth = Draw.Create(0.1)
BloomRadius = Draw.Create(0.1)

## Overall color gain
DiffuseGain = Draw.Create(1.00)
SpecularGain = Draw.Create(1.00)

# text color fix
textcol = [0, 0, 0]
geom_pfilename = ""

## Registry
def update_Registry():
	#global EnvFile, EnvMapType
	d = {}
	d['colexponent'] = ColExponent.val
	d['filmwidth'] = FilmWidth.val
	d['apertureradius'] = LensRadius.val
	d['focusdistance'] = FocalDistance.val
	d['whitebalance'] = WhiteBalance.val
	d['filmiso'] = FilmIso.val
	d['saveexr'] = SaveEXR.val
	d['saveexrint'] = SaveEXRint.val
	d['saveigi'] = SaveIGI.val
	d['saveigiint'] = SaveIGIint.val
	d['savetga'] = SaveTGA.val
	d['savetgaint'] = SaveTGAint.val
	d['savedisplayint'] = Displayint.val
	d['mlt'] = MLT.val
	d['lmp'] = LMP.val
	d['maxchange'] = MaxChange.val
	d['maxnumconsrej'] = MaxNumConsRej.val
	d['bidirectional'] = Bidirectional.val
	d['rrlp'] = RRLP.val
	d['maxdepth'] = MaxDepth.val
	d['stratawidth'] = StrataWidth.val
	d['threads'] = Threads.val
	d['logging'] = Logging.val
	d['groundplane'] = GroundPlane.val
	d['saveutmexr'] = SaveUTMExr.val
	d['savetmexr'] = SaveTMExr.val
	d['tonemaptype'] = ToneMapType.val
	d['tonemapscale'] = ToneMapScale.val
	d['autoexp'] = Autoexp.val
	d['tonemapprescale'] = ToneMapPreScale.val
	d['tonemappostscale'] = ToneMapPostScale.val
	d['outputgamma'] = OutputGamma.val
	d['outputdither'] = OutputDither.val
	d['tonemapburn'] = ToneMapBurn.val
	d['envtype'] = EnvType.val
	d['envfile'] = EnvFile.val
	d['envmaptype'] = EnvMapType.val
	d['envgain'] = EnvGain.val
	d['envwidth'] = EnvWidth.val
	d['turbidity'] = Turbidity.val
	d['skygain'] = SkyGain.val
	d['matfile'] = MatFile.val
	d['ExecuteLux'] = ExecuteLux.val
	d['HaltTime'] = HaltTime.val
	d['frameup'] = FrameUp.val
	d['imagesave'] = ImageSave.val
	d['pfile'] = geom_pfilename

#TODO save/retrieve to registry for samplers, filters and engine (renderer tab contents)

	Blender.Registry.SetKey('BlenderLux', d, True)

rdict = Blender.Registry.GetKey('BlenderLux', True)

if rdict:
	try:
		ColExponent.val = rdict['colexponent']
		FilmWidth.val = rdict['filmwidth']
		LensRadius.val = rdict['apertureradius']
		FocalDistance.val = rdict['focusdistance']
		WhiteBalance.val = rdict['whitebalance']
		FilmIso.val = rdict['filmiso']
		SaveEXR.val = rdict['saveexr']
		SaveEXRint.val = rdict['saveexrint']
		SaveIGI.val = rdict['saveigi']
		SaveIGIint.val = rdict['saveigiint']
		SaveTGA.val = rdict['savetga']
		SaveTGAint.val = rdict['savetgaint']
		Displayint.val = rdict['savedisplayint']
		MLT.val = rdict['mlt'] 
		LMP.val = rdict['lmp']
		MaxChange.val = rdict['maxchange']
		MaxNumConsRej.val = rdict['maxnumconsrej']
		Bidirectional.val = rdict['bidirectional']
		RRLP.val = rdict['rrlp']
		MaxDepth.val = rdict['maxdepth']
		StrataWidth.val = rdict['stratawidth']
		Threads.val = rdict['threads']
		Logging.val = rdict['logging']
		GroundPlane.val = rdict['groundplane']
		SaveUTMExr.val = rdict['saveutmexr']
		SaveTMExr.val = rdict['savetmexr']
		ToneMapType.val = rdict['tonemaptype']
		ToneMapScale.val = rdict['tonemapscale']
		Autoexp.val = rdict['autoexp']
		ToneMapPreScale.val = rdict['tonemapprescale']
		ToneMapPostScale.val = rdict['tonemappostscale']
		OutputGamma.val = rdict['outputgamma']
		OutputDither.val = rdict['outputdither']
		ToneMapBurn.val = rdict['tonemapburn']
		EnvType.val = rdict['envtype']
		EnvFile.val = rdict['envfile']
		EnvMapType.val = rdict['envmaptype']
		EnvGain.val = rdict['envgain']
		EnvWidth.val = rdict['envwidth']
		Turbidity.val = rdict['turbidity']
		SkyGain.val = rdict['skygain']
		MatFile.val = rdict['matfile']
		ExecuteLux.val = rdict['ExecuteLux']
		LuxDir.val = rdict['LuxDir']
		HaltTime.val = rdict['HaltTime']
		FrameUp.val = rdicr['frameup']
		ImageSave.val = rdict['imagesave']
		geom_pfilename = rdict['pfile']
		
	except: update_Registry()   
		
######  Draw Camera  ###############################################
def drawCamera():
####################################################################
	global evtNoEvt, evtExport, evtExportAnim, evtFocusS, evtFocusC, openCamera, openEnv
	global ColExponent, RRLP, MaxDepth, Bidirectional, StrataWidth, Logging, LensRadius, FocalDistance, GroundPlane, MatFile, FilmWidth
	global SaveUTMExr, SaveTMExr, ToneMapType, ToneMapScale, Autoexp, ToneMapPreScale, ToneMapPostScale, ToneMapBurn, OutputGamma
	global MLT, LMP, MaxChange, MaxNumConsRej
	global textcol, strEnvType, EnvType, EnvFile, strEnvMapType, EnvMapType, EnvGain, EnvWidth, Turbidity, SkyGain, DiffuseGain, SpecularGain
	global strWhiteBalance, WhiteBalance, whiteBalanceV, Screen, HaltTime, ExecuteLux, FilmIso

	drawButtons()
	
	BGL.glColor3f(1.0,0.5,0.4)
	BGL.glRectf(10,182,90,183)
	BGL.glColor3f(0.9,0.9,0.9)

	LensRadius = Draw.Number("Lens Radius: ", evtNoEvt, 10, 130, 200, 18, LensRadius.val, 0.0, 3.0, "Defines the lens radius. Values higher than 0. enable DOF and control the amount")
	FocalDistance = Draw.Number("Focal Distance: ", evtNoEvt, 10, 90, 200, 18, FocalDistance.val, 0.0, 100, "Distance from the camera at which objects will be in focus. Has no effect if Lens Radius is 0.")
	Draw.Button("S", evtFocusS, 215, 90, 20, 18, "Get the distance from the selected object")
	Draw.Button("C", evtFocusC, 235, 90, 20, 18, "Get the distance from the 3d cursor")

##############  Draw Environment  #######################################
def drawEnv():
####################################################
	global evtNoEvt, evtExport, evtExportAnim, evtFocusS, evtFocusC, openCamera, openEnv, evtloadimg
	global ColExponent, RRLP, MaxDepth, Bidirectional, StrataWidth, Logging, LensRadius, FocalDistance, GroundPlane, MatFile, FilmWidth
	global SaveUTMExr, SaveTMExr, ToneMapType, ToneMapScale, Autoexp, ToneMapPreScale, ToneMapPostScale, ToneMapBurn, OutputGamma
	global MLT, LMP, MaxChange, MaxNumConsRej
	global textcol, strEnvType, EnvType, EnvFile, strEnvMapType, EnvMapType, EnvGain, EnvWidth, Turbidity, SkyGain, DiffuseGain, SpecularGain
	global strWhiteBalance, WhiteBalance, whiteBalanceV, Screen, HaltTime, ExecuteLux
	
	drawButtons()
	
	BGL.glColor3f(1.0,0.5,0.4)
	BGL.glRectf(90,182,170,183)
	BGL.glColor3f(0.9,0.9,0.9)
	
	EnvType = Draw.Menu(strEnvType, evtNoEvt, 10, 150, 150, 18, EnvType.val, "Set the Enviroment type")
	if EnvType.val == 2:
		EnvFile = Draw.String("Probe: ", evtNoEvt, 10, 130, 255, 18, EnvFile.val, 50, "the file name of the raw/exr probe")
		EnvMapType = Draw.Menu(strEnvMapType, evtNoEvt, 10, 110, 100, 18, EnvMapType.val, "Set the map type of the probe")
		#EnvGain = Draw.Number("Gain: ", evtNoEvt, 165, 150, 100, 18, EnvGain.val, 0.001, 1000.00, "Gain")
		Draw.Button("Load", evtloadimg, 235, 110, 30,18,"Load Env Map")
		#if EnvMapType.val == 0:
		#	EnvWidth = Draw.Number("Width: ", evtNoEvt, 110, 110, 100, 18, EnvWidth.val, 1, 10000, "Width")
	if EnvType.val == 1:
		Turbidity = Draw.Number("Sky Turbidity", evtNoEvt, 10, 130, 150, 18, Turbidity.val, 1.5, 5.0, "Sky Turbidity")
		SkyGain = Draw.Number("Sky Gain", evtNoEvt, 10, 110, 150, 18, SkyGain.val, 0.0, 5.0, "Sky Gain")
	
	#GroundPlane = Draw.Toggle("Ground Plane", evtNoEvt, 10, 60, 150, 18, GroundPlane.val, "Place infinite large ground plane at 0,0,0")
	
###############  Draw Rendersettings   ###################################
def drawSettings():
#####################################################
	global ColExponent, RRLP, MaxDepth, Bidirectional, StrataWidth, Logging, LensRadius, FocalDistance, GroundPlane, MatFile, FilmWidth
	global SaveUTMExr, SaveTMExr, ToneMapType, ToneMapScale, Autoexp, ToneMapPreScale, ToneMapPostScale, ToneMapBurn, OutputGamma
	global MLT, LMP, MaxChange, MaxNumConsRej, Threads
	global textcol, strEnvType, EnvType, EnvFile, strEnvMapType, EnvMapType, EnvGain, EnvWidth, Turbidity, SkyGain, DiffuseGain, SpecularGain
	global strWhiteBalance, WhiteBalance, whiteBalanceV, Screen, HaltTime, ExecuteLux
	global IntegratorType, SamplerType, FilterType, SamplerProgressive, SamplerPixelsamples, Filterxwidth, Filterywidth
	global pathMaxDepth, pathRRcontinueprob, pathRRforcetransmit


	drawButtons()
	
	BGL.glColor3f(1.0,0.5,0.4)
	BGL.glRectf(170,182,250,183)
	BGL.glColor3f(0.9,0.9,0.9)


	IntegratorType = Draw.Menu(strIntegratorType, evtNoEvt, 10, 150, 120, 18, IntegratorType.val, "Engine Integrator type")
	pathMaxDepth = Draw.Number("Maxdepth:", evtNoEvt,140,150,120,18, pathMaxDepth.val,1,1024, "Maximum path depth (bounces)")
	pathRRcontinueprob = Draw.Number("RRcProb:", evtNoEvt,140,130,140,18, pathRRcontinueprob.val,0.01,1.0, "Russian Roulette continue probability")
	pathRRforcetransmit = Draw.Toggle("RRfTransmit", evtNoEvt, 290, 130, 100, 18, pathRRforcetransmit.val, "Russian Roulette force transmission")

	SamplerType = Draw.Menu(strSamplerType, evtNoEvt, 10, 100, 120, 18, SamplerType.val, "Engine Sampler type")
	SamplerProgressive = Draw.Toggle("Progressive", evtNoEvt, 140, 100, 120, 18, SamplerProgressive.val, "Sample film progressively or linearly")
	SamplerPixelsamples = Draw.Number("Pixelsamples:", evtNoEvt,260,100,150,18, SamplerPixelsamples.val,1,512, "Number of samples per pixel")

	FilterType = Draw.Menu(strFilterType, evtNoEvt, 10, 70, 120, 18, FilterType.val, "Engine pixel reconstruction filter type")
	Filterxwidth = Draw.Number("X width:", evtNoEvt,140,70,120,18, Filterxwidth.val,1,4, "Horizontal filter width")
	Filterywidth = Draw.Number("Y width:", evtNoEvt,260,70,120,18, Filterywidth.val,1,4, "Vertical filter width")

##################  Draw RSettings  #########################	
def drawSystem():
########################################
	global Logging, MatFile
	global SaveUTMExr, SaveTMExr, ColExponent, OutputGamma, SaveEXR, SaveEXRint, SaveIGI, SaveIGIint, SaveTGA, SaveTGAint, Displayint, OutputDither
	global HaltTime, FrameUp, ImageSave
	
	drawButtons()
	
	BGL.glColor3f(1.0,0.5,0.4)
	BGL.glRectf(330,182,410,183)
	BGL.glColor3f(0.9,0.9,0.9)
	
	SaveIGI = Draw.Toggle("Save IGI", evtNoEvt, 10, 160, 80, 18, SaveIGI.val, "Save untonemapped IGI file")
	SaveIGIint = Draw.Number("Interval", evtNoEvt,132,160,150,18, SaveIGIint.val,20,10000, "Set Interval for IGI file write (seconds)")
	SaveEXR = Draw.Toggle("Save EXR", evtNoEvt, 10, 140, 80, 18, SaveEXR.val, "Save untonemapped EXR file")
	SaveEXRint = Draw.Number("Interval", evtNoEvt,132,140,150,18, SaveEXRint.val,20,10000, "Set Interval for EXR file write (seconds)")
	SaveTGA = Draw.Toggle("Save TGA", evtNoEvt, 10, 120, 80, 18, SaveTGA.val, "Save tonemapped TGA file")
	SaveTGAint = Draw.Number("Interval", evtNoEvt,132,120,150,18, SaveTGAint.val,20,10000, "Set Interval for TGA file write (seconds)")

	Displayint = Draw.Number("Display Interval", evtNoEvt,10,90,150,18, Displayint.val,5,10000, "Set Interval for Display (seconds)")

	OutputGamma = Draw.Number("Output Gamma: ", evtNoEvt, 10, 60, 200, 18, OutputGamma.val, 0.0, 6.0, "Output Image Gamma")
	OutputDither = Draw.Number("Output Dither: ", evtNoEvt, 210, 60, 150, 18, OutputDither.val, 0.0, 1.0, "Output Image Dither")

#################  Draw Tonemapping  #########################
def drawTonemap():
#######################################
	global ColExponent, RRLP, MaxDepth, Bidirectional, StrataWidth, Logging, LensRadius, FocalDistance, GroundPlane, MatFile, FilmWidth
	global SaveUTMExr, SaveTMExr, ToneMapType, ToneMapScale, Autoexp, ToneMapPreScale, ToneMapPostScale, ToneMapBurn, OutputGamma
	global MLT, LMP, MaxChange, MaxNumConsRej
	global textcol, strEnvType, EnvType, EnvFile, strEnvMapType, EnvMapType, EnvGain, EnvWidth, Turbidity, SkyGain, DiffuseGain, SpecularGain
	global strWhiteBalance, WhiteBalance, whiteBalanceV, Screen, HaltTime, ExecuteLux, Bloom, BloomWidth, BloomRadius
	
	drawButtons()
	
	BGL.glColor3f(1.0,0.5,0.4)
	BGL.glRectf(250,182,330,183)
	BGL.glColor3f(0.9,0.9,0.9)
	
	ToneMapType = Draw.Menu(strToneMapType, evtNoEvt, 10, 150, 85, 18, ToneMapType.val, "Set the type of the tonemapping")
	
	if ToneMapType.val == 1:
		ToneMapBurn = Draw.Number("Burn: ", evtNoEvt, 95, 150, 135, 18, ToneMapBurn.val, 0.1, 12.0, "12.0: no burn out, 0.1 lot of burn out")
		ToneMapPreScale = Draw.Number("PreS: ", evtNoEvt, 10, 130, 110, 18, ToneMapPreScale.val, 0.01,100.0, "Pre Scale: See Lux Manual ;)")
		ToneMapPostScale = Draw.Number("PostS: ", evtNoEvt, 120, 130, 110, 18, ToneMapPostScale.val, 0.01,100.0, "Post Scale: See Lux Manual ;)")
	
	Bloom = Draw.Toggle("Bloom", evtNoEvt, 10, 80, 80, 18, Bloom.val, "Enable HDR Bloom")
	BloomWidth = Draw.Number("Width: ", evtNoEvt, 90, 80, 120, 18, BloomWidth.val, 0.1, 2.0, "Amount of bloom")
	BloomRadius = Draw.Number("Radius: ", evtNoEvt, 210, 80, 120, 18, BloomRadius.val, 0.1, 2.0, "Radius of the bloom filter")
	
##############
def drawGUI():
##############
	global Screen
	if Screen==0:	drawCamera()
	elif Screen==1:	drawEnv()
	elif Screen==2:	drawSettings()
	elif Screen==3:	drawSystem()
	elif Screen==4:	drawTonemap()

##################
def drawButtons():
##################

	## buttons
	global evtExport, evtExportAnim, openCamera, openEnv, openRSet, openSSet, openTmap, evtNoEvt, ExecuteLux, DefaultExport, ExportGeom
	
	BGL.glColor3f(0.2,0.2,0.2)
	BGL.glRectf(0,0,440,230)
	BGL.glColor3f(0.9,0.9,0.9);BGL.glRasterPos2i(10,205) ; Draw.Text("LuxBlend v0.1alpha9", "small")
	
	Draw.BeginAlign()
	Draw.Button("Camera", openCamera, 10, 185, 80, 13, "Open Camera Dialog")
	Draw.Button("Environment", openEnv, 90, 185, 80, 13, "Open Environment Dialog")
	Draw.Button("Renderer", openRSet, 170, 185, 80, 13, "Open Rendersettings Dialog")
	Draw.Button("Tonemap", openTmap, 250, 185, 80, 13, "open Tonemap Settings")
	Draw.Button("System", openSSet, 330, 185, 80, 13, "open System Settings")
	Draw.EndAlign()
	
	Draw.BeginAlign()
	Draw.Button("Render", evtExport, 10, 19, 100, 30, "Open file dialog and export")
	Draw.Button("Export Anim", evtExportAnim, 112, 19, 100, 30, "Open file dialog and export animation (careful: takes a lot of diskspace!!!)")
	Draw.EndAlign()
	
	#ExecuteLux = Draw.Toggle("Run", evtNoEvt, 10, 5, 30, 10, ExecuteLux.val, "Execute Lux and render the saved .lxs file")
	#DefaultExport = Draw.Toggle("def",evtNoEvt,40,5,30,10, DefaultExport.val, "Use default.lxs as filename") 
	
	BGL.glColor3f(0.9, 0.9, 0.9) ; BGL.glRasterPos2i(340,7) ; Draw.Text("Press Q or ESC to quit.", "tiny")
	
		
def event(evt, val):  # function that handles keyboard and mouse events
	if evt == Draw.ESCKEY or evt == Draw.QKEY:
		stop = Draw.PupMenu("OK?%t|Cancel export %x1")
		if stop == 1:
			Draw.Exit()
			return

def setEnvMap(efilename):
	EnvFile.val = os.path.basename(efilename)
	
def buttonEvt(evt):  # function that handles button events
	
	global Screen, EnFile
	
	if evt == evtExport:
		#if DefaultExport == 0:
			Blender.Window.FileSelector(save_still, "Export", sys.makename(ext='.lxs'))
		#else:
		#	datadir=Blender.Get("datadir")
		#	f = open(datadir + '/LuxWrapper.conf', 'r+')
		#	ic=f.readline()
		#	f.close()
		#	filename = ic + "\default.lxs"
		#	save_still(filename)
	
	if evt == evtExportAnim:
		Blender.Window.FileSelector(save_anim, "Export Animation", sys.makename(ext='.lxs'))
	#if there was an event, redraw the window   
	if evt:
		Draw.Redraw()
		
	if evt == evtNoEvt:
		Draw.Redraw()
		update_Registry()
		
	if evt == openCamera:
		Screen = 0
		drawGUI()
		Draw.Redraw()
	
	if evt == openEnv:
		Screen = 1
		drawGUI()
		Draw.Redraw()
		
	if evt == openRSet:
		Screen = 2
		drawGUI()
		Draw.Redraw()
	
	if evt == openSSet:
		Screen = 3
		drawGUI()
		Draw.Redraw()
	
	if evt == openTmap:
		Screen = 4
		drawGUI()
		Draw.Redraw()
	
	if evt == evtloadimg:
		Blender.Window.FileSelector(setEnvMap, "Load Environment Map", ('.exr'))
		Draw.Redraw()
		update_Registry()
	
	if evt == evtFocusS:
		setFocus("S")
		Draw.Redraw()
		update_Registry()
	if evt == evtFocusC:
		setFocus("C")
		Draw.Redraw()
		update_Registry()

def setFocus(target):
	# This functionality is in trunk - (camera can focus on object) but until then, for 2.45 this is ok to have
	# TODO - deprecate ;)
	global FocalDistance
	currentscene = Scene.GetCurrent()
	ob_cam = currentscene.getCurrentCamera()
	loc1 = ob_cam.matrixWorld.translationPart()
	if target == "S":
		try:	loc2 = currentscene.objects.active.matrixWorld.translationPart()
		except:	print "select an object to focus"
	if target == "C":
		loc2 = Mathutils.Vector(Window.GetCursorPos())
	FocalDistance.val = (loc1-loc2).length

Screen = 0

if __name__ == '__main__':
	Draw.Register(drawGUI, event, buttonEvt)