Removed old source of blender scripts. No need to keep them

blenderscripts/blender_python_old/OLD/OLD2_export_bone_animation.py

@@ -1,157 +0,0 @@
-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

@@ -1,267 +0,0 @@
-
-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

@@ -1,175 +0,0 @@
-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

@@ -1,268 +0,0 @@
-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

@@ -1,94 +0,0 @@
-
-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

@@ -1,88 +0,0 @@
-
-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

@@ -1,155 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,327 +0,0 @@
-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

@@ -1,541 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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 + "\"" )