#!BPY

#**************************************************************************************************
# Supreme Commander Importer for Blender3D - www.blender3d.org
#
# Written by dan - www.sup-com.net
#
# History
#   0.1.0   06/06/06   - Initial version. 
#   0.2.0   06/06/10   - Added SCA (Animation) support
#   0.3.0   06/07/02   - Alpha release
#
# Todo
#   - Material/uv map 2
#   - Bone pos/rot for scm & sca. Not perfect to use gentle words.
#   - Make sca loading independent of the scm_mesh. (e.g get bone pos/loc from armature instead)
#   - GUI for loading
#
#**************************************************************************************************

"""
Name: 'SupCom Model (.scm) 3.5'
Blender: 232
Group: 'Import'
Tooltip: 'Import Supreme Commander Models (*.scm) and Animations (*.sca)'
"""

import Blender
from Blender import NMesh, Scene, Object

from Blender import Mathutils
from Blender.Mathutils import *

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

import os
from os import path


import struct
import string
import math
from math import *


VERSION = '3.5'

######################################################
# User defined behaviour, Select as you need
######################################################

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

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

######################################################
# Init Supreme Commander SCM( _bone, _vertex, _mesh), SCA(_bone, _frame, _anim) Layout
######################################################
#xy_to_xz_transform = Matrix([1, 0, 0], [ 0, 0, 1], [ 0, 1, 0])
xy_to_xz_transform = Matrix([1, 0, 0], [ 0, 0, 1], [ 0, -1, 0])


	#	-1	0	0
	#	0	0	1
	#	0	1	0


class scm_bone :
	
	name = ""
	#rest_pose_inv = []
	rel_mat = []
	rel_mat_inv = []
	position = []
	rotation = []
	#abs_pos = []
	parent = 0
	parent_index = 0
	
	rel_matrix_inv = []
	#children = []
	#numchildren = 0
	#global xy_to_xz_transform
	
	def __init__(self, name):
		self.name = name
		#self.rest_pose_inv = [[0.0] * 4] * 4
		#self.position = [0.0] * 3
		#self.rotation = [0.0] * 4
		self.rel_mat_inv = Matrix([0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0])
		self.rel_mat = Matrix([0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0])
		self.rotation = Quaternion(0,0,0,0)
		self.position = Vector(0,0,0)

	def load(self, file):
		#global xy_to_xz_transform
		bonestruct = '16f3f4f4i'
		buffer = file.read(struct.calcsize(bonestruct))
		readout = struct.unpack(bonestruct, buffer)

		#supcom information:
		readRPI = Matrix([0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0])
		#// Inverse transform of the bone relative to the local origin of the mesh
		#// 4x4 Matrix with row major (i.e. D3D default ordering)
		for i in range(4):
			readRPI[i] = readout[i*4:i*4+4]
		
		self.rel_mat_inv = Matrix(readRPI[0], readRPI[1], readRPI[2], readRPI[3])#*xy_to_xz_transform #note rot here changes pointing direction of spikie 
		self.rel_mat = self.rel_mat_inv.invert()

		#self.rel_mat = (Matrix(rest_pose_inv).invert()) 

		#// Position relative to the parent bone.
		pos = readout[16:19]
		self.position = Vector(pos[0], pos[1], pos[2])
		
		#// Rotation relative to the parent bone.
		rot = readout[19:23]
		self.rotation = Quaternion( rot[0], rot[1], rot[2], rot[3] )

		#// Index of the bone's parent in the SCM_BoneData array
		self.parent_index = readout[24]
		
		# Read bone name
		#oldpos = file.tell()
		#file.seek(bone[..], 0)
		#self.name = file.readline()
		#file.seek(oldpos, 0)

		
		return self
	
	def dump(self):
		print 'Bone       ', self.name
		print 'Position   ', self.position
		print 'Rotation   ', self.rotation
		print 'Parent Idx ', self.parent_index		
		if (self.parent != 0): 
			print 'Parent     ', self.parent.name
		else:
			print 'Parent     <NONE>'		
		print 'Rest Pose Inv.'
		#for row in range(4):
			#print '  ', self.rest_pose_inv[row]		


