Initial import, blender scripts

blenderscripts/blender_python_old/OLD/OLD2_export_bone_animation.py

@@ -0,0 +1,157 @@
+import Blender
+import os.path
+
+
+##################
+#  matrix funcs  #
+##################
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[i][j], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+def NewMatrix():
+	n = range(4)	
+	for i in range(0, 4):
+		n[i] = range(4)		
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if i!=j: n[i][j] = 0.0
+			else:    n[i][j] = 1.0
+	return n
+
+
+def CopyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = round( matfrom[i][j], 5 )
+			
+
+def IdenticalMatrices( m0, m1 ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			a = round(m0[i][j], 5)
+			b = round(m1[i][j], 5) 
+			if a != b: return 0
+	return 1
+
+##########
+#  main  #
+##########
+def main():
+	
+	print "\n---- Exporting Bone IPO ----"
+	
+	g_obj = Blender.Object.GetSelected()
+	g_keyframes_num = 0
+	g_matrices_d = {}
+	g_matrix_indeces_d = {}
+	
+	######################################
+	########## extract the data ##########
+	######################################
+	if len( g_obj ) < 1:
+		print "-->ERROR: Object not selected"
+		return
+	
+	g_obj = g_obj[0]
+	if g_obj.getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + g_obj.getType()
+		return
+	
+	if g_obj.getAction() == 0:
+		print "-->ERROR: No action selected"
+		return
+	
+	list = g_obj.getAction().getFrameNumbers()
+	g_keyframes_num = list[ len(list) -1 ]
+	
+	
+	Blender.Set( "curframe", 1 )
+	for key in range( 1, g_keyframes_num+1 ):
+		Blender.Set( "curframe", key )
+		Blender.Redraw()
+		
+		pb_names = g_obj.getPose().bones.keys()
+	
+		pb_names.sort()
+		for pb_nam in pb_names:
+			pb = g_obj.getPose().bones[ pb_nam ]
+				
+			
+			if key==1:
+				g_matrices_d[pb_nam] = []
+				g_matrix_indeces_d[pb_nam] = []
+
+			index_mat = NewMatrix()
+			src_m = NewMatrix()
+			CopyMatrix( pb.localMatrix, src_m )
+			
+			i = 0
+			found = 0
+			for mat in g_matrices_d[pb_nam]:
+				if IdenticalMatrices( mat, src_m ):
+					found = 1
+					break
+				i = i+1
+			
+			if found:
+				g_matrix_indeces_d[pb_nam].append( i )
+			elif IdenticalMatrices( src_m, index_mat ):
+				g_matrix_indeces_d[pb_nam].append( -1 )	
+			else:
+				g_matrices_d[pb_nam].append( src_m )
+				g_matrix_indeces_d[pb_nam].append( len(g_matrices_d[pb_nam])-1 )
+
+			# search and if you find in all the bone's matrice_indeces the -1 the bone doesnt have any animation
+			# then delete the appropriate
+			if key == g_keyframes_num:
+				anim = 0
+				for i in g_matrix_indeces_d[pb_nam]:
+					if i != -1:
+						anim = 1
+				if not anim:
+					del g_matrix_indeces_d[pb_nam]
+					del g_matrices_d[pb_nam]
+								
+	
+	###################################
+	########## write to file ##########
+	####################################
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ):
+		path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"	
+	filename = path + g_obj.getAction().name + ".armat_ipo.txt"
+	file = open( filename, "w" )
+
+	file.write( "BONES_NUM " + str( len(g_matrices_d) ) + "\n" )
+	file.write( "KEYFRAMES_NUM " + str( g_keyframes_num ) + "\n" )
+
+	# for every bone
+	for pb_nam in g_matrices_d.keys():
+		file.write( "BONE * NAME " + pb_nam + "\n" )
+		file.write( "MATRICES_NUM " + str( len(g_matrices_d[pb_nam]) ) + "\n" )
+		
+		for mat in g_matrices_d[pb_nam]:
+			file.write( "MATRIX * " )
+			for i in range(0, 4):
+				for j in range(0, 4):
+					file.write( "%f " % mat[j][i] )
+			file.write( "\n" )
+	
+		file.write( "MATRIX_INDECES " )
+		for i in g_matrix_indeces_d[pb_nam]:
+			file.write( str(i) + " " )
+		file.write( "\n" )
+
+	file.close()
+	print "Done! File \"%s\" created successfuly" %filename
+
+main()

blenderscripts/blender_python_old/OLD/OLD_export_bone_animation.py

@@ -0,0 +1,267 @@
+
+import Blender
+
+
+
+#=================
+# matrices funcs
+#=================
+def NewMatrix():
+	n = range(4)	
+	for i in range(0, 4):
+		n[i] = range(4)
+		
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if i!=j: n[i][j] = 0.0
+			else:    n[i][j] = 1.0
+	return n
+
+
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[i][j], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+			
+		print "]"
+
+
+def ReverseMatrix( matrix_ ):
+	matrix = matrix_[:]
+
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if j < i:
+				tmp = matrix[i][j]
+				matrix[i][j] = matrix[j][i]
+				matrix[j][i] = tmp
+	
+	return matrix
+
+
+def CopyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = matfrom[i][j]
+			
+
+def IdenticalMatrices( m0, m1 ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if m0[i][j] != m1[i][j]: return 0
+	return 1
+
+
+#==============
+# global vars
+#==============
+path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\"
+file = 0
+obj = 0
+matrices = {} # create the array that holds all the unique matrices
+poses = {} # this dict holds the matrix indeces for every bone. poses["bone_name"][frame-1] = matrix_index
+
+
+#==============
+# frames funcs
+#==============
+def GetFramesNum():
+	global obj
+	
+	list = obj.getAction().getFrameNumbers()
+	return list[ len(list) -1 ]
+
+
+def GetFirstFrame():
+	global obj
+	return obj.getAction().getFrameNumbers()[0]
+
+
+def MoveToFrame( num ):
+	Blender.Set( "curframe", num )
+	Blender.Redraw()
+	
+
+#==============
+# GetData
+#==============
+def GetData():
+	global file
+	global obj
+	
+	print "Extracting data..."
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + objs[0].getType()
+		return 0
+
+	obj = objs[0]
+
+	# see if it has actions
+	if obj.getAction == 0:
+		print "-->ERROR: No action selected"
+		return 0
+	
+	print "Done!\n"
+	return 1
+
+
+#==============
+# GetAnim
+#==============
+def GetAnim():
+	global metrices
+	global poses
+
+	print "Extracting animation data..."
+	crntFra = Blender.Get( "curframe" )
+	
+	MoveToFrame(1)
+	
+	pose_bone_names = obj.getPose().bones.keys()
+	
+	for pb_nam in pose_bone_names: # for every pose bone
+		
+		poses[pb_nam] = range( GetFramesNum() )
+		matrices[pb_nam] = []
+		
+		for f in range( GetFirstFrame(), GetFramesNum()+1 ): # for every frame of that bone
+			MoveToFrame(f)
+			
+			pb = obj.getPose().bones[ pb_nam ]
+			
+			found = 0
+			i = -1 # set it as -1 cause in case of not exec of the below for
+			for i in range( 0, len(matrices[pb_nam]) ): # for all matrices of tha bone
+				if IdenticalMatrices( matrices[pb_nam][i], pb.localMatrix ) == 1:
+					found = 1
+					break
+			
+			if not found:
+				ide_mat = NewMatrix()
+				# if the local matrix is the identity matrix then put -1 to save space
+				if IdenticalMatrices( pb.localMatrix, ide_mat ):
+					i = -1
+				else:
+					tmp = NewMatrix()
+					CopyMatrix( pb.localMatrix, tmp )
+					matrices[pb_nam].append( tmp )
+					i = i + 1
+				
+			poses[pb_nam][f-1] = i
+		# } end for every frame	
+		
+		# now do a check
+		# check if the bone has moved at all
+		ide_mat = NewMatrix()
+		if len(matrices[pb_nam]) == 0 :
+			del poses[pb_nam]
+				
+		
+		MoveToFrame(1)
+	# end for every bone
+	
+	
+	MoveToFrame( crntFra )
+	print "Done!\n"
+	return 1
+
+
+#==============
+# WriteFile
+#==============
+def WriteFile():
+	global matrices
+	global poses
+	global path
+	global obj
+	
+	print "Writing data to file..."
+	
+	# open file
+	file = open( path + obj.getAction().name + ".armat_ipo.g", "w" )
+	
+	# write header
+	file.write( "BONES_NUM " + str(len(poses)) + "\n" )
+	file.write( "KEYFRAMES_NUM " + str(GetFramesNum()) + "\n" )
+	
+	# for every bone
+	i = 0
+	for pose_nam in poses.keys():
+		file.write( "BONE " + str(i) + " NAME " + str(pose_nam) + "\n" )
+		
+		file.write( "MATRICES_NUM " + str(len(matrices[pose_nam])) + "\n" )
+		
+		# write matrices
+		for j in range( 0, len(matrices[pose_nam]) ):
+			file.write( "MATRIX " + str(j) + " " )
+			ReverseMatrix( matrices[pose_nam][j] )
+			for k in range(0, 4):
+				for l in range(0, 4):
+					file.write( str(matrices[pose_nam][j][k][l]) + " " )
+			file.write( "\n" )
+		
+		# write matreix inteces
+		file.write( "MAT_INDECES " )
+		for j in range(0, GetFramesNum()):
+			file.write( str(poses[pose_nam][j]) + " " )
+			
+		i = i + 1
+		file.write("\n")
+	file.close()
+	
+	print "Done!\n"
+	return 1
+
+
+#==============
+# main
+#==============
+def main():
+
+	print "\n--------------------------------------------------------"
+	print "                     EXPORT ANIMATIONS"
+	print "--------------------------------------------------------\n"
+	
+	if GetData():
+		if GetAnim():
+			WriteFile()
+	
+	"""print poses
+	print 
+	
+	names = matrices.keys()
+	for nam in names:
+		for mat in matrices[nam]:
+			PrintMatrix( mat )
+			print
+		break
+		
+	
+	
+	pb = obj.getPose().bones.values()[0];
+
+	print "HEAD:  " + str(pb.head)
+	print "TAIL:  " + str(pb.tail)
+	print
+	
+	mat = NewMatrix()
+	CopyMatrix( pb.localMatrix, mat )
+	ReverseMatrix( mat )
+	
+	PrintMatrix(mat)"""
+	
+	print "\n--------------------------------------------------------"
+		
+
+main()

blenderscripts/blender_python_old/OLD/OLD_export_mesh.py

@@ -0,0 +1,175 @@
+import Blender
+import string
+import os.path
+
+def MatrixMul( matrix, vector ):
+	vec = [0, 0, 0]
+	
+	for i in range(0, 3):
+		for j in range(0, 3):
+			vec[i] = vec[i] + matrix[j][i] * vector[j]
+		vec[i] = vec[i] + matrix[3][i]
+		
+	for i in range(0, 3):
+		vector[i] = vec[i]
+	
+
+####################################################################################
+file = 0
+mesh = 0
+round_to = 4
+matrix = 0
+path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+if not os.path.exists( path ):
+	path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	
+
+####################################################################################
+def GetMesh():
+	global file
+	global mesh
+	global path
+	global matrix
+	
+	print "Getting mesh data..."
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData( 0, 1 )
+	
+	if not mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+	matrix = objs[0].getMatrix()
+
+	# open file
+	file = open( path + mesh.name + ".mesh.g", "w" )
+	
+	print "Done!\n"
+	return 1
+	
+
+####################################################################################
+def VertGroups():
+	global mesh
+	global file
+	print "Saving vertex groups..."
+	
+	# write vert groups
+	group_names = mesh.getVertGroupNames()
+	file.write( "GROUPS_NUM " + str(len( group_names )) + "\n" )
+	i = 0
+	for group_name in group_names:
+		file.write( "GROUP " + str(i) + " GROUP_NAME " + group_name + " VERTS_NUM " )
+		verts = mesh.getVertsFromGroup( group_name )
+		file.write( str(len(verts)) + " VERTS " )
+		for vert in verts: 
+			file.write( str(vert) + " " )
+		file.write( "\n" )
+		i = i+1
+
+	print "Done!\n"	
+	return 1
+	
+	
+####################################################################################
+def Verts():
+	global file
+	global mesh
+	global matrix
+	print "Saving vertices..."
+
+	# write vert data
+	file.write( "VERTS_NUM " + str( len(mesh.verts) ) + "\n" )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		MatrixMul( matrix, coords )
+		MatrixMul( matrix, normal )
+		
+		file.write( "VERT %d COORDS %f %f %f" %(vert.index, coords[0], coords[1], coords[2]) )
+		file.write( " NORMAL %f %f %f\n" %(normal[0], normal[1], normal[2]) )
+	
+	print "Done!\n"
+	return 1
+
+
+####################################################################################
+def Faces():
+	print "Saving faces..."
+
+	# WRITE THE FACES
+	file.write( "FACE_NUM " + repr( len( mesh.faces ) ) + "\n" )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+		
+		# print type
+		if( len( face.v ) != 3 ):
+			print "-->ERROR: The mesh must contain only triagles"
+			return 0
+			
+		file.write( "TRIANGLE " + str(i) + " VERTS " )
+		
+		# print index
+		for vert in face.v:
+			file.write( str(vert.index) + " " )
+		
+		# print normal cordS
+		x = round( face.no.x, round_to)
+		y = round( face.no.y, round_to)
+		z = round( face.no.z, round_to)
+		file.write( "NORMAL " + str(x) + " " + str(y) + " " + str(z) + " " )
+		
+		# WRITE UVs
+		file.write( "UV " )
+		for uv in face.uv:
+			x = round( uv.x, round_to )
+			y = round( uv.y, round_to )
+			file.write( str(x) + " " + str(y) + " " )
+		
+		file.write( "\n" )
+		
+		i = i+1
+	
+	print "Done!\n"	
+	return 1
+
+
+####################################################################################
+def main():
+	global file
+	
+	print "\n--------------------------------------------------------"
+	print "                       EXPORT MESH"
+	print "--------------------------------------------------------\n"
+	
+	if GetMesh():
+		if VertGroups():
+			if Verts(): 
+			 if Faces():
+				print "File created at \"%s\"" %path
+	
+	
+	if file: file.close()
+	
+	print "\n--------------------------------------------------------"
+
+main()

blenderscripts/blender_python_old/OLD/armature_animation(bone poses).py

@@ -0,0 +1,268 @@
+import Blender
+import os.path
+from Blender.Mathutils import *
+
+
+######################
+#### matrix funcs ####
+######################
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = matrix[i][j]
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+		
+		
+def MulMatrix( m, b ):
+	c = NewMatrix()
+	c[0][0] = m[0][0]*b[0][0] + m[0][1]*b[1][0] + m[0][2]*b[2][0] + m[0][3]*b[3][0]
+	c[0][1] = m[0][0]*b[0][1] + m[0][1]*b[1][1] + m[0][2]*b[2][1] + m[0][3]*b[3][1]
+	c[0][2] = m[0][0]*b[0][2] + m[0][1]*b[1][2] + m[0][2]*b[2][2] + m[0][3]*b[3][2]
+	c[0][3] = m[0][0]*b[0][3] + m[0][1]*b[1][3] + m[0][2]*b[2][3] + m[0][3]*b[3][3]
+	c[1][0] = m[1][0]*b[0][0] + m[1][1]*b[1][0] + m[1][2]*b[2][0] + m[1][3]*b[3][0]
+	c[1][1] = m[1][0]*b[0][1] + m[1][1]*b[1][1] + m[1][2]*b[2][1] + m[1][3]*b[3][1]
+	c[1][2] = m[1][0]*b[0][2] + m[1][1]*b[1][2] + m[1][2]*b[2][2] + m[1][3]*b[3][2]
+	c[1][3] = m[1][0]*b[0][3] + m[1][1]*b[1][3] + m[1][2]*b[2][3] + m[1][3]*b[3][3]
+	c[2][0] = m[2][0]*b[0][0] + m[2][1]*b[1][0] + m[2][2]*b[2][0] + m[2][3]*b[3][0]
+	c[2][1] = m[2][0]*b[0][1] + m[2][1]*b[1][1] + m[2][2]*b[2][1] + m[2][3]*b[3][1]
+	c[2][2] = m[2][0]*b[0][2] + m[2][1]*b[1][2] + m[2][2]*b[2][2] + m[2][3]*b[3][2]
+	c[2][3] = m[2][0]*b[0][3] + m[2][1]*b[1][3] + m[2][2]*b[2][3] + m[2][3]*b[3][3]
+	c[3][0] = m[3][0]*b[0][0] + m[3][1]*b[1][0] + m[3][2]*b[2][0] + m[3][3]*b[3][0]
+	c[3][1] = m[3][0]*b[0][1] + m[3][1]*b[1][1] + m[3][2]*b[2][1] + m[3][3]*b[3][1]
+	c[3][2] = m[3][0]*b[0][2] + m[3][1]*b[1][2] + m[3][2]*b[2][2] + m[3][3]*b[3][2]
+	c[3][3] = m[3][0]*b[0][3] + m[3][1]*b[1][3] + m[3][2]*b[2][3] + m[3][3]*b[3][3]
+	return c
+	
+		
+def NewMatrix():
+	m4 = Matrix( [1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.] )
+	return m4
+
+
+def CpyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = round( matfrom[i][j], 5 )
+
+
+def CpyQuat( qfrom, qto ):
+	for i in range(0, 4):
+		qto[i] = qfrom[i]
+		
+		
+def CpyVec( vfrom, vto ):
+	for i in range(0, 3):
+		vto[i] = vfrom[i]
+
+
+identity_mat = NewMatrix()
+
+
+#################
+#### classes ####
+#################
+class pose_t:
+	def __init__(self):
+		self.keyframe = 0
+		self.matrix = NewMatrix()
+		self.quat = Quaternion()
+		self.loc  = Vector( 0.0, 0.0, 0.0 )
+		self.scale = Vector( 0.0, 0.0, 0.0 )
+
+class bone_ipo_t:
+	def __init__(self):
+		self.poses = []
+
+
+###############
+#### main  ####
+###############
+def main():
+	
+	print "\n\n---- Exporting Bone IPO ----"
+	
+	obj = Blender.Object.GetSelected()
+	keyframes_num = 0
+	bone_ipos = {}
+
+	######################################
+	########## extract the data ##########
+	######################################
+	if len( obj ) < 1:
+		print "-->ERROR: Object not selected"
+		return
+	
+	obj = obj[0]
+	if obj.getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + obj.getType()
+		return
+	
+	armat = obj.getData(0,1)
+	
+	if obj.getAction() == 0:
+		print "-->ERROR: No action selected"
+		return
+	
+	kframes = obj.getAction().getFrameNumbers()
+	# for every nodal keyframe aka keyframe
+	for kframe in kframes:
+		Blender.Set( "curframe", kframe )
+		Blender.Redraw()
+		
+		#determin if it is the first or the last frame
+		first_kframe = 0
+		last_kframe = 0
+		if kframe == obj.getAction().getFrameNumbers()[0]: first_kframe = 1
+		if kframe == obj.getAction().getFrameNumbers()[ len(obj.getAction().getFrameNumbers())-1 ]: last_kframe = 1
+		
+		# for all bones
+		pb_names = obj.getPose().bones.keys()
+		for pb_nam in pb_names:
+			pb = obj.getPose().bones[ pb_nam ]
+			pose = pose_t()
+				
+			if first_kframe:
+				bone_ipos[pb_nam] = bone_ipo_t()
+		
+			############
+			#  matrix  #
+			############
+			CpyMatrix( pb.localMatrix, pose.matrix )
+			
+			
+			############
+			#  kframe  #
+			############
+			pose.keyframe = kframe
+
+
+			################
+			#  quaternion  #
+			################
+			m4rot = pb.quat.toMatrix() # the quat to mat3...
+			m4rot.resize4x4()          # and now to mat4
+			ma = NewMatrix()           # bone's matrix in armature space
+			mai = NewMatrix()          # and the inverted
+			# set ma and mai
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], ma )
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], mai )
+			mai.invert()
+			# calc the rotation in armature space cause its in bone space
+			# use my mul matrix cause blenders produces wrong results
+			ma.transpose()
+			m4rot.transpose()
+			mai.transpose()
+			m4total = MulMatrix( ma, m4rot)
+			m4total = MulMatrix( m4total, mai) 
+			# now convert total m4 to quaternion
+			m3tmp = Matrix( [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] )
+			for ii in range( 0, 3 ):
+				for jj in range( 0, 3 ):
+					m3tmp[ii][jj] = m4total[ii][jj] # the matrix is transposed
+			m3tmp.transpose()
+			qtotal = m3tmp.toQuat()
+			
+			CpyQuat( qtotal, pose.quat )
+	
+	
+			##############
+			#  location  #
+			##############
+			# the pose bone gives the loc in bones space thats why we have to convert it...
+			# to armatur space. This means that...
+			# new_loc = ToVec( bone.mat_armatspace * ToMat(posebone.loc) * bone.mat_armatspace.inverted() ) 
+			ma = NewMatrix()
+			mai = NewMatrix()
+			m4tmp = NewMatrix()
+			vectotal = Vector(0.0, 0.0, 0.0)
+			# init them
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], ma )
+			CpyMatrix( ma, mai )
+			mai.invert()
+			# load the pose's loc to a mat4
+			m4tmp[0][3] = pb.loc[0]
+			m4tmp[1][3] = pb.loc[1]
+			m4tmp[2][3] = pb.loc[2]
+			# now calc the m4tmp = ma * m4tmp * mai
+			ma.transpose()
+			mai.transpose()
+			m4tmp = MulMatrix( ma, m4tmp )
+			m4tmp = MulMatrix( m4tmp, mai )
+			# now create the total vec3
+			vectotal[0] = m4tmp[0][3]
+			vectotal[1] = m4tmp[1][3]
+			vectotal[2] = m4tmp[2][3]
+			CpyVec( vectotal, pose.loc )
+			
+			
+			# now put them
+			bone_ipos[ pb_nam ].poses.append( pose )
+			
+			# we want to check the 2 previous matrices
+			# and if the middle matrice is the same withe the crnt and the
+			# pre-previous we throw it as well as his keyframe
+			i = len( bone_ipos[pb_nam].poses )-1
+			if i-2 >= 0:
+				prev = bone_ipos[pb_nam].poses[i-1].matrix
+				pprev = bone_ipos[pb_nam].poses[i-2].matrix
+				crnt = pose.matrix
+				if prev == pprev and prev == crnt:
+					#print "I will delete the %d keyframe from %s " % ( kframes[i-1], pb_nam )
+					del bone_ipos[pb_nam].poses[i-1]
+					
+
+	
+	###################################
+	########## write to file ##########
+	####################################
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ):
+		path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"	
+	filename =  path + obj.getAction().name + ".animation.txt"
+	file = open( filename, "w" )
+
+	file.write( "FRAMES_NUM %d\n" % kframes[-1] )
+	file.write( "BONES_NUM %d\n" % len(bone_ipos) )
+
+	bi = 0
+	names = bone_ipos.keys()
+	names.sort()
+	for nam in names:
+		ipo = bone_ipos[ nam ]
+		file.write( "\tBONE %d NAME %s " % (bi, nam) )
+		file.write( "POSES_NUM %d\n" % (len(ipo.poses)) )
+		
+		p = 0
+		for pose in ipo.poses:
+			file.write( "\t\tPOSE %d\n" % p )			
+			file.write( "\t\t\tKEYFRAME %d\n" % (pose.keyframe-1) )			
+						
+			mat = pose.matrix
+			file.write( "\t\t\tMATRIX " )
+			for i in range(0, 4):
+				for j in range(0, 4):
+					file.write( "%f " % mat[j][i] )
+			file.write( "\n" )
+			p = p+1
+			
+			file.write( "\t\t\tLOCATION " )
+			for i in range(0, 3):
+				file.write( "%f " % pose.loc[i] )
+			file.write( "\n" )
+			
+			file.write( "\t\t\tQUATERNION " )
+			for i in range(0, 4):
+				file.write( "%f " % pose.quat[i] )
+			file.write( "\n" )
+		
+		bi = bi+1		
+
+	file.close()
+	print "Done! File \"%s\" created successfuly" %filename
+
+main()

