#!BPY

#**************************************************************************************************
# Supreme Commander Exporter for Blender3D - www.blender3d.org
#
# Written by dan - www.sup-com.net), Brent (www.scmods.net)
#
# further improvements by GeomanNL and Darius 
#
# History
#
# 0.1.0  2006-07-02	Dan Initial version.
#
# 0.2.0   2007-03-11	Brent Fixed UV coords, V was inverted.
#				Support for exporting quads.
#				Fixed a padding issue.
#
# 0.3.0   2007-03-18	Dan Code refactoring / Clean up.
#				Fixed 'INFO' section size in header.
#
# 0.3.3  2007-09-25	GeomanNL  fixed a file-write bug 
#				orientation fix, changed to matrix rotation
#				other excellent stuff 
#				(me darius took the freedom to write your entry:D)
#									
# 0.3.5  2009-03-20	Darius_  tangent and binormal calc
#				vertex optimation
#				blender front to supcom front
#				some more fixes and reorganizing/cleanup code
#				  
#								
# Todo
#   - GUI improvements
#   - Support for LOD exporting. Eg. not merging all meshes for an armature into one mech but rather only
#     sub-meshes and export the top level meshes to different files.
#   - Validation, ensure that
#     - Prompt before overwriting files & check that directories exists
#   - Second UV set?
#   - Set animation time per frame
#   - Export LUA script for use in the animation viewer (eg, start anim, set texture etc)..
#   - Set root rot/pos for sca
#
#**************************************************************************************************

"""
Name: 'Supreme Commander 3.5'
Blender: 242
Group: 'Export'
Tooltip: 'Model / Animation Exporter for Supreme Commander'
"""
import Blender
import struct

from Blender.BGL import *
from Blender import Draw
from Blender.Draw import *

from Blender import Mathutils
from Blender.Mathutils import *

from Blender import Window



import os
from os import path

VERSION = '3.5'

######################################################
# User defined behaviour, Select as you need
######################################################
#if you want to leave an info in your scm file put it in there
USER_INFO = ""


#Enable Progress Bar ( 0 = faster )
PROG_BAR_ENABLE = 1
#how many steps a progress bar has (the lesser the faster)
PROG_BAR_STEP = 25

#slower - reduce vertex amount 
VERTEX_OPTIMIZE = 1	

#LOG File for debuging
#Enable LOG File (0 = Disabled , 1 = Enabled )
LOG_ENABLE = 0
#Filename / Path. Default is blender directory Filename SC-E_LOG.txt
LOG_FILENAME = "SC-E_LOG.txt"

LOG_BONE = 1
LOG_VERT = 0


######################################################
# Init Supreme Commander SCM( _bone, _vertex, _mesh), SCA(_bone, _frame, _anim) Layout
######################################################

#Transform matrix	    z -> yx -> xy -> z	
xy_to_xz_transform = Matrix([ 1, 0, 0], 
							[ 0, 0, -1], 
							[ 0, 1, 0])
						
#xy_to_xz_transform = Matrix([ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1])
							
# Armature world matrix
MArmatureWorld = Matrix()
BONES = []

ANIMATION_DURATION = 1.5

class scm_bone :
	
	rest_pose = []		
	rest_pose_inv = []							
	rotation = []
	position = []	
	parent_index = 0
	used = False
	name = ""
	
	def __init__(self, name, rest_pose_inv, rotation, position, parent_index):
									
		self.rest_pose_inv = rest_pose_inv									
		self.rotation = rotation		
		self.position = position		
		self.parent_index = parent_index
		self.used = False
		self.name = name

	def save(self, file):
		bonestruct = '16f3f4f4i'
		#bonestruct = '16f3f4f4L' #Deprecation warning L and mistyrious binary output
		rp_inv = [0] * 16

		icount = 0
		for irow in xrange(4):
			#rest pose_inv
			for icol in xrange(4):
				rp_inv[icount] = self.rest_pose_inv[irow][icol]
				icount = icount + 1
		
		bonedata = struct.pack(bonestruct,									
			rp_inv[0], rp_inv[1], rp_inv[2], rp_inv[3],							
			rp_inv[4], rp_inv[5], rp_inv[6], rp_inv[7],							
			rp_inv[8], rp_inv[9], rp_inv[10],rp_inv[11],						
			rp_inv[12],rp_inv[13],rp_inv[14],rp_inv[15],						
			self.position[0],self.position[1],self.position[2],					
			self.rotation.w,self.rotation.x,self.rotation.y,self.rotation.z, #Quaternion (w,x,y,z)#w,x,y,z
			self.name_offset, self.parent_index,								
			0,0)
		
		
		#print self.name
		#print self.rest_pose_inv
			
		
		if LOG_BONE :	
			LOGn(" %s rp_inv: [%.3f, %.3f, %.3f, %.3f],\t [%.3f, %.3f, %.3f, %.3f],\t [%.3f, %.3f, %.3f, %.3f],\t [%.3f, %.3f, %.3f, %.3f] \tpos: [%.3f, %.3f, %.3f] \trot: [%.3f, %.3f, %.3f, %.3f] %d" 
			% (	self.name, rp_inv[0], rp_inv[1], rp_inv[2], rp_inv[3],							
				rp_inv[4], rp_inv[5], rp_inv[6], rp_inv[7],							
				rp_inv[8], rp_inv[9], rp_inv[10],rp_inv[11],						
				rp_inv[12],rp_inv[13],rp_inv[14],rp_inv[15],						
				self.position[0],self.position[1],self.position[2],					
				self.rotation[0],self.rotation[1],self.rotation[2],self.rotation[3], self.parent_index))
		
		
		file.write(bonedata)
	