class scm_vertex :
	
	position = []
	tangent = []
	normal = []
	binormal = []
	uv1 = []
	uv2 = []
	bone_index = []

	def __init__(self):
		self.position 	= Vector(0,0,0)
		self.tangent 	= Vector(0,0,0)
		self.normal 	= Vector(0,0,0)
		self.binormal 	= Vector(0,0,0)
		self.uv1 	= Vector(0,0)
		self.uv2 	= Vector(0,0)
		self.bone_index = [0]*4

	def load(self, file):
		
		vertstruct = '3f3f3f3f2f2f4B'
		vertsize = struct.calcsize(vertstruct)
		
		buffer = file.read(vertsize)
		vertex = struct.unpack(vertstruct, buffer)
		
		self.position = vertex[0:3]
		self.tangent = vertex[3:6]
		self.normal = vertex[6:9]
		self.binormal = vertex[9:12]
		self.uv1 = vertex[12:14]
		self.uv2 = vertex[14:16]
		self.bone_index = vertex[16:20]	
		
		return self
	
	def dump(self):
		print 'position ', self.position
		print 'tangent  ', self.tangent
		print 'normal   ', self.normal
		print 'binormal ', self.binormal
		print 'uv1      ', self.uv1
		print 'uv2      ', self.uv2
		print 'bones    ', self.bone_index


class scm_mesh :
	
	bones = []
	vertices = []
	faces = []
	info = []
	filename = ""
	
	def __init__(self):
		self.bones = []
		self.vertices = []
		self.faces = []
		self.info = []
		self.filename = ""

	def load(self, filename):	
		global xy_to_xz_transform
		self.filename = filename
		scm = file(filename, 'rb')
		
		# Read header
		headerstruct = '4s11L'
		buffer = scm.read(struct.calcsize(headerstruct))
		header = struct.unpack(headerstruct, buffer)
		
		marker = header[0]
		version = header[1]
		boneoffset = header[2]
		bonecount = header[3]
		vertoffset = header[4]
		extravertoffset = header[5]
		vertcount = header[6]
		indexoffset = header[7]
		indexcount = header[8]
		tricount = indexcount / 3 #?
		infooffset = header[9]
		infocount = header[10]
		totalbonecount = header[11]
		
		if (marker != 'MODL'):
			print 'Not a valid scm'
			return
			
		if (version != 5):
			print 'Unsupported version (%d)' % version
			return
		
		# Read bone names
		scm.seek(pad(scm.tell()), 1)
		length = (boneoffset - 4) - scm.tell()

		# This should probably be handeled by the scm_bone reader as it contains the nameoffset. But I'm lazy
		# and logic tells me it's written in the same order as the bones.
		buffer = scm.read(length)		
		rawnames = struct.unpack(str(length)+'s',buffer)		
		bonenames = string.split(rawnames[0],'\0')[:-1]
		
		# Read bones
		scm.seek(boneoffset, 0)
		for b in range(0, totalbonecount):
			bone = scm_bone(bonenames[b])
			bone.load(scm) 			
			self.bones.append(bone)
				
		#show them (for debug)				
		#for b in range(0, totalbonecount):
			#print "bone %d has %d children = " %(b, self.bones[b].numchildren)
		
		# Set parent (this could probably be done in the other loop since parents are usually written to the file
		# before the children. But you never know..
		for bone in self.bones:
			if (bone.parent_index != -1):
				bone.parent = self.bones[bone.parent_index]
			else:
				bone.parent = 0
		
			# the bone matrix relative to the parent.
			if (bone.parent != 0):
				mrel = (bone.rel_mat) * Matrix(bone.parent.rel_mat).invert() #* xy_to_xz_transform
				bone.rel_matrix_inv = Matrix(mrel).invert()
			else:
				mrel = bone.rel_mat * xy_to_xz_transform  #there is no parent
				bone.rel_matrix_inv = Matrix(mrel).invert()
				
				
		#self.rest_pose = Matrix(self.rest_pose[0], self.rest_pose[1], self.rest_pose[2], self.rest_pose[3])    	in sc =  rest pose inv
		#self.rel_mat = (Matrix(self.rest_pose).invert()) * xy_to_xz_transform  				in sc = rest pose yz
			
		
		# Read vertices
		scm.seek(vertoffset, 0)
		for b in range(0, vertcount):
			vert = scm_vertex()
			vert.load(scm)			
			self.vertices.append(vert)
		
		# Read extra vertex data		
		# Not implemented in Sup Com 1.0!
		
		# Read indices (triangles)
		tristruct = '3h'
		trisize = struct.calcsize(tristruct)
			
		scm.seek(indexoffset, 0)			
		for t in range(tricount):			
			buffer = scm.read(trisize)
			face = struct.unpack(tristruct, buffer)
			self.faces.append(list(face))
			
		
		# Read info
		if (infocount > 0):
			scm.seek(infooffset)
			buffer = scm.read()
			rawinfo = struct.unpack(str(len(buffer))+'s',buffer)		
			self.info = string.split(rawinfo[0],'\0')[:-1]
		
		scm.close()	
		
		return self

	def dump(self):
		print ''
		print 'Filename: ', self.filename
		print 'Bones ', len(self.bones)
		print 'Verts ', len(self.vertices)
		print 'Faces ', len(self.faces)		
		print ''
		print 'INFO: '
		for info in self.info:
			print '  ', info
		