blenderscripts/blender_python_old/OLD/export_armature(armat as modifier).py

@@ -0,0 +1,94 @@
+
+import Blender
+import os.path
+
+
+
+########
+# main #
+########
+def main():
+
+	print "\n\n---- Export Armature ----"
+
+	########
+	# vars #
+	########
+	file = 0
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	if not os.path.exists( path ): path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	armat = 0
+	mesh = 0
+
+
+	##################################
+	# make some checks and open file #
+	##################################
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	obj = objs[0]
+	
+	if obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must be a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = obj.getData(0,1)
+
+	# get the armature
+	if len( obj.modifiers )<1:
+		print "-->ERROR: Mesh doesnt have modifiers"
+		return 0
+
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			armat = Blender.Object.Get( aobj.name ).getData( 0, 1 )
+	
+	if armat == 0:
+		print "-->ERROR: There is no modifier of type armature"
+		return 0
+	
+	filename = path + "armature.txt"
+	file = open( filename, "w" )
+	
+	
+	###############
+	# write bones #
+	###############	
+	bone_names = armat.bones.keys()
+	
+	file.write( "BONES_NUM " + str(len( bone_names )) + "\n" )
+
+	i = 0
+	bone_names.sort() # the bones are written in alpabetical order
+	for bone_nam in bone_names:
+		
+		vgroup_names = mesh.getVertGroupNames()
+		vgroup_names.sort()
+		vg_i = 0
+		for vgroup_nam in vgroup_names:
+			if vgroup_nam == bone_nam:
+				break
+			vg_i = vg_i+1
+		if vg_i == len(vgroup_names): vg_i=-1
+			
+		
+		bone = armat.bones[ bone_nam ]
+		file.write( "BONE %d NAME %s VGROUP_INDEX %d " %(i, bone.name, vg_i) )
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "HEAD %f %f %f " %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "TAIL %f %f %f\n" %(co.x, co.y, co.z) )
+
+		i = i+1
+	
+
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/OLD/export_armature.py

@@ -0,0 +1,88 @@
+
+import Blender
+import os.path
+
+
+
+########
+# main #
+########
+def main():
+
+	print "\n---- Export Armature ----"
+
+	########
+	# vars #
+	########
+	file = 0
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	if not os.path.exists( path ): path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	armat = 0
+	mesh = 0
+
+
+	##################################
+	# make some checks and open file #
+	##################################
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must be a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData(0,1)
+
+	if objs[0].getParent() == "":
+		print "-->ERROR: Mesh doesnt have a parent"
+		return 0		
+
+	if Blender.Object.Get( objs[0].getParent().name ).getType() != "Armature": 
+		print "-->ERROR: The parent must be an armature and not in a(n) " + Blender.Object.Get( objs[0].getParent().name ).getType()
+		return 0
+
+	armat = Blender.Object.Get( objs[0].getParent().name ).getData( 0, 1 )
+	
+	filename = path + "armature.txt"
+	file = open( filename, "w" )
+	
+	
+	###############
+	# write bones #
+	###############	
+	bone_names = armat.bones.keys()
+	
+	file.write( "BONES_NUM " + str(len( bone_names )) + "\n" )
+
+	i = 0
+	bone_names.sort() # the bones are written in alpabetical order
+	for bone_nam in bone_names:
+		
+		vgroup_names = mesh.getVertGroupNames()
+		vgroup_names.sort()
+		vg_i = 0
+		for vgroup_nam in vgroup_names:
+			if vgroup_nam == bone_nam:
+				break
+			vg_i = vg_i+1
+		if vg_i == len(vgroup_names): vg_i=-1
+			
+		
+		bone = armat.bones[ bone_nam ]
+		file.write( "BONE %d NAME %s VGROUP_INDEX %d " %(i, bone.name, vg_i) )
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "HEAD %f %f %f " %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "TAIL %f %f %f\n" %(co.x, co.y, co.z) )
+
+		i = i+1
+	
+
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/OLD/export_bone_animation(all frames).py

@@ -0,0 +1,155 @@
+import Blender
+import os.path
+
+
+##################
+#  matrix funcs  #
+##################
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[i][j], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+def NewMatrix():
+	n = range(4)	
+	for i in range(0, 4):
+		n[i] = range(4)		
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if i!=j: n[i][j] = 0.0
+			else:    n[i][j] = 1.0
+	return n
+
+
+def CopyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = round( matfrom[i][j], 5 )
+			
+
+def IdenticalMatrices( m0, m1 ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			a = round(m0[i][j], 5)
+			b = round(m1[i][j], 5) 
+			if a != b: return 0
+	return 1
+
+##########
+#  main  #
+##########
+def main():
+	
+	print "\n---- Exporting Bone IPO ----"
+	
+	obj = Blender.Object.GetSelected()
+	frames_num = 0
+	matrices = []
+	matrix_indeces = {}
+	index_mat = NewMatrix()
+	
+	matrices.append( index_mat )  # the first matrix is allways the indentity mat
+	
+	######################################
+	########## extract the data ##########
+	######################################
+	if len( obj ) < 1:
+		print "-->ERROR: Object not selected"
+		return
+	
+	obj = obj[0]
+	if obj.getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + obj.getType()
+		return
+	
+	if obj.getAction() == 0:
+		print "-->ERROR: No action selected"
+		return
+	
+	list = obj.getAction().getFrameNumbers()
+	frames_num = list[ len(list) -1 ]
+	
+	
+	Blender.Set( "curframe", 1 )
+	for frame in range( 1, frames_num+1 ):
+		Blender.Set( "curframe", frame )
+		Blender.Redraw()
+		
+		pb_names = obj.getPose().bones.keys()
+	
+		pb_names.sort()
+		for pb_nam in pb_names:
+			pb = obj.getPose().bones[ pb_nam ]
+				
+			
+			if frame==1:
+				matrix_indeces[pb_nam] = []
+
+			src_m = NewMatrix()
+			CopyMatrix( pb.localMatrix, src_m )
+			
+			i = 0
+			found = 0
+			for mat in matrices:
+				if IdenticalMatrices( mat, src_m ):
+					found = 1
+					break
+				i = i+1
+			
+			if found:
+				matrix_indeces[pb_nam].append( i )
+			#elif IdenticalMatrices( src_m, index_mat ):
+				#matrix_indeces[pb_nam].append( -1 )	
+			else:
+				matrices.append( src_m )
+				matrix_indeces[pb_nam].append( len(matrices)-1 )
+												
+	
+	###################################
+	########## write to file ##########
+	####################################
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ):
+		path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"	
+	filename = path + obj.getAction().name + ".armat_ipo.txt"
+	file = open( filename, "w" )
+
+	file.write( "BONES_NUM %d\n" % len(matrix_indeces) )
+	file.write( "FRAMES_NUM %d\n" % frames_num )
+	file.write( "MATRICES_NUM %d\n" % len(matrices) )
+
+	# matrices
+	k = 0
+	for mat in matrices:
+		file.write( "MATRIX %d " % k )
+		for i in range(0, 4):
+			for j in range(0, 4):
+				file.write( "%f " % mat[j][i] )
+		file.write( "\n" )
+		k = k+1
+		
+		
+	# for every bone
+	k = 0
+	pb_names = matrix_indeces.keys()
+	pb_names.sort()
+	for pb_nam in pb_names:
+		file.write( "BONE %d NAME %s\n" % (k, pb_nam) )
+		
+		file.write( "MATRIX_INDECES " )
+		for i in matrix_indeces[pb_nam]:
+			file.write( "%s " % i )
+		file.write( "\n" )
+		k = k+1
+
+	file.close()
+	print "Done! File \"%s\" created successfuly" %filename
+
+main()

blenderscripts/blender_python_old/OLD/export_bone_animation_(armat poses).py

@@ -0,0 +1,153 @@
+import Blender
+import os.path
+
+
+######################
+#### matrix funcs ####
+######################
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[i][j], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+def NewMatrix():
+	n = range(4)	
+	for i in range(0, 4):
+		n[i] = range(4)		
+	for i in range(0, 4):
+		for j in range(0, 4):
+			if i!=j: n[i][j] = 0.0
+			else:    n[i][j] = 1.0
+	return n
+
+
+def CopyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = round( matfrom[i][j], 5 )
+			
+
+def IdenticalMatrices( m0, m1 ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			a = round(m0[i][j], 5)
+			b = round(m1[i][j], 5) 
+			if a != b: return 0
+	return 1
+
+
+identity_mat = NewMatrix()
+
+
+#################
+#### classes ####
+#################
+class obj_trans_ipo_t:
+	def __init__(self):
+		self.keyframes = []
+		self.matrices = []
+		
+
+
+###############
+#### main  ####
+###############
+def main():
+	
+	print "\n\n---- Exporting Bone IPO ----"
+	
+	obj = Blender.Object.GetSelected()
+	keyframes_num = 0
+	trans_ipos = {}
+
+	######################################
+	########## extract the data ##########
+	######################################
+	if len( obj ) < 1:
+		print "-->ERROR: Object not selected"
+		return
+	
+	obj = obj[0]
+	if obj.getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + obj.getType()
+		return
+	
+	if obj.getAction() == 0:
+		print "-->ERROR: No action selected"
+		return
+	
+	
+	Blender.Set( "curframe", 1 )
+	kframes = obj.getAction().getFrameNumbers()
+	# for every nodal keyframe aka keyframe
+	for kframe in kframes:
+		Blender.Set( "curframe", kframe )
+		Blender.Redraw()
+		
+		#determin if it is the first or the last frame
+		first_kframe = 0
+		last_kframe = 0
+		if kframe == obj.getAction().getFrameNumbers()[0]: first_kframe = 1
+		if kframe == obj.getAction().getFrameNumbers()[ len(obj.getAction().getFrameNumbers())-1 ]: last_kframe = 1
+		
+		# for all bones
+		pb_names = obj.getPose().bones.keys()
+		pb_names.sort()
+		for pb_nam in pb_names:
+			pb = obj.getPose().bones[ pb_nam ]
+				
+			if first_kframe:
+				trans_ipos[pb_nam] = obj_trans_ipo_t()
+		
+			src_m = NewMatrix()
+			CopyMatrix( pb.localMatrix, src_m )
+		
+			trans_ipos[pb_nam].keyframes.append( kframe )			
+			trans_ipos[pb_nam].matrices.append( src_m )	
+
+	
+	###################################
+	########## write to file ##########
+	####################################
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ):
+		path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"	
+	filename =  path + obj.getAction().name + ".armat_ipo.txt"
+	file = open( filename, "w" )
+
+	file.write( "BONES_NUM %d\n" % len(trans_ipos) )
+	
+	file.write( "KEYFRAMES_NUM %d\n" % len(kframes) )
+	file.write( "KEYFRAMES " )
+	for kf in kframes:
+		file.write( "%d " % kf )
+	file.write( "\n" )
+
+	l = 0
+	names = trans_ipos.keys()
+	names.sort()
+	for nam in names:
+		ipo = trans_ipos[ nam ]
+		file.write( "BONE %d NAME %s\n" % (l, nam) )
+		
+		k = 0
+		for mat in ipo.matrices:
+			file.write( "MATRIX %d " % k )
+			for i in range(0, 4):
+				for j in range(0, 4):
+					file.write( "%f " % mat[j][i] )
+			k = k+1
+			file.write( "\n" )
+		l = l+1
+
+	file.close()
+	print "Done! File \"%s\" created successfuly" %filename
+
+main()

blenderscripts/blender_python_old/OLD/export_mesh.py

