def test_eq_false(self):
ver = Version(major=4, minor=2)
other = Version(major=2, minor=1)
self.assertNotEqual(ver, other)
self.assertNotEqual(ver, 1)
self.assertNotEqual(ver, "test")
def test_write_read(self):
expected = Version(major=8, minor=2)
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
self.assertEqual(expected, Version.read(io_stream))
def test_write_read(self):
expected = Box()
expected.version = Version(major=5, minor=22)
expected.box_type = 3
expected.collision_types = 64
expected.name = "TestBoxxx"
expected.color = RGBA(r=125, g=110, b=55, a=244)
expected.center = Vector((1.0, 2.0, 3.0))
expected.extend = Vector((4.0, 5.0, 6.0))
self.assertEqual(68, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, _) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_BOX, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Box.read(io_stream)
self.assertEqual(expected.version.major, actual.version.major)
self.assertEqual(expected.version.minor, actual.version.minor)
self.assertEqual(expected.box_type, actual.box_type)
self.assertEqual(expected.collision_types, actual.collision_types)
self.assertEqual(expected.name, actual.name)
self.assertEqual(expected.color, actual.color)
self.assertEqual(expected.center.x, actual.center.x)
self.assertEqual(expected.center.y, actual.center.y)
self.assertEqual(expected.center.z, actual.center.z)
self.assertEqual(expected.extend.x, actual.extend.x)
self.assertEqual(expected.extend.y, actual.extend.y)
self.assertEqual(expected.extend.z, actual.extend.z)
def test_write_read(self):
expected = HLod()
expected.header = HLodHeader(version=Version(major=3, minor=2),
lod_count=3,
model_name="TestModelName",
hierarchy_name="TestHieraName")
expected.lod_array = HLodArray()
self.assertEqual(40, expected.header.size_in_bytes())
expected.lod_array.header = HLodArrayHeader(model_count=2,
max_screen_size=5442)
self.assertEqual(8, expected.lod_array.header.size_in_bytes())
sub_object1 = HLodSubObject(bone_index=3, name="SubObjectNumber1")
self.assertEqual(36, sub_object1.size_in_bytes())
sub_object2 = HLodSubObject(bone_index=44, name="SubObjectNumber2")
self.assertEqual(36, sub_object2.size_in_bytes())
expected.lod_array.sub_objects.append(sub_object1)
expected.lod_array.sub_objects.append(sub_object2)
self.assertEqual(160, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_HLOD, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = HLod.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.lod_count, actual.header.lod_count)
self.assertEqual(expected.header.model_name, actual.header.model_name)
self.assertEqual(expected.header.hierarchy_name,
actual.header.hierarchy_name)
self.assertEqual(expected.lod_array.header.model_count,
actual.lod_array.header.model_count)
self.assertEqual(expected.lod_array.header.max_screen_size,
actual.lod_array.header.max_screen_size)
self.assertEqual(len(expected.lod_array.sub_objects),
len(actual.lod_array.sub_objects))
self.assertEqual(expected.lod_array.sub_objects[0].bone_index,
actual.lod_array.sub_objects[0].bone_index)
self.assertEqual(expected.lod_array.sub_objects[0].name,
actual.lod_array.sub_objects[0].name)
self.assertEqual(expected.lod_array.sub_objects[1].bone_index,
actual.lod_array.sub_objects[1].bone_index)
self.assertEqual(expected.lod_array.sub_objects[1].name,
actual.lod_array.sub_objects[1].name)
class AnimationHeader(Struct):
version = Version()
name = ""
hierarchy_name = ""
num_frames = 0
frame_rate = 0
@staticmethod
def read(io_stream):
return AnimationHeader(version=Version.read(io_stream),
name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream),
num_frames=read_ulong(io_stream),
frame_rate=read_ulong(io_stream))
@staticmethod
def size_in_bytes():
return 44
def write(self, io_stream):
write_chunk_head(io_stream, W3D_CHUNK_ANIMATION_HEADER,
self.size_in_bytes())
self.version.write(io_stream)
write_fixed_string(io_stream, self.name)
write_fixed_string(io_stream, self.hierarchy_name)
write_ulong(io_stream, self.num_frames)
write_ulong(io_stream, self.frame_rate)
class Box(Struct):
version = Version()
box_type = 0
collision_types = 0
name = ""
color = RGBA()
center = Vector((0.0, 0.0, 0.0))
extend = Vector((0.0, 0.0, 0.0))
@staticmethod
def read(io_stream):
ver = Version.read(io_stream)
flags = read_ulong(io_stream)
return Box(version=ver,
box_type=(flags & 0b11),
collision_types=(flags & 0xFF0),
name=read_long_fixed_string(io_stream),
color=RGBA.read(io_stream),
center=read_vector(io_stream),
extend=read_vector(io_stream))
@staticmethod
def size_in_bytes():
return 68
def write(self, io_stream):
write_chunk_head(io_stream, W3D_CHUNK_BOX, self.size_in_bytes())
self.version.write(io_stream)
write_ulong(io_stream,
(self.collision_types & 0xFF) | (self.box_type & 0b11))
write_long_fixed_string(io_stream, self.name)
self.color.write(io_stream)
write_vector(io_stream, self.center)
write_vector(io_stream, self.extend)
def test_write_read_minimal(self):
expected = Hierarchy(pivots=[], pivot_fixups=[])
expected.header = HierarchyHeader(version=Version(major=4, minor=1),
name="HieraHeader",
num_pivots=33,
center_pos=Vector((2.0, 3.0, 1.0)))
self.assertEqual(36, expected.header.size_in_bytes())
pivot1 = HierarchyPivot(name="Roottransform",
parent_id=-1,
translation=Vector((22.0, 33.0, 1.0)),
euler_angles=Vector((1.0, 12.0, -2.0)),
rotation=Quaternion((1.0, -0.1, -0.2, -0.3)))
self.assertEqual(60, pivot1.size_in_bytes())
expected.pivots.append(pivot1)
self.assertEqual(112, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_HIERARCHY, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Hierarchy.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.num_pivots, actual.header.num_pivots)
self.assertEqual(expected.header.center_pos, actual.header.center_pos)
self.assertEqual(len(expected.pivots), len(actual.pivots))
def test_write_read(self):
expected = Hierarchy(pivots=[], pivot_fixups=[])
expected.header = HierarchyHeader(version=Version(major=4, minor=1),
name="HieraHeader",
num_pivots=33,
center_pos=Vector((2.0, 3.0, 1.0)))
self.assertEqual(36, expected.header.size_in_bytes())
pivot1 = HierarchyPivot(name="Roottransform",
parent_id=-1,
translation=Vector((22.0, 33.0, 1.0)),
euler_angles=Vector((1.0, 12.0, -2.0)),
rotation=Quaternion((1.0, -0.1, -0.2, -0.3)))
self.assertEqual(60, pivot1.size_in_bytes())
expected.pivots.append(pivot1)
pivot2 = HierarchyPivot(name="Spine",
parent_id=0,
translation=Vector((-22.0, -33.0, -1.0)),
euler_angles=Vector((-1.0, -12.0, 2.0)),
rotation=Quaternion((-1.0, 0.1, 0.2, 0.3)))
self.assertEqual(60, pivot2.size_in_bytes())
expected.pivots.append(pivot2)
for _ in range(64):
expected.pivot_fixups.append(Vector((-1.0, -2.0, -3.0)))
self.assertEqual(948, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_HIERARCHY, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Hierarchy.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.num_pivots, actual.header.num_pivots)
self.assertEqual(expected.header.center_pos, actual.header.center_pos)
self.assertEqual(len(expected.pivots), len(actual.pivots))
for i, piv in enumerate(expected.pivots):
act = actual.pivots[i]
self.assertEqual(piv.name, act.name)
self.assertEqual(piv.parent_id, act.parent_id)
self.assertEqual(piv.translation, act.translation)
self.assertEqual(piv.euler_angles, act.euler_angles)
self.assertEqual(piv.rotation, act.rotation)
self.assertEqual(len(expected.pivot_fixups), len(actual.pivot_fixups))
for i, fix in enumerate(expected.pivot_fixups):
self.assertEqual(fix, actual.pivot_fixups[i])
def read(io_stream):
return CompressedAnimationHeader(
version=Version.read(io_stream),
name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream),
num_frames=read_ulong(io_stream),
frame_rate=read_ushort(io_stream),
flavor=read_ushort(io_stream))
def read(io_stream):
ver = Version.read(io_stream)
flags = read_ulong(io_stream)
return Box(version=ver,
box_type=(flags & 0b11),
collision_types=(flags & 0xFF0),
name=read_long_fixed_string(io_stream),
color=RGBA.read(io_stream),
center=read_vector(io_stream),
extend=read_vector(io_stream))
class CompressedAnimationHeader(Struct):
version = Version()
name = ""
hierarchy_name = ""
num_frames = 0
frame_rate = 0
flavor = 0
@staticmethod
def read(io_stream):
return CompressedAnimationHeader(
version=Version.read(io_stream),
name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream),
num_frames=read_ulong(io_stream),
frame_rate=read_ushort(io_stream),
flavor=read_ushort(io_stream))
def test_write_read_minimal(self):
expected = CompressedAnimation(time_coded_channels=[],
adaptive_delta_channels=[],
time_coded_bit_channels=[],
motion_channels=[])
expected.header = CompressedAnimationHeader(version=Version(major=4,
minor=1),
name="CompAniHead",
hierarchy_name="HieraName",
num_frames=155,
frame_rate=300,
flavor=0)
self.assertEqual(44, expected.header.size_in_bytes())
self.assertEqual(52, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_COMPRESSED_ANIMATION, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = CompressedAnimation.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.hierarchy_name,
actual.header.hierarchy_name)
self.assertEqual(expected.header.num_frames, actual.header.num_frames)
self.assertEqual(expected.header.frame_rate, actual.header.frame_rate)
self.assertEqual(expected.header.flavor, actual.header.flavor)
self.assertEqual(len(expected.time_coded_channels),
len(actual.time_coded_channels))
self.assertEqual(len(expected.adaptive_delta_channels),
len(actual.adaptive_delta_channels))
self.assertEqual(len(expected.time_coded_bit_channels),
len(actual.time_coded_bit_channels))
self.assertEqual(len(expected.motion_channels),
len(actual.motion_channels))
def read(io_stream):
return MeshHeader(
version=Version.read(io_stream),
attrs=read_ulong(io_stream),
mesh_name=read_fixed_string(io_stream),
container_name=read_fixed_string(io_stream),
face_count=read_ulong(io_stream),
vert_count=read_ulong(io_stream),
matl_count=read_ulong(io_stream),
damage_stage_count=read_ulong(io_stream),
sort_level=read_ulong(io_stream),
prelit_version=read_ulong(io_stream),
future_count=read_ulong(io_stream),
vert_channel_flags=read_ulong(io_stream),
face_channel_falgs=read_ulong(io_stream),
# bounding volumes
min_corner=read_vector(io_stream),
max_corner=read_vector(io_stream),
sph_center=read_vector(io_stream),
sph_radius=read_float(io_stream))
class HierarchyHeader(Struct):
version = Version()
name = ""
num_pivots = 0
center_pos = Vector((0.0, 0.0, 0.0))
@staticmethod
def read(io_stream):
return HierarchyHeader(
version=Version.read(io_stream),
name=read_fixed_string(io_stream),
num_pivots=read_ulong(io_stream),
center_pos=read_vector(io_stream))
@staticmethod
def size_in_bytes():
return 36
def write(self, io_stream):
write_chunk_head(io_stream, W3D_CHUNK_HIERARCHY_HEADER, self.size_in_bytes())
self.version.write(io_stream)
write_fixed_string(io_stream, self.name)
write_ulong(io_stream, self.num_pivots)
write_vector(io_stream, self.center_pos)
class HLodHeader(Struct):
version = Version()
lod_count = 1
model_name = ""
hierarchy_name = ""
@staticmethod
def read(io_stream):
return HLodHeader(
version=Version.read(io_stream),
lod_count=read_ulong(io_stream),
model_name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream))
@staticmethod
def size_in_bytes():
return 40
def write(self, io_stream):
write_chunk_head(io_stream, W3D_CHUNK_HLOD_HEADER, self.size_in_bytes())
self.version.write(io_stream)
write_ulong(io_stream, self.lod_count)
write_fixed_string(io_stream, self.model_name)
write_fixed_string(io_stream, self.hierarchy_name)
def test_eq_true(self):
ver = Version(major=3, minor=1)
self.assertEqual(ver, ver)
def read(io_stream):
return HierarchyHeader(
version=Version.read(io_stream),
name=read_fixed_string(io_stream),
num_pivots=read_ulong(io_stream),
center_pos=read_vector(io_stream))
def read(io_stream):
return AnimationHeader(version=Version.read(io_stream),
name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream),
num_frames=read_ulong(io_stream),
frame_rate=read_ulong(io_stream))
def test_write_read(self):
expected = CompressedAnimation(time_coded_channels=[],
adaptive_delta_channels=[],
time_coded_bit_channels=[],
motion_channels=[])
expected.header = CompressedAnimationHeader(version=Version(major=4,
minor=1),
name="CompAniHead",
hierarchy_name="HieraName",
num_frames=155,
frame_rate=300,
flavor=0)
self.assertEqual(44, expected.header.size_in_bytes())
# TimeCodedChannels
tc_channel = TimeCodedAnimationChannel(num_time_codes=55,
pivot=4,
vector_len=4,
type=6,
time_codes=[])
tc_datum = TimeCodedDatum(time_code=34,
non_interpolated=True,
value=Quaternion((0.1, -2.0, -0.3, 2.0)))
for _ in range(tc_channel.num_time_codes):
tc_channel.time_codes.append(tc_datum)
for _ in range(31):
expected.time_coded_channels.append(tc_channel)
# TimeCodedBitChannels
tcb_channel = TimeCodedBitChannel(num_time_codes=55,
pivot=52,
type=0,
default_value=12,
time_codes=[])
tcb_datum = TimeCodedBitDatum(time_code=1, value=True)
for _ in range(tcb_channel.num_time_codes):
tcb_channel.time_codes.append(tcb_datum)
for _ in range(31):
expected.time_coded_bit_channels.append(tcb_channel)
# MotionChannels
m_channel_tc = MotionChannel(delta_type=0,
vector_len=1,
type=0,
num_time_codes=55,
pivot=182,
data=[])
datum = TimeCodedDatum(time_code=3, value=2.0)
for _ in range(m_channel_tc.num_time_codes):
m_channel_tc.data.append(datum)
expected.motion_channels.append(m_channel_tc)
m_channel_ad_y_4 = MotionChannel(delta_type=1,
vector_len=1,
type=2,
num_time_codes=55,
pivot=182,
data=[])
m_ad_y_4 = AdaptiveDeltaMotionAnimationChannel(
scale=4.0,
initial_value=-1.0,
data=self.get_adaptive_delta_data(2, 4,
m_channel_ad_y_4.num_time_codes))
m_channel_ad_y_4.data = m_ad_y_4
expected.motion_channels.append(m_channel_ad_y_4)
m_channel_ad_q_4 = MotionChannel(delta_type=1,
vector_len=4,
type=6,
num_time_codes=55,
pivot=182,
data=[])
m_ad_q_4 = AdaptiveDeltaMotionAnimationChannel(
scale=4.0,
initial_value=Quaternion((3.0, 2.0, 0.1, -1.9)),
data=self.get_adaptive_delta_data(6, 4,
m_channel_ad_q_4.num_time_codes))
m_channel_ad_q_4.data = m_ad_q_4
expected.motion_channels.append(m_channel_ad_q_4)
m_channel_ad_y_8 = MotionChannel(delta_type=2,
vector_len=1,
type=2,
num_time_codes=55,
pivot=182,
data=[])
m_ad_y_8 = AdaptiveDeltaMotionAnimationChannel(
scale=4.0,
initial_value=-1.0,
data=self.get_adaptive_delta_data(2, 8,
m_channel_ad_y_8.num_time_codes))
m_channel_ad_y_8.data = m_ad_y_8
expected.motion_channels.append(m_channel_ad_y_8)
m_channel_ad_q_8 = MotionChannel(delta_type=2,
vector_len=4,
type=6,
num_time_codes=55,
pivot=182,
data=[])
m_ad_q_8 = AdaptiveDeltaMotionAnimationChannel(
scale=4.0,
initial_value=Quaternion((3.0, 2.0, 0.1, -1.9)),
data=self.get_adaptive_delta_data(6, 8,
m_channel_ad_q_8.num_time_codes))
m_channel_ad_q_8.data = m_ad_q_8
expected.motion_channels.append(m_channel_ad_q_8)
self.assertEqual(42842, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_COMPRESSED_ANIMATION, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = CompressedAnimation.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.hierarchy_name,
actual.header.hierarchy_name)
self.assertEqual(expected.header.num_frames, actual.header.num_frames)
self.assertEqual(expected.header.frame_rate, actual.header.frame_rate)
self.assertEqual(expected.header.flavor, actual.header.flavor)
self.assertEqual(len(expected.time_coded_channels),
len(actual.time_coded_channels))
self.assertEqual(len(expected.time_coded_bit_channels),
len(actual.time_coded_bit_channels))
for i, chan in enumerate(expected.time_coded_channels):
act = actual.time_coded_channels[i]
self.assertEqual(chan.num_time_codes, act.num_time_codes)
self.assertEqual(chan.pivot, act.pivot)
self.assertEqual(chan.vector_len, act.vector_len)
self.assertEqual(chan.type, act.type)
self.assertEqual(len(chan.time_codes), len(act.time_codes))
for j, time_code in enumerate(chan.time_codes):
self.assertEqual(time_code.time_code,
act.time_codes[j].time_code)
self.assertAlmostEqual(time_code.value,
act.time_codes[j].value, 5)
for i, chan in enumerate(expected.time_coded_bit_channels):
act = actual.time_coded_bit_channels[i]
self.assertEqual(chan.num_time_codes, act.num_time_codes)
self.assertEqual(chan.pivot, act.pivot)
self.assertEqual(chan.type, act.type)
self.assertAlmostEqual(chan.default_value, act.default_value, 5)
self.assertEqual(len(chan.time_codes), len(act.time_codes))
for j, time_code in enumerate(chan.time_codes):
self.assertEqual(time_code.time_code,
act.time_codes[j].time_code)
self.assertAlmostEqual(time_code.value,
act.time_codes[j].value, 5)
class MeshHeader(Struct):
version = Version()
attrs = 0
mesh_name = ""
container_name = ""
face_count = 0
vert_count = 0
matl_count = 0
damage_stage_count = 0
sort_level = 0
prelit_version = 0
future_count = 0
vert_channel_flags = 3
face_channel_falgs = 1
min_corner = Vector((0.0, 0.0, 0.0))
max_corner = Vector((0.0, 0.0, 0.0))
sph_center = Vector((0.0, 0.0, 0.0))
sph_radius = 0.0
@staticmethod
def read(io_stream):
return MeshHeader(
version=Version.read(io_stream),
attrs=read_ulong(io_stream),
mesh_name=read_fixed_string(io_stream),
container_name=read_fixed_string(io_stream),
face_count=read_ulong(io_stream),
vert_count=read_ulong(io_stream),
matl_count=read_ulong(io_stream),
damage_stage_count=read_ulong(io_stream),
sort_level=read_ulong(io_stream),
prelit_version=read_ulong(io_stream),
future_count=read_ulong(io_stream),
vert_channel_flags=read_ulong(io_stream),
face_channel_falgs=read_ulong(io_stream),
# bounding volumes
min_corner=read_vector(io_stream),
max_corner=read_vector(io_stream),
sph_center=read_vector(io_stream),
sph_radius=read_float(io_stream))
@staticmethod
def size_in_bytes():
return 116
def write(self, io_stream):
write_chunk_head(io_stream, W3D_CHUNK_MESH_HEADER,
self.size_in_bytes())
self.version.write(io_stream)
write_ulong(io_stream, self.attrs)
write_fixed_string(io_stream, self.mesh_name)
write_fixed_string(io_stream, self.container_name)
write_ulong(io_stream, self.face_count)
write_ulong(io_stream, self.vert_count)
write_ulong(io_stream, self.matl_count)
write_ulong(io_stream, self.damage_stage_count)
write_ulong(io_stream, self.sort_level)
write_ulong(io_stream, self.prelit_version)
write_ulong(io_stream, self.future_count)
write_ulong(io_stream, self.vert_channel_flags)
write_ulong(io_stream, self.face_channel_falgs)
write_vector(io_stream, self.min_corner)
write_vector(io_stream, self.max_corner)
write_vector(io_stream, self.sph_center)
write_float(io_stream, self.sph_radius)
def test_write_read_adaptive_delta(self):
expected = CompressedAnimation(time_coded_channels=[],
adaptive_delta_channels=[],
time_coded_bit_channels=[],
motion_channels=[])
expected.header = CompressedAnimationHeader(version=Version(major=4,
minor=1),
name="CompAniHead",
hierarchy_name="HieraName",
num_frames=155,
frame_rate=300,
flavor=1)
self.assertEqual(44, expected.header.size_in_bytes())
(ad_y_channel,
ad_q_channel) = self.get_adaptive_delta_channels(num_bits=4)
for _ in range(46):
expected.adaptive_delta_channels.append(ad_y_channel)
expected.adaptive_delta_channels.append(ad_q_channel)
self.assertEqual(4974, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
self.assertEqual(4982, io_stream.tell())
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_COMPRESSED_ANIMATION, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = CompressedAnimation.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.hierarchy_name,
actual.header.hierarchy_name)
self.assertEqual(expected.header.num_frames, actual.header.num_frames)
self.assertEqual(expected.header.frame_rate, actual.header.frame_rate)
self.assertEqual(expected.header.flavor, actual.header.flavor)
self.assertEqual(len(expected.adaptive_delta_channels),
len(actual.adaptive_delta_channels))
for i, chan in enumerate(expected.adaptive_delta_channels):
act = actual.adaptive_delta_channels[i]
self.assertEqual(chan.num_time_codes, act.num_time_codes)
self.assertEqual(chan.pivot, act.pivot)
self.assertEqual(chan.vector_len, act.vector_len)
self.assertEqual(chan.type, act.type)
self.assertEqual(chan.scale, act.scale)
self.assertEqual(chan.data.initial_value, act.data.initial_value)
self.assertEqual(chan.data.bit_count, act.data.bit_count)
self.assertEqual(len(chan.data.delta_blocks),
len(act.data.delta_blocks))
for j, block in enumerate(chan.data.delta_blocks):
current = act.data.delta_blocks[j]
self.assertEqual(block.vector_index, current.vector_index)
self.assertEqual(block.block_index, current.block_index)
self.assertEqual(len(block.delta_bytes),
len(current.delta_bytes))
for k, byt in enumerate(block.delta_bytes):
self.assertEqual(int(byt), int(current.delta_bytes[k]))
def test_write_read(self):
expected = Animation()
expected.header = AnimationHeader(version=Version(major=4, minor=1),
name="AniHeader",
hierarchy_name="HieraName",
num_frames=155,
frame_rate=300)
self.assertEqual(44, expected.header.size_in_bytes())
x_channel = AnimationChannel(first_frame=1,
last_frame=33,
vector_len=1,
type=3,
pivot=33,
unknown=123,
data=[])
for i in range(55):
x_channel.data.append(2.0)
expected.channels.append(x_channel)
q_channel = AnimationChannel(first_frame=1,
last_frame=33,
vector_len=4,
type=6,
pivot=33,
unknown=123,
data=[])
for i in range(55):
q_channel.data.append(Quaternion((1.0, 2.0, 3.0, 4.0)))
expected.channels.append(q_channel)
self.assertEqual(1192, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunkType, chunkSize, chunkEnd) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_ANIMATION, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Animation.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.name, actual.header.name)
self.assertEqual(expected.header.hierarchy_name,
actual.header.hierarchy_name)
self.assertEqual(expected.header.num_frames, actual.header.num_frames)
self.assertEqual(expected.header.frame_rate, actual.header.frame_rate)
self.assertEqual(len(expected.channels), len(actual.channels))
for i, chan in enumerate(expected.channels):
act = actual.channels[i]
self.assertEqual(chan.first_frame, act.first_frame)
self.assertEqual(chan.last_frame, act.last_frame)
self.assertEqual(chan.vector_len, act.vector_len)
self.assertEqual(chan.type, act.type)
self.assertEqual(chan.pivot, act.pivot)
self.assertEqual(chan.unknown, act.unknown)
self.assertEqual(len(chan.data), len(act.data))
for j, d in enumerate(chan.data):
self.assertEqual(d, act.data[j])
def read(io_stream):
return HLodHeader(
version=Version.read(io_stream),
lod_count=read_ulong(io_stream),
model_name=read_fixed_string(io_stream),
hierarchy_name=read_fixed_string(io_stream))