class scm_vertex :

	global xy_to_xz_transform
	position = []
	tangent  = []
	normal   = []
	binormal = []
	uvc = 0
	uv1 = []
	uv2 = []
	bone_index = []
			
	def __init__(self, pos , no , uv1, bone_index):
			
		self.position = pos
		self.normal   = no
		
		#tangent and binormal wil be calculated by face
		self.tangent  = Vector( 0, 0, 0)
		self.binormal = Vector( 0, 0, 0)
		
		self.uvc = 1
		self.uv1 = uv1 
		self.uv2 = uv1# Vector(0,0) #uv1 #better results with copy ... strange, where is the use of that?
		
		self.bone_index = bone_index
			

	def save(self, file):
		
		vertstruct = '3f3f3f3f2f2f4B'
		
		#so finaly we can norm because here it is sure that no tang norm will be added
		#self.normal = CrossVecs(self.tangent, self.binormal).normalize()
		self.tangent.normalize()
		self.binormal.normalize()
		self.normal.normalize()
		
		if False :
			self.tangent = Vector(0,0,0)
			self.binormal= Vector(0,0,0)
			#self.normal  = Vector(0,0,0)

		if LOG_VERT :		
			LOGn( " pos: [%.3f, %.3f, %.3f] \tn: [%.3f, %.3f, %.3f] \tt: [%.3f, %.3f, %.3f] \tb: [%.3f, %.3f, %.3f] \tuv [ %.3f, %.3f | %.3f, %.3f ] \tbi: [%d, %d, %d, %d]" 
			
			% (
				self.position[0], self.position[1], self.position[2],	
				self.normal[0],   self.normal[1],   self.normal[2],		
				self.tangent[0],  self.tangent[1],  self.tangent[2],	
				self.binormal[0], self.binormal[1], self.binormal[2],	
				self.uv1[0], self.uv1[1],								
				self.uv2[0], self.uv2[1],								
				self.bone_index[0], self.bone_index[1],					
				self.bone_index[2], self.bone_index[3]) )
					
        # so you store in this order:
        # pos, normal, tangent, binormal, uv1, uv2, ibone
		vertex = struct.pack(vertstruct, 							
			self.position[0], self.position[1], self.position[2],	
			self.normal[0],   self.normal[1],   self.normal[2],		
			self.tangent[0],  self.tangent[1],  self.tangent[2],	
			self.binormal[0], self.binormal[1], self.binormal[2],	
			self.uv1[0], self.uv1[1],								
			self.uv2[0], self.uv2[1],								
			self.bone_index[0], self.bone_index[1],					
			self.bone_index[2], self.bone_index[3])
		

		file.write(vertex)
		
#helper the real scm face 'tupel is stored in mesh
#quad face
class qFace : 

		vertex_cont = []
		
		def __init__(self):
			self.vertex_cont = []
		
		def addVert(self, vertex):
			self.vertex_cont.extend( vertex )
			
		def addToMesh(self, mesh):
		
			face1 = Face()
			face1.addVert([ self.vertex_cont[0], self.vertex_cont[1], self.vertex_cont[2] ])
			face1.CalcTB()
			
			face2 = Face()
			face2.addVert([ self.vertex_cont[2], self.vertex_cont[3], self.vertex_cont[0] ])
			face2.CalcTB()
			
			mesh.addQFace(face1, face2)
			
		