@@ -0,0 +1,164 @@
+import Blender
+import string
+import os.path
+
+################
+# MATRIX FUNCS #
+################
+def MatrixMul( matrix, vector ):
+	vec = [0, 0, 0]
+	
+	for i in range(0, 3):
+		for j in range(0, 3):
+			vec[i] = vec[i] + matrix[j][i] * vector[j]
+		vec[i] = vec[i] + matrix[3][i]
+		
+	for i in range(0, 3):
+		vector[i] = vec[i]
+	
+		
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+########
+# main #
+########
+def main():
+	
+	print "\n---- Export Mesh ----"
+	
+	########
+	# vars #
+	########
+	file = 0
+	mesh = 0	
+	matrix = 0
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ): path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	
+	
+	######################
+	# init and open file #
+	######################	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData( 0, 1 )
+	
+	if not mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+	matrix = objs[0].getMatrix( "localspace" )
+	
+	filename = path + "mesh.txt"
+	file = open( filename, "w" )
+	
+	
+	###########
+	# vgroups #
+	###########
+	group_names = mesh.getVertGroupNames()
+	file.write( "GROUPS_NUM " + str(len( group_names )) + "\n" )
+	i = 0
+	group_names.sort()  # !!!!!!!!!!! everythins is put alphabeticaly
+	for group_name in group_names:
+		file.write( "GROUP %d VGROUP_NAME %s VERTS_NUM " % (i, group_name) )
+		verts = mesh.getVertsFromGroup( group_name )
+		file.write( str(len(verts)) + " VERTS " )
+		for vert in verts: 
+			file.write( str(vert) + " " )
+		file.write( "\n" )
+		i = i+1
+		
+		
+	#########
+	# verts #
+	#########
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		MatrixMul( matrix, coords )
+		MatrixMul( matrix, normal )
+		
+		file.write( "VERT %d COORDS %f %f %f\n" %(vert.index, coords[0], coords[1], coords[2]) )
+		#file.write( " NORMAL %f %f %f\n" %(normal[0], normal[1], normal[2]) )
+	
+	
+	#########
+	# faces #
+	#########
+	#first count the faces as triangles
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1
+		else:
+			tris_num = tris_num + 2
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "FACE %d VERTS " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+				
+		# WRITE UVs
+		file.write( "UV " )
+		for j in order:
+			file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "FACE %d VERTS " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "UV " )
+			for j in order:
+				file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+			file.write( "\n" )	
+			i = i+1
+		
+		
+		
+	########
+	# DONE #
+	########
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/OLD/fix_brocken_uvs.py

@@ -0,0 +1,27 @@
+import Blender
+
+print "\n\n----"
+
+
+Blender.Window.EditMode(0)
+
+
+objs = Blender.Object.GetSelected()
+mesh = objs[0].getData( 0, 1 )
+
+
+for face in mesh.faces:
+	face.sel = 0
+
+	
+for face in mesh.faces:
+	found = 0
+	for uv in face.uv:
+		x = uv.x
+		y = uv.y 
+		if (x==0.0 or x==1.0) and (y==0.0 or y==1.0):
+			found = found + 1
+	if found:
+		face.sel = 1
+
+Blender.Window.EditMode(1)

blenderscripts/blender_python_old/OLD/mesh(no vertgroups).py

@@ -0,0 +1,163 @@
+import Blender
+import string
+import os.path
+
+################
+# MATRIX FUNCS #
+################
+def MatrixMul( matrix, vector ):
+	vec = [0, 0, 0]
+	
+	for i in range(0, 3):
+		for j in range(0, 3):
+			vec[i] = vec[i] + matrix[j][i] * vector[j]
+		vec[i] = vec[i] + matrix[3][i]
+		
+	for i in range(0, 3):
+		vector[i] = vec[i]
+	
+		
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+########
+# main #
+########
+def main():
+	
+	print "\n---- Export Mesh ----"
+	
+	########
+	# vars #
+	########
+	file = 0
+	mesh = 0	
+	matrix = 0
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	
+	
+	######################
+	# init and open file #
+	######################	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData( 0, 1 )
+	
+	if not mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+	matrix = objs[0].getMatrix( "localspace" )
+	
+	filename = path + "mesh.txt"
+	file = open( filename, "w" )
+		
+		
+	#########
+	# verts #
+	#########
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		MatrixMul( matrix, coords )
+		MatrixMul( matrix, normal )
+		
+		file.write( "\tVERT %d COORDS %f %f %f\n" %(vert.index, coords[0], coords[1], coords[2]) )
+		#file.write( " NORMAL %f %f %f\n" %(normal[0], normal[1], normal[2]) )
+	
+	
+	#########
+	# faces #
+	#########
+	#first count the faces as triangles
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1
+		else:
+			tris_num = tris_num + 2
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "\tFACE %d VERT_INDECES " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tFACE %d VERT_INDECES " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "\n" )	
+			i = i+1
+	
+			
+	#######
+	# uvs #
+	#######
+	file.write( "UVS_NUM %d\n" % tris_num )
+	
+	i = 0
+	for face in mesh.faces:
+			
+		order = [0,1,2]
+		file.write( "\tUV %d " % i )
+		for j in order:
+			file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tUV %d " % i )
+			for j in order:
+				file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+			file.write( "\n" )	
+			i = i+1
+		
+		
+	########
+	# DONE #
+	########
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/all in one (mesh,skeleton,weights).py

@@ -0,0 +1,327 @@
+print "\n\n---- ALL IN ONE EXPORTER ----"
+
+import Blender
+import string
+import os.path
+from Numeric import *
+
+
+#===================================================================================================
+# global vars                                                                                      =
+#===================================================================================================
+class globals_t:
+	def __init__(self):
+		self.mesh = 0
+		self.skeleton = 0
+		self.obj = 0   # selected object
+		self.path = "/home/godlike/src/3d_engine/meshes/cube/"
+		
+		if not os.path.exists( self.path ):
+			print "-->ERROR: path \"%s\" doesnt exists" % self.path
+
+g = globals_t()
+		
+	
+		
+#===================================================================================================
+# ExportMesh                                                                                       =
+#===================================================================================================
+def ExportMesh():
+	filename = g.path + g.obj.getName() + ".mesh"
+	file = open( filename, "w" )
+	
+	mesh = g.mesh
+	
+	file.write( "MATERIAL %s\n" % "put_something_here" )
+	
+	# the verts
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		file.write( "\tVERT %d COORDS %f %f %f\n" %(vert.index, coords[0], coords[1], coords[2]) )
+
+	
+	# the faces
+	# first count the triangles
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1 # if tris
+		else:
+			tris_num = tris_num + 2 # if quad
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "\tFACE %d VERT_IDS " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tFACE %d VERT_IDS " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "\n" )	
+			i = i+1
+	
+
+	# the uvs
+	# create and populate tha vertuvs array
+	vertuvs = {}
+	for vert in mesh.verts:
+		vertuvs[ vert.index ] = [ -1.0, -1.0 ]
+	
+	
+	for face in mesh.faces:
+			
+		order = [0,1,2] # verts order
+		
+		for j in order:
+			vert_id = face.verts[j].index
+			
+			uvx = face.uv[j].x
+			uvy = face.uv[j].y
+			
+			# if we put a new value in the array OR the values already set and they are the same then
+			if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+				vertuvs[ vert_id ][0] = uvx
+				vertuvs[ vert_id ][1] = uvy
+			else:
+				print "-->ERROR: More than 1 coords for the %d vert" % vert_id
+				#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+			
+		# do the same if quat for the other forming triangle
+		if( len( face.verts ) == 4 ):
+			order = [0,2,3]
+			
+			for j in order:
+				vert_id = face.verts[j].index
+				
+				uvx = face.uv[j].x
+				uvy = face.uv[j].y
+				
+				# if we put a new value in the array OR the values already set and they are the same then
+				if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+					vertuvs[ vert_id ][0] = uvx
+					vertuvs[ vert_id ][1] = uvy
+				else:
+					print "-->ERROR: More than 1 coords for the %d vert" % vert_id
+					#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+	
+	# one last check
+	if( len( vertuvs ) != len( mesh.verts ) ):
+		print "-->ERROR: There is a difference of verts num and verts uvs"
+			
+	# now write the uvs to file
+	file.write( "UVS_NUM %d\n" % len(vertuvs) )
+	
+	for i in range( 0, len(vertuvs) ):
+		file.write( "\tUV %d COORDS %f %f\n" % ( i, vertuvs[i][0], vertuvs[i][1] ) )
+	
+	file.close()
+	print "Mesh exported!! %s" % filename
+	
+
+
+	
+#===================================================================================================
+# ExportSkeleton                                                                                   =
+#===================================================================================================
+def ExportSkeleton():
+	filename = g.path + g.obj.getName() + ".skel"
+	file = open( filename, "w" )
+	
+	# write the file
+	bone_names = g.skeleton.bones.keys()
+	bone_names.sort() # the bones are written in alpabetical order
+
+	file.write( "BONES_NUM %d\n" % len( bone_names ) )
+
+	for bone_nam in bone_names:	
+		
+		bone = g.skeleton.bones[ bone_nam ]
+		file.write( "\tBONE %d\n \t\tNAME %s\n" %( bone_names.index(bone_nam), bone.name) )
+		
+		"""file.write( "\t\tLENGTH %f\n" % bone.length )"""
+		
+		# head
+		"""co = bone.head["BONESPACE"]
+		file.write( "\t\tHEAD_BS %f %f %f\n" %(co.x, co.y, co.z) )"""
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD_AS %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		# tail
+		"""co = bone.tail["BONESPACE"]
+		file.write( "\t\tTAIL_BS %f %f %f\n" %(co.x, co.y, co.z) )"""
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL_AS %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		# matrix
+		"""file.write( "\t\tMATRIX_BS " )
+		for i_ in range(0, 3):
+			for j_ in range(0, 3):
+				file.write( "%f " % bone.matrix["BONESPACE"][j_][i_] )
+		file.write( "\n" )"""
+		
+		file.write( "\t\tMATRIX_AS " )
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				file.write( "%f " % bone.matrix["ARMATURESPACE"][j_][i_] )
+		file.write( "\n" )
+		
+		# write the parent
+		if not bone.parent:
+			file.write( "\t\tPARENT -1\n" )
+		else:
+			file.write( "\t\tPARENT %d\n" % (bone_names.index( bone.parent.name )) )
+			
+		# write the childs
+		file.write( "\t\tCHILDS_NUM %d CHILD_IDS " % len(bone.children) )
+		for child in bone.children:
+			file.write( "%s " % bone_names.index( child.name ) )
+		file.write( "\n" )
+	
+
+	print "Skeleton exported! %s" % filename
+	
+
+
+#===================================================================================================
+# ExportVWeights                                                                                   =
+#===================================================================================================
+def ExportVWeights():
+	bone_names = g.skeleton.bones.keys()
+	bone_names.sort()
+	mesh = g.mesh
+	
+	# open file
+	filename = g.path + g.obj.getName() + ".vw"
+	file = open( filename, "w" )
+	
+	
+	# link the vert groups to the bone ids
+	vgroup2bone_id = {}   # we give the vgroup name and we get the bone's id in the skeleton
+	vgroup_names = mesh.getVertGroupNames()
+	
+	for vgroup_name in vgroup_names:
+		bone_id = -1
+		for bone_name in bone_names:
+			if bone_name == vgroup_name:
+				bone_id = bone_names.index( bone_name )
+				break
+		
+		if bone_id == -1:
+			print "-->WARNING: Vert group \"%s\" cant link to a bone" % vgroup_name
+		
+		vgroup2bone_id[ vgroup_name ] = bone_id
+	
+	file.write( "VERTS_NUM %d\n" % len( mesh.verts ) )
+	
+	# for every vert do some shit
+	for vert in mesh.verts:
+		influences = mesh.getVertexInfluences( vert.index )
+		
+		influences_num = 0
+		sumw = 0.0
+		# calc the influences num and the total weight (NOTE:we may have...
+		# ...a vert group that doesnt connect to a bone)
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				influences_num = influences_num + 1
+				sumw = sumw + weight
+		
+		# a check
+		if( influences_num > 4 ):
+			print "-->ERROR: Cannot have more than 4 bones per vert"
+			file.close()
+			return 0
+	
+		# write to file
+		file.write( "\tVERT_ID %d\n\t\tBONES_NUM %d\n" %( vert.index, influences_num ) )
+		
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				file.write( "\t\t\tBONE_ID %d WEIGHT %f\n" %( vgroup2bone_id[ vgroup ], weight/sumw ) )
+	
+	
+	# finished
+	file.close()
+	print "Vertex weights exported! %s" % filename
+
+	
+
+#===================================================================================================
+# main                                                                                             =
+#===================================================================================================
+def main():
+
+	# init some globals	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) != 1: 
+		print "-->ERROR: You have to select ONE object"
+		return 0
+
+	g.obj = objs[0]  # set g.obj
+	
+	if g.obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + g.obj.getType()
+		return 0
+
+	g.mesh = g.obj.getData( 0, 1 )  # set g.mesh
+	
+	if not g.mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+
+	ExportMesh()
+	
+	# skeleton
+	if len(g.obj.modifiers) < 1:
+		print "Obj doesnt have modifiers (skeleton & vert weights wont be exported)"
+	else:
+		# search for modifier of skeleton type
+		for mod in g.obj.modifiers:
+			if mod.type == Blender.Modifier.Types.ARMATURE:
+				aobj = mod[Blender.Modifier.Settings.OBJECT]
+				g.skeleton = Blender.Object.Get( aobj.name ).getData( 0, 1 ) # set g.skeleton
+		
+		if g.skeleton == 0:
+			print "There is no modifier of type armature (skeleton & vert weights wont be exported)"
+		else:
+			ExportSkeleton()
+			ExportVWeights()
+
+	print "All Done!"
+	
+	
+main()

blenderscripts/blender_python_old/all in one (mesh,skeleton,weights)_new.py