class sca_bone:

	position = []
	rotation = []
	#changed: rototation -> rotation
	pose_pos = []
	pose_rot = []
	rel_matrix = []
	pose_matrix = []
	#rel_mat = None

	def __init__(self, pos, rot):
		self.position = pos
		self.rotation = rot
		self.rel_matrix = None
		self.pose_matrix = None
		#self.rel_mat = None
		

	def dump(self):
		print 'Position ', self.position
		print 'Rotation ', self.rotation
		


class sca_frame:

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

	def load(self, file):		
		frameheader_fmt = 'fl'
		frameheader_size = struct.calcsize(frameheader_fmt)
		buffer = file.read(frameheader_size)
		
		(self.keytime, self.keyflags) = struct.unpack(frameheader_fmt, buffer)
		
		posrot_fmt = '3f4f'
		posrot_size = struct.calcsize(posrot_fmt)
		
		for b in range (0, self.anim.numbones) :
			buffer = file.read(posrot_size)
			posrot = struct.unpack(posrot_fmt, buffer)			
			bone = sca_bone(posrot[0:3], posrot[3:7])			
			self.bones.append(bone)

	def dump(self):
		print 'Time  ', self.keytime
		print 'Flags ', self.keyflags
		


class sca_anim :
	
	filename = ""
	frames = []
	bones = []
	bonelinks = []
	bonenames = []
	numbones = 0
	duration = 0.0
	
	def __init__(self):
		self.filename = ""
		self.frames = []
		self.bones = []
		self.numbones = 0
		self.bonelinks = []
		self.bonenames = []
		self.duration = 0.0




	def calcAnimBoneMatrix(self, frame, bone_index, armature_bones, frame_index):
		global xy_to_xz_transform
		
		bone = frame.bones[bone_index];	
		parent_index = self.bonelinks[bone_index]

		# note that the pos/rot of the armature_bones are still in relative supcom coordinates.
		# so we can correct the relative pos-increase by the relative armature-increase
		pose_rel_pos = Vector(bone.position) 
		pose_rel_rot = Quaternion(bone.rotation) 

		# the matrix representation... it's easier to work with matrix notation I think.
		# the rotation:
		pose_rel_matrix = (pose_rel_rot.toMatrix()).resize4x4() 
		
		
		# the translation:
		for i in xrange(3):
			pose_rel_matrix[3][i] = pose_rel_pos[i]

		#pose_rel_matrix = pose_rel_matrix * xy_to_xz_transform
		#rel_pos = pose_rel_pos - armature_bones[bone_index].position
		#rel_rot = DifferenceQuats(pose_rel_rot, armature_bones[bone_index].rotation)
		
		if (parent_index == -1) :
			# for the root bone, this is already the absolution pos/rot, but,
			# the root bone should be rotated into the blender coordinates
			bone.rel_matrix = pose_rel_matrix * xy_to_xz_transform
			
			#testmat =(bone.rel_mat) * Matrix(bone.parent.rel_mat).invert()
			
		if (parent_index >= 0):
			# for all the children, they are seen relative to the parents.
			bone.rel_matrix = pose_rel_matrix 
		
		# Call all children
		for b in range(len(self.bonelinks)):
			if (self.bonelinks[b] == bone_index):
				self.calcAnimBoneMatrix(frame, b, armature_bones, frame_index)

		# the (rendered) animation positions are relative to
		# both the parent, and to the relative rest position of the bone.
		bone.pose_matrix = Matrix(bone.rel_matrix * armature_bones[bone_index].rel_matrix_inv)#* xy_to_xz_transform)

		#bone.pose_matrix = bone.pose_matrix * xy_to_xz_transform
		# pose position relative to the armature
		bone.pose_pos = Vector(bone.pose_matrix.translationPart())
		
		bone.pose_rot = bone.pose_matrix.toQuat()
		
		#test = bone.pose_matrix.toQuat()
		#bone.pose_rot = Quaternion( test.x, test.y, test.z, test.w)


	def load(self, filename):
		self.filename = filename
		sca = file(filename, 'rb')
		
		# Read header
		headerstruct = '4sllflllll'
		buffer = sca.read(struct.calcsize(headerstruct))
		header = struct.unpack(headerstruct, buffer)
		
		(magic,             \
		 version,           \
		 numframes,         \
		 self.duration,     \
		 self.numbones,     \
		 namesoffset,       \
		 linksoffset,       \
		 animoffset,        \
		 framesize) = struct.unpack(headerstruct, buffer)
		
		if (magic != 'ANIM'):
			print 'Not a valid .sca animation file'
			return
		
		if (version != 5):
			print 'Unsupported sca version: %d'  % version
			return
		
		# Read bone names
		sca.seek(namesoffset, 0)
		length = linksoffset - namesoffset
		buffer = sca.read(length)		
		rawnames = struct.unpack(str(length)+'s',buffer)		
		self.bonenames = string.split(rawnames[0], '\0')[:-1]
		
		# Read links
		links_fmt = str(self.numbones)+'l'
		links_size = struct.calcsize(links_fmt)
		
		buffer = sca.read(links_size)
		self.bonelinks = struct.unpack(links_fmt, buffer)
			
		posrot_fmt = '3f4f'
		posrot_size = struct.calcsize(posrot_fmt)
		
		sca.seek(animoffset)
		buffer = sca.read(posrot_size)
		root_posrot = struct.unpack(posrot_fmt, buffer)
		
		for f in range (0, numframes) :
			frame = sca_frame(self)
			frame.load(sca)
			self.frames.append(frame)
		
		sca.close()
		
		return self

	def dump(self):
		print 'SCA:  ', self.filename
		print 'Duration: %fs' % self.duration
		print 'Num loaded frames ', len(self.frames)
		
		print 'Bonelinks'		
		for link in self.bonelinks:
			print ' ', link
		
		print 'Bone names'
		for name in self.bonenames:
			print ' ', name
	
				
