##############################################
# SIMPLE FULL-SCENE BLENDER TO YAFRAY EXPORT #
##############################################

# GENERAL USAGE:
# Specify the filename and layer bitmask below and use alt-p to export
# Use '_ASxx' appended to objectnames to export autosmooth settings
# set GZIPIT to 1 to export as .gz file, '.gz' will be appended to the filename automatically
#--------------------------
# CURRENTLY EXPORTED:
# All Blender lighttypes.
# Hemi is exported as hemilight, might be changed to actual Blender Hemi emulation.
# A spot light is exported as a softlight, when using Publisher the shadowmap parameters can be used to control
# radius with the 'softness' parameter, bias with 'bias', res with 'BufSi'
# In 2.23 these are set to defaults: res=100, bias=0.3, but radius can be controlled with the Quad1 slider.
# When a World is used, the Horizon color will be used as the scene background color. (NOT IN PUBLISHER)
# The hemicolor will not be exported in that case, so it will automatically use the background color
# If a mesh has uv-coords they will be exported as well, all meshes are exported with their corresponding transforms.


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

# name and full path of the output .XML file
filename = 'PATH_HERE/export_test.xml'

# the layer bitmask of the layers that should be exported to the file
layermask = 1

# Export as gzip file? 1=yes, 0=no
GZIPIT = 0

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


import Blender
from math import *

# Depending on the python compilation/installation, gzip might not be available on some systems.
# The required zlib module is however also included with Publisher, so that will probably always work.
try:
	import gzip
	GZIPOK = 1
except ImportError:
	print "Gzip module not supported!"
	GZIPOK = 0

BL_VERSION = Blender.Get('version')

if BL_VERSION<=223:
	import Blender210


mesh_list = []
lamp_list = []

for ob in Blender.Object.Get():
	if BL_VERSION<=223:
		dt = ob.data
	else:
		dt = ob.getData()
	if dt and (ob.Layer & layermask):
		if dt.block_type=='NMesh':
			mesh_list.append(ob)
		elif dt.block_type=='Lamp':
			lamp_list.append(ob)

# if no meshes were found, stop, nothing to be done further
if len(mesh_list)==0:
	raise "No meshes to export"

# if no lamps found, print a warning
if len(lamp_list)==0:
	print "WARNING: No lamps exported!"

# test to see if a World is used, if so, background color will be set from it later
# also used for the hemilight to see it it's color needs to be exported
# Unfortunately the World module was removed in Publisher, so it only works in 223 or lower
bworld = None
if BL_VERSION<=223:
	bworld = Blender.World.Get()
	# only use first world in the list
	if len(bworld)!=0:
		bworld = bworld[0]
	else:
		bworld = None

# the outputfile as a string
st = "<scene>\n\n"

# only write shaders once if used on more than one object
shader_written = {}

# name of the default grey blender material
bdefname = 'blender_default'

# export materials first, only (diffuse) color & specular color
# only the first material in mesh material list is exported
for ob in mesh_list:
	mt = None
	if BL_VERSION<=223:
		me = ob.data
		materials = me.mats
		if len(materials):
			mt = Blender.Material.Get(materials[0])
	else:
		me = ob.getData()
		materials = me.getMaterials()
		if len(materials):
			mt = materials[0]
	if mt and not shader_written.has_key(mt.name):
		st += '<shader type="generic" name="%s" >\n' % mt.name
		st += '\t<attributes>\n'
		st += '\t\t<color r="%f" g="%f" b="%f" />\n' % (mt.R, mt.G, mt.B)
		if BL_VERSION<=223:
			st += '\t\t<specular r="%f" g="%f" b="%f" />\n' % (mt.SpecR, mt.SpecG, mt.SpecB)
		else:
			st += '\t\t<specular r="%f" g="%f" b="%f" />\n' % (mt.specR, mt.specG, mt.specB)
		st += '\t\t<hard value="%d" />\n' % mt.Hard
		st += '\t</attributes>\n</shader>\n\n'
		shader_written[mt.name] = 1
	elif not shader_written.has_key(bdefname):
		st += '<shader type="generic" name="%s"\n >' % bdefname
		st += '\t<attributes>\n'
		st += '\t\t<color r="0.8" g="0.8" b="0.8" />\n'
		st += '\t\t<specular r="1.0" g="1.0" b="1.0" />\n'
		st += '\t\t<hard value="50" />\n'
		st += '\t</attributes>\n</shader>\n\n'		
		shader_written[bdefname] = 1