#helper the real scm face 'tupel is stored in mesh
#tri face
class Face :
	
	vertex_cont = []
	
	def __init__(self):	
		self.vertex_cont = []
		
	def addVert(self, vertex):
		self.vertex_cont.extend(vertex)
		
	#now contains 3 vertexes calculate bi and ta and add to mesh
			
	def CalcTB( self ) :
		vert1 = self.vertex_cont[0]
		vert2 = self.vertex_cont[1]
		vert3 = self.vertex_cont[2]
		
		uv = [ vert1.uv1, vert2.uv1, vert3.uv1]

		# Calculate Tangent and Binormal
		#		(v3 - v1).(p2 - p1) - (v2 - v1).(p3 - p1)
		#	T  =  ------------------------------------------------
		#		(u2 - u1).(v3 - v1) - (v2 - v1).(u3 - u1)
		#		(u3 - u1).(p2 - p1) - (u2 - u1).(p3 - p1)
		#	B  =  -------------------------------------------------
		#		(v2 - v1).(u3 - u1) - (u2 - u1).(v3 - v1)		
		
		P2P1 = vert2.position - vert1.position
		P3P1 = vert3.position - vert1.position
		
		#UV2UV1 = [ uv[1][0]-uv[0][0], uv[1][1]-uv[0][1] ]
		#UV3UV1 = [ uv[2][0]-uv[0][0], uv[2][1]-uv[0][1] ]
	
		UV2UV1 = uv[1] - uv[0]
		UV3UV1 = uv[2] - uv[0]
		
		divide = (UV2UV1[1]*UV3UV1[0] - UV2UV1[0]*UV3UV1[1])
		
		if ( divide != 0.0 ) :		
			tangent = Vector((UV3UV1[1]*P2P1 - UV2UV1[1]*P3P1)/(divide))
			binormal = Vector((UV3UV1[0]*P2P1 - UV2UV1[0]*P3P1)/(-divide))
		else :			
			countLOG("<Warning: Vertex-T-B divided through zero")	
			tangent = Vector(0,0,0)
			binormal = Vector(0,0,0)	

		
		#add calculated tangent and binormal to vertices
		for ind in xrange(3):
			self.vertex_cont[ind].tangent = tangent
			self.vertex_cont[ind].binormal =  binormal	
			
	def addToMesh( self, mesh ) :
		self.CalcTB()
		mesh.addFace( self )
		
 
class scm_mesh :
	
	bones = []
	vertices = []
	vertcounter = 0
	faces = []
	info = []
	
	def __init__(self):
		self.bones = []
		self.vertices = []
		self.faces = []
		self.info = []
		self.vertcounter = 0
		
	def addVert( self, nvert ):
		if VERTEX_OPTIMIZE :		
			#search for vertex already in list
			vertind = 0
			for vert in self.vertices :								
				if nvert.uv1 == vert.uv1 and nvert.position == vert.position :
					break	#found vert in list keep that index				
				vertind += 1 #hmm not that one
				
			if vertind == len(self.vertices)  :
				self.vertices.append( nvert )
			else:
				vert = self.vertices[vertind]
				
				vert.tangent = Vector( (vert.tangent + nvert.tangent) )					
				vert.binormal = Vector( (vert.binormal + nvert.binormal) )					
				vert.normal = Vector( (vert.normal + nvert.normal) )
				
				self.vertices[vertind] = vert					
			
			return vertind 			
		else:
			self.vertices.append(nvert)
			return len(self.vertices)-1
			
	def addFace( self, face ):
		
		facein = [ self.addVert(nvert) for nvert in face.vertex_cont]
		self.faces.append(facein)
	
	def addQFace( self, face1, face2):
		
		facein = [ self.addVert(nvert) for nvert in face1.vertex_cont]
		self.faces.append(facein)
		
		facein = [ facein[2], self.addVert(face2.vertex_cont[1]), facein[0]]
		self.faces.append(facein)
		

	def save(self, filename):	
		
		LOGp('Writing Mesh...')
		
		scm = file(filename, 'wb')
		
		
		#headerstruct = '12L' #Deprecation warning L and mistyrious binary output
	
		headerstruct = '4s11L'
		headersize = struct.calcsize(headerstruct)
		
		#marker = 'MODL'
		marker = 'MODL'
		version = 5
		boneoffset = 0
		bonecount = 0  
		vertoffset = 0
		extravertoffset = 0
		vertcount = len(self.vertices)
		indexoffset = 0
		indexcount = len(self.faces) * 3
		infooffset = 0
		infosize = 0
		totalbonecount = len(self.bones)
		
		
		
		# Write dummy header
		header = struct.pack(headerstruct + '',						
			marker, version, boneoffset, bonecount, vertoffset, 	
			extravertoffset, vertcount, indexoffset, indexcount, 	
			infooffset, infosize, totalbonecount)
		
		scm.write(header)
		
		
		# Write bone names
		pad_file(scm, 'NAME')
		
		for bone in self.bones:
			bone.name_offset = scm.tell()			
			name = bone.name		
			buffer = struct.pack(str(len(name) + 1)+'s', name)
			scm.write(buffer)
			#Log(buffer)
		
		LOGn("[/bone struckt]")
		
		# Write bones
		boneoffset = pad_file(scm, 'SKEL')
			
		for bone in self.bones:
			bone.save(scm)
			# if bone.used == True: 
			bonecount = bonecount + 1
		

		
		
		# Write vertices		
		vertoffset = pad_file(scm, 'VTXL')
		
		for vertex in self.vertices:
			vertex.save(scm)
			
		
				
		# Write Faces
		indexoffset = pad_file(scm, 'TRIS')
		
		for f in range(len(self.faces)):
			face = struct.pack('3H', self.faces[f][0], self.faces[f][1], self.faces[f][2])
			#face = struct.pack('3h', self.faces[f][0], self.faces[f][1], self.faces[f][2])
			scm.write(face)
		
		
		LOGp( "Bones: %d, Vertices: %d, Faces: %d; \n" % (bonecount, len(self.vertices), len(self.faces)))			
		
		#Write Info
		if len(self.info) > 0:
			
			infooffset = pad_file(scm, 'INFO')
						
			for i in range(len(self.info)):
				info = self.info[i]
				infolen = len(info) + 1			
				buffer = struct.pack(str(infolen)+'s', info)
				scm.write(buffer)
			
			infosize = scm.tell() - infooffset;
		
		# Now we can update the header	
		scm.seek(0, 0)	
		
		header = struct.pack(headerstruct,							
			marker, version, boneoffset, bonecount, vertoffset, 	
			extravertoffset, vertcount, indexoffset, indexcount, 	
			infooffset, infosize, totalbonecount)		
			
		scm.write(header)
		
		scm.close()