def pad(size):
	val = 32 - (size % 32)
	
	if (val > 31):
		return 0
		
	return val
			
			
#**************************************************************************************************
# Blender Interface
#**************************************************************************************************

def read_scm() :
	global xy_to_xz_transform
	global scm_filepath # [0] both [1] path [2] name
	global sca_filepath # [0] both [1] path [2] name
	
	print "=== LOADING Sup Com Model ==="
	print ""
	
	xy_to_xz_transform.resize4x4()
	
	scene = Blender.Scene.GetCurrent() 	
	
	mesh = scm_mesh()
	
	if (mesh.load(scm_filepath[0]) == None):
		print 'Failed to load %s' %scm_filepath[2]
		return
	
	ProgBarLSCM = ProgressBar( "Imp: load SCM", (2*len(mesh.vertices) + len(mesh.faces)))	
	
	armature_name = string.rstrip(scm_filepath[2], ".scm")
	print "armature ", armature_name
	
	###		CREATE ARMATURE 
	armObj = Object.New('Armature', armature_name)	#bad 
	
	armData = Blender.Armature.Armature(armature_name) 
	armData.drawAxes = True 
	armData.makeEditable()	
	 
	for index in range(len(mesh.bones)):
		bone = mesh.bones[index]	
		blender_bone = Blender.Armature.Editbone()		
		#not nice parent may not exist,  but usualy should exist (depends on storing in scm)
		if (bone.parent != 0) :
			blender_bone.parent = armData.bones[bone.parent.name]
		

		#blender_bone.options(Armature.CONNECTED)
		blender_bone.matrix = Matrix(bone.rel_mat * xy_to_xz_transform)		
				
		armData.bones[bone.name] = blender_bone

	
	#save changes (after linking!)
	armObj.link(armData)
	scene.link(armObj)
	#scene.objects.new(armData)
	###		CREATE MESH
	meshData = Blender.Mesh.New('Mesh')
	
	ProgBarLSCM.text = "IMP: Verticles"
	#add verts
	vertlist = []
	for vert in mesh.vertices:
		ProgBarLSCM.do()
		vertlist.append(Vector(vert.position)*xy_to_xz_transform)
	
	meshData.verts.extend(vertlist)

	meshData.vertexUV = True
	for i_v in xrange(len(meshData.verts)):
		uv1 = mesh.vertices[i_v].uv1
		meshData.verts[i_v].uvco = Vector(uv1[0], 1.0-uv1[1])
	
	ProgBarLSCM.text = "IMP: Faces"
	
	#reverse faces
	#for face in mesh.faces:
	#	face.reverse()
		
	#add faces
	meshData.faces.extend(mesh.faces)	
	meshData.faceUV = True	
	for face in meshData.faces :
		ProgBarLSCM.do()
		face.uv = [face.verts[i].uvco for i in range(3)]
	
	#put in scene
	mesh_obj = Object.New('Mesh','Mesh')
	mesh_obj.link(meshData)
	
	#scene.objects.new(meshData)

	#assigns vertex groups #mesh must be in object
	for bone in mesh.bones:
		meshData.addVertGroup(bone.name)

	for vertex_index in range(len(mesh.vertices)):
		ProgBarLSCM.do()
		vertex = mesh.vertices[vertex_index]
		bone_index = vertex.bone_index[0]
		meshData.assignVertsToGroup(mesh.bones[bone_index].name, [vertex_index], 1.0, Blender.Mesh.AssignModes.REPLACE) #'REPLACE'
	
	# it works... but you've to select/change to edit mode for the object to show up.
	# dunno why that is, maybe because Nmesh is depracated.
	meshData.update()
		
	#bones disapear wen update ?
	#armData.update()

	scene.link(mesh_obj)
	
	#must be in scene
	#armObj = None 
	#meshObj = None
	#for obj in Object.Get():
	#	if obj.getType() == 'Armature':
	#		armObj = obj
	#	if obj.getType() == 'Mesh':
	#		meshObj = obj
			
	#mesh_obj = Blender.Object.Get('Mesh')
	armObj.makeParentDeform([mesh_obj], 0, 0)
	#makeParentVertex(objects, indices, noninverse=0, fast=0)
	
	meshData.update()
	armData.update() 

	if len(mesh.info):
		print "=== INFO ==="
		for info in mesh.info:
			print "",info

	print "=== COMPLETE ==="
	
	if sca_filepath[0] != "" :
		read_anim(mesh)

	


