quats

Mat4.py

@@ -93,13 +93,8 @@ class Mat4:
 		self.multiply(tmp)
 
 	# rotate by vec3
-    def rotate(self, vec3, zxy_order = False):
+	def rotate(self, vec3):
 
-        if zxy_order:
-            z = vec3[0]
-            x = vec3[1]
-            y = vec3[2]
-        else:
 		x = vec3[0]
 		y = vec3[1]
 		z = vec3[2]
@@ -134,6 +129,63 @@ class Mat4:
 		tmp[1][1] = c;
 		self.multiply(tmp)
 
+	def toQuat(self):
+
+		m11 = self.mtx[0][0]
+		m21 = self.mtx[1][0]
+		m31 = self.mtx[2][0]
+
+		m12 = self.mtx[0][1]
+		m22 = self.mtx[1][1]
+		m32 = self.mtx[2][1]
+
+		m13 = self.mtx[0][2]
+		m23 = self.mtx[1][2]
+		m33 = self.mtx[2][2]
+
+		trace = m11 + m22 + m33;
+		
+		x = 0
+		y = 0
+		z = 0
+		w = 1
+
+		if (trace > 0):
+			
+			s = 0.5 / math.sqrt( trace + 1.0 )
+			w = 0.25 / s
+			x = ( m32 - m23 ) * s
+			y = ( m13 - m31 ) * s
+			z = ( m21 - m12 ) * s
+
+		elif ( m11 > m22 and m11 > m33 ):
+
+			s = 2.0 * math.sqrt( 1.0 + m11 - m22 - m33 )
+			w = ( m32 - m23 ) / s
+			x = 0.25 * s
+			y = ( m12 + m21 ) / s
+			z = ( m13 + m31 ) / s
+
+		elif (m22 > m33) :
+
+			s = 2.0 * math.sqrt( 1.0 + m22 - m11 - m33 )
+
+			w = ( m13 - m31 ) / s
+			x = ( m12 + m21 ) / s
+			y = 0.25 * s
+			z = ( m23 + m32 ) / s
+
+		else:
+			
+			s = 2.0 * math.sqrt( 1.0 + m33 - m11 - m22 )
+
+			w = ( m21 - m12 ) / s
+			x = ( m13 + m31 ) / s
+			y = ( m23 + m32 ) / s
+			z = 0.25 * s
+
+		return [x, y, z, w]
+
 #==============================================================
 """
 Program End

NinjaBone.py

@@ -37,6 +37,9 @@ class NinjaBone: # {
 		self.world = Mat4()
 		self.parent = None
 		self.children = []
+		self.rotation = [ 0, 0, 0 ]
+		self.position = [ 0, 0, 0 ]
+		self.scale = [ 1, 1, 1]
 		return None
 
 	def getIndex(self):
@@ -45,6 +48,15 @@ class NinjaBone: # {
 	def getWorld(self):
 		return self.world.mtx
 
+	def getScale(self):
+		return self.scale
+	
+	def getPosition(self):
+		return self.position
+
+	def getRotation(self):
+		return self.rotation
+
 	def setName(self, num):
 		self.index = num
 		self.name = 'bone_%03d' % num
@@ -62,16 +74,31 @@ class NinjaBone: # {
 		return None
 
 	def setScale(self, vec3):
+		self.scale = vec3
 		self.local.scale(vec3)
 		self.world.scale(vec3)
 		return None
 
-	def setRotation(self, vec3, zxy_order):
+	def setRotation(self, vec3, zxy_order = False):
-		self.local.rotate(vec3, zxy_order)
+		
-		self.world.rotate(vec3, zxy_order)
+		if zxy_order:
+			z = vec3[0]
+			x = vec3[1]
+			y = vec3[2]
+		else:
+			x = vec3[0]
+			y = vec3[1]
+			z = vec3[2]
+
+		rot = [ x, y, z ]
+		self.rotation = rot
+
+		self.local.rotate(vec3)
+		self.world.rotate(vec3)
 		return None
 
 	def setPosition(self, vec3):
+		self.position = vec3
 		self.local.translate(vec3)
 		self.world.translate(vec3)
 		return None
@@ -80,7 +107,6 @@ class NinjaBone: # {
 		return self.world.apply(vec3)
 
 	def createDmfEntry(self, file):
-
 		# 0x00 Name
 		name = self.name
 		while len(name) < 0x20:

NinjaModel.py

@@ -433,6 +433,7 @@ class NinjaModel:
 			'rot' : p[2] & 0x02,
 			'scl' : p[2] & 0x04
 		}
+
 		factor_count = p[3] & 0x03
 		spline_interpolation = p[3] & 0x40
 		user_function_interpolation = p[3] & 0x80
@@ -443,22 +444,12 @@ class NinjaModel:
 		anim.setSkeleton(self.bones)
 		self.anim_list.append(anim)
 
-		print("READING ANIMTION!!!!")
-		print(motion_type)
-
-		print("FRAME COUNT: %d" % frame_count)
-		print("Factor Count %d" % factor_count)
-		print("Spline Function %d" % spline_interpolation)
-		
 		# Read Motion Table
 		anim_vals = []
 
-		print("Table Offset: 0x%08x" % table_ofs)
 		self.file.seek(table_ofs, 0)
 		for i in range(len(self.bones)):
 	
-			print("Current Offset: 0x%08x" % self.file.tell())
-
 			entry = {
 				'bone_index' : i,
 				'pos_ofs' : 0,
@@ -496,13 +487,13 @@ class NinjaModel:
 			bytes = self.file.read(4)
 			p = struct.unpack('I', bytes)
 			entry['scl_num'] = p[0]
-			
 			anim_vals.append(entry)
 
 		c = 2 * 3.141592 / 0x10000;
 		for entry in anim_vals:
 
 			boneIndex = entry['bone_index']
+			print("Bone Index: %d" % boneIndex)
 
 			self.file.seek(entry['pos_ofs'], 0)
 			for i in range(entry['pos_num']):
@@ -514,8 +505,8 @@ class NinjaModel:
 
 			self.file.seek(entry['rot_ofs'], 0)
 			for i in range(entry['rot_num']):
-				bytes = self.file.read(16)
+				bytes = self.file.read(8)
-				p = struct.unpack('Ifff', bytes)
+				p = struct.unpack('Hhhh', bytes)
 				frame = p[0]
 				vec3 = [ p[1]*c, p[2]*c, p[3]*c ]
 				anim.appendKeyFrame(boneIndex, frame, vec3, 'rot')
@@ -527,7 +518,7 @@ class NinjaModel:
 				frame = p[0]
 				vec3 = [ p[1], p[2], p[3] ]
 				anim.appendKeyFrame(boneIndex, frame, vec3, 'scl')
-
+			anim.save(boneIndex)
 		return None
 
 	def export(self):

NinjaMotion.py

@@ -42,7 +42,7 @@ class NinjaMotion:
 		return None
 	
 	def setSkeleton(self, bones):
-		self.seleton = bones
+		self.skeleton = bones
 		for i in range(len(bones)):
 			self.keyFrames.append([])
 		return None
@@ -68,4 +68,49 @@ class NinjaMotion:
 		keyFrames.append(keyFrame)
 		return None
 	
+	def save(self, boneIndex):
+		
+		bone = self.skeleton[boneIndex]
+		keyFrames = self.keyFrames[boneIndex]
+		
+		if len(keyFrames) == 0:
+			keyFrames.append({
+				'frame' : 0
+			})
+			keyFrames.append({
+				'frame' : self.frames - 1
+			})
+
+		if 'scl' not in keyFrames[0].keys():
+			keyFrames[0]['scl'] = bone.getScale()
+		
+		if 'pos' not in keyFrames[0].keys():
+			keyFrames[0]['pos'] = bone.getPosition()
+		
+		if 'rot' not in keyFrames[0].keys():
+			keyFrames[0]['rot'] = bone.getRotation()
+
+		lastIndex = len(keyFrames) - 1
+
+		if 'scl' not in keyFrames[lastIndex].keys():
+			keyFrames[lastIndex]['scl'] = bone.getScale()
+		
+		if 'pos' not in keyFrames[lastIndex].keys():
+			keyFrames[lastIndex]['pos'] = bone.getPosition()
+		
+		if 'rot' not in keyFrames[lastIndex].keys():
+			keyFrames[lastIndex]['rot'] = bone.getRotation()
+
+		for keyFrame in keyFrames:
+
+			if 'rot' not in keyFrame.keys():
+				continue
+
+			mat4 = Mat4()
+			mat4.rotate(keyFrame['rot'])
+			keyFrame['quat'] = mat4.toQuat()
+			print(keyFrame['quat'])
+
+
+		return None