# export the meshes, verts, faces & uv-coords (if used)
for ob in mesh_list:
	mtx = ob.matrix
	mt = None
	if BL_VERSION<=223:
		me = ob.data
		materials = me.mats
		if len(materials):
			matname = materials[0]
	else:
		me = ob.getData()
		materials = me.getMaterials()
		if len(materials):
			matname = materials[0].name
	me = Blender.NMesh.GetRawFromObject(ob.name)

	# Write the object transform matrix
	st += '<transform \t m00="%f" m10="%f" m20="%f" m30="%f"\n' % tuple(mtx[0])
	st += '\t\t m01="%f" m11="%f" m21="%f" m31="%f"\n' % tuple(mtx[1])
	st += '\t\t m02="%f" m12="%f" m22="%f" m32="%f"\n' % tuple(mtx[2])
	st += '\t\t m03="%f" m13="%f" m23="%f" m33="%f" >\n' % tuple(mtx[3])

	if len(materials):
		st += '<object name="%s" shader_name="%s">\n' % (ob.name, matname)
	else:
		st += '<object name="%s" shader_name="blender_default">\n' % ob.name
	# need to change for solidshading & autosmooth separately
	st += '\t<attributes>\n\t</attributes>\n\t<mesh'
	if ob.name[-5:-2]=='_AS':
		st += ' autosmooth="%d"' % int(ob.name[-2:])
	st += '>\n\t\t<points>\n'
	for v in me.verts:
		st += '\t\t\t<p x="%f" y="%f" z="%f" />\n' % tuple(v.co)

	st += "\t\t</points>\n\t\t<faces>\n"

	hasuv = me.hasFaceUV()
	for f in me.faces:
		numverts = len(f.v)
		if numverts==3:
			if hasuv:
				st += '\t\t\t<f a="%d" b="%d" c="%d" ' % (f.v[0].index, f.v[1].index, f.v[2].index)
				st += 'u_a="%f" v_a="%f" ' % tuple(f.uv[0])
				st += 'u_b="%f" v_b="%f" ' % tuple(f.uv[1])
				st += 'u_c="%f" v_c="%f" />\n' % tuple(f.uv[2])
			else:
				st += '\t\t\t<f a="%d" b="%d" c="%d" />\n' % (f.v[0].index, f.v[1].index, f.v[2].index)
		elif numverts==4:
			# quad, export as two triangles
			if hasuv:
				st += '\t\t\t<f a="%d" b="%d" c="%d" ' % (f.v[0].index, f.v[1].index, f.v[2].index)
				st += 'u_a="%f" v_a="%f" ' % tuple(f.uv[0])
				st += 'u_b="%f" v_b="%f" ' % tuple(f.uv[1])
				st += 'u_c="%f" v_c="%f" />\n' % tuple(f.uv[2])
				st += '\t\t\t<f a="%d" b="%d" c="%d" ' % (f.v[2].index, f.v[3].index, f.v[0].index)
				st += 'u_a="%f" v_a="%f" ' % tuple(f.uv[2])
				st += 'u_b="%f" v_b="%f" ' % tuple(f.uv[3])
				st += 'u_c="%f" v_c="%f" />\n' % tuple(f.uv[0])
			else:
				st += '\t\t\t<f a="%d" b="%d" c="%d" />' % (f.v[0].index, f.v[1].index, f.v[2].index)
				st += '<f a="%d" b="%d" c="%d" />\n' % (f.v[2].index, f.v[3].index, f.v[0].index)
		
	st += "\t\t</faces>\n\t</mesh>\n</object>\n"
	st += "</transform>\n\n"