class sca_bone:

	position = Vector( 0, 0, 0)
	rotation = Quaternion( 0, 0, 0, 0 )

	def __init__(self, pos, rot):
		self.position = pos
		self.rotation = rot

		
class sca_frame:

	keytime = 0.0
	keyflags = 0
	bones = []
	anim = None
	
	def __init__(self, anim):
		self.keytime = 0.0
		self.keyflags = 0
		self.anim = anim
		self.bones = []

	def save(self, file):
		frameheader_fmt = 'fl'
		frameheader_size = struct.calcsize(frameheader_fmt)
		
		posrot_fmt = '3f4f'
		posrot_size = struct.calcsize(posrot_fmt)
		
		# Frame header
		buffer = struct.pack(frameheader_fmt, self.keytime, self.keyflags)
		file.write(buffer)
		
		#Log(":%d:" % (len(self.bones)))
		
		# Bones		
		for bone in self.bones:
			
			buffer = struct.pack(	posrot_fmt, 										
									bone.position.x, bone.position.y, bone.position.z,					
									bone.rotation.w, bone.rotation.x, bone.rotation.y, bone.rotation.z)
									
			file.write(buffer)


class sca_anim :
	frames = []
	bonelinks = []
	bonenames = []
	duration = 0.0
	
	def __init__(self):
		global ANIMATION_DURATION
		self.frames = []
		self.bonelinks = []
		self.bonenames = []
		self.duration = ANIMATION_DURATION
	
	def save(self, filename):
	
		LOGp('Writing SCA...')
		
		#self.filename = filename
		sca = file(filename, 'wb')
		
		headerstruct = '4sllflllll'
		
		# Write temp header		
		magic = 'ANIM'
		version = 5
		numframes = len(self.frames)
		numbones = len(self.bonenames)		
		
		namesoffset = 0
		linksoffset = 0
		animoffset = 0
		framesize = 0
		
		header = struct.pack(headerstruct, 
			magic, version, numframes, self.duration, numbones,
			namesoffset, linksoffset, animoffset, framesize)
		#note: this header is seen correctly by the GPG dumpsca.py
		
		sca.write(header)		
		
		# Write bone names
		namesoffset = pad_file(sca, 'NAME')

		for bone_name in self.bonenames:
			buffer = struct.pack(str(len(bone_name) + 1)+'s', bone_name)
			sca.write(buffer)
		

		# Write bone links
		linksoffset = pad_file(sca, 'LINK')
		
		for link in self.bonelinks:
			buffer = struct.pack('l', link)
			sca.write(buffer)
		
		
		# Write data
		animoffset = pad_file(sca, 'DATA')
		
		#the space occupied by postion and rotation info on the bones.
		posrot_fmt = '3f4f'
		posrot_size = struct.calcsize(posrot_fmt)
		
		#this writes the position/rotation of the root bone in the first animation, as if it is at position 0, and no rotation
		#note: it looks like rot=1,0,0,0 is needed to indicate no rotation.
		buffer = struct.pack(posrot_fmt, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0)
		sca.write(buffer)
		
		for frame in self.frames:
			framesize = sca.tell()
			frame.save(sca)
			framesize = sca.tell() - framesize		
		
		
		# Update header
		sca.seek(0, 0)
		
		header = struct.pack(headerstruct, 
			magic, version, numframes, self.duration, numbones,
			namesoffset, linksoffset, animoffset, framesize)
		
		sca.write(header)
		
		sca.close()
		
		LOGp( "Bones: %d, Frames: %d;\n" % (numbones, numframes) )			
		
		#Log('OFFSETS: names = %d  links = %d  anim = %d  framesize = %d' % (namesoffset, linksoffset, animoffset, framesize))