@@ -0,0 +1,541 @@
+print "\n\n---- ALL IN ONE EXPORTER ----"
+
+import Blender
+import string
+import os.path
+from Blender import Mathutils
+from Blender.Mathutils import *
+from Numeric import *
+
+
+#===================================================================================================
+# global vars                                                                                      =
+#===================================================================================================
+g_engine_path = "/home/godlike/src/3d_engine/"
+g_store_dir = ""
+		
+if not os.path.exists( g_engine_path + g_store_dir ):
+	print "[E] path \"%s\" doesnt exist" % g_engine_path + g_store_dir
+
+
+
+#===================================================================================================
+# GetMesh                                                                                          =
+#===================================================================================================
+def GetMesh( obj ):
+	if obj.getType() != "Mesh": 
+		print "[E] The obj \"%s\" must link to a mesh and not to a(n) %s" % ( obj.getName(), obj.getType() )
+		return 0
+
+	mesh = obj.getData( 0, 1 ) 
+	return mesh
+
+
+#===================================================================================================
+# GetMaterial                                                                                      =
+#===================================================================================================
+def GetMaterial( obj ):
+	mesh = GetMesh(obj)
+	if mesh == 0:
+		return 0
+	
+	# check
+	mats = mesh.materials
+	if( len(mats) < 1 or len(mats) > 1 ):
+		print "[E] Obj \"%s\" has no or too many materials" % obj.getName()
+		return 0
+	
+	mat = mats[0]
+	return mat
+
+
+#===================================================================================================
+# HasSkeleton                                                                                      =
+#===================================================================================================
+def HasSkeleton( obj ):
+	# check modifiers
+	if len(obj.modifiers) < 1:
+		return 0
+	
+	# search for modifier of skeleton type
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			return 1
+	
+	return 0
+	
+
+#===================================================================================================
+# GetSkeleton                                                                                      =
+#===================================================================================================
+def GetSkeleton( obj ):	
+	# check modifiers
+	if len(obj.modifiers) < 1:
+		print "[E] Obj \"%s\" doesnt have modifiers so no armature found" % obj.getName()
+		return 0
+	
+	# search for modifier of skeleton type
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			skeleton = Blender.Object.Get( aobj.name ).getData( 0, 1 ) # set skeleton
+			return skeleton
+	
+	print "[E] Obj \"%s\" has no modifier of type armature" % obj.getName()
+	return 0
+		
+
+
+#===================================================================================================
+# RepeatTex                                                                                        =
+# check if the mesh UVs are in [0,1] if not then the texture must be repeated                      =
+#===================================================================================================
+def RepeatTex( obj ):
+	mesh = GetMesh( obj )
+	if mesh == 0:
+		return 0
+	
+	for face in mesh.faces:
+		for i in range( 0, len(face.verts) ):
+			uvx = face.uv[i].x
+			uvy = face.uv[i].y
+			
+			if uvx < 0.0 or uvx > 1.0:
+				return 1
+			
+			if uvy < 0.0 or uvy > 1.0:
+				return 1
+			
+	return 0
+	
+
+		
+#===================================================================================================
+# ExportMesh                                                                                       =
+#===================================================================================================
+def ExportMesh( path, obj ):
+	print "[I] Trying to export mesh for obj \"%s\"" % obj.getName()
+	
+	mesh = GetMesh(obj)  # set mesh
+	if mesh == 0:
+		return 0
+	
+	# check verts
+	if len(mesh.verts) < 3:
+		print "[E] The object named \"%s\" has insufficient vert num. Skipping" % obj.getName()		
+		return 0
+
+	# check UVs
+	if not mesh.faceUV:
+		print "[E] The mesh doesnt have UVs"
+		return 0
+	
+	# open file for writing
+	filename = path + obj.getName() + ".mesh"
+	file = open( filename, "w" )
+	
+	# material
+	mat = GetMaterial(obj)	
+	if mat != 0:
+		full = path + mat.getName() + ".mat"
+		relative = full.replace( g_engine_path, "" )
+		file.write( "MATERIAL \"%s\"\n" % relative )
+	else:	
+		file.write( "MATERIAL \"%s\"\n" % "put_something_here" )
+	
+	# the verts
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		vec = Vector( vert.co )
+		mat = obj.getMatrix( "worldspace" )
+		mat2 = obj.getMatrix( "localspace" )
+		
+		vec = mat2 * vec
+		
+		file.write( "\tVERT %d COORDS %f %f %f\n" %(vert.index, vec.x, vec.z, -vec.y) )
+
+	
+	# the faces
+	# first calc the triangle num
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1 # if tris
+		else:
+			tris_num = tris_num + 2 # if quad
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "\tFACE %d VERT_IDS " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tFACE %d VERT_IDS " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "\n" )	
+			i = i+1
+	
+
+	# the uvs
+	# create and populate tha vertuvs array
+	vertuvs = {}
+	for vert in mesh.verts:
+		vertuvs[ vert.index ] = [ -1.0, -1.0 ]
+	
+	
+	for face in mesh.faces:
+			
+		order = [0,1,2] # verts order
+		
+		for j in order:
+			vert_id = face.verts[j].index
+			
+			uvx = face.uv[j].x
+			uvy = face.uv[j].y
+			
+			# if we put a new value in the array OR the values already set and they are the same then
+			if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+				vertuvs[ vert_id ][0] = uvx
+				vertuvs[ vert_id ][1] = uvy
+			else:
+				print "[E] Obj \"%s\" More than 1 coords for the %d vert" % (obj.getName(), vert_id)
+				mesh.verts[vert_id].sel=1
+				return 0
+				#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+			
+		# do the same if quat for the other forming triangle
+		if( len( face.verts ) == 4 ):
+			order = [0,2,3]
+			
+			for j in order:
+				vert_id = face.verts[j].index
+				
+				uvx = face.uv[j].x
+				uvy = face.uv[j].y
+				
+				# if we put a new value in the array OR the values already set and they are the same then
+				if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+					vertuvs[ vert_id ][0] = uvx
+					vertuvs[ vert_id ][1] = uvy
+				else:
+					print "[E] Obj \"%s\" More than 1 coords for the %d vert" % (obj.getName(), vert_id)
+					mesh.verts[vert_id].sel=1
+					return 0
+					#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+	
+	# one last check
+	if( len( vertuvs ) != len( mesh.verts ) ):
+		print "[E] There is a difference of verts num and verts uvs"
+		return 0
+			
+	# now write the uvs to file
+	file.write( "UVS_NUM %d\n" % len(vertuvs) )
+	
+	for i in range( 0, len(vertuvs) ):
+		file.write( "\tUV %d COORDS %f %f\n" % ( i, vertuvs[i][0], vertuvs[i][1] ) )
+	
+	file.close()
+	print "[I] Mesh exported!! %s" % filename
+	
+	return 1
+	
+
+
+	
+#===================================================================================================
+# ExportSkeleton                                                                                   =
+#===================================================================================================
+def ExportSkeleton( path, obj ):
+	
+	skeleton = GetSkeleton( obj )
+	if skeleton == 0:
+		return 0
+	
+	filename = g.path + g.obj.getName() + ".skel"
+	file = open( filename, "w" )
+	
+	# write the file
+	bone_names = skeleton.bones.keys()
+	bone_names.sort() # the bones are written in alpabetical order
+
+	file.write( "BONES_NUM %d\n" % len( bone_names ) )
+
+	for bone_nam in bone_names:	
+		
+		bone = skeleton.bones[ bone_nam ]
+		file.write( "\tBONE %d\n \t\tNAME %s\n" %( bone_names.index(bone_nam), bone.name) )
+		
+		"""file.write( "\t\tLENGTH %f\n" % bone.length )"""
+		
+		# head
+		"""co = bone.head["BONESPACE"]
+		file.write( "\t\tHEAD_BS %f %f %f\n" %(co.x, co.y, co.z) )"""
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD_AS %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		# tail
+		"""co = bone.tail["BONESPACE"]
+		file.write( "\t\tTAIL_BS %f %f %f\n" %(co.x, co.y, co.z) )"""
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL_AS %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		# matrix
+		"""file.write( "\t\tMATRIX_BS " )
+		for i_ in range(0, 3):
+			for j_ in range(0, 3):
+				file.write( "%f " % bone.matrix["BONESPACE"][j_][i_] )
+		file.write( "\n" )"""
+		
+		file.write( "\t\tMATRIX_AS " )
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				file.write( "%f " % bone.matrix["ARMATURESPACE"][j_][i_] )
+		file.write( "\n" )
+		
+		# write the parent
+		if not bone.parent:
+			file.write( "\t\tPARENT -1\n" )
+		else:
+			file.write( "\t\tPARENT %d\n" % (bone_names.index( bone.parent.name )) )
+			
+		# write the childs
+		file.write( "\t\tCHILDS_NUM %d CHILD_IDS " % len(bone.children) )
+		for child in bone.children:
+			file.write( "%s " % bone_names.index( child.name ) )
+		file.write( "\n" )
+	
+
+	print "Skeleton exported! %s" % filename
+	return 1
+	
+
+
+#===================================================================================================
+# ExportVWeights                                                                                   =
+#===================================================================================================
+def ExportVWeights( path, obj ):
+	print "[I] Trying to export vwights for the \"%s\"" % obj.getName()
+	
+	mesh = GetMesh( obj )
+	if mesh == 0:
+		return 0
+	skeleton = GetSkeleton( obj )
+	if skeleton == 0:
+		return 0
+
+	bone_names = skeleton.bones.keys()
+	bone_names.sort()
+	
+	# open file
+	filename = path + obj.getName() + ".vw"
+	file = open( filename, "w" )
+	
+	
+	# link the vert groups to the bone ids
+	vgroup2bone_id = {}   # we give the vgroup name and we get the bone's id in the skeleton
+	vgroup_names = mesh.getVertGroupNames()
+	
+	for vgroup_name in vgroup_names:
+		bone_id = -1
+		for bone_name in bone_names:
+			if bone_name == vgroup_name:
+				bone_id = bone_names.index( bone_name )
+				break
+		
+		if bone_id == -1:
+			print "[W] Obj \"%s\": Vert group \"%s\" cant link to a bone" % (obj.getName(), vgroup_name)
+		
+		vgroup2bone_id[ vgroup_name ] = bone_id
+	
+	file.write( "VERTS_NUM %d\n" % len( mesh.verts ) )
+	
+	# for every vert do some shit
+	for vert in mesh.verts:
+		influences = mesh.getVertexInfluences( vert.index )
+		
+		influences_num = 0
+		sumw = 0.0
+		# calc the influences num and the total weight (NOTE:we may have...
+		# ...a vert group that doesnt connect to a bone)
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				influences_num = influences_num + 1
+				sumw = sumw + weight
+		
+		# a check
+		if( influences_num > 4 ):
+			print "[E] Cannot have more than 4 bones per vert"
+			file.close()
+			return 0
+	
+		# write to file
+		file.write( "\tVERT_ID %d\n\t\tBONES_NUM %d\n" %( vert.index, influences_num ) )
+		
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				file.write( "\t\t\tBONE_ID %d WEIGHT %f\n" %( vgroup2bone_id[ vgroup ], weight/sumw ) )
+	
+	
+	# finished
+	file.close()
+	print "Vertex weights exported! %s" % filename
+	return 1
+
+
+#===================================================================================================
+# ExportMaterial                                                                                   =
+#===================================================================================================
+def ExportMaterial( path, obj ):
+	print "[I] Trying to export material for obj \"%s\"" % obj.getName()
+	
+	mat = GetMaterial(obj)
+	if mat == 0:
+		return 0
+	
+	# file ops
+	filename = path + mat.getName() + ".mat"
+	file = open( filename, "w" )
+	
+	# write the colors
+	col = mat.getRGBCol()
+	file.write( "DIFFUSE_COL %f %f %f\n" %(col[0], col[1], col[2]) )
+	
+	col = mat.getSpecCol()
+	file.write( "SPECULAR_COL %f %f %f\n" %(col[0], col[1], col[2]) )
+	
+	#** TEXTURES **
+	texs = mat.getTextures()
+	has_diff = 0
+	has_norm = 0
+	has_spec = 0
+	
+	for tex in texs:
+		if tex != None:
+			tex = tex.tex 
+			
+			# get the script identifier
+			str = ""
+			if tex.name == "diff":
+				str = "DIFFUSE_MAP"
+				has_diff = 1
+			elif tex.name == "norm":
+				str = "NORMAL_MAP"
+				has_norm = 1
+			elif tex.name == "spec":
+				str = "SPECULAR_MAP"
+				has_spec = 1
+			else:
+				print "[W] Mat \"%s\": Tex name \"%s\" cannot be processed" % (mat.getName(), tex.name)
+				continue
+			
+			img = tex.getImage()
+			# check if someone forgot to actually put an image
+			if img == None:
+				print "[E] Mat \"%s\": There is no image set for \"%s\" tex" % (mat.getName(), tex.name)
+				return 0
+				
+			# create the corect filename of the tex. We want the path to be relative
+			full = img.getFilename() # getFilename returnes the full path
+			if full.find( g_engine_path ) == -1: # the img is not in the engine's path
+				print "[E] Mat \"%s\": Img \"%s\" is not in the engine's dir" % (mat.getName(), full)
+				return 0
+				
+			relative = full.replace( g_engine_path, "" )
+			
+			# now its time to write to the file
+			file.write( "%s \"%s\"\n" %(str, relative) )
+	
+	
+	# shader
+	# choose a shader from one of the standards
+	shader_str = "mp_"
+	if has_diff:
+		shader_str = shader_str + "d"
+	if has_norm:
+		shader_str = shader_str + "n"
+	if has_spec:
+		shader_str = shader_str + "s"
+		
+	shader_str = shader_str + ".shdr"
+	
+	file.write( "SHADER \"%s\"\n" %("shaders/" + shader_str) )
+	
+	# shininess
+	# we borow the shininess factor from the specular hardness
+	sh = mat.getHardness()
+	if sh > 128:
+		print "[W] Obj \"%s\" and mat \"%s\": Choose spec hardness from 0 to 128" % (obj.getName(), mat.getName())
+		sh = 128
+	file.write( "SHININESS %d\n" % sh )
+	
+	
+	# repeat texes ??
+	if RepeatTex( obj ):
+		file.write( "REPEAT_TXTR_MAP_S %d\n" % 1 )
+		file.write( "REPEAT_TXTR_MAP_T %d\n" % 1 )
+	else:
+		file.write( "REPEAT_TXTR_MAP_S %d\n" % 0 )
+		file.write( "REPEAT_TXTR_MAP_T %d\n" % 0 )
+	
+	# end
+	file.close()
+	print "[I] Material exported!! %s" % filename
+	return 1
+	
+
+#===================================================================================================
+# ExportAllSelcted                                                                                 =
+#===================================================================================================
+def ExportAllSelected( path ):
+	objs = Blender.Object.GetSelected()
+
+	if len(objs) < 1:
+		print "[E] Not selected objs"
+		return 0
+	
+	# file ops
+	filename = path + "map.map"
+	file = open( filename, "w" )
+	
+	for obj in objs:
+		ExportMesh( path, obj )
+		ExportMaterial( path, obj )
+		file.write( "\"%s\"\n" % obj.getName() )
+		print " "
+		
+	file.close()
+	return 1	
+
+#===================================================================================================
+# main                                                                                             =
+#===================================================================================================
+def main():
+
+	ExportAllSelected( g_engine_path + g_store_dir )
+
+	print "\nAll Done!"
+	
+	
+main()

blenderscripts/blender_python_old/animation.py

@@ -0,0 +1,275 @@
+import Blender
+import os.path
+from Blender.Mathutils import *
+
+
+######################
+#### matrix funcs ####
+######################
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = matrix[i][j]
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+		
+		
+def MulMatrix( m, b ):
+	c = NewMatrix()
+	c[0][0] = m[0][0]*b[0][0] + m[0][1]*b[1][0] + m[0][2]*b[2][0] + m[0][3]*b[3][0]
+	c[0][1] = m[0][0]*b[0][1] + m[0][1]*b[1][1] + m[0][2]*b[2][1] + m[0][3]*b[3][1]
+	c[0][2] = m[0][0]*b[0][2] + m[0][1]*b[1][2] + m[0][2]*b[2][2] + m[0][3]*b[3][2]
+	c[0][3] = m[0][0]*b[0][3] + m[0][1]*b[1][3] + m[0][2]*b[2][3] + m[0][3]*b[3][3]
+	c[1][0] = m[1][0]*b[0][0] + m[1][1]*b[1][0] + m[1][2]*b[2][0] + m[1][3]*b[3][0]
+	c[1][1] = m[1][0]*b[0][1] + m[1][1]*b[1][1] + m[1][2]*b[2][1] + m[1][3]*b[3][1]
+	c[1][2] = m[1][0]*b[0][2] + m[1][1]*b[1][2] + m[1][2]*b[2][2] + m[1][3]*b[3][2]
+	c[1][3] = m[1][0]*b[0][3] + m[1][1]*b[1][3] + m[1][2]*b[2][3] + m[1][3]*b[3][3]
+	c[2][0] = m[2][0]*b[0][0] + m[2][1]*b[1][0] + m[2][2]*b[2][0] + m[2][3]*b[3][0]
+	c[2][1] = m[2][0]*b[0][1] + m[2][1]*b[1][1] + m[2][2]*b[2][1] + m[2][3]*b[3][1]
+	c[2][2] = m[2][0]*b[0][2] + m[2][1]*b[1][2] + m[2][2]*b[2][2] + m[2][3]*b[3][2]
+	c[2][3] = m[2][0]*b[0][3] + m[2][1]*b[1][3] + m[2][2]*b[2][3] + m[2][3]*b[3][3]
+	c[3][0] = m[3][0]*b[0][0] + m[3][1]*b[1][0] + m[3][2]*b[2][0] + m[3][3]*b[3][0]
+	c[3][1] = m[3][0]*b[0][1] + m[3][1]*b[1][1] + m[3][2]*b[2][1] + m[3][3]*b[3][1]
+	c[3][2] = m[3][0]*b[0][2] + m[3][1]*b[1][2] + m[3][2]*b[2][2] + m[3][3]*b[3][2]
+	c[3][3] = m[3][0]*b[0][3] + m[3][1]*b[1][3] + m[3][2]*b[2][3] + m[3][3]*b[3][3]
+	return c
+	
+		
+def NewMatrix():
+	m4 = Matrix( [1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.] )
+	return m4
+
+
+def CpyMatrix( matfrom, matto ):
+	for i in range(0, 4):
+		for j in range(0, 4):
+			matto[i][j] = round( matfrom[i][j], 5 )
+
+
+def CpyQuat( qfrom, qto ):
+	for i in range(0, 4):
+		qto[i] = qfrom[i]
+		
+		
+def CpyVec( vfrom, vto ):
+	for i in range(0, 3):
+		vto[i] = vfrom[i]
+
+
+identity_mat = NewMatrix()
+
+
+#################
+#### classes ####
+#################
+class pose_t:
+	def __init__(self):
+		self.keyframe = 0
+		self.matrix = NewMatrix()
+		self.quat = Quaternion()
+		self.loc  = Vector( 0.0, 0.0, 0.0 )
+		self.scale = Vector( 0.0, 0.0, 0.0 )
+
+class bone_ipo_t:
+	def __init__(self):
+		self.poses = []
+
+
+###############
+#### main  ####
+###############
+def main():
+	
+	print "\n\n---- Exporting Bone IPO ----"
+	
+	obj = Blender.Object.GetSelected()
+	keyframes_num = 0
+	bone_ipos = {}
+
+	######################################
+	########## extract the data ##########
+	######################################
+	if len( obj ) < 1:
+		print "-->ERROR: Object not selected"
+		return
+	
+	obj = obj[0]
+	if obj.getType() != "Armature": 
+		print "-->ERROR: The selected object must link to an armature and not in a(n) " + obj.getType()
+		return
+	
+	armat = obj.getData(0,1)
+	
+	if obj.getAction() == 0:
+		print "-->ERROR: No action selected"
+		return
+	
+	kframes = obj.getAction().getFrameNumbers()
+	# for every nodal keyframe aka keyframe
+	for kframe in kframes:
+		Blender.Set( "curframe", kframe )
+		Blender.Redraw()
+		
+		#determin if it is the first or the last frame
+		first_kframe = 0
+		last_kframe = 0
+		if kframe == obj.getAction().getFrameNumbers()[0]: first_kframe = 1
+		if kframe == obj.getAction().getFrameNumbers()[ len(obj.getAction().getFrameNumbers())-1 ]: last_kframe = 1
+		
+		# for all bones
+		pb_names = obj.getPose().bones.keys()
+		for pb_nam in pb_names:
+			pb = obj.getPose().bones[ pb_nam ]
+			pose = pose_t()
+				
+			if first_kframe:
+				bone_ipos[pb_nam] = bone_ipo_t()
+		
+			############
+			#  matrix  #
+			############
+			CpyMatrix( pb.localMatrix, pose.matrix )
+			
+			
+			############
+			#  kframe  #
+			############
+			pose.keyframe = kframe
+
+
+			################
+			#  quaternion  #
+			################
+			m4rot = pb.quat.toMatrix() # the quat to mat3...
+			m4rot.resize4x4()          # and now to mat4
+			ma = NewMatrix()           # bone's matrix in armature space
+			mai = NewMatrix()          # and the inverted
+			# set ma and mai
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], ma )
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], mai )
+			mai.invert()
+			# calc the rotation in armature space cause its in bone space
+			# use my mul matrix cause blenders produces wrong results
+			ma.transpose()
+			m4rot.transpose()
+			mai.transpose()
+			m4total = MulMatrix( ma, m4rot)
+			m4total = MulMatrix( m4total, mai) 
+			# now convert total m4 to quaternion
+			m3tmp = Matrix( [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] )
+			for ii in range( 0, 3 ):
+				for jj in range( 0, 3 ):
+					m3tmp[ii][jj] = m4total[ii][jj] # the matrix is transposed
+			m3tmp.transpose()
+			qtotal = m3tmp.toQuat()
+			
+			CpyQuat( qtotal, pose.quat )
+	
+	
+			##############
+			#  location  #
+			##############
+			# the pose bone gives the loc in bones space thats why we have to convert it...
+			# to armatur space. This means that...
+			# new_loc = ToVec( bone.mat_armatspace * ToMat(posebone.loc) * bone.mat_armatspace.inverted() ) 
+			ma = NewMatrix()
+			mai = NewMatrix()
+			m4tmp = NewMatrix()
+			vectotal = Vector(0.0, 0.0, 0.0)
+			# init them
+			CpyMatrix( armat.bones[pb_nam].matrix["ARMATURESPACE"], ma )
+			CpyMatrix( ma, mai )
+			mai.invert()
+			# load the pose's loc to a mat4
+			m4tmp[0][3] = pb.loc[0]
+			m4tmp[1][3] = pb.loc[1]
+			m4tmp[2][3] = pb.loc[2]
+			# now calc the m4tmp = ma * m4tmp * mai
+			ma.transpose()
+			mai.transpose()
+			m4tmp = MulMatrix( ma, m4tmp )
+			m4tmp = MulMatrix( m4tmp, mai )
+			# now create the total vec3
+			vectotal[0] = m4tmp[0][3]
+			vectotal[1] = m4tmp[1][3]
+			vectotal[2] = m4tmp[2][3]
+			CpyVec( vectotal, pose.loc )
+			
+			
+			# now put them
+			bone_ipos[ pb_nam ].poses.append( pose )
+			
+			# we want to check the 2 previous matrices
+			# and if the middle matrice is the same withe the crnt and the
+			# pre-previous we delete the pose
+			"""i = len( bone_ipos[pb_nam].poses )-1
+			if i-2 >= 0:
+				prev = bone_ipos[pb_nam].poses[i-1].matrix
+				pprev = bone_ipos[pb_nam].poses[i-2].matrix
+				crnt = pose.matrix
+				if prev == pprev and prev == crnt:
+					#print "I will delete the %d keyframe from %s " % ( kframes[i-1], pb_nam )
+					del bone_ipos[pb_nam].poses[i-1]"""
+					
+
+	
+	###################################
+	########## write to file ##########
+	####################################
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"			
+	if not os.path.exists( path ):
+		path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"	
+	filename =  path + obj.getAction().name + ".animation.txt"
+	file = open( filename, "w" )
+
+	file.write( "FRAMES_NUM %d\n" % kframes[-1] )
+	
+	file.write( "KEYFRAMES_NUM %d KEYFRAMES " %len(kframes) )
+	for kf in kframes:
+		file.write( "%d " %(kf-1) )
+	file.write("\n")
+		
+	
+	file.write( "POSEBONES_NUM %d\n" % len(bone_ipos) )
+
+	bi = 0
+	names = bone_ipos.keys()
+	names.sort()
+	for nam in names:
+		ipo = bone_ipos[ nam ]
+		file.write( "\tBONE %d NAME %s " % (bi, nam) )
+		file.write( "POSES_NUM %d\n" % (len(ipo.poses)) )
+		
+		p = 0
+		for pose in ipo.poses:
+			file.write( "\t\tPOSE %d\n" % p )			
+			file.write( "\t\t\tKEYFRAME %d\n" % (pose.keyframe-1) )			
+						
+			mat = pose.matrix
+			file.write( "\t\t\tMATRIX " )
+			for i in range(0, 4):
+				for j in range(0, 4):
+					file.write( "%f " % mat[j][i] )
+			file.write( "\n" )
+			p = p+1
+			
+			file.write( "\t\t\tLOCATION " )
+			for i in range(0, 3):
+				file.write( "%f " % pose.loc[i] )
+			file.write( "\n" )
+			
+			file.write( "\t\t\tQUATERNION " )
+			for i in range(0, 4):
+				file.write( "%f " % pose.quat[i] )
+			file.write( "\n" )
+		
+		bi = bi+1		
+
+	file.close()
+	print "Done! File \"%s\" created successfuly" %filename
+
+main()