def read_anim(mesh):
	global xy_to_xz_transform
	global sca_filepath # [0] both [1] path [2] name
	
	#xy_to_xz_quat = xy_to_xz_transform.toQuat()
	
	print "=== LOADING Sup Com Animation ==="
	print ""
	
	anim = sca_anim()
	anim.load(sca_filepath[0])
	
	ProgBarLSCA = ProgressBar( "Imp: Frames", len(anim.frames))
	
	scene = Blender.Scene.GetCurrent()
	
	arm_obj = None
	for obj in scene.objects:
		data = obj.getData()
		if type(data) is Blender.Types.ArmatureType:
			arm_obj = obj
			break
		
	if arm_obj == None:
		print "couldn't apply animation, no armature in the scene" 
		return
	#arm_obj = armObj

	print arm_obj.name
	#actionpath, actionname = os.path.split(filename)
	
	action = Blender.Armature.NLA.NewAction(sca_filepath[2])
	action.setActive(arm_obj)
	
	pose = arm_obj.getPose()
	
	for frame_index in xrange(len(anim.frames)):
		ProgBarLSCA.do()

		Blender.Set("curframe", frame_index+1)
		frame = anim.frames[frame_index]

		# this changes the relative orientation (supcom) to absolute orientation (blender)
		anim.calcAnimBoneMatrix(frame, 0, mesh.bones, frame_index)

		# this inserts the bones information into blender.
		for b in range(len(frame.bones)):
			pose_bone = pose.bones[anim.bonenames[b]]
			
			if (pose_bone == None):
				print 'Frame %d - Bone \"%s\" not found' % (frame_index, anim.bonenames[b])
				continue	
				
			anim_bone = frame.bones[b]
			
			pose_bone.loc =  anim_bone.pose_pos 
			pose_bone.quat = anim_bone.pose_rot
			pose_bone.size = Vector(1,1,1)
					
			pose.update()
			pose_bone.insertKey(arm_obj, frame_index+1, [Blender.Object.Pose.LOC, Blender.Object.Pose.ROT, Blender.Object.Pose.SIZE])
			pose.update()
	
	Blender.Set("curframe", 1)
	
	#scene = Blender.Scene.GetCurrent()
	context = scene.getRenderingContext()

	context.endFrame(len(anim.frames)+1)
	
	print "=== COMPLETE ==="



