示例#1
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.hash(self.name)
     s.i32(self.start_index)
     s.i32(self.start_vertex)
     s.i32(self.vertex_count)
     s.i32(self.index_count)
示例#2
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.chars(self.TAG)
     s.u32(self.version)
     cBlends = len(self.blends)
     cLods = 0
     if cBlends:
         len(self.blends[0].lods)
示例#3
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.u32(self.vertex_size)
     s.u32(self.vertex_count)
     s.u32(self.byte_offset)
     assert len(self.commands) == (int(self.vertex_size / 4))
     for cmd in self.commands:
         s.u32(cmd)
示例#4
0
文件: __init__.py 项目: garthand/s3py
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     flags = 0
     flags |= (self.type << 0)
     if self.static: flags |= (1 << 1)
     flags |= (self.unknown << 4)
     s.u8(flags)
     return self
示例#5
0
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     flags = 0
     flags |= (self.type << 0)
     if self.static: flags |= (1 << 1)
     flags |= (self.unknown << 4)
     s.u8(flags)
     return self
示例#6
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     cBones = len(self.bones)
     s.i32(cBones)
     for i in range(cBones):
         s.hash(self.bones[i].name)
     for bone in self.bones:
         s.m43(bone.inverse_bind_pose)
示例#7
0
文件: catalog.py 项目: garthand/s3py
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     s.u32(self.version)
     tgi = TGIList()
     tgi.begin_write(stream)
     for shader_key in self.shader_keys: shader_key.write(stream, tgi)
     s.u32(tgi.get_resource_index(self.sub_skin_ramp))
     s.u32(tgi.get_resource_index(self.tone_ramp))
     for texture_key in self.texture_keys: texture_key.write(stream, tgi)
     s.u8(self.is_dominant)
示例#8
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.i32(len(self.outcomes))
     for outcome in self.outcomes:
         outcome.write(stream, rcol)
     s.u32(DEADBEEF)
     s.u32(self.flags)
     DecisionGraphNode.write(self, stream, rcol)
示例#9
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.hash(self.name)
     s.i32(self.start_index)
     s.i32(self.start_vertex)
     s.i32(self.vertex_count)
     s.i32(self.index_count)
示例#10
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.u32(self.vertex_size)
     s.u32(self.vertex_count)
     s.u32(self.byte_offset)
     assert len(self.commands) == (int(self.vertex_size / 4))
     for cmd in self.commands: s.u32(cmd)
示例#11
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.u32(self.type)
     for i in range(3): s.f32(self.origin[i])
     for i in range(3): s.f32(self.normal[i])
     for i in range(3): s.f32(self.x_axis[i])
     for i in range(3): s.f32(self.y_axis[i])
     s.f32(self.pair_offset)
示例#12
0
    def serialize(self,complate,stream,resources):
        def write_element(s,tgi_list):
            def write_complate_string(string,s):
                if not string:
                    s.i8(0)
                    return
                if string in self.complate_string_lookup:
                    idx = self.complate_string_lookup[string]
                    if idx > 0x40:
                        s.i8(0x40)
                    s.i8(idx &0x3F)
                else:
                    x = len(string)


                pass
            def write_typecode(value,s,tgi_list):
                if isinstance(value,str):
                    s.i8(0x01)
                    write_complate_string(value,s)
                elif isinstance(value,list):
                    if len(value) == 4:
                        s.i8(0x02)
                        for e in value: s.u8(e)
                    elif len(value) == 2:
                        s.i8(0x05)
                        for e in value: s.f32(e)
                    elif len(value) == 3:
                        s.i8(0x06)
                        for e in value: s.f32(e)
                elif isinstance(value,Resource):
                    s.i8(0x03)
                    s.i8(tgi_list.get_resource_index(value))
                elif isinstance(value,float):
                    s.i8(0x04)
                    s.f32(value)
                elif isinstance(value,bool):
                    s.i8(0x07)
                    s.i8(1 if value else 0)
                else:
                    raise Exception ("Unable to handle typecode data %" %value)


                pass

            pass
        assert isinstance(complate,ComplateElement)
        s= StreamWriter(stream)
        s.i16(complate.priority)
        preset_tgi = TGIList(use_length=True)
        preset_tgi.begin_write(stream)

        raise NotImplementedError()