######################################################
# Exporter Functions
######################################################

# Helper methods
######################################################

def pad(size):
	val = 32 - (size % 32)
	if (val < 4):
		val = val + 32
	
	return val

def pad_file(file, s4comment):
	N = pad(file.tell()) - 4
	filldata = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
	padding = struct.pack(str(N)+'s4s', filldata[0:N], s4comment)
	
	file.write(padding)

	return file.tell()
	

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



# Helper method for itterating through the bone tree
def itterate_bones(mesh, bone, parent = None, scm_parent_index = -1):
	
	global MArmatureWorld
	global BONES
	global xy_to_xz_transform
	


	
	if (parent != None and bone.parent.name != parent.name):
		PupMenu("Error: Invalid parenting in bone ... multiple parents?!%t|OK")
		Exit()
		#print "Invalid parenting in bone", bone.name," and parent ", parent.name
		return

	b_rest_pose 	= Matrix([0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0])
	b_rest_pose_inv = Matrix([0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0])
	b_rotation		= Quaternion( 0,0,0,0 )
	b_position		= Vector( 0,0,0 )
	b_index = len(mesh.bones)
	
	
	#MArmatureWorld = Matrix(arm_obj.matrixWorld)
	bone_matrix = Matrix(bone.matrix['ARMATURESPACE'])
	
	# Calculate the inverse rest pose for the bone #instead bonearmmat*worldmat = Matrix['BONESPACE']
	b_rest_pose 	= Matrix( bone_matrix * MArmatureWorld  )	
	b_rest_pose_inv = Matrix( b_rest_pose * xy_to_xz_transform ).invert()
	
	if (parent == None):
		rel_mat = b_rest_pose * xy_to_xz_transform 
		#root pos is the same as the rest-pose		
	else:
		parent_matrix_inv = Matrix( parent.matrix['ARMATURESPACE'] ).invert()
		rel_mat = Matrix(bone_matrix * parent_matrix_inv)
		# must be BM * PMI in that order
		# do not use an extra (absolute) extra rotation here, cause this is only relative
	
	#  Position & Rotation   relative to parent (if there is a parent)		
	b_rotation = 	rel_mat.toQuat()#.normalize()
	
	#row 3, cols 0,1,2 indicate position	
	b_position = Vector( rel_mat[3] )
	
	#def __init__(self, name, rest_pose_inv, rotation, position, parent_index):
	sc_bone = scm_bone( bone.name, b_rest_pose_inv, b_rotation, b_position, scm_parent_index )
	
	BONES.append(sc_bone)
	mesh.bones.append(sc_bone)
	
	# recursive call for all children
	if (bone.children != None):
		for child in bone.children: 
			itterate_bones( mesh, child, bone, b_index )