# export the light(s)
# type 2=spot, 0=lamp, 1=sun, 3=hemi
# sun exported as sunlight
# lamp exported as pointlight
# spot exported as softlight
# hemi exported as hemilight
# shadows can be disabled/enabled with the shadows button
for ob in lamp_list:
	if BL_VERSION<=223:
		lp = ob.data
		tp = lp.type
	else:
		lp = ob.getData()
		tp = {'Lamp':0, 'Sun':1, 'Spot':2, 'Hemi':3}[lp.getType()]

	mtx = ob.matrix
	isz = ob.size[2]
	if isz!=0.0: isz = 1.0/isz

	# shadow switch
	if (lp.mode & 1):
		shd = "on"
	else:
		shd = "off"

	if tp==0:
		# pointlight
		st += '<light type="pointlight" name="%s" power="%f" cast_shadows="%s" >\n' % (ob.name, lp.Energ*lp.Dist, shd)
		st += '\t<from x="%f" y="%f" z="%f" />\n' % tuple(ob.loc)
		st += '\t<color r="%f" g="%f" b="%f" />\n' % (lp.R, lp.G, lp.B)
		st += '</light>\n\n'
	elif tp==1:
		# sunlight, uses only energy
		st += '<light type="sunlight" name="%s" power="%f" cast_shadows="%s" >\n' % (ob.name, lp.Energ, shd)
		# direction from matrix
		direction = (-mtx[2][0]*isz, -mtx[2][1]*isz, -mtx[2][2]*isz)
		st += '\t<from x="%f" y="%f" z="%f" />\n' % direction
		st += '\t<color r="%f" g="%f" b="%f" />\n' % (lp.R, lp.G, lp.B)
		st += '</light>\n\n'
	elif tp==2:
		# spot, exported as soflight
		st += '<light type="softlight" name="%s" power="%f" ' % (ob.name, lp.Energ*lp.Dist)
		if BL_VERSION<=223:
			# blender 223 or lower, can't access shadowmap parameters,
			# so to be able to set the radius, the quad1 slider value *10 is used instead
			# The value + 3 is used, so that the shadows are at least not too blocky when set to zero
			st += 'radius="%f" res="100" bias="0.3" >' % (10*lp.Quad1 + 3.0)
		else:
			# 225 or higher, use shadowmap parameters
			# Since YafRay doesn't need huge shadowmaps, use different sizes
			sizemap = {512:100, 768:200, 1024:300, 1536:400, 2560:500}
			# softness value is also  lowered
			st += 'radius="%f" res="%d" bias="%f" >' % (lp.softness*0.2, sizemap[lp.bufferSize], lp.bias)
		st += '\t<from x="%f" y="%f" z="%f" />\n' % tuple(ob.loc)
		st += '\t<color r="%f" g="%f" b="%f" />\n' % (lp.R, lp.G, lp.B)
		st += '</light>\n\n'
	elif tp==3:
		# hemi, export as hemilight
		# if a WORLD is used, the color will not be exported, since the background color will be set later
		# the dist value is used as the 'samples' value
		st += '<light type="hemilight" name="%s" power="%f" samples="%d">\n' % (ob.name, lp.Energ, lp.Dist)
		if bworld==None:
			# no world, use hemi color
			st += '\t<color r="%f" g="%f" b="%f" />\n' % (lp.R, lp.G, lp.B)
		st += '</light>\n\n'


# then the main scene camera
if BL_VERSION<=223:
	camob = Blender210.getCurrentScene().getCurrentCamera()
	camname = camob.data
	cam = Blender210.getCamera(camname)
else:
	camob = Blender.Scene.getCurrent().getCurrentCamera()
	cam = camob.getData()
	camname = cam.name
camtx = camob.matrix

loc, size = tuple(camob.loc), tuple(camob.size)
isy, isz = size[1], size[2]
if isy!=0.0: isy = 1.0/isy
if isz!=0.0: isz = 1.0/isz
lookdir = (-camtx[2][0]*isz, -camtx[2][1]*isz, -camtx[2][2]*isz)
lookAt = (loc[0] + lookdir[0], loc[1] + lookdir[1], loc[2] + lookdir[2])
up = (camtx[1][0]*isy, camtx[1][1]*isy, camtx[1][2]*isy)

# no display settings in 225, so use a preset of 640X480...
if BL_VERSION<=223:
	disp = Blender210.getDisplaySettings()
	resx, resy = disp.xResolution, disp.yResolution
else:
	resx, resy = 640, 480
aspect = resx / float(resy)
# 'focal' is not really field of view in YafRay, but anyway...
fov = 2.0 * atan(aspect * 16.0 / cam.Lens)

st += '<camera name="%s" resx="%d" resy="%d" focal="%f" >\n' % (camname, resx, resy, fov)
st += '\t<from x="%f" y="%f" z="%f" />\n' % loc
st += '\t<to x="%f" y="%f" z="%f" />\n' % lookAt
st += '\t<up x="%f" y="%f" z="%f" />\n' % (loc[0]+up[0], loc[1]+up[1], loc[2]+up[2])
st += '</camera>\n\n'

# and finally the render info
st += '<render camera_name="%s" samples="1" raydepth="3" >\n' % camname
st += '\t<outfile value="export_test.tga" />\n'

# if world used, set background color from horizon color
if bworld:
	st += '\t<background r="%f" g="%f" b="%f" />\n' % (bworld.HorR, bworld.HorG, bworld.HorB)

st += '</render>\n\n'

st += '</scene>\n'

if GZIPIT and GZIPOK:
	if filename[-3:].lower()!='.gz': filename += '.gz'
	fp = gzip.open(filename, 'wb', 9)
	fp.write(st)
	fp.close()
else:
	fp = open(filename, 'w')
	fp.write(st)
	fp.close()

print "File %s written.\n" % filename
print "%d materials exported." % len(shader_written)
print "%d meshes exported." % len(mesh_list)
print "%d light exported." % len(lamp_list)
print "Done.\n"