示例#13
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     cBones = len(self.bones)
     s.i32(cBones)
     for i in range(cBones): s.hash(self.bones[i].name)
     for bone in self.bones:
         s.m43(bone.inverse_bind_pose)
示例#14
0
文件: jazz.py 项目: markmanching/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.i32(len(self.outcomes))
     for outcome in self.outcomes: outcome.write(stream, rcol)
     s.u32(DEADBEEF)
     s.u32(self.flags)
     DecisionGraphNode.write(self, stream, rcol)
示例#15
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     s.u32(self.flags)
     s.u32(self.unknown)
     last = 0
     for i in range(len(self.buffer)):
         cur = self.buffer[i]
         if Flag.is_set(self.flags, self.FLAGS.DIFFERENCED_INDICES):
             cur -= last
             last = self.buffer[i]
         s.i32(cur) if Flag.is_set(self.flags, self.FLAGS.INDEX_32) else s.i16(cur)
示例#16
0
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.f32(self.framerate)
     cFrames = len(self.frames)
     s.i32(cFrames)
     data_pos = stream.tell() + (cFrames * 4)
     for frame in self.frames:
         s.u32(data_pos)
         data_pos += len(frame)
     for frame in self.frames:
         stream.write(frame)
示例#17
0
文件: catalog.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.u8(self.level)
     s.u32(self.dest_texture)
     s.u8(len(self.assets))
     for asset in self.assets:
         asset.write(stream)
示例#18
0
文件: lights.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     for i in range(3):
         s.f32(self.transform[i])
     for i in range(3):
         s.f32(self.colour[i])
     s.f32(self.intensity)
示例#19
0
文件: lights.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3):
         s.f32(self.at[i])
     s.f32(self.tube_length)
     s.f32(self.blur_scale)
示例#20
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     keys = self.names.keys()
     s.u32(len(keys))
     for key in keys:
         s.u64(key)
         s.p32(self.names[key])
示例#21
0
文件: lights.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3):
         s.f32(self.at[i])
     s.f32(self.falloff_angle)
     s.f32(self.blur_scale)
示例#22
0
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(0)
     s.u32(rcol.get_block_index(self.swizzle_info))
     self.buffer.stream.seek(0, SEEK_SET)
     stream.write(self.buffer.stream.read())
示例#23
0
文件: lights.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3):
         s.f32(self.at[i])
     for i in range(3):
         s.f32(self.right[i])
     s.f32(self.radius)
示例#24
0
文件: rig.py 项目: garthand/s3py
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     for i in range(3):
         s.f32(self.position[i])
     for i in range(3):
         s.f32(self.scale[i])
     for i in range(4):
         s.f32(self.orientation[i])
示例#25
0
文件: rig.py 项目: garthand/s3py
    def write_rcol(self, stream, rcol):
        s = StreamWriter(stream)
        s.u32(self.version)
        s.i32(len(self.deltas))

        for hash in self.deltas:
            delta = self.deltas[hash]
            s.u32(hash)
            delta.write(stream)
示例#26
0
 def write_presets(cls, stream,presets, resources):
     s = StreamWriter(stream)
     s.i32(len(presets))
     ce = ComplateEncoder()
     for preset in presets:
         assert isinstance(preset,cls.BuildBuyPreset)
         s.i8(preset.unk1)
         if preset.unk1 != 1:
             s.i32(preset.unk2)
         preset_ptr = StreamPtr.begin_write(s)
         ce.serialize(preset.complate,stream,resources)
         preset_ptr.end()
         s.u32(preset.id)