def make_scm(arm_obj):
	
	global MArmatureWorld
	global xy_to_xz_transform
	
	arm = arm_obj.getData()
	
	scn = Blender.Scene.GetCurrent()
	
	# Get all mesh objects for the selected armature & calculate progbar length
	pb_length = 0
	mesh_objs = []
	for obj in scn.objects:
		if obj.parent == arm_obj and obj.getType() == 'Mesh':
			#calculate progbar length
			bmesh_data = obj.getData(False, True)
			pb_length += len(bmesh_data.faces)
			
			mesh_objs.append(obj)	
		
	ProgBarFaces = ProgressBar( "Exp: Verts", pb_length )
			
	# Create SCM Mesh
	supcom_mesh = scm_mesh()
	
	# Traverse the bone tree	and  check if there is one root bone 
	numroots = 0
	for bone in arm.bones.values():			
		if (bone.parent == None):
			numroots += 1
			itterate_bones(supcom_mesh, bone)			
			
	if numroots > 1:
		PupMenu("Error: there are multiple root bones -> check you bone relations!%t|OK")
		Exit()
		return

	#this inserts a converted armature back into the existing model, to see
	#if the bone locations are correct (was used for debugging)
	#test_the_armature = 1
	#if test_the_armature:
	#	#create an extra test armature
	#	testarm_data= Blender.Armature.New('testArmature')
	#	testarm_ob = scn.objects.new(testarm_data)
	#	testarm_data.makeEditable()
	#	prev_eb = Non
	#	for bone in supcom_mesh.bones:
	#		print "mesh bone: ", bone.name
	#		eb = Blender.Armature.Editbone()
	#		eb.name = bone.name
	#		rest_pose = bone.rest_pose[3]
	#		eb.head = Vector(rest_pose[0], rest_pose[1], rest_pose[2])
	#		eb.tail = eb.head + Vector(1,0,0)
	#		if bone.parent_index != -1:
	#			eb.parent = prev_eb
	#		prev_eb = eb
	#		testarm_data.bones[eb.name]= eb
	#	testarm_data.update()
	

	
	# Process all the meshes
	for mesh_obj in mesh_objs:
		
		bmesh_data = mesh_obj.getData(False, True)	

		if not bmesh_data.faceUV :
			PupMenu("Error: Mesh has no texture values -> Please set your UV!%t|OK")
			Exit()
			return
			
		MatrixMesh = Matrix(mesh_obj.matrixWorld)
		mesh_name = mesh_obj.name
		
		for face in bmesh_data.faces:
		
			ProgBarFaces.do()									
			
			vertList = []
						
			for i in xrange(len(face.verts)):
				vert = face.verts[i]
				
				v_nor = Vector( 0, 0, 0 )
				v_pos = Vector( 0, 0, 0 )
				v_uv1 = Vector( 0, 0) #SC allows 2 uv's				
				v_boneIndex = [0]*4 #  SC supports up to 4 bones we will use only one
				#v_boneIndex = [-1,0,0,0]
				
				#Find controling bone
				v_boneIndex[0] = -1
				inf = bmesh_data.getVertexInfluences(vert.index)
				for j in xrange(len(inf)) :
					bonename = inf[j][0]
					for b in range(len(supcom_mesh.bones)):
						bone = supcom_mesh.bones[b]
						if bone.name == bonename:
							bone.used = True
							v_boneIndex[0] = b
							break
							
				if (v_boneIndex[0] == -1):
					v_boneIndex[0] = 0
					
					Blender.Window.EditMode(0)
					vert.sel = 1
					
					countLOG("Warning: Verticle without Bone Influence in %s. Selected " % (mesh_name))
				
				v_pos = Vector( vert.co * (MatrixMesh * xy_to_xz_transform))			
				
				v_nor = vert.no * (MatrixMesh * xy_to_xz_transform)
				
				#needed cause supcom scans an image in the opposite vertical direction or something?.
				v_uv1 = Vector(face.uv[i][0], 1.0 - face.uv[i][1])					
			
				vertList.append( scm_vertex( v_pos, v_nor, v_uv1 , v_boneIndex) )				
			
			if len(vertList) > 3:
				newFace = qFace()				
			else:
				newFace = Face()				
				
			newFace.addVert(vertList)
			newFace.addToMesh(supcom_mesh)	

	return supcom_mesh


def make_sca(arm_obj, action):

	global BONES
	global MArmatureWorld
	global xy_to_xz_transform
	
	action.setActive(arm_obj)
	
	scene = Blender.Scene.GetCurrent()
	render_context = scene.getRenderingContext()
	endframe = render_context.endFrame()
	animation = sca_anim()	
	#animation.duration = 1.5
	
	# Add bone names & links
	for bone in BONES:
		animation.bonenames.append(bone.name)
		animation.bonelinks.append(bone.parent_index)
		LOGn('adding bone: %s with parent %d ' % (bone.name, bone.parent_index))
	
	ProgBarAnimation = ProgressBar( "Exp: Anim", endframe) 
	
	# Add frames
	frame_counter = 1
	while frame_counter <= endframe:
		LOGn('adding frame %d of %d' % (frame_counter, endframe))		
		ProgBarAnimation.do()

		frame = sca_frame(animation)
			
		arm_obj.evaluatePose(frame_counter)
		frame_counter += 1
		
		POSED_BONES = {}
		for posebone in arm_obj.getPose().bones.values():
			POSED_BONES[posebone.name] = posebone.poseMatrix
		
		for bone in BONES:
			pose_bone_matrix = POSED_BONES[bone.name]
			
			if (bone.parent_index == -1):
				rel_mat = (Matrix(pose_bone_matrix) * MArmatureWorld) * xy_to_xz_transform
			else:
				rel_mat = Matrix(pose_bone_matrix) * Matrix(POSED_BONES[BONES[bone.parent_index].name]).invert()
			
			rotation = rel_mat.toQuat().normalize()
			#rot = rotation #[ rotation.w, rotation.x, rotation.y, rotation.z ]		
			pos = Vector( rel_mat[3][0], rel_mat[3][1], rel_mat[3][2] )
			
			anim_bone = sca_bone(pos, rotation)
			frame.bones.append(anim_bone)
		
		animation.frames.append(frame)		
	
	return animation

