12 class Vector2(object):
\r
14 2D coordinate for uv value
\r
16 __slots__=['x', 'y']
\r
17 def __init__(self, x=0, y=0):
\r
22 return "<%f %f>" % (self.x, self.y)
\r
24 def __eq__(self, rhs):
\r
25 return self.x==rhs.x and self.y==rhs.y
\r
27 def __getitem__(self, key):
\r
36 return (self.x, self.y)
\r
38 def cross(self, rhs):
\r
39 """cross(outer) product"""
\r
40 return self.x*rhs.y-self.y*rhs.x
\r
43 class Vector3(object):
\r
45 3D coordinate for vertex position, normal direction
\r
47 __slots__=['x', 'y', 'z']
\r
48 def __init__(self, x=0, y=0, z=0):
\r
54 return "<%f %f %f>" % (self.x, self.y, self.z)
\r
56 def __eq__(self, rhs):
\r
57 return self.x==rhs.x and self.y==rhs.y and self.z==rhs.z
\r
59 def __getitem__(self, key):
\r
70 return (self.x, self.y, self.z)
\r
72 def __add__(self, r):
\r
73 return Vector3(self.x+r.x, self.y+r.y, self.z+r.z)
\r
75 def __sub__(self, rhs):
\r
76 return Vector3(self.x-rhs.x, self.y-rhs.y, self.z-rhs.z)
\r
78 def getSqNorm(self):
\r
79 return self.x*self.x + self.y*self.y + self.z*self.z
\r
82 return math.sqrt(self.getSqNorm())
\r
84 def normalize(self):
\r
85 factor=1.0/self.getNorm()
\r
92 return [self.x, self.y, self.z]
\r
95 """dot(inner) product"""
\r
96 return self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
\r
98 def cross(self, rhs):
\r
99 """cross(outer) product"""
\r
101 self.y*rhs.z - rhs.y*self.z,
\r
102 self.z*rhs.x - rhs.z*self.x,
\r
103 self.x*rhs.y - rhs.x*self.y,
\r
107 class Quaternion(object):
\r
109 rotation representation in vmd motion
\r
111 __slots__=['x', 'y', 'z', 'w']
\r
112 def __init__(self, x=0, y=0, z=0, w=1):
\r
119 return "<%f %f %f %f>" % (self.x, self.y, self.z, self.w)
\r
121 def __mul__(self, rhs):
\r
122 u=numpy.array([self.x, self.y, self.z], 'f')
\r
123 v=numpy.array([rhs.x, rhs.y, rhs.z], 'f')
\r
124 xyz=self.w*v+rhs.w*u+numpy.cross(u, v)
\r
125 q=Quaternion(xyz[0], xyz[1], xyz[2], self.w*rhs.w-numpy.dot(u, v))
\r
128 def dot(self, rhs):
\r
129 return self.x*rhs.x+self.y*rhs.y+self.z*rhs.z+self.w*rhs.w
\r
131 def getMatrix(self):
\r
141 return numpy.array([
\r
143 [1-2*sqY-2*sqZ, 2*xy+2*wz, 2*xz-2*wy, 0],
\r
145 [2*xy-2*wz, 1-2*sqX-2*sqZ, 2*yz+2*wx, 0],
\r
147 [2*xz+2*wy, 2*yz-2*wx, 1-2*sqX-2*sqY, 0],
\r
152 def getRHMatrix(self):
\r
166 return numpy.array([
\r
168 [1-2*sqY-2*sqZ, 2*xy+2*wz, 2*xz-2*wy, 0],
\r
170 [2*xy-2*wz, 1-2*sqX-2*sqZ, 2*yz+2*wx, 0],
\r
172 [2*xz+2*wy, 2*yz-2*wx, 1-2*sqX-2*sqY, 0],
\r
177 def getRollPitchYaw(self):
\r
180 roll = math.atan2(m[0, 1], m[1, 1])
\r
181 pitch = math.asin(-m[2, 1])
\r
182 yaw = math.atan2(m[2, 0], m[2, 2])
\r
184 if math.fabs(math.cos(pitch)) < 1.0e-6:
\r
185 roll += m[0, 1] > math.pi if 0.0 else -math.pi
\r
186 yaw += m[2, 0] > math.pi if 0.0 else -math.pi
\r
188 return roll, pitch, yaw
\r
190 def getSqNorm(self):
\r
191 return self.x*self.x+self.y*self.y+self.z*self.z+self.w*self.w
\r
193 def getNormalized(self):
\r
194 f=1.0/self.getSqNorm()
\r
195 q=Quaternion(self.x*f, self.y*f, self.z*f, self.w*f)
\r
198 def getRightHanded(self):
\r
199 "swap y and z axis"
\r
200 return Quaternion(-self.x, -self.z, -self.y, self.w)
\r
203 def createFromAxisAngle(axis, rad):
\r
206 c=math.cos(half_rad)
\r
207 s=math.sin(half_rad)
\r
208 return Quaternion(axis[0]*s, axis[1]*s, axis[2]*s, c)
\r
215 __slots__=['r', 'g', 'b']
\r
216 def __init__(self, r=0, g=0, b=0):
\r
221 def __eq__(self, rhs):
\r
222 return self.r==rhs.r and self.g==rhs.g and self.b==rhs.b
\r
224 def __getitem__(self, key):
\r
235 class RGBA(object):
\r
239 __slots__=['r', 'g', 'b', 'a']
\r
240 def __init__(self, r=0, g=0, b=0, a=1):
\r
246 def __getitem__(self, key):
\r
262 def radian_to_degree(x):
\r
263 """darian to deglee"""
\r
265 return x/math.pi * 180.0
\r
268 class ParseException(Exception):
\r
273 """read all bytes from path
\r
275 with open(path, "rb") as f:
\r
279 class BinaryLoader(object):
\r
280 """general BinaryLoader
\r
282 def __init__(self, ios):
\r
286 return not self.ios.readable()
\r
288 def unpack(self, fmt, size):
\r
289 result=struct.unpack(fmt, self.ios.read(size))
\r
292 def read_uint(self, size):
\r
294 return self.unpack("B", size)
\r
296 return self.unpack("H", size)
\r
298 return self.unpack("I", size)
\r
299 print("not reach here")
\r
300 raise ParseException("invalid int size: "+size)
\r
302 def read_float(self):
\r
303 return self.unpack("f", 4)
\r
305 def read_vector2(self):
\r
307 self.read_float(),
\r
311 def read_vector3(self):
\r
313 self.read_float(),
\r
314 self.read_float(),
\r
318 def read_rgba(self):
\r
320 self.read_float(),
\r
321 self.read_float(),
\r
326 def read_rgb(self):
\r
328 self.read_float(),
\r
329 self.read_float(),
\r
334 class BinaryWriter(object):
\r
335 def __init__(self, ios):
\r
338 def write_text(self, v, size=None):
\r
340 self.ios.write(struct.pack("={0}s".format(size), v))
\r
344 def write_float(self, v):
\r
345 self.ios.write(struct.pack("f", v))
\r
347 def write_uint(self, v, size):
\r
349 self.ios.write(struct.pack("B", v))
\r
351 self.ios.write(struct.pack("H", v))
\r
353 self.ios.write(struct.pack("I", v))
\r
355 raise WriteError("invalid int uint size")
\r
357 def write_vector2(self, v):
\r
358 self.ios.write(struct.pack("=2f", v.x, v.y))
\r
360 def write_vector3(self, v):
\r
361 self.ios.write(struct.pack("=3f", v.x, v.y, v.z))
\r
363 def write_rgb(self, v):
\r
364 self.ios.write(struct.pack("=3f", v.r, v.g, v.b))
\r