示例#27
0
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.f32(self.framerate)
     cFrames = len(self.frames)
     s.i32(cFrames)
     data_pos = stream.tell() + (cFrames * 4)
     for frame in self.frames:
         s.u32(data_pos)
         data_pos += len(frame)
     for frame in self.frames:
         stream.write(frame)
示例#28
0
文件: __init__.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     cFootprints = len(self.footprint_polygons)
     s.i8(cFootprints)
     for footprint_index in range(cFootprints): self.footprint_polygons[footprint_index].write_rcol(stream)
     cSlots = len(self.routing_slot_footprint_polygons)
     s.i8(cSlots)
     for slot_index in range(cSlots): self.routing_slot_footprint_polygons[slot_index].write_rcol(stream)
示例#29
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     keys = self.names.keys()
     s.u32(len(keys))
     for key in keys:
         s.u64(key)
         s.p32(self.names[key])
示例#30
0
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(0)
     s.u32(rcol.get_block_index(self.swizzle_info))
     self.buffer.stream.seek(0, SEEK_SET)
     stream.write(self.buffer.stream.read())
示例#31
0
文件: rig.py 项目: markmanching/s3py
    def write_rcol(self, stream, rcol):
        s = StreamWriter(stream)
        s.u32(self.version)
        s.i32(len(self.deltas))

        for hash in self.deltas:
            delta = self.deltas[hash]
            s.u32(hash)
            delta.write(stream)
示例#32
0
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     cFootprints = len(self.footprint_polygons)
     s.i8(cFootprints)
     for footprint_index in range(cFootprints): self.footprint_polygons[footprint_index].write(stream)
     cSlots = len(self.routing_slot_footprint_polygons)
     s.i8(cSlots)
     for slot_index in range(cSlots): self.routing_slot_footprint_polygons[slot_index].write(stream)
示例#33
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     s.i32(len(self.meshes))
     for mesh in self.meshes:
         mesh.write(stream, rcol)
示例#34
0
文件: geometry.py 项目: garthand/s3py
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     s.chars(self.TAG)
     s.u32(self.version)
     cBlends = len(self.blends)
     cLods = 0
     if cBlends:
         len(self.blends[0].lods)
示例#35
0
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     s.u32(self.version)
     tgi = TGIList()
     tgi.begin_write(stream)
     if self.version >= 0x00000003:
         ProductBase.write_presets(stream,self.presets,tgi)
     self.product_info.write(stream,tgi)
     s.i32(tgi.get_resource_index(self.railing_4x_model))
     s.i32(tgi.get_resource_index(self.railing_1x_model))
     s.i32(tgi.get_resource_index(self.post_model))
     tgi.end_write(stream)
示例#36
0
 def write_pointer(self, stream):
     self.size32 = 1
     t = type(self.value)
     if isinstance(self.value, list):
         self.size32 = len(self.value)
         t = type(self.value[0])
     if t == float:
         self.type_code = self.TYPE.FLOAT
     elif t == int:
         self.type_code = self.TYPE.INT
     elif t == ExternalResource:
         self.type_code = self.TYPE.TEXTURE
     elif t == ResourceKey:
         self.size32 = 4
         self.type_code = self.TYPE.TEXTURE
     else:
         raise NotImplementedError(
             "Serialization of type %s is not supported in this format!"
             % t)
     s = StreamWriter(stream)
     s.hash(self.name)
     s.u32(self.type_code)
     s.u32(self.size32)
     self.pointer = StreamPtr.begin_write(s)
示例#37
0
 def write_pointer(self, stream):
     self.size32 = 1
     t = type(self.value)
     if isinstance(self.value, list):
         self.size32 = len(self.value)
         t = type(self.value[0])
     if t == float:
         self.type_code = self.TYPE.FLOAT
     elif t == int:
         self.type_code = self.TYPE.INT
     elif  t == ExternalResource:
         self.type_code = self.TYPE.TEXTURE
     elif t == ResourceKey:
         self.size32 = 4
         self.type_code = self.TYPE.TEXTURE
     else:
         raise NotImplementedError("Serialization of type %s is not supported in this format!" % t)
     s = StreamWriter(stream)
     s.hash(self.name)
     s.u32(self.type_code)
     s.u32(self.size32)
     self.pointer = StreamPtr.begin_write(s)