def export(outdir):
	global VERSION, USER_INFO
	global MArmatureWorld
	global xy_to_xz_transform
	
	w_edit_mode = Blender.Window.EditMode()
		
	#No animation export in editmode
	if w_edit_mode :
		Blender.Window.EditMode(0)
		
	Blender.Window.WaitCursor(1)
	
	xy_to_xz_transform.resize4x4()	
	
	scn = Blender.Scene.GetCurrent()
	# Get Selected object(s)
	selected_objects = Blender.Object.GetSelected()
	
	# Look for an armature
	arm = None
	arm_obj = None
	for obj in selected_objects:
		data = obj.getData()
		if type(data) is Blender.Types.ArmatureType:
			arm = data
			arm_obj = obj
			break
	
	# Is there one armature? Take this one
	if arm == None :	
		for obj in scn.objects:
			data = obj.getData()
			if obj.getType() == 'Armature' :
				if arm == None:
					arm = data
					arm_obj = obj
				else :
					arm = None
					break	
						
				
	if arm == None:
		PupMenu("Error: Please select your armature.%t|OK")
		Exit()
		return
		
	# this defines the ARMATURE_SPACE.
	# all bones in the armature are positioned relative to this space.
	MArmatureWorld = Matrix(arm_obj.matrixWorld)	
		
	# SCM
	LOGp(' ')
	LOGp(' ')
	LOGp('Exporting model: ' + arm_obj.name )
	LOGp('----------------------------------')
	mesh = make_scm(arm_obj)
	if mesh == None :
		LOGp('Aborted!')
		return
		
	mesh.info.append('Exported with Blender SupCom-Exporter ' + VERSION)
	if USER_INFO != "" :
		mesh.info.append( USER_INFO )
	mesh.save(outdir + arm_obj.name + '.scm')
	mesh = None

	# SCA
	actions = Blender.Armature.NLA.GetActions().iteritems()
	for action in actions:
		#action[0] = the key,  action[1] = the dictionary
		####maybe this could help?
		LOGp(' ')
		LOGp('Animation: ' + action[0])
		animation = make_sca(arm_obj, action[1])
		animation.save(outdir + action[0] + '.sca')		

	Blender.Window.EditMode(w_edit_mode)	
	Blender.Window.WaitCursor(0)

	LOGp('----------------------------------')
	
	closeLog()

	
	
	
	
	
######################################################
# GUI
######################################################

	
log = []
log_max_lines = 14
LOG_FILE = None

#log to file
def LOGn(message):
	global LOG_FILE
	global LOG_ENABLE
	global LOG_FILENAME
	
	if LOG_ENABLE :
		if LOG_FILE == None :			
			LOG_FILE = open( LOG_FILENAME, 'w')
			LOG_FILE.write('SupCom Exporter LOG File:\n\n')
			
			LOGp( "LOG enabled: %s" % (LOG_FILENAME))
			Log(message + '\n')
			
		else :		
			LOG_FILE.write(message + '\n')
			
#Log to file, to console and exp window					
def LOGp(message):
	global log, log_max_lines
	
	LOGn(message)
	print message	
	log.append(message)
	
	if len(log) > log_max_lines:
		del log[0]
		
		
counter = []
cLog = []
#log for a amount of errors like vertex errors
def countLOG(message):
	global cLog
	global counter
	
	cont = False
	
	for i in xrange(len(cLog)):
		if cLog[i] == message:
			cont = True
			counter[i] +=1
			break
			
	if not cont :
		
		cLog.append( message)
		counter.append( 1)