######################################################
# 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_DRAW = 1
EVENT_EXIT = 2
EVENT_SCMDIR = 3
EVENT_SCADIR = 4


show_log = 0

sca_filepath = [ "", "", "None"]
scm_filepath = [ "", "", "None"]

def anim_fileselector_callback(filename):
	global sca_filepath
	
	sca_filepath[0] = filename
	
	#print "Filename%sI\n" % filename
	#if ( filename != "" ) :
		#sca_filepath = [ "" , "None"]
		#return
	#else :
	
	length = len(filename)
	if filename[length-4:length] == ".sca" :		
		sca_filepath[1], sca_filepath[2]  = os.path.split(filename)
	else :
		sca_filepath[0] = ""
		sca_filepath[1] = ""
		sca_filepath[2] = "Non Supported"
	#sca_filepath[1] , sca_filepath[2] = os.path.split(filename)


def fileselector_callback(filename):
	global scm_filepath
	#sadly you cant check whether the cancel button is pressed
	scm_filepath[0] = filename
	#print "Filename%sI\n" % filename
	#if ( filename != "" ) :
	length = len(filename)
	if filename[length-4:length] == ".scm" :		
		scm_filepath[1], scm_filepath[2]  = os.path.split(filename)
	else :
		scm_filepath[0] = ""
		scm_filepath[1] = ""
		scm_filepath[2] = "Non Supported"
	#	Exit()
	

#def forcequit()
#	Exit()

	
def draw():
	global EVENT_DRAW, EVENT_EXIT,EVENT_SCADIR,EVENT_SCADIR
	global scm_filepath, sca_filepath, 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 Importer " + 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)

		# Exporter GUI
	else:
		
		

		#if scm_directory.val == 'scm':
		#if scm_filepath[1] == 'None' :
			#automatically launch the browse window once
		#	Blender.Window.FileSelector (fileselector_callback, "Select SCM File", "*.scm")
			#Exit() # why dont you go to exit?, never
		#	forcequit()

		
		Blender.Draw.Button("Browse SCM", EVENT_SCMDIR, 10, 45, 80, 18, "Select scm")
		Blender.Draw.Button("Browse SCA", EVENT_SCADIR, 10, 80, 80, 18, "Select sca")	
		
		glRasterPos2d(100, 47)
		if scm_filepath[0] == "" :
			Text("SCM: " + scm_filepath[2])
		else:
			Text(":" + scm_filepath[2])
			
		glRasterPos2d(100, 82)
		if sca_filepath[0] == "" :
			Text("SCA: " + sca_filepath[2])
		else : 
			Text(":" + sca_filepath[2])

		# Draw and Exit Buttons
		Button("Import", 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_DRAW,EVENT_EXIT
	global scm_filepath
	global show_log

	if (evt == EVENT_EXIT): 
		#show_log = 1
		Exit()
	
	elif (evt == EVENT_SCMDIR):
		Blender.Window.FileSelector (fileselector_callback, "Select SCM File")
		Blender.Redraw()
		
	elif (evt == EVENT_SCADIR):
		if scm_filepath[0] != "" :			
			Blender.Window.FileSelector (anim_fileselector_callback, "Select SCA File", scm_filepath[1]+"\\")			
		else :
			Blender.Window.FileSelector (anim_fileselector_callback, "Select SCA File")			
		Blender.Redraw()
	
	elif (evt == EVENT_DRAW):
		
		if (scm_filepath[0] != ''):		
			show_log = 1			
			read_scm() 
			
		#if (sca_filepath[0] != ''):
		#	show_log = 1
		#	read_sca()
		
		Blender.Redraw()

		

Register(draw, event, bevent)

#open fileselector automaticly
Blender.Window.FileSelector (fileselector_callback, "Select SCM File")