示例#38
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.hash(self.name)
     s.i32(len(self.actors))
     for actor in self.actors:
         s.u32(rcol.get_block_index(actor, ActorDefinition))
     s.i32(len(self.parameters))
     for parameter in self.parameters:
         s.u32(rcol.get_block_index(parameter, ParameterDefinition))
     s.i32(len(self.states))
     for state in self.states:
         s.u32(rcol.get_block_index(state, State))
     s.i32(len(self.namespace_map))
     for actor_pair in self.namespace_map:
         actor_pair.write(stream)
     s.u32(DEADBEEF)
     s.u32(self.flags)
     s.u32(self.default_priority)
     s.u32(self.awareness_overlay_level)
     for i in range(4):
         s.u32(0)
示例#39
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     AnimationNode.write_rcol(self, stream, rcol)
示例#40
0
文件: jazz.py 项目: garthand/s3py
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     s.hash(self.filename)
     s.hash(self.clip_actor)
     s.hash(self.jazz_actor)
示例#41
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(rcol.get_block_index(self.actor))
     s.u32(self.parameter)
     s.tgi(self.prop, 'ITG')
     for i in range(4):
         s.u32(0)
     MulticastDecisionGraphNode.write(self, stream, rcol)
示例#42
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(rcol.get_block_index(self.target))
     s.u32(self.operation)
     s.u32(self.operand)
     for i in range(3):
         s.u32(0)
     MulticastDecisionGraphNode.write(self, stream, rcol)
示例#43
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     self.bounds.clear()
     s.hash(self.name)
     s.i8(self.priority)
     s.u32(self.footprint_type_flags)
     s.i32(len(self.points))
     for point in self.points:
         self.bounds.add(point)
         s.f32(point[0])
         s.f32(point[1])
     s.u32(self.allow_intersection_flags)
     s.u32(self.surface_type_flags)
     s.u32(self.surface_attribute_flags)
     s.i8(self.level_offset)
     if self.ftpt.version >= Footprint.VERSION.EXTENDED: s.f32(self.elevation_offset)
     self.bounds.write(stream)
示例#44
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(rcol.get_block_index(self.next_state))
     DecisionGraphNode.read(self, stream, rcol)
示例#45
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.hash(self.name)
     s.u32(self.properties)
     s.u32(rcol.get_block_index(self.decision_graph, DecisionGraph))
     s.i32(len(self.transitions))
     for transition in self.transitions:
         s.u32(rcol.get_block_index(transition, State))
     s.u32(self.awareness_overlay_level)
示例#46
0
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     s.u8(self.index)
     s.u8(len(self.resources))
     for resource in self.resources: s.u32(resources.get_resource_index(resource))
示例#47
0
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.at[i])
     s.f32(self.falloff_angle)
     s.f32(self.shade_light_rig_multiplier)
     s.f32(self.bottom_angle)
     for i in range(3): s.f32(self.shade_colour[i])
示例#48
0
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.at[i])
     s.f32(self.falloff_angle)
     s.f32(self.blur_scale)
示例#49
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     cLights = len(self.lights)
     cOccluders = len(self.occluders)
     s.u32(4 + (cLights * 128) + (cOccluders * 14))
     s.u8(cLights)
     s.u8(cOccluders)
     s.u16(cOccluders * 14)
     for light in self.lights:
         start = stream.tell()
         light.write_rcol(stream)
         end = stream.tell()
         size = end - start
         blank = 128 - size
         dwords = int(blank / 4)
         for i in range(int(dwords)): s.u32(0)
     for occluder in self.occluders:
         occluder.write_rcol(stream)
示例#50
0
 def write(self, stream, resource=None):
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.transform[i])
     for i in range(3): s.f32(self.colour[i])
     s.f32(self.intensity)