blenderscripts/blender_python_old/armature(+vert weights).py

@@ -0,0 +1,185 @@
+import Blender
+import os.path
+
+def PrintMatrixR( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+
+
+########
+# main #
+########
+def main():
+
+	print "\n\n---- Export Armature ----"
+
+	########
+	# vars #
+	########
+	file = 0
+	path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	if not os.path.exists( path ): path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\satan\\"
+	armat = 0
+	mesh = 0
+
+
+	##################################
+	# make some checks and open file #
+	##################################
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	obj = objs[0]
+	
+	if obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must be a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = obj.getData(0,1)
+
+	# get the armature
+	if len( obj.modifiers )<1:
+		print "-->ERROR: Mesh doesnt have modifiers"
+		return 0
+
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			armat = Blender.Object.Get( aobj.name ).getData( 0, 1 )
+	
+	if armat == 0:
+		print "-->ERROR: There is no modifier of type armature"
+		return 0
+	
+	filename = path + "armature.txt"
+	file = open( filename, "w" )
+	
+	
+	# create bones dictonary
+	bone_names = armat.bones.keys()
+	bones_d = {}
+	bone_names.sort()
+	i = 0
+	for bone_nam in bone_names:
+		bones_d[ bone_nam ] = i
+		i = i+1
+	
+	###############
+	# write bones #
+	###############	
+	file.write( "BONES_NUM " + str(len( bone_names )) + "\n" )
+
+	i = 0
+	bone_names.sort() # the bones are written in alpabetical order
+	for bone_nam in bone_names:
+		
+		vgroup_names = mesh.getVertGroupNames()
+		vgroup_names.sort()
+		vg_i = 0
+		for vgroup_nam in vgroup_names:
+			if vgroup_nam == bone_nam:
+				break
+			vg_i = vg_i+1
+		if vg_i == len(vgroup_names): vg_i=-1
+			
+		
+		bone = armat.bones[ bone_nam ]
+		file.write( "\tBONE %d\n \t\tNAME %s\n" %(i, bone.name) )
+		
+		"""co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.head["BONESPACE"]
+		file.write( "\t\tHEAD_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["BONESPACE"]
+		file.write( "\t\tTAIL_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		file.write( "\t\tMATRIX4_ARMATURESPACE " )
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				file.write( "%f " % bone.matrix["ARMATURESPACE"][j_][i_] )
+		file.write( "\n" )
+
+		file.write( "\t\tMATRIX3_BONESPACE     " )
+		for i_ in range(0, 3):
+			for j_ in range(0, 3):
+				file.write( "%f " % bone.matrix["BONESPACE"][j_][i_] )
+		file.write( "\n" )
+		
+		file.write("\t\tLENGTH %f\n" % bone.length)"""
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		
+		# write the parent
+		bpar = bone.parent
+		if not bpar:
+			file.write( "\t\tPARENT -1\n" )
+		else:
+			bpar_index = bones_d[ bpar.name ]
+			file.write( "\t\tPARENT %d\n" %(bpar_index) )
+			
+		# write the childs
+		file.write( "\t\tCHILDS_NUM %d CHILD_INDECES " % len(bone.children) )
+		for bch in bone.children:
+			file.write( "%d " % bones_d[bch.name] )
+		file.write( "\n" )
+		
+		i = i+1
+		
+	
+	
+	######################
+	# write vert weights #
+	######################
+		
+	# now do the rest
+	file.write( "VERTS_NUM %d\n" % len( mesh.verts ) )
+	i = 0
+	for vert in mesh.verts:  # for all verts
+		infs = mesh.getVertexInfluences( vert.index )
+		
+		# make a check
+		if len( infs ) > 4:
+			print "-->ERROR: You cannot have more than 4 bones per vert"
+			file.close()
+			return 0
+		
+		# calc the sum of all weights (and dividde later with the sum)
+		sum_w = 0
+		for inf in infs:
+			sum_w = sum_w + inf[1]
+		
+		# now write to file
+		file.write( "\tVERT %d WEIGHTS_NUM %d " %(i, len(infs)) )
+		for inf in infs:
+			file.write( "BONE %d WEIGHT %f " % ( bones_d[ inf[0] ], inf[1]/sum_w ) ) 
+		
+		file.write("\n")
+			
+		i = i+1
+	
+
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/armature.py

@@ -0,0 +1,152 @@
+import Blender
+import os.path
+
+def PrintMatrixR( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+
+
+########
+# main #
+########
+def main():
+
+	print "\n\n---- Export Armature ----"
+
+	########
+	# vars #
+	########
+	file = 0
+	path = "c:\\src\\VisualC++\\3d_engine\\models\\imp\\"
+	armat = 0
+	mesh = 0
+
+
+	##################################
+	# make some checks and open file #
+	##################################
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	obj = objs[0]
+	
+	if obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must be a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = obj.getData(0,1)
+
+	# get the armature
+	if len( obj.modifiers )<1:
+		print "-->ERROR: Mesh doesnt have modifiers"
+		return 0
+
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			armat = Blender.Object.Get( aobj.name ).getData( 0, 1 )
+	
+	if armat == 0:
+		print "-->ERROR: There is no modifier of type armature"
+		return 0
+	
+	filename = path + "armature.txt"
+	file = open( filename, "w" )
+	
+	
+	# create bones dictonary
+	bone_names = armat.bones.keys()
+	bones_d = {}
+	bone_names.sort()
+	i = 0
+	for bone_nam in bone_names:
+		bones_d[ bone_nam ] = i
+		i = i+1
+	
+	###############
+	# write bones #
+	###############	
+	file.write( "BONES_NUM " + str(len( bone_names )) + "\n" )
+
+	i = 0
+	bone_names.sort() # the bones are written in alpabetical order
+	for bone_nam in bone_names:
+		
+		vgroup_names = mesh.getVertGroupNames()
+		vgroup_names.sort()
+		vg_i = 0
+		for vgroup_nam in vgroup_names:
+			if vgroup_nam == bone_nam:
+				break
+			vg_i = vg_i+1
+		if vg_i == len(vgroup_names): vg_i=-1
+			
+		
+		bone = armat.bones[ bone_nam ]
+		file.write( "\tBONE %d\n \t\tNAME %s\n" %(i, bone.name) )
+		
+		"""co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.head["BONESPACE"]
+		file.write( "\t\tHEAD_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["BONESPACE"]
+		file.write( "\t\tTAIL_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		file.write( "\t\tMATRIX4_ARMATURESPACE " )
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				file.write( "%f " % bone.matrix["ARMATURESPACE"][j_][i_] )
+		file.write( "\n" )
+
+		file.write( "\t\tMATRIX3_BONESPACE     " )
+		for i_ in range(0, 3):
+			for j_ in range(0, 3):
+				file.write( "%f " % bone.matrix["BONESPACE"][j_][i_] )
+		file.write( "\n" )
+		
+		file.write("\t\tLENGTH %f\n" % bone.length)"""
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		
+		# write the parent
+		bpar = bone.parent
+		if not bpar:
+			file.write( "\t\tPARENT -1\n" )
+		else:
+			bpar_index = bones_d[ bpar.name ]
+			file.write( "\t\tPARENT %d\n" %(bpar_index) )
+			
+		# write the childs
+		file.write( "\t\tCHILDS_NUM %d CHILD_INDECES " % len(bone.children) )
+		for bch in bone.children:
+			file.write( "%d " % bones_d[bch.name] )
+		file.write( "\n" )
+		
+		i = i+1
+	
+
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/mesh.py

@@ -0,0 +1,220 @@
+import Blender
+import string
+import os.path
+
+################
+# MATRIX FUNCS #
+################
+def MatrixMul( matrix, vector ):
+	vec = [0, 0, 0]
+	
+	for i in range(0, 3):
+		for j in range(0, 3):
+			vec[i] = vec[i] + matrix[j][i] * vector[j]
+		vec[i] = vec[i] + matrix[3][i]
+		
+	for i in range(0, 3):
+		vector[i] = vec[i]
+	
+		
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+		
+########
+# main #
+########
+def main():
+	
+	print "\n---- Export Mesh ----"
+	
+	########
+	# vars #
+	########
+	file = 0
+	mesh = 0	
+	matrix = 0
+	path = "c:\\src\\VisualC++\\3d_engine\\models\\imp\\"
+	
+	
+	######################
+	# init and open file #
+	######################	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData( 0, 1 )
+	
+	if not mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+	matrix = objs[0].getMatrix( "localspace" )
+	
+	filename = path + "mesh.txt"
+	file = open( filename, "w" )
+		
+		
+	#########
+	# verts #
+	#########
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		MatrixMul( matrix, coords )
+		MatrixMul( matrix, normal )
+		
+		file.write( "\tVERT %d COORDS %f %f %f\n" %(vert.index, coords[0], coords[1], coords[2]) )
+		#file.write( " NORMAL %f %f %f\n" %(normal[0], normal[1], normal[2]) )
+	
+	
+	#########
+	# faces #
+	#########
+	#first count the faces as triangles
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1
+		else:
+			tris_num = tris_num + 2
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "\tFACE %d VERT_IDS " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tFACE %d VERT_IDS " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "\n" )	
+			i = i+1
+	
+			
+	#######
+	# uvs #
+	#######
+	file.write( "UVS_NUM %d\n" % tris_num )
+	
+	i = 0
+	for face in mesh.faces:
+			
+		order = [0,1,2]
+		file.write( "\tUV %d " % i )
+		for j in order:
+			file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tUV %d " % i )
+			for j in order:
+				file.write( "%f %f " % (face.uv[j].x, face.uv[j].y) )
+			file.write( "\n" )	
+			i = i+1
+			
+			
+	###############
+	# vert groups #
+	###############
+	vert_groups_names = mesh.getVertGroupNames()
+	vert_groups_names.sort()
+	file.write( "VERT_GROUPS_NUM %d\n" % (len(vert_groups_names)) )
+	i = 0
+	for vert_group_name in vert_groups_names:
+		file.write( "\tVERT_GROUP %d NAME %s\n" %( i, vert_group_name ) )
+		i = i+1
+	
+	
+	###########
+	# weights #
+	###########
+	
+	# if there are vert groups then put weights
+	if len(vert_groups_names) > 0:
+		
+		file.write( "VERTEX_WEIGHTS_NUM %d\n" % len( mesh.verts ) )
+		i = 0
+		for vert in mesh.verts:  # for all verts
+			infs = mesh.getVertexInfluences( vert.index )
+			
+			# make a check
+			if len( infs ) > 4:
+				print "-->ERROR: You cannot have more than 4 bones/groups per vert"
+				file.close()
+				return 0
+			
+			# calc the sum of all weights (and dividde later with the sum)
+			sum_w = 0
+			for inf in infs:
+				sum_w = sum_w + inf[1]
+			
+			# now write to file
+			file.write( "\tWEIGHTS %d VERT_ID %d PAIRS_NUM %d " %(i, i, len(infs)) )
+			for inf in infs:
+				# find group id
+				j = 0
+				for vert_group_name in vert_groups_names:
+					if inf[0] == vert_group_name:
+						break
+					j = j+1
+				
+				# write to file
+				file.write( "GROUP_ID %d WEIGHT %f " % ( j, inf[1]/sum_w ) ) 
+			
+			file.write("\n")
+		
+		
+			i = i+1
+		
+	# else if there arent vert groups
+	else:
+		file.write( "VERTEX_WEIGHTS_NUM 0\n" )
+		
+	########
+	# DONE #
+	########
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/mesh_unwrapped.py

@@ -0,0 +1,201 @@
+import Blender
+import string
+import os.path
+from Numeric import *
+
+################
+# MATRIX FUNCS #
+################
+def MatrixMul( matrix, vector ):
+	vec = [0, 0, 0]
+	
+	for i in range(0, 3):
+		for j in range(0, 3):
+			vec[i] = vec[i] + matrix[j][i] * vector[j]
+		vec[i] = vec[i] + matrix[3][i]
+		
+	for i in range(0, 3):
+		vector[i] = vec[i]
+	
+		
+def PrintMatrix( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+##########
+# IsZero #
+##########
+def IsZero( f ):
+	return ( fabs(f) > 1.0e-6 )
+
+		
+########
+# main #
+########
+def main():
+	
+	print "\n---- Export Mesh ----"
+	
+	########
+	# vars #
+	########
+	file = 0
+	mesh = 0	
+	matrix = 0
+	path = "/home/godlike/src/3d_engine/meshes/imp/"
+	
+	
+	######################
+	# init and open file #
+	######################	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	if objs[0].getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = objs[0].getData( 0, 1 )
+	
+	if not mesh.faceUV:
+		print "-->ERROR: The mesh doesnt have UVs"
+		return 0
+
+	matrix = objs[0].getMatrix( "localspace" )
+	
+	filename = path + "mesh.txt"
+	file = open( filename, "w" )
+		
+		
+	#########
+	# verts #
+	#########
+	file.write( "VERTS_NUM %d\n" % len(mesh.verts) )
+	for vert in mesh.verts:
+		coords = [0.0, 0.0, 0.0]
+		normal = [0.0, 0.0, 0.0]
+		
+		coords[0] = vert.co.x
+		coords[1] = vert.co.y
+		coords[2] = vert.co.z
+		normal[0] = vert.no.x
+		normal[1] = vert.no.y
+		normal[2] = vert.no.z
+		
+		MatrixMul( matrix, coords )
+		MatrixMul( matrix, normal )
+		
+		file.write( "\tVERT %d COORDS %f %f %f\n" %(vert.index, coords[0], coords[1], coords[2]) )
+		#file.write( " NORMAL %f %f %f\n" %(normal[0], normal[1], normal[2]) )
+	
+	
+	#########
+	# faces #
+	#########
+	#first count the faces as triangles
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1
+		else:
+			tris_num = tris_num + 2
+	
+	file.write( "FACE_NUM %d\n" % tris_num )
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+			
+		file.write( "\tFACE %d VERT_IDS " % i )
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			file.write( "%d " % face.v[j].index )
+		
+		file.write( "\n" )
+		i = i+1
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+			file.write( "\tFACE %d VERT_IDS " % i )
+			for j in order:
+				file.write( "%d " % face.v[j].index )
+			file.write( "\n" )	
+			i = i+1
+	
+
+	#######
+	# uvs #
+	#######	
+	
+	# create and populate tha vertuvs array
+	vertuvs = {}
+	for vert in mesh.verts:
+		vertuvs[ vert.index ] = [ -1.0, -1.0 ]
+	
+	
+	for face in mesh.faces:
+			
+		order = [0,1,2] # verts order
+		
+		for j in order:
+			vert_id = face.verts[j].index
+			
+			uvx = face.uv[j].x
+			uvy = face.uv[j].y
+			
+			# if we put a new value in the array OR the values already set and they are the same then
+			if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+				vertuvs[ vert_id ][0] = uvx
+				vertuvs[ vert_id ][1] = uvy
+			else:
+				print "-->ERROR: More than 1 coords for the %d vert" % vert_id
+				#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+			
+		# do the same if quat for the other forming triangle
+		if( len( face.verts ) == 4 ):
+			order = [0,2,3]
+			
+			for j in order:
+				vert_id = face.verts[j].index
+				
+				uvx = face.uv[j].x
+				uvy = face.uv[j].y
+				
+				# if we put a new value in the array OR the values already set and they are the same then
+				if vertuvs[ vert_id ][0]==-1.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+					vertuvs[ vert_id ][0] = uvx
+					vertuvs[ vert_id ][1] = uvy
+				else:
+					print "-->ERROR: More than 1 coords for the %d vert" % vert_id
+					#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+	
+	# one last check
+	if( len( vertuvs ) != len( mesh.verts ) ):
+		print "-->ERROR: There is a difference of verts num and verts uvs"
+			
+	# now write the uvs to file
+	file.write( "UVS_NUM %d\n" % len(vertuvs) )
+	
+	for i in range( 0, len(vertuvs) ):
+		file.write( "\tUV %d COORDS %f %f\n" % ( i, vertuvs[i][0], vertuvs[i][1] ) )
+		
+	########
+	# DONE #
+	########
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/select_symetric.py

@@ -0,0 +1,53 @@
+import Blender
+
+
+
+print "\n---- Selecting Symetric ----"
+
+obj = Blender.Object.GetSelected()[0]
+mesh = obj.getData( 0, 1 )
+edit_mode = Blender.Window.EditMode()
+Blender.Window.EditMode(0) # exit from editmode
+
+
+# get selected verts
+sel_verts = []
+for i in range( 0, len(mesh.verts) ):
+	if mesh.verts[i].sel:
+		sel_verts.append( mesh.verts[i] )
+		
+
+# get the x symetric
+ABBERANCE = 0.005
+
+for sel_vert in sel_verts:
+	sel_x = sel_vert.co.x
+	sel_y = sel_vert.co.y
+	sel_z = sel_vert.co.z
+
+	# for every vert select the symetric	
+	sym_verts = []
+	
+	for vert in mesh.verts:
+		x = -vert.co.x
+		y = vert.co.y
+		z = vert.co.z
+		
+		if ( sel_x >= x-ABBERANCE and sel_x <= x+ABBERANCE ):
+			if ( sel_y >= y-ABBERANCE and sel_y <= y+ABBERANCE ):
+				if ( sel_z >= z-ABBERANCE and sel_z <= z+ABBERANCE ):
+					sym_verts.append( vert )
+	
+					
+	if len( sym_verts ) > 1 :
+		print "More than one symetric verteces found. Please lower the ABBERANCE"
+	elif len( sym_verts ) < 1:
+		print "No symetric vertex found. Please higher the ABBERANCE"
+	else:
+		sym_verts[0].sel = 1
+		sel_vert.sel = 0
+
+
+Blender.Window.EditMode( edit_mode )
+
+print "Done!"

blenderscripts/blender_python_old/select_tris.py

@@ -0,0 +1,23 @@
+import Blender
+
+
+print "\n---- Select Triagles ----"
+
+obj = Blender.Object.GetSelected()[0]
+mesh = obj.getData( 0, 1 )
+
+edit_mode = Blender.Window.EditMode()
+Blender.Window.EditMode(0) # exit from editmode
+
+tris_num = 0
+for face in mesh.faces:
+	if len(face.verts) == 3:
+		face.sel = 1
+		tris_num = tris_num + 1
+	else:
+		face.sel = 0
+	
+	
+Blender.Window.EditMode( edit_mode )
+print "%d triangles selected" %tris_num
+	

blenderscripts/blender_python_old/skeleton animation.py

@@ -0,0 +1,204 @@
+import Blender
+import os.path
+from Blender.Mathutils import *
+
+
+# MulMatrix
+def MulMatrix( m, b ):
+	c = Matrix()
+	c[0][0] = m[0][0]*b[0][0] + m[0][1]*b[1][0] + m[0][2]*b[2][0] + m[0][3]*b[3][0]
+	c[0][1] = m[0][0]*b[0][1] + m[0][1]*b[1][1] + m[0][2]*b[2][1] + m[0][3]*b[3][1]
+	c[0][2] = m[0][0]*b[0][2] + m[0][1]*b[1][2] + m[0][2]*b[2][2] + m[0][3]*b[3][2]
+	c[0][3] = m[0][0]*b[0][3] + m[0][1]*b[1][3] + m[0][2]*b[2][3] + m[0][3]*b[3][3]
+	c[1][0] = m[1][0]*b[0][0] + m[1][1]*b[1][0] + m[1][2]*b[2][0] + m[1][3]*b[3][0]
+	c[1][1] = m[1][0]*b[0][1] + m[1][1]*b[1][1] + m[1][2]*b[2][1] + m[1][3]*b[3][1]
+	c[1][2] = m[1][0]*b[0][2] + m[1][1]*b[1][2] + m[1][2]*b[2][2] + m[1][3]*b[3][2]
+	c[1][3] = m[1][0]*b[0][3] + m[1][1]*b[1][3] + m[1][2]*b[2][3] + m[1][3]*b[3][3]
+	c[2][0] = m[2][0]*b[0][0] + m[2][1]*b[1][0] + m[2][2]*b[2][0] + m[2][3]*b[3][0]
+	c[2][1] = m[2][0]*b[0][1] + m[2][1]*b[1][1] + m[2][2]*b[2][1] + m[2][3]*b[3][1]
+	c[2][2] = m[2][0]*b[0][2] + m[2][1]*b[1][2] + m[2][2]*b[2][2] + m[2][3]*b[3][2]
+	c[2][3] = m[2][0]*b[0][3] + m[2][1]*b[1][3] + m[2][2]*b[2][3] + m[2][3]*b[3][3]
+	c[3][0] = m[3][0]*b[0][0] + m[3][1]*b[1][0] + m[3][2]*b[2][0] + m[3][3]*b[3][0]
+	c[3][1] = m[3][0]*b[0][1] + m[3][1]*b[1][1] + m[3][2]*b[2][1] + m[3][3]*b[3][1]
+	c[3][2] = m[3][0]*b[0][2] + m[3][1]*b[1][2] + m[3][2]*b[2][2] + m[3][3]*b[3][2]
+	c[3][3] = m[3][0]*b[0][3] + m[3][1]*b[1][3] + m[3][2]*b[2][3] + m[3][3]*b[3][3]
+	return c
+
+
+
+class bone_pose_t:
+	def __init__(self):
+		self.rotation = Quaternion( 1.0, 0.0, 0.0, 0.0 )
+		self.translation = Vector( 0.0, 0.0, 0.0 )
+
+
+class bone_anim_t:
+	def __init__(self):
+		self.keyframes = [] # before the "write to file" phase this array is ether empty
+		                    # if the bone doesnt have animation or an array of poses
+	
+	
+class skeleton_anim_t:
+	def __init__(self):
+		self.bones = []
+		self.keyframes = []
+
+
+########################################################################################
+# main                                                                                 #
+########################################################################################
+def main():
+	print "\n\n---- Skeletal Animation Exporter ----"
+		
+	# get selected
+	objarr = Blender.Object.GetSelected() # returns an array of the selected objs
+	if len(objarr) != 1:
+		print "-->ERROR: You have to select ONE object"
+		return 0
+	obj = objarr[0]
+	if obj.getType() != "Armature":
+		print "-->ERROR: Select a skeleton and not a(n) %s" % obj.getType()
+		return 0
+	
+	skeleton = obj.getData( 0, 0 )
+	action = obj.getAction()
+	
+	if action == 0:
+		print "-->ERROR: Empty action"
+		return 0
+	
+	
+	# init and populate the instances
+	skeleton_anim = skeleton_anim_t()
+	skeleton_anim.keyframes = action.getFrameNumbers()
+	
+	bone_names = skeleton.bones.keys()
+	bone_names.sort()
+	
+	for i in range( 0, len(bone_names) ):
+			skeleton_anim.bones.append( bone_anim_t() )
+			for j in range( 0, len(skeleton_anim.keyframes) ):
+				skeleton_anim.bones[i].keyframes.append( bone_pose_t() )
+	
+	
+	# now populate with the correct data
+	# for all the kframes
+	for i in range( 0, len(skeleton_anim.keyframes) ):
+		kframe = skeleton_anim.keyframes[i]
+		Blender.Set( "curframe", kframe )
+		Blender.Redraw()
+		pose = obj.getPose()
+		
+		# for all bones
+		for j in range( 0, len(bone_names) ):
+			bone_name = bone_names[j]
+			pose_bone = pose.bones[bone_name]
+			bone = skeleton.bones[bone_name]
+			
+			# rotation
+			rot = pose_bone.quat.toMatrix()
+			rot.resize4x4()
+			# translation
+			tra = Matrix()
+			tra.identity()
+			for m in range(0, 3):
+				tra[m][3] = pose_bone.loc[m]
+			# bone matris at armature space aka MA
+			MA = Matrix( bone.matrix["ARMATURESPACE"] )
+			MAi = Matrix( MA )
+			MAi.invert()
+			
+			# calc the m4 = MA * tra * rot * MAi
+			rot.transpose()
+			tra.transpose()
+			MA.transpose()
+			MAi.transpose()
+			
+			m4 = MulMatrix( rot, MAi )
+			m4 = MulMatrix( tra, m4 )
+			m4 = MulMatrix( MA, m4 )
+			
+			m4.transpose()
+			
+			# get the final quat and loc
+			quat = m4.rotationPart()
+			quat = quat.toQuat()
+			loc  = m4.translationPart()
+			
+			quat = pose_bone.quat
+			loc = pose_bone.loc
+			
+			for k in range(0, 4):
+				skeleton_anim.bones[j].keyframes[i].rotation[k] = quat[k]
+			
+			for k in range(0, 3):
+				skeleton_anim.bones[j].keyframes[i].translation[k] = loc[k]
+	
+	Blender.Set( "curframe", 1 )
+	Blender.Redraw()	
+	
+	
+	# now do the apropriate for the bones without translation or rotation
+	zero_vec = Vector( 0.0, 0.0, 0.0 )
+	ident_quat = Quaternion( 1.0, 0.0, 0.0, 0.0 )
+	# for all the bones
+	for i in range( 0, len(bone_names) ):
+		no_anim_num = 0   # how many times we found that the bone has no anim
+		bone = skeleton_anim.bones[i]
+		# for all the keyframes
+		for j in range( 0, len(skeleton_anim.keyframes) ):
+			
+			if bone.keyframes[j].rotation == ident_quat and bone.keyframes[j].translation == zero_vec:
+				no_anim_num = no_anim_num + 1
+			
+		if no_anim_num == len( skeleton_anim.keyframes ):
+			print "Bone \"%s\" has no animation" % bone_names[ i ]
+			bone.keyframes = []
+	
+		
+	# write the file
+	filename = "/home/godlike/src/3d_engine/models/test/" + obj.getAction().name + "." + obj.getName() + ".anim"
+	file = open( filename, "w" )
+	
+	# the keyframes
+	file.write( "KEYFRAMES_NUM %d\n\tKEYFRAMES " % len(skeleton_anim.keyframes) )
+	for kf in skeleton_anim.keyframes:
+		file.write( "%i " % (kf - 1) )
+	file.write( "\n" )
+	
+	# the bones num
+	file.write( "BONES_NUM %d\n" % len(bone_names) )
+	
+	for i in range( 0, len(bone_names) ):
+		bone = skeleton_anim.bones[i]
+		file.write( "\tBONE %d NAME %s\n" %( i, bone_names[i] ) )
+		
+		if len( bone.keyframes ):
+			file.write( "\t\tHAS_ANIM 1\n" )
+			
+			for j in range( 0, len( skeleton_anim.keyframes ) ):
+				file.write( "\t\tKEYFRAME %d\n" % (skeleton_anim.keyframes[j] - 1) ) # -1 cause my keyframes start from 0
+				
+				# write rotation			
+				file.write( "\t\t\tROTATION " )
+				for k in range( 0, 4 ):
+					file.write( "%f " % bone.keyframes[j].rotation[k] )
+				file.write( "\n" )
+				
+				# write translation
+				file.write( "\t\t\tTRANSLATION " )
+				for k in range( 0, 3 ):
+					file.write( "%f " % bone.keyframes[j].translation[k] )
+				file.write( "\n" )
+			
+		else:
+			file.write( "\t\tHAS_ANIM 0\n" )
+	
+	file.close()
+	
+	
+	# done
+	print "Exported! \"%s\"" % filename
+	return 1
+
+main()

blenderscripts/blender_python_old/skeleton.py

@@ -0,0 +1,152 @@
+import Blender
+import os.path
+
+def PrintMatrixR( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+
+
+########
+# main #
+########
+def main():
+
+	print "\n\n---- Export Armature ----"
+
+	########
+	# vars #
+	########
+	file = 0
+	path = "c:\\src\\VisualC++\\3d_engine\\models\\imp\\"
+	armat = 0
+	mesh = 0
+
+
+	##################################
+	# make some checks and open file #
+	##################################
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) < 1: 
+		print "-->ERROR: No object selected"
+		return 0
+	
+	obj = objs[0]
+	
+	if obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must be a mesh and not in a(n) " + objs[0].getType()
+		return 0
+
+	mesh = obj.getData(0,1)
+
+	# get the armature
+	if len( obj.modifiers )<1:
+		print "-->ERROR: Mesh doesnt have modifiers"
+		return 0
+
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			armat = Blender.Object.Get( aobj.name ).getData( 0, 1 )
+	
+	if armat == 0:
+		print "-->ERROR: There is no modifier of type armature"
+		return 0
+	
+	filename = path + "armature.txt"
+	file = open( filename, "w" )
+	
+	
+	# create bones dictonary
+	bone_names = armat.bones.keys()
+	bones_d = {}
+	bone_names.sort()
+	i = 0
+	for bone_nam in bone_names:
+		bones_d[ bone_nam ] = i
+		i = i+1
+	
+	###############
+	# write bones #
+	###############	
+	file.write( "BONES_NUM " + str(len( bone_names )) + "\n" )
+
+	i = 0
+	bone_names.sort() # the bones are written in alpabetical order
+	for bone_nam in bone_names:
+		
+		vgroup_names = mesh.getVertGroupNames()
+		vgroup_names.sort()
+		vg_i = 0
+		for vgroup_nam in vgroup_names:
+			if vgroup_nam == bone_nam:
+				break
+			vg_i = vg_i+1
+		if vg_i == len(vgroup_names): vg_i=-1
+			
+		
+		bone = armat.bones[ bone_nam ]
+		file.write( "\tBONE %d\n \t\tNAME %s\n" %(i, bone.name) )
+		
+		"""co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.head["BONESPACE"]
+		file.write( "\t\tHEAD_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL_ARMATURESPACE %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["BONESPACE"]
+		file.write( "\t\tTAIL_BONESPACE     %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		file.write( "\t\tMATRIX4_ARMATURESPACE " )
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				file.write( "%f " % bone.matrix["ARMATURESPACE"][j_][i_] )
+		file.write( "\n" )
+
+		file.write( "\t\tMATRIX3_BONESPACE     " )
+		for i_ in range(0, 3):
+			for j_ in range(0, 3):
+				file.write( "%f " % bone.matrix["BONESPACE"][j_][i_] )
+		file.write( "\n" )
+		
+		file.write("\t\tLENGTH %f\n" % bone.length)"""
+		
+		co = bone.head["ARMATURESPACE"]
+		file.write( "\t\tHEAD %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		co = bone.tail["ARMATURESPACE"]
+		file.write( "\t\tTAIL %f %f %f\n" %(co.x, co.y, co.z) )
+		
+		
+		# write the parent
+		bpar = bone.parent
+		if not bpar:
+			file.write( "\t\tPARENT -1\n" )
+		else:
+			bpar_index = bones_d[ bpar.name ]
+			file.write( "\t\tPARENT %d\n" %(bpar_index) )
+			
+		# write the childs
+		file.write( "\t\tCHILDS_NUM %d CHILD_INDECES " % len(bone.children) )
+		for bch in bone.children:
+			file.write( "%d " % bones_d[bch.name] )
+		file.write( "\n" )
+		
+		i = i+1
+	
+
+	print "Done! File \"%s\" created" % filename
+	file.close()
+main()

blenderscripts/blender_python_old/test.py

@@ -0,0 +1,45 @@
+import Blender
+
+
+def PrintMatR( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+print "\n\n----"
+
+obj = Blender.Object.GetSelected()[0]
+arm = obj.getData(0,1)
+act = obj.getAction()
+ipo = act.getAllChannelIpos()["down"]
+
+print ipo.curves
+print ipo.curves[5].__getitem__(3)
+
+print
+
+
+kframes = obj.getAction().getFrameNumbers()
+print kframes
+
+for frame in kframes:
+	Blender.Set( "curframe", frame )
+	Blender.Redraw()
+
+	pb_names = obj.getPose().bones.keys()
+	for pb_nam in pb_names:
+		pb = obj.getPose().bones[ pb_nam ]
+		
+		if pb_nam == "up":
+			print "HEAD ", pb.head
+			print "TAIL ", pb.tail
+			print
+			PrintMatR( pb.localMatrix )
+			print

blenderscripts/blender_python_old/test_armat.py

@@ -0,0 +1,65 @@
+import Blender
+import os.path
+
+
+def PrintMatR( matrix ):
+	for i in range(0, 4):
+		print "[",
+		for j in range(0, 4):
+			f = round( matrix[j][i], 5)
+			if f >= 0 :
+				print " %04f" % f,
+			else:
+				print "%04f" % f,
+		print "]"
+
+
+print "\n\n----"
+
+path = "c:\\src\\VisualC++\\gmdl_3d_format\\models\\"			
+if not os.path.exists( path ):
+	path = "c:\\data\\projects\\VisualC++\\gmdl_3d_format\\models\\"
+file = open( path+"matrices.txt", "w" )
+
+
+obj = Blender.Object.GetSelected()[0]
+
+frames_num = obj.getAction().getFrameNumbers()[ len(obj.getAction().getFrameNumbers())-1 ]
+
+for frame in (1, 20, 27):
+	Blender.Set( "curframe", frame )
+	Blender.Redraw()
+	print "FRAME ", frame
+
+	file.write( "------------------- FRAME %d ----------------\n" % frame )
+
+	pb_names = obj.getPose().bones.keys()
+	for pb_nam in pb_names:
+		pb = obj.getPose().bones[ pb_nam ]
+		
+		
+		file.write( "BONE \"%s\"\n" % pb_nam )
+		
+		file.write( "HEAD " )
+		for i in range( 3 ):
+			file.write( "%f " % pb.head[i] )
+		file.write( "\n" )
+		
+		file.write( "TAIL " )
+		for i in range( 3 ):
+			file.write( "%f " % pb.tail[i] )
+		file.write( "\n" )
+	
+		file.write( "LOC  " )
+		for i in range( 3 ):
+			file.write( "%f " % pb.loc[i] )
+		file.write( "\n" )
+		
+	
+		for i in range(0, 4):
+			for j in range(0, 4):
+				file.write( "%f " % pb.localMatrix[j][i] )
+			file.write( "\n" )
+		file.write( "\n" )
+			
+file.close()

blenderscripts/blender_python_old/vert_coords_as_C_array.py

@@ -0,0 +1,75 @@
+print "\n\n---- ALL IN ONE EXPORTER ----"
+
+import Blender
+import string
+import os.path
+from Numeric import *
+
+
+#===================================================================================================
+# global vars                                                                                      =
+#===================================================================================================
+class globals_t:
+	def __init__(self):
+		self.mesh = 0
+		self.skeleton = 0
+		self.obj = 0   # selected object
+		self.path = "/home/godlike/"
+		
+		if not os.path.exists( self.path ):
+			print "-->ERROR: path \"%s\" doesnt exists" % self.path
+
+g = globals_t()
+		
+	
+		
+#===================================================================================================
+# ExportMesh                                                                                       =
+#===================================================================================================
+def ExportMesh():
+	filename = g.path + g.obj.getName() + ".mesh"
+	file = open( filename, "w" )
+	
+	mesh = g.mesh
+	
+	file.write( "{ " )
+	
+	# for every face
+	for face in mesh.faces:
+		for vert in face.v:
+			for coord in vert.co:
+				file.write( "%f, " % coord )
+		
+	file.write( " } " )
+	
+
+
+	
+
+#===================================================================================================
+# main                                                                                             =
+#===================================================================================================
+def main():
+
+	# init some globals	
+	objs = Blender.Object.GetSelected()
+
+	if len( objs ) != 1: 
+		print "-->ERROR: You have to select ONE object"
+		return 0
+
+	g.obj = objs[0]  # set g.obj
+	
+	if g.obj.getType() != "Mesh": 
+		print "-->ERROR: The selected object must link to a mesh and not in a(n) " + g.obj.getType()
+		return 0
+
+	g.mesh = g.obj.getData( 0, 1 )  # set g.mesh
+
+	ExportMesh()
+	
+
+	print "All Done!"
+	
+	
+main()

blenderscripts/blender_python_old/vweights.py

@@ -0,0 +1,106 @@
+from common import *
+import sys
+reload( sys.modules["common"] )
+
+
+#===================================================================================================
+# ScriptVWeights                                                                                   =
+#===================================================================================================
+def ScriptVWeights( mesh, skeleton, b_cmnts ):
+	#check if mesh is the correct class
+	if( mesh.__class__.__name__ != "Blender Mesh" ):
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return "error"
+	
+	#check if skeleton is the correct class
+	if( skeleton.__class__.__name__ != "Armature" ):
+		ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+		return "error"
+	
+	bone_names = skeleton.bones.keys()
+	bone_names.sort()
+	
+	# init text
+	ftxt = ""
+	
+	# link the vert groups to the bone ids
+	vgroup2bone_id = {}   # we give the vgroup name and we get the bone's id in the skeleton
+	vgroup_names = mesh.getVertGroupNames()
+	
+	for vgroup_name in vgroup_names:
+		bone_id = -1
+		for bone_name in bone_names:
+			if bone_name == vgroup_name:
+				bone_id = bone_names.index( bone_name )
+				break
+		
+		if bone_id == -1:
+			WARNING( "Vert group \"" + vgroup_name + "\" cant link to a bone" )
+		
+		vgroup2bone_id[ vgroup_name ] = bone_id
+	
+	if( b_cmnts ):ftxt += "/*VERTS*/ "
+	ftxt += str( len( mesh.verts ) ) + "\n"
+	
+	# for every vert do some shit
+	for vert in mesh.verts:
+		influences = mesh.getVertexInfluences( vert.index )
+		
+		influences_num = 0
+		sumw = 0.0
+		# calc the influences num and the total weight (NOTE:we may have...
+		# ...a vert group that doesnt connect to a bone)
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				influences_num = influences_num + 1
+				sumw = sumw + weight
+		
+		# a check
+		if( influences_num > 4 ):
+			ERROR( "Cannot have more than 4 bones per vert" );
+			return "error"
+	
+		# write to file
+		if( b_cmnts ): ftxt += "\t/*VERT_ID " + str( vert.index ) + "*/\n"
+		
+		if( b_cmnts ): ftxt += "\t/*BONE_CONNECTIONS*/ "
+		ftxt += str( influences_num ) + "\n"
+				
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:	
+				if( b_cmnts ): ftxt += "\t\t/*BONE_ID*/ "
+				ftxt += str( vgroup2bone_id[ vgroup ] ) + " "
+				if( b_cmnts ): ftxt += "/*WEIGHT*/ "
+				ftxt += str( weight/sumw ) + "\n"
+	# end for all verts
+	
+	return ftxt
+
+
+#===================================================================================================
+# ExportVWeights                                                                                   =
+#===================================================================================================
+def ExportVWeights( path, mesh, skeleton, b_cmnts ):
+	#check if mesh is the correct class
+	if( mesh.__class__.__name__ != "Blender Mesh" ):
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return 0
+	
+	#check if skeleton is the correct class
+	if( skeleton.__class__.__name__ != "Armature" ):
+		ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+		return 0
+	
+	
+	INFO( "Trying to export vert weights for mesh \"" + mesh.name + "\"" )
+	
+	filename = path + mesh.name + ".vw"
+	WriteFile( filename, ScriptVWeights( mesh, skeleton, b_cmnts ) )
+	
+	INFO( "Vert weights exported!! \"" + filename + "\"" )

blenderscripts/common.py

@@ -0,0 +1,52 @@
+import Blender
+import string
+import os.path
+from Blender import Mathutils
+from Blender.Mathutils import *
+from Numeric import *
+
+
+#===================================================================================================
+# vars                                                                                             =
+#===================================================================================================
+NULL = 0
+false = 0
+true = 1
+
+
+#===================================================================================================
+# Messages                                                                                         =
+#===================================================================================================
+"""
+Print a generic error. Used by ERROR, WARNING and INFO only
+"""
+def GenericError( msg0, msg1 ):
+	import sys
+	line = sys._getframe(2).f_lineno
+	fname = sys._getframe(2).f_code.co_filename
+	func_name = sys._getframe(2).f_code.co_name
+
+	print( "-->%s (%s:%i %s): %s" % (msg0, fname, line, func_name, msg1) )
+
+
+""" Prints an error """
+def ERROR( msg ):
+	GenericError( "ERROR", msg )
+
+
+""" Prints a warning """    
+def WARNING( msg ):
+	GenericError( "WARNING", msg )
+
+
+""" Prints some info """
+def INFO( msg ):
+	GenericError( "INFO", msg )
+	
+	
+#===================================================================================================
+# WriteFile                                                                                        =
+#===================================================================================================
+def WriteFile( filename, txt ):
+	file = open( filename, "w" )
+	file.write( txt )

blenderscripts/main.py

@@ -0,0 +1,41 @@
+print( "\n\n\n\n\n\n\n---- STARTING EXPORTER ----" )
+
+import sys
+
+from common import *
+reload( sys.modules["common"] )
+
+from mesh import *
+reload( sys.modules["mesh"] )
+
+from skeleton import *
+reload( sys.modules["skeleton"] )
+
+from vweights import *
+reload( sys.modules["vweights"] )
+
+from material import *
+reload( sys.modules["material"] )
+
+
+cmnts = true
+path = "/home/godlike/src/3d_engine/models/imp/"
+epath = "/home/godlike/src/3d_engine/"
+
+objs = Blender.Object.GetSelected()
+
+if len(objs) < 1:
+	ERROR( "Not selected objs" )
+
+for obj in objs:
+	mesh = GetMesh( obj )
+	mtl = GetMaterial( mesh )
+	skel = GetSkeleton( obj )
+	
+	ExportMesh( path, mesh, skel, "models/imp/" + mtl.getName() + ".mtl" , cmnts )
+	ExportSkeleton( path, skel, cmnts )
+	#ExportVWeights( path, mesh, skel, cmnts )
+	#ExportMaterial( path, epath, mtl, cmnts )
+
+
+print( "---- ENDING EXPORTER ----" )

blenderscripts/material.py

@@ -0,0 +1,140 @@
+import sys
+from common import *
+reload( sys.modules["common"] )
+
+
+
+#===================================================================================================
+# GetMaterial                                                                                      =
+#===================================================================================================
+def GetMaterial( mesh ):
+	#check if mesh is the correct class
+	if( mesh.__class__.__name__ != "Blender Mesh" ):
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return 0
+	
+	# check
+	mats = mesh.materials
+	if( len(mats) < 1 or len(mats) > 1 ):
+		ERROR( "Mesh \"" + mesh.getName() + "\" has non or too many materials" )
+		return 0
+	
+	mat = mats[0]
+	return mat
+
+
+#===================================================================================================
+# ScriptMaterial                                                                                   =
+#===================================================================================================
+def ScriptMaterial( mtl, rpath, b_cmnts ):
+	#check if mesh is the correct class
+	if( mtl.__class__.__name__ != "Blender Material" ):
+		ERROR( "The given func param is not a \"Blender Material\" class but a \"" + mtl.__class__.__name__ + "\"" )
+		return "error"
+	
+	ftxt = ""
+	
+	# write the colors
+	col = mtl.getRGBCol()
+	ftxt += "DIFFUSE_COL {" + str(col[0]) + " " + str(col[1]) + " " + str(col[2]) + " 1.0}\n"
+	
+	ftxt += "SPECULAR_COL {" + str(col[0]) + " " + str(col[1]) + " " + str(col[2]) + " 1.0}\n"
+	
+	# shininess
+	# we borow the shininess factor from the specular hardness
+	sh = mtl.getHardness()
+	if sh > 128:
+		WARNING( "Mat \"" + mtl.getName() + ": Choose spec hardness from 0 to 128" )
+		sh = 128
+	ftxt += "SHININESS " + str(sh) + "\n"
+	
+	#from now on only user defined vars
+	ftxt += "USER_DEFINED_VARS\n{\n"
+	
+	
+	#** TEXTURES **
+	texs = mtl.getTextures()
+	has_diff = 0
+	has_norm = 0
+	has_spec = 0
+	
+	for tex in texs:
+		if tex != None:
+			tex = tex.tex 
+			
+			# get the script identifier
+			if tex.name == "diffuse_map":
+				has_diff = 1
+			elif tex.name == "normal_map":
+				has_norm = 1
+			elif tex.name == "specular_map":
+				has_spec = 1
+			else:
+				WARNING( "Mat \"" + mtl.getName() + "\": Tex name \"" + tex.name + "\" cannot be processed" )
+				continue
+			
+			img = tex.getImage()
+			# check if someone forgot to actually put an image
+			if img == None:
+				WARNING( "Mat \"" + mtl.getName() + "\": There is no image set for \"" + tex.name + "\" texture" )
+				continue
+				
+			ftxt += "\t"
+			
+			# compute the fname
+			fname = img.getFilename()
+			if fname.find( rpath ) == -1: # the img is not in the engine's path
+				WARNING( "Mat \"" + mtl.getName() + "\": Img \"" + fname + "\" is not in the engine's dir" )		
+				continue
+				
+			relative = fname.replace( rpath, "" )
+			
+			ftxt += "TEXTURE " + tex.name + " \"" + relative + "\"\n"
+		#endif
+	#endfor
+	ftxt += "}\n"
+	
+	# shader
+	# choose a shader from one of the standards
+	shader_str = "ms_mp_"
+	if has_diff:
+		shader_str += "d"
+	else:
+		shader_str += "*"
+	if has_norm:
+		shader_str += "n"
+	else:
+		shader_str += "*"
+	if has_spec:
+		shader_str += "s"
+	else:
+		shader_str += "*"
+
+	shader_str += "*****"
+		
+		
+	shader_str = "shaders/" + shader_str + ".shdr"
+	
+	ftxt += "SHADER \"" + shader_str + "\"\n"
+	
+	
+	# end
+	return ftxt
+	
+	
+	
+#===================================================================================================
+# ExportMaterial                                                                                   =
+#===================================================================================================
+def ExportMaterial( path, rpath, mtl, b_cmnts ):
+	#check if mesh is the correct class
+	if( mtl.__class__.__name__ != "Blender Material" ):
+		ERROR( "The given func param is not a \"Blender Material\" class but a \"" + mtl.__class__.__name__ + "\"" )
+		return false
+	
+	INFO( "Trying to export material \"" + mtl.getName() + "\"" )
+	
+	filename = path + mtl.getName() + ".mtl"
+	WriteFile( filename, ScriptMaterial( mtl, rpath, b_cmnts ) )
+	
+	INFO( "Material exported!! \"" + filename + "\"" )

blenderscripts/mesh.py

@@ -0,0 +1,274 @@
+import sys
+from common import *
+reload( sys.modules["common"] )
+
+
+#===================================================================================================
+# GetMesh                                                                                          =
+#===================================================================================================
+def GetMesh( obj ):
+	if( obj.__class__.__name__ != "Blender Object" ):
+		ERROR( "The given func param is not a \"Blender Object\" class but a \"" + obj.__class__.__name__ + "\"" )
+		return 0
+	
+	if obj.getType() != "Mesh": 
+		ERROR( "The obj \"" + obj.getName() + "\" must link to a mesh and not to a(n) " + obj.getType() )
+		return 0
+
+	mesh = obj.getData( 0, 1 ) 
+	return mesh
+
+		
+#===================================================================================================
+# ScriptMesh                                                                                       =
+#===================================================================================================
+def ScriptMesh( mesh, mtl_fname, b_cmnts ):
+	#check if mesh is the correct class
+	if( mesh.__class__.__name__ != "Blender Mesh" ):
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return "error"
+
+	# check verts number
+	if len(mesh.verts) < 3:
+		ERROR( "The mesh named \"" + mesh.name + "\" has insufficient vert num. Skipping" )
+		return "error"
+
+	# check UVs
+	"""if not mesh.faceUV:
+		ERROR( "The mesh named \"" + mesh.name + "\" doesnt have UVs" )
+		return "error"""
+	
+	# init txt
+	ftxt = ""
+	
+	# material
+	if(b_cmnts): ftxt += "/*MATERIAL*/ "
+	ftxt += "\"" + mtl_fname + "\"\n"
+	
+	# the verts
+	if(b_cmnts): ftxt += "/*VERTS*/ "
+	
+	ftxt += str( len(mesh.verts) ) + "\n"
+	
+	for vert in mesh.verts:
+		vec = Vector( vert.co )
+		
+		if(b_cmnts): ftxt += "\t/*VERT_ID "+str(vert.index)+" COORDS*/ "
+		
+		ftxt += str( vec.x ) + " " + str( vec.y ) + " " + str( vec.z ) + "\n"
+
+	
+	# the faces
+	# first calc the triangles num
+	tris_num = 0
+	for face in mesh.faces:
+		if len(face.v) == 3:
+			tris_num = tris_num + 1 # if tris
+		else:
+			tris_num = tris_num + 2 # if quad
+
+	if(b_cmnts): ftxt += "/*FACES*/ "
+	ftxt += str( tris_num ) + "\n"
+	
+	# for every face
+	i = 0
+	for face in mesh.faces:
+		
+		if(b_cmnts): ftxt += "\t/*FACE_ID " + str(i) + " VERT_IDS*/ "
+		
+		order = [0,1,2]
+		# print index
+		for j in order:
+			ftxt += str( face.v[j].index ) + " "
+		
+		i = i+1
+		
+		ftxt += "\n"
+		
+		# if the face is quad then triangulate
+		if( len( face.v ) == 4 ):
+			order = [0,2,3]
+		
+			if(b_cmnts): ftxt += "\t/*FACE_ID " + str(i) + " VERT_IDS*/ "
+			
+			for j in order:
+				ftxt += str( face.v[j].index ) + " "
+				
+			ftxt += "\n"
+			i = i+1
+	
+
+	# the uvs
+	# create and populate the vertuvs array
+	vertuvs = {}
+	
+	# if has UVs
+	if mesh.faceUV:
+		for vert in mesh.verts:
+			vertuvs[ vert.index ] = [ -1000.0, -1000.0 ]
+	
+		for face in mesh.faces:
+			
+			order = [0,1,2] # verts order
+		
+			for j in order:
+				vert_id = face.verts[j].index
+			
+				uvx = face.uv[j].x
+				uvy = face.uv[j].y
+			
+				# if we put a new value in the array OR the values already set and they are the same then
+				if vertuvs[ vert_id ][0]==-1000.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+					vertuvs[ vert_id ][0] = uvx
+					vertuvs[ vert_id ][1] = uvy
+				else:
+					ERROR( "The mesh \"" + mesh.name + "\" More than 1 coords for the " + str(vert_id) + " vert" )
+					mesh.verts[vert_id].sel=1
+					return "error"
+					#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+			
+			# do the same if quat for the other forming triangle
+			if( len( face.verts ) == 4 ):
+				order = [0,2,3]
+			
+				for j in order:
+					vert_id = face.verts[j].index
+				
+					uvx = face.uv[j].x
+					uvy = face.uv[j].y
+				
+					# if we put a new value in the array OR the values already set and they are the same then
+					if vertuvs[ vert_id ][0]==-1000.0 or ( vertuvs[ vert_id ][0] == uvx and vertuvs[ vert_id ][1] == uvy ):
+						vertuvs[ vert_id ][0] = uvx
+						vertuvs[ vert_id ][1] = uvy
+					else:
+						ERROR( "The mesh \"" + mesh.name + "\" More than 1 coords for the " + str(vert_id) + " vert" )
+						mesh.verts[vert_id].sel=1
+						return "error"
+						#print " %f %f %f %f" % ( vertuvs[ vert_id ][0], vertuvs[ vert_id ][1], uvx, uvy )
+	# endif has UVs
+				
+	# now put the UVs in the ftxt
+	if(b_cmnts): ftxt += "/*VERT_TEX_COORDS*/ "
+		
+	ftxt += str( len(vertuvs) ) + "\n"
+	
+	for i in range( 0, len(vertuvs) ):
+		if(b_cmnts): ftxt += "\t/*VERT_ID " + str(i) + " UV_COORDS*/ "
+				
+		ftxt += str( vertuvs[i][0] ) + " " + str( vertuvs[i][1] ) + "\n"
+	
+	
+	return ftxt
+
+
+#===================================================================================================
+# ScriptVWeights                                                                                   =
+#===================================================================================================
+def ScriptVWeights( mesh, skeleton, b_cmnts ):
+	#check if mesh is the correct class
+	if( mesh.__class__.__name__ != "Blender Mesh" ):
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return "error"
+	
+	#check if skeleton is the correct class
+	if( skeleton.__class__.__name__ != "Armature" ):
+		ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+		return "error"
+	
+	bone_names = skeleton.bones.keys()
+	bone_names.sort()
+	
+	# init text
+	ftxt = ""
+	
+	# link the vert groups to the bone ids
+	vgroup2bone_id = {}   # we give the vgroup name and we get the bone's id in the skeleton
+	vgroup_names = mesh.getVertGroupNames()
+	
+	for vgroup_name in vgroup_names:
+		bone_id = -1
+		for bone_name in bone_names:
+			if bone_name == vgroup_name:
+				bone_id = bone_names.index( bone_name )
+				break
+		
+		if bone_id == -1:
+			WARNING( "Vert group \"" + vgroup_name + "\" cant link to a bone" )
+		
+		vgroup2bone_id[ vgroup_name ] = bone_id
+	
+	if( b_cmnts ):ftxt += "/*VERT_WEIGHTS*/ "
+	ftxt += str( len( mesh.verts ) ) + "\n"
+	
+	# for every vert do some shit
+	for vert in mesh.verts:
+		influences = mesh.getVertexInfluences( vert.index )
+		
+		influences_num = 0
+		sumw = 0.0
+		# calc the influences num and the total weight (NOTE:we may have...
+		# ...a vert group that doesnt connect to a bone)
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:
+				influences_num = influences_num + 1
+				sumw = sumw + weight
+		
+		# a check
+		if( influences_num > 4 ):
+			ERROR( "Cannot have more than 4 bones per vert" );
+			return "error"
+	
+		# write to file
+		if( b_cmnts ): ftxt += "\t/*VERT_ID " + str( vert.index ) + "*/\n"
+		
+		if( b_cmnts ): ftxt += "\t/*BONE_CONNECTIONS*/ "
+		ftxt += str( influences_num ) + "\n"
+				
+		for influence in influences:
+			vgroup = influence[0]
+			weight = influence[1]
+			
+			if vgroup2bone_id[ vgroup ] != -1:	
+				if( b_cmnts ): ftxt += "\t\t/*BONE_ID*/ "
+				ftxt += str( vgroup2bone_id[ vgroup ] ) + " "
+				if( b_cmnts ): ftxt += "/*WEIGHT*/ "
+				ftxt += str( weight/sumw ) + "\n"
+	# end for all verts
+	
+	return ftxt
+
+
+#===================================================================================================
+# ExportMesh                                                                                       =
+#===================================================================================================
+def ExportMesh( path, mesh, skeleton, mtl_fname, b_cmnts ):
+	#check if mesh is the correct class
+	if mesh.__class__.__name__ != "Blender Mesh":
+		ERROR( "The given func param is not a \"Blender Mesh\" class but a \"" + mesh.__class__.__name__ + "\"" )
+		return false
+	
+	if skeleton != NULL:
+		#check if skeleton is the correct class
+		if( skeleton.__class__.__name__ != "Armature" ):
+			ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+			return false
+	
+	INFO( "Trying to export mesh \"" + mesh.name + "\"" )
+	
+	filename = path + mesh.name + ".mesh"
+	
+	str = ScriptMesh( mesh, mtl_fname, b_cmnts );
+	if skeleton != NULL:
+		str += ScriptVWeights( mesh, skeleton, b_cmnts )
+	else:
+		if b_cmnts:
+			str += "/*VERT_WEIGHTS*/ "
+		str += "0"
+	
+	WriteFile( filename, str )
+	
+	INFO( "Mesh exported!! \"" + filename + "\"" )	

blenderscripts/skeleton.py

@@ -0,0 +1,119 @@
+from common import *
+import sys
+reload( sys.modules["common"] )
+
+
+
+
+#===================================================================================================
+# GetSkeleton                                                                                      =
+#===================================================================================================
+def GetSkeleton( obj ):	
+	# check if obj is correct class
+	if( obj.__class__.__name__ != "Blender Object" ):
+		ERROR( "The given func param is not a \"Blender Object\" class but a \"" + obj.__class__.__name__ + "\"" )
+		return 0
+	
+	# check modifiers
+	if len(obj.modifiers) < 1:
+		ERROR( "Obj \"" + obj.getName() + "\" doesnt have modifiers so no armature found" )
+		return 0
+	
+	# search for modifier of skeleton type
+	for mod in obj.modifiers:
+		if mod.type == Blender.Modifier.Types.ARMATURE:
+			aobj = mod[Blender.Modifier.Settings.OBJECT]
+			skeleton = Blender.Object.Get( aobj.name ).getData( 0, 1 ) # set skeleton
+			return skeleton
+	
+	ERROR( "Obj \"" + obj.getName() + "\" has no modifier of type armature" )
+	return 0
+		
+
+
+#===================================================================================================
+# ScriptSkeleton                                                                                   =
+#===================================================================================================
+def ScriptSkeleton( skeleton, b_cmnts ):
+	# check if skeleton is correct class
+	if( skeleton.__class__.__name__ != "Armature" ):
+		ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+		return "error"
+	
+	ftxt = "" # file text
+	
+	# write the file
+	bone_names = skeleton.bones.keys()
+	bone_names.sort() # the bones are written in alpabetical order
+
+	if( b_cmnts ): ftxt += "/*BONES*/ "
+	ftxt += str( len(bone_names) ) + "\n"
+
+	for bone_nam in bone_names:	
+		bone = skeleton.bones[ bone_nam ]
+		if( b_cmnts ): ftxt += "\t/*\"" + bone.name + "\" BONE_ID " + str(bone_names.index(bone_nam)) + "*/\n"
+		
+		# name
+		if( b_cmnts ): ftxt += "\t\t/*BONE_NAME*/ "	
+		ftxt += "\"" + bone.name + "\"\n"
+		
+		# head
+		co = bone.head["ARMATURESPACE"]
+		if( b_cmnts ): ftxt +=  "\t\t/*HEAD_ARMATURE_SPACE*/ "
+		ftxt += str(co.x) + " " + str(co.y) + " " + str(co.z) + "\n"
+		
+		# tail
+		co = bone.tail["ARMATURESPACE"]				
+		if( b_cmnts ): ftxt +=  "\t\t/*TAIL_ARMATURE_SPACE*/ "
+		
+		ftxt += str(co.x) + " " + str(co.y) + " " + str(co.z) + "\n"
+		
+		# matrix		
+		if( b_cmnts ): ftxt += "\t\t/*MATRIX_ARMATURE_SPACE*/ "
+				
+		for i_ in range(0, 4):
+			for j_ in range(0, 4):
+				ftxt += str( bone.matrix["ARMATURESPACE"][j_][i_] ) + " "
+		ftxt += "\n"
+		
+		# write the parent
+		if( b_cmnts ): ftxt += "\t\t/*PARENT_ID*/ "
+				
+		if not bone.parent:
+			ftxt += "NULL\n"
+		else:
+			ftxt += str( bone_names.index( bone.parent.name ) )
+			if( b_cmnts ): ftxt += " // " + bone.parent.name
+			ftxt += "\n"
+					
+
+			
+		# write the childs
+		if( b_cmnts ): ftxt += "\t\t/*CHILD_IDS_NUM*/ "
+		ftxt += str( len(bone.children) ) + " "
+		if( b_cmnts ): ftxt += "/*CHILD_IDS*/ "
+		
+		for child in bone.children:
+			ftxt += str( bone_names.index( child.name ) ) + " "
+			if( b_cmnts ): ftxt += "/*" + child.name + "*/ "
+		
+		ftxt += "\n"	
+		
+	return ftxt
+	
+	
+#===================================================================================================
+# ExportSkeleton                                                                                   =
+#===================================================================================================
+def ExportSkeleton( path, skeleton, b_cmnts ):
+	#check if mesh is the correct class
+	if( skeleton.__class__.__name__ != "Armature" ):
+		ERROR( "The given func param is not a \"Armature\" class but a \"" + skeleton.__class__.__name__ + "\"" )
+		return false
+	
+	INFO( "Trying to export skeleton \"" + skeleton.name + "\"" )
+	
+	filename = path + skeleton.name + ".skel"
+	WriteFile( filename, ScriptSkeleton( skeleton, b_cmnts ) )
+	
+	INFO( "Skeleton exported!! \"" + filename + "\"" )	

blenderscripts/skeleton_anim.py

@@ -0,0 +1,224 @@
+import sys
+from common import *
+reload( sys.modules["common"] )
+from Blender.Mathutils import *
+
+
+# MulMatrix
+def MulMatrix( m, b ):
+	c = Matrix()
+	c[0][0] = m[0][0]*b[0][0] + m[0][1]*b[1][0] + m[0][2]*b[2][0] + m[0][3]*b[3][0]
+	c[0][1] = m[0][0]*b[0][1] + m[0][1]*b[1][1] + m[0][2]*b[2][1] + m[0][3]*b[3][1]
+	c[0][2] = m[0][0]*b[0][2] + m[0][1]*b[1][2] + m[0][2]*b[2][2] + m[0][3]*b[3][2]
+	c[0][3] = m[0][0]*b[0][3] + m[0][1]*b[1][3] + m[0][2]*b[2][3] + m[0][3]*b[3][3]
+	c[1][0] = m[1][0]*b[0][0] + m[1][1]*b[1][0] + m[1][2]*b[2][0] + m[1][3]*b[3][0]
+	c[1][1] = m[1][0]*b[0][1] + m[1][1]*b[1][1] + m[1][2]*b[2][1] + m[1][3]*b[3][1]
+	c[1][2] = m[1][0]*b[0][2] + m[1][1]*b[1][2] + m[1][2]*b[2][2] + m[1][3]*b[3][2]
+	c[1][3] = m[1][0]*b[0][3] + m[1][1]*b[1][3] + m[1][2]*b[2][3] + m[1][3]*b[3][3]
+	c[2][0] = m[2][0]*b[0][0] + m[2][1]*b[1][0] + m[2][2]*b[2][0] + m[2][3]*b[3][0]
+	c[2][1] = m[2][0]*b[0][1] + m[2][1]*b[1][1] + m[2][2]*b[2][1] + m[2][3]*b[3][1]
+	c[2][2] = m[2][0]*b[0][2] + m[2][1]*b[1][2] + m[2][2]*b[2][2] + m[2][3]*b[3][2]
+	c[2][3] = m[2][0]*b[0][3] + m[2][1]*b[1][3] + m[2][2]*b[2][3] + m[2][3]*b[3][3]
+	c[3][0] = m[3][0]*b[0][0] + m[3][1]*b[1][0] + m[3][2]*b[2][0] + m[3][3]*b[3][0]
+	c[3][1] = m[3][0]*b[0][1] + m[3][1]*b[1][1] + m[3][2]*b[2][1] + m[3][3]*b[3][1]
+	c[3][2] = m[3][0]*b[0][2] + m[3][1]*b[1][2] + m[3][2]*b[2][2] + m[3][3]*b[3][2]
+	c[3][3] = m[3][0]*b[0][3] + m[3][1]*b[1][3] + m[3][2]*b[2][3] + m[3][3]*b[3][3]
+	return c
+
+
+
+class bone_pose_t:
+	def __init__(self):
+		self.rotation = Quaternion( 1.0, 0.0, 0.0, 0.0 )
+		self.translation = Vector( 0.0, 0.0, 0.0 )
+
+
+class bone_anim_t:
+	def __init__(self):
+		self.keyframes = [] # before the "write to file" phase this array is ether empty
+		                    # if the bone doesnt have animation or an array of poses
+	
+	
+class skeleton_anim_t:
+	def __init__(self):
+		self.bones = []
+		self.keyframes = []
+
+
+#===================================================================================================
+# ScriptAnim                                                                                       =
+#===================================================================================================
+def ScriptAnim( obj, b_cmnts ):
+	
+	if obj.getType() != "Armature":
+		ERROR( "Select a skeleton and not a(n) " + obj.getType() )
+		return 0
+	
+	skeleton = obj.getData( 0, 0 ) 
+	
+	
+	# init and populate the instances
+	skeleton_anim = skeleton_anim_t()
+	skeleton_anim.keyframes = action.getFrameNumbers()
+	
+	bone_names = skeleton.bones.keys()
+	bone_names.sort()
+	
+	for i in range( 0, len(bone_names) ):
+		skeleton_anim.bones.append( bone_anim_t() )
+		for j in range( 0, len(skeleton_anim.keyframes) ):
+			skeleton_anim.bones[i].keyframes.append( bone_pose_t() )
+	
+	
+	# now populate with the correct data
+	# for all the kframes
+	for i in range( 0, len(skeleton_anim.keyframes) ):
+		kframe = skeleton_anim.keyframes[i]
+		Blender.Set( "curframe", kframe )
+		Blender.Redraw()
+		pose = obj.getPose()
+		
+		# for all bones
+		for j in range( 0, len(bone_names) ):
+			bone_name = bone_names[j]
+			pose_bone = pose.bones[bone_name]
+			bone = skeleton.bones[bone_name]
+			
+			# rotation
+			rot = pose_bone.quat.toMatrix()
+			rot.resize4x4()
+			# translation
+			tra = Matrix()
+			tra.identity()
+			for m in range(0, 3):
+				tra[m][3] = pose_bone.loc[m]
+			# bone matris at armature space aka MA
+			MA = Matrix( bone.matrix["ARMATURESPACE"] )
+			MAi = Matrix( MA )
+			MAi.invert()
+			
+			# calc the m4 = MA * tra * rot * MAi
+			rot.transpose()
+			tra.transpose()
+			MA.transpose()
+			MAi.transpose()
+			
+			m4 = MulMatrix( rot, MAi )
+			m4 = MulMatrix( tra, m4 )
+			m4 = MulMatrix( MA, m4 )
+			
+			m4.transpose()
+			
+			# get the final quat and loc
+			quat = m4.rotationPart()
+			quat = quat.toQuat()
+			loc  = m4.translationPart()
+			
+			quat = pose_bone.quat
+			loc = pose_bone.loc
+			
+			for k in range(0, 4):
+				skeleton_anim.bones[j].keyframes[i].rotation[k] = quat[k]
+			
+			for k in range(0, 3):
+				skeleton_anim.bones[j].keyframes[i].translation[k] = loc[k]
+	
+	Blender.Set( "curframe", 1 )
+	Blender.Redraw()	
+	
+	
+	# now do the apropriate for the bones without translation or rotation
+	zero_vec = Vector( 0.0, 0.0, 0.0 )
+	ident_quat = Quaternion( 1.0, 0.0, 0.0, 0.0 )
+	# for all the bones
+	for i in range( 0, len(bone_names) ):
+		no_anim_num = 0   # how many times we found that the bone has no anim
+		bone = skeleton_anim.bones[i]
+		# for all the keyframes
+		for j in range( 0, len(skeleton_anim.keyframes) ):
+			
+			if bone.keyframes[j].rotation == ident_quat and bone.keyframes[j].translation == zero_vec:
+				no_anim_num = no_anim_num + 1
+			
+		if no_anim_num == len( skeleton_anim.keyframes ):
+			print "Bone \"%s\" has no animation" % bone_names[ i ]
+			bone.keyframes = []
+	
+		
+	# write to ftxt
+	ftxt = ""
+	
+	# the keyframes
+	if b_cmnts:
+		ftxt += "/*KEYFRAMES_NUM*/ "
+	ftxt += len(skeleton_anim.keyframes) + "\n"
+	
+	if b_cmnts:
+		ftxt += "/*KEYFRAMES*/ "
+	for kf in skeleton_anim.keyframes:
+		ftxt += str(kf - 1)
+	ftxt += "\n"
+	
+	# the bones num
+	if b_cmnts:
+		ftxt += "/*BONES_NUM*/ " 
+	ftxt += str( len(bone_names) )
+	
+	for i in range( 0, len(bone_names) ):
+		bone = skeleton_anim.bones[i]
+		if b_cmnts:
+			ftxt += "\t/*BONE_NAME " + bone_names[i] + "*/\n"
+		
+		if len( bone.keyframes ):
+			if b_cmnts:
+				ftxt += "\t\t/*HAS_ANIM*/ "
+			ftxt += "1\n"
+			
+			for j in range( 0, len( skeleton_anim.keyframes ) ):
+				file.write( "\t\tKEYFRAME %d\n" % (skeleton_anim.keyframes[j] - 1) ) # -1 cause my keyframes start from 0
+				if b_cmnts:
+					ftxt += "\t\t/*KEYFRAME" + str(skeleton_anim.keyframes[j] - 1) + "*/\n"
+				
+				# write rotation			
+				if b_cmnts:
+					ftxt += "\t\t\t/*ROTATION*/ "
+				for k in range( 0, 4 ):
+					ftxt += str( bone.keyframes[j].rotation[k] ) + " "
+				ftxt += "\n"
+				
+				# write translation
+				if b_cmnts:
+					ftxt += "\t\t\t/*TRANSLATION*/ "
+				for k in range( 0, 3 ):
+					ftxt += str( bone.keyframes[j].translation[k] ) + " "
+				ftxt += "\n"
+			
+		else:
+			if b_cmnts:
+				ftxt += "\t\t/*HAS_ANIM*/ "
+			ftxt += "0\n"
+	
+	return ftxt
+
+
+
+#===================================================================================================
+# ExportAnim                                                                                       =
+#===================================================================================================
+def ExportAnim( path, obj, b_cmnts ):
+	print obj.__class__.__name__
+	
+
+	
+	
+	action = obj.getAction()
+	if action == 0:
+		ERROR( "Empty action for obj " + obj.getName() )
+		return false
+	
+	INFO( "Trying to export skeleton animation \"" + skeleton.name + "\"" )
+	
+	filename = path + action.name + "." + obj.getName() + ".anim"
+	WriteFile( filename, ScriptAnim( obj, b_cmnts ) )
+	
+	INFO( "Skeleton animation exported!! \"" + filename + "\"" )