def test_write_read(self):
expected = Texture(name="TestName")
expected.texture_info = TextureInfo(attributes=555,
animation_type=33,
frame_count=63,
frame_rate=16.0)
self.assertEqual(12, expected.texture_info.size_in_bytes())
self.assertEqual(37, 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_TEXTURE, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Texture.read(self, io_stream, chunkEnd)
self.assertEqual(expected.name, actual.name)
self.assertEqual(expected.texture_info.attributes,
actual.texture_info.attributes)
self.assertEqual(expected.texture_info.animation_type,
actual.texture_info.animation_type)
self.assertEqual(expected.texture_info.frame_count,
actual.texture_info.frame_count)
self.assertEqual(expected.texture_info.frame_rate,
actual.texture_info.frame_rate)
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)
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_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_chunk_array(self, io_stream, chunk_end, type_, read_func):
result = []
while io_stream.tell() < chunk_end:
(chunk_type, chunk_size, subchunk_end) = read_chunk_head(io_stream)
if chunk_type == type_:
result.append(read_func(self, io_stream, subchunk_end))
else:
skip_unknown_chunk(self, io_stream, chunk_type, chunk_size)
return result
def test_minimal_write_read(self):
expected = Texture(name="TestName")
self.assertEqual(17, 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_TEXTURE, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = Texture.read(self, io_stream, chunkEnd)
self.assertEqual(expected.name, actual.name)
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 test_write_read_minimal(self):
expected = ShaderMaterial()
expected.header = ShaderMaterialHeader(number=55,
type_name="headerType",
reserver=99)
self.assertEqual(223, 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_SHADER_MATERIAL, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = ShaderMaterial.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.number, actual.header.number)
self.assertEqual(expected.header.type_name, actual.header.type_name)
self.assertEqual(expected.header.reserved, actual.header.reserved)
self.assertEqual(len(expected.properties), len(actual.properties))
def test_write_read(self):
expected = ShaderMaterial()
expected.header = ShaderMaterialHeader(number=55,
type_name="headerType",
reserver=99)
self.assertEqual(37, expected.header.size_in_bytes())
prop1 = ShaderMaterialProperty(type=1,
name="prop1",
num_chars=44,
value="test")
expected.properties.append(prop1)
prop2 = ShaderMaterialProperty(type=2,
name="prop2",
num_chars=44,
value=3.14)
expected.properties.append(prop2)
prop3 = ShaderMaterialProperty(type=4,
name="prop3",
num_chars=44,
value=Vector((1.0, 2.0, 3.0)))
expected.properties.append(prop3)
prop4 = ShaderMaterialProperty(type=5,
name="prop4",
num_chars=44,
value=RGBA(r=3, g=1, b=22, a=133))
expected.properties.append(prop4)
prop5 = ShaderMaterialProperty(type=6,
name="prop5",
num_chars=44,
value=1234)
expected.properties.append(prop5)
prop6 = ShaderMaterialProperty(type=7,
name="prop6",
num_chars=44,
value=255)
expected.properties.append(prop6)
self.assertEqual(223, 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_SHADER_MATERIAL, chunkType)
self.assertEqual(expected.size_in_bytes(), chunkSize)
actual = ShaderMaterial.read(self, io_stream, chunkEnd)
self.assertEqual(expected.header.number, actual.header.number)
self.assertEqual(expected.header.type_name, actual.header.type_name)
self.assertEqual(expected.header.reserved, actual.header.reserved)
self.assertEqual(len(expected.properties), len(actual.properties))
for i, prop in enumerate(expected.properties):
self.assertEqual(prop.type, actual.properties[i].type)
self.assertEqual(prop.name, actual.properties[i].name)
self.assertEqual(prop.num_chars, actual.properties[i].num_chars)
self.assertAlmostEqual(prop.value, actual.properties[i].value, 5)
def test_write_read_minimal(self):
expected = Mesh(
header=MeshHeader(),
user_text="",
verts=[],
normals=[],
vert_infs=[],
triangles=[],
shade_ids=[],
mat_info=None,
shaders=[],
vert_materials=[],
textures=[],
shader_materials=[],
material_pass=None,
aabbtree=None)
self.assertEqual(116, expected.header.size_in_bytes())
self.assertEqual(148, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunk_type, chunk_size, subchunk_end) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_MESH, chunk_type)
self.assertEqual(expected.size_in_bytes(), chunk_size)
actual = Mesh.read(self, io_stream, subchunk_end)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.attrs, actual.header.attrs)
self.assertEqual(expected.header.mesh_name, actual.header.mesh_name)
self.assertEqual(expected.header.container_name, actual.header.container_name)
self.assertEqual(expected.header.face_count, actual.header.face_count)
self.assertEqual(expected.header.vert_count, actual.header.vert_count)
self.assertEqual(expected.header.matl_count, actual.header.matl_count)
self.assertEqual(expected.header.damage_stage_count, actual.header.damage_stage_count)
self.assertEqual(expected.header.sort_level, actual.header.sort_level)
self.assertEqual(expected.header.prelit_version, actual.header.prelit_version)
self.assertEqual(expected.header.future_count, actual.header.future_count)
self.assertEqual(expected.header.vert_channel_flags, actual.header.vert_channel_flags)
self.assertEqual(expected.header.face_channel_falgs, actual.header.face_channel_falgs)
self.assertEqual(expected.header.min_corner, actual.header.min_corner)
self.assertEqual(expected.header.max_corner, actual.header.max_corner)
self.assertEqual(expected.header.sph_center, actual.header.sph_center)
self.assertEqual(expected.header.sph_radius, actual.header.sph_radius)
self.compare_list(expected.verts, actual.verts)
self.compare_list(expected.normals, actual.normals)
self.compare_list(expected.vert_infs, actual.vert_infs)
self.compare_list(expected.triangles, actual.triangles)
self.compare_list(expected.shade_ids, actual.shade_ids)
self.assertEqual(expected.mat_info, actual.mat_info)
self.assertEqual(len(expected.shaders), len(actual.shaders))
self.assertEqual(len(expected.vert_materials), len(actual.vert_materials))
self.assertEqual(len(expected.textures), len(actual.textures))
self.assertEqual(len(expected.shader_materials), len(actual.shader_materials))
self.assertEqual(expected.material_pass, actual.material_pass)
self.assertEqual(expected.aabbtree, actual.aabbtree)
def test_write_read(self):
expected = Mesh(
header=MeshHeader(),
user_text="TestUserText",
verts=[],
normals=[],
vert_infs=[],
triangles=[],
shade_ids=[],
mat_info=MaterialInfo(),
shaders=[MeshShader(), MeshShader(), MeshShader()],
vert_materials=[VertexMaterial(), VertexMaterial(), VertexMaterial()],
textures=[Texture(), Texture(), Texture(), Texture()],
shader_materials=[ShaderMaterial(), ShaderMaterial()],
material_pass=MaterialPass(),
aabbtree=MeshAABBTree())
self.assertEqual(116, expected.header.size_in_bytes())
for i in range(332):
expected.verts.append(Vector((0.0, 2.0, -1.2)))
expected.normals.append(Vector((0.0, 1.0, 0.0)))
expected.vert_infs.append(MeshVertexInfluence())
expected.triangles.append(MeshTriangle())
expected.shade_ids.append(i)
self.assertEqual(23347, expected.size_in_bytes())
io_stream = io.BytesIO()
expected.write(io_stream)
io_stream = io.BytesIO(io_stream.getvalue())
(chunk_type, chunk_size, subchunk_end) = read_chunk_head(io_stream)
self.assertEqual(W3D_CHUNK_MESH, chunk_type)
self.assertEqual(expected.size_in_bytes(), chunk_size)
actual = Mesh.read(self, io_stream, subchunk_end)
self.assertEqual(expected.header.version, actual.header.version)
self.assertEqual(expected.header.attrs, actual.header.attrs)
self.assertEqual(expected.header.mesh_name, actual.header.mesh_name)
self.assertEqual(expected.header.container_name, actual.header.container_name)
self.assertEqual(expected.header.face_count, actual.header.face_count)
self.assertEqual(expected.header.vert_count, actual.header.vert_count)
self.assertEqual(expected.header.matl_count, actual.header.matl_count)
self.assertEqual(expected.header.damage_stage_count, actual.header.damage_stage_count)
self.assertEqual(expected.header.sort_level, actual.header.sort_level)
self.assertEqual(expected.header.prelit_version, actual.header.prelit_version)
self.assertEqual(expected.header.future_count, actual.header.future_count)
self.assertEqual(expected.header.vert_channel_flags, actual.header.vert_channel_flags)
self.assertEqual(expected.header.face_channel_falgs, actual.header.face_channel_falgs)
self.assertEqual(expected.header.min_corner, actual.header.min_corner)
self.assertEqual(expected.header.max_corner, actual.header.max_corner)
self.assertEqual(expected.header.sph_center, actual.header.sph_center)
self.assertEqual(expected.header.sph_radius, actual.header.sph_radius)
self.compare_list(expected.verts, actual.verts)
self.compare_list(expected.normals, actual.normals)
self.assertEqual(len(expected.vert_infs), len(actual.vert_infs))
self.assertEqual(len(expected.triangles), len(actual.triangles))
self.assertEqual(len(expected.shade_ids), len(actual.shade_ids))
self.assertEqual(len(expected.shaders), len(actual.shaders))
self.assertEqual(len(expected.vert_materials), len(actual.vert_materials))
self.assertEqual(len(expected.textures), len(actual.textures))
self.assertEqual(len(expected.shader_materials), len(actual.shader_materials))
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 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 = 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)