def closeLog():
	global cLog, LOG_FILE
	global counter
	
	for i in xrange(len(cLog)):
		LOGp("%s (Times:%d)" % (cLog[i], counter[i]))

	if LOG_FILE != None :
		LOG_FILE.close()	
		
	Blender.Window.RedrawAll()
		

class ProgressBar :

	global PROG_BAR_STEP
	global PROG_BAR_ENABLE
	
	progress = 0
	progressold = 0	
	current = 0	
	end = 0
	div = 0
	text = "None"	
	
	def __init__(self, text, end):
		self.progress = 0
		self.progressold = 0
		self.current = 0
		self.end = end
		self.text = text
		self.div = PROG_BAR_STEP
		
		#it looks like blender needs to init this progress bar with 0.0
		if PROG_BAR_ENABLE :
			Blender.Window.DrawProgressBar ( 0.0 , text)
		
	def do(self):	
		
		if PROG_BAR_ENABLE :
			self.current += 1
			self.progress = (self.current*self.div)/self.end
			
			if self.progress != self.progressold :
				self.progressold = self.progress
				Blender.Window.DrawProgressBar ( float(self.progress)/self.div , self.text)
				





# Events
EVENT_NOEVENT = 1
EVENT_DRAW = 2
EVENT_EXIT = 3
EVENT_CLOSE_LOG = 4
EVENT_EXPORTDIR_TEXT = 5
EVENT_EXPORTDIR = 6

export_directory = Blender.Draw.Create("sds")

show_log = 0

def fileselector_callback(filename):
	modelpath, modelfile = os.path.split(filename)
	export_directory.val = modelpath + '/'

def draw():
	global EVENT_NOEVENT, EVENT_DRAW, EVENT_EXIT, EVENT_CLOSE_LOG
	global export_directory, show_log
	global log_max_lines, log
	global VERSION

	# Titles
	glClear(GL_COLOR_BUFFER_BIT)
	
	top = 60 + log_max_lines * 12 + 8
	#top = 500
	top_x = 304
	
	glColor3f(0.8, 0.8, 1)
	glRecti(top_x, top, 4, 4)
	glBegin(GL_LINES)
	glColor3f(0.8, 0.8, 0.8)
	glVertex2d(4, top)
	glVertex2d(4, 4)
	glVertex2d(4, 4)
	glVertex2d(top_x, 4)
	glColor3f(0.5, 0.5, 0.5)
	glVertex2d(top_x, top)
	glVertex2d(4, top)
	glVertex2d(top_x, top)
	glVertex2d(top_x, top-1)
	glEnd()
	
	glColor3f(0, 0, 0)
	glRasterPos2d(10, top-16)
	Text("Supreme Commander Exporter " + VERSION)	
	
	# Show exporting log
	if show_log:

		for index in range(0, len(log)):
			i = (len(log) - 1) - index
			glRasterPos2i(10, 40 + i*12)
			Text(log[index]) #, 'tiny')
		
		
		Button("Close", EVENT_EXIT , 10, 10, 80, 18)
		#Blender.Window.RedrawAll()

		# Exporter GUI
	else:
		Blender.Draw.Button("Browse...", EVENT_EXPORTDIR, 10, 40, 80, 18, "")

		#if export_directory.val == 'sds':
			#automatically launch the browse window once
		#	Blender.Window.FileSelector (fileselector_callback, "Select output DIR")
		#	Blender.Redraw()
			
		export_directory = Blender.Draw.String("", EVENT_EXPORTDIR_TEXT, 100, 40, 200, 18, export_directory.val, 255, "Where to save the exported files")
			
		# Draw and Exit Buttons
		Button("Export", EVENT_DRAW , 10, 10, 80, 18)
		Button("Exit", EVENT_EXIT , 100, 10, 80, 18)

def event(evt, val):	
	if (evt == QKEY and not val): 
		Exit()

def bevent(evt):
	global EVENT_NOEVENT,EVENT_DRAW,EVENT_EXIT
	global export_directory
	global show_log

	if (evt == EVENT_EXIT): 
		show_log = 1
		Exit()
	
	elif (evt == EVENT_EXPORTDIR):
		Blender.Window.FileSelector (fileselector_callback, "Select output DIR")
		#Blender.Redraw()
	
	elif (evt == EVENT_DRAW):
		
		if (export_directory.val == ""):
			return
		
		show_log = 1
		modelpath, modelfile = os.path.split(export_directory.val)
		export(modelpath + '/')
		#changed cause filename was included in the dir selection		 
		#Blender.Redraw()


Register(draw, event, bevent)

#automatically launch the browse window once
Blender.Window.FileSelector (fileselector_callback, "Select output DIR")