示例#51
0
 def write_rcol(self, stream, rcol):
     self.write_tag(stream)
     s = StreamWriter(stream)
     s.u32(self.version)
     tgi = TGIList()
     tgi.begin_write(stream)
     s.u8(len(self.entries))
     for entry in self.entries:
         s.u8(entry.TYPE)
         entry.write(stream, tgi)
     s.u8(2)
     self.bounds.write(stream)
     s.u32(self.flags)
     if self.routing_footprint.key != ResourceKey():
         s.u8(1)
         s.tgi(self.routing_footprint.key, 'TGI')
     else: s.u8(0)
     tgi.end_write(stream)
示例#52
0
 def write(self, stream, tgi=None):
     s = StreamWriter(stream)
     s.u32(self.index)
     s.u32(tgi.get_resource_index(self.resource))
示例#53
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     raise NotImplementedError()
示例#54
0
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.at[i])
     s.f32(self.tube_length)
     s.f32(self.blur_scale)
示例#55
0
文件: jazz.py 项目: garthand/s3py
 def write_rcol(self, stream, rcol):
     s = StreamWriter(stream)
     self.write_tag(stream)
     s.u32(self.version)
     s.u32(0)
     s.i32(len(self.children))
     for child in self.children:
         s.u32(rcol.get_block_index(child))
     s.i32(len(self.parents))
     for parent in self.parents:
         s.u32(rcol.get_block_index(parent))
     s.u32(DEADBEEF)
示例#56
0
    def write_rcol(self, stream, rcol):
        s = StreamWriter(stream)

        def write_names(slots):
            for slot in slots: s.hash(slot.name)

        def write_bones(slots):
            for slot in slots: s.hash(slot.bone_name)

        def write_transforms(slots):
            for slot in slots:
                s.m43(slot.transform)

        def write_offsets(slots):
            if any(slots):
                s.i32(len(list(filter(lambda slot: slot.offset != None, slots))))
                for i, slot in enumerate(slots):
                    if slot.offset != None:
                        s.i32(i)
                        for i in range(3): s.i32(slot.offset.position)
                        for i in range(3): s.i32(slot.offset.rotation)

        self.write_tag(stream)
        s.u32(self.version)
        s.i32(len(self.routing_slots))
        s.i32(len(self.container_slots))
        s.i32(len(self.effect_slots))
        s.i32(len(self.target_slots))
        s.i32(len(self.cone_slots))

        write_names(self.routing_slots)
        write_bones(self.routing_slots)
        write_transforms(self.routing_slots)
        write_offsets(self.routing_slots)

        write_names(self.container_slots)
        write_bones(self.container_slots)
        for slot in self.container_slots:
            s.u32(slot.flags)
        write_transforms(self.container_slots)
        write_offsets(self.container_slots)

        write_names(self.effect_slots)
        write_bones(self.effect_slots)
        write_transforms(self.effect_slots)
        write_offsets(self.effect_slots)

        write_names(self.target_slots)
        write_bones(self.target_slots)
        write_transforms(self.target_slots)
        write_offsets(self.target_slots)

        write_names(self.cone_slots)
        write_bones(self.cone_slots)
        write_transforms(self.cone_slots)
        for slot in self.cone_slots:
            s.f32(slot.radius)
            s.f32(slot.angle)
        write_offsets(self.cone_slots)
示例#57
0
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.at[i])
     for i in range(3): s.f32(self.right[i])
     s.f32(self.width)
     s.f32(self.height)
     s.f32(self.falloff_angle)
     s.f32(self.window_top_bottom_angle)
示例#58
0
文件: geometry.py 项目: garthand/s3py
 def write(self, stream, resources=None):
     s = StreamWriter(stream)
     for val in self.min:
         s.f32(val)
     for val in self.max:
         s.f32(val)
示例#59
0
 def write(self, stream, resource=None):
     Light.write(self, stream)
     s = StreamWriter(stream)
     for i in range(3): s.f32(self.at[i])
     for i in range(3): s.f32(self.right[i])
     s.f32(self.radius)