def read(self, stream, resources=None):
     s = StreamReader(stream)
     flags = s.u8()
     self.type = (flags & 0x07) >> 0
     self.static = ((flags & 0x08) >> 3) == 1
     self.unknown = (flags & 0xF0) >> 4
     return self

 def read(self, stream, resources):
     s = StreamReader(stream)
     self.age_gender = s.u32()
     self.edge_color = s.u32()
     self.specular_color = s.u32()
     self.specular_power = s.f32()
     self.is_genetic = bool(s.u8())

 def read(self, stream, resource=None):
     s = StreamReader(stream)
     self.name = s.u32()
     self.start_index = s.i32()
     self.start_vertex = s.i32()
     self.vertex_count = s.i32()
     self.index_count = s.i32()

 def read_rcol(self, stream, rcol):
     s = StreamReader(stream)
     self.read_tag(stream)
     self.version = s.u32()
     self.outcomes = [self.Outcome(stream, rcol) for i in range(s.i32())]
     assert s.u32() == DEADBEEF
     self.flags = s.u32()
     DecisionGraphNode.read(self, stream, rcol)

 def read(self, stream, resource=None):
     s = StreamReader(stream)
     self.version = s.u32()
     cNames = s.u32()
     for i in range(cNames):
         iid = s.u64()
         name = s.p32()
         self.names[iid] = name

 def read(self, stream, resource=None):
     s = StreamReader(stream)
     self.type = s.u32()
     self.origin = [s.f32() for i in range(3)]
     self.normal = [s.f32() for i in range(3)]
     self.x_axis = [s.f32() for i in range(3)]
     self.y_axis = [s.f32() for i in range(3)]
     self.pair_offset = s.f32()

 def read_rcol(self, stream, rcol):
     self.read_tag(stream)
     s = StreamReader(stream)
     self.version = s.u32()
     cBones = s.i32()
     names = [s.u32() for i in range(cBones)]
     poses = [s.m43() for pose_index in range(cBones)]
     self.bones = [self.Bone(names[i], poses[i]) for i in range(cBones)]

 def read_rcol(self, stream, rcol):
     s = StreamReader(stream)
     self.version = s.u32()
     self.deltas = {}
     c = s.i32()
     for i in range(c):
         hsh = s.hash()
         self.deltas[hsh] = self.Delta(stream)
     pass

    def read_rcol(self, stream, rcol):
        s = StreamReader(stream)
        self.read_tag(stream)
        self.version = s.u32()

        self.routing_slots = [RoutingSlot() for i in range(s.i32())]
        self.container_slots = [ContainerSlot() for i in range(s.i32())]
        self.effect_slots = [EffectSlot() for i in range(s.i32())]
        self.target_slots = [TargetSlot() for i in range(s.i32())]
        self.cone_slots = [ConeSlot() for i in range(s.i32())]

        def read_names(slots):
            for slot in slots: slot.name = s.hash(Slot.NAMES)

        def read_bones(slots):
            for slot in slots: slot.bone_name = s.u32()

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

        def read_offsets(slots):
            if any(slots):
                for i in range(s.i32()):
                    slots[i].offset = SlotOffset([s.f32(), s.f32(), s.f32()], [s.f32(), s.f32(), s.f32()])
                    pass
                pass

        read_names(self.routing_slots)
        read_bones(self.routing_slots)
        read_transforms(self.routing_slots)
        read_offsets(self.routing_slots)

        read_names(self.container_slots)
        read_bones(self.container_slots)
        for slot in self.container_slots:
            slot.flags = s.u32()
        read_transforms(self.container_slots)
        read_offsets(self.container_slots)

        read_names(self.effect_slots)
        read_bones(self.effect_slots)
        read_transforms(self.effect_slots)
        read_offsets(self.effect_slots)

        read_names(self.target_slots)
        read_bones(self.target_slots)
        read_transforms(self.target_slots)
        read_offsets(self.target_slots)

        read_names(self.cone_slots)
        read_bones(self.cone_slots)
        read_transforms(self.cone_slots)
        for cone_slot in self.cone_slots:
            cone_slot.radius = s.f32()
            cone_slot.angle = s.f32()
        read_offsets(self.cone_slots)
        pass

 def read_rcol(self, stream, rcol):
     s = StreamReader(stream)
     self.read_tag(stream)
     self.version = s.u32()
     self.framerate = s.f32()
     cFrames = s.i32()
     offsets = [s.u32() for i in range(cFrames)]
     offsets.append(-1)
     for frame_index in range(cFrames):
         offset = offsets[frame_index]
         next = offsets[frame_index + 1]
         cBytes = next - offset if next > 0 else -1
         data = stream.read(cBytes)
         self.frames.append(data)

 def fix_read_offset(self, stream):
     s = StreamReader(stream)
     pos = stream.tell()
     fix_bytes = 0
     if pos % 2 == 0:
         fix_bytes = pos % 4
     else:
         fix_bytes = pos % 2
         if (pos + fix_bytes) % 2 == 0:
             fix_bytes += 2
     assert fix_bytes <= 3
     for i in range(fix_bytes):
         b = s.i8()
         assert b == i

 def read_presets(cls,stream,resources=None):
     s = StreamReader(stream)
     c = s.i32()
     ce = ComplateEncoder()
     presets = []
     for i in range(c):
         preset = cls.BuildBuyPreset()
         preset.unk1 = s.i8()
         if preset.unk1 != 1:
             preset.unk2 = s.i32()
         preset_ptr = StreamPtr.begin_read(s,relative=True,offset_start=True)
         preset.complate = ce.deserialize(stream,resources)
         preset_ptr.end()
         preset.id = s.u32()
         presets.append(preset)
     return presets

    def read(self, stream, keys):
        s = StreamReader(stream)
        tag = s.chars(4)
        if not tag == self.TAG_TEXTURES or tag == self.TAG_NO_TEXTURES:
            raise IOError(
                "Invalid data, expected %s or %s, but got %s" % (self.TAG_TEXTURES, self.TAG_NO_TEXTURES, tag))
        zero = s.u32()
        assert zero == 0

        param_len = s.u32()
        cParams = s.i32()
        items = []
        for i in range(cParams):
            item = self.Item()
            item.read_pointer(stream)
            items.append(item)
        start = stream.tell()
        for item in items:
            self.__parameters[item.name] = item.read_data(stream, keys)
        end = stream.tell()
        assert (end - start) == param_len

 def read(self, stream, resource=None):
     s = StreamReader(stream)
     self.bones = []
     bone_count=s.i32()
     for i in range(bone_count):
         bone=self.parent.get_bone(s.i32())
         self.bones.append(bone)
     if self.parent.version_major >= 4:
         self.info_nodes = [self.parent.get_bone(s.i32()) for i in range(11)]
     self.pole = self.parent.get_bone(s.i32())
     if self.parent.version_major >= 4:
         self.slot_info = self.parent.get_bone(s.i32())
     self.slot_offset = self.parent.get_bone(s.i32())
     self.root = self.parent.get_bone(s.i32())

    def deserialize(self,stream,parent_tgi):
        def read_element(s,tgi_list):
            def read_complate_string(s):
                a = s.i8()
                if not a: return None
                if a & 0x80: return s.chars(s.i8() if a & 0x40 else a &0x3F)
                if a & 0x40: a = (a & 0x3F) + s.i8()
                return self.complate_string_lookup[a]
            def read_typecode(s,tgi_list):
                tc = s.u8()
                if   tc == 1: return read_complate_string(s)
                elif tc == 0x02: return [s.u8() for i in range(4)]
                elif tc == 0x03: return tgi_list.get_resource(s.i8())
                elif tc == 0x04: return s.f32()
                elif tc == 0x05: return [s.f32() for i in range(2)]
                elif tc == 0x06: return [s.f32() for i in range(3)]
                elif tc == 0x07: return bool(s.i8())
                else: raise Exception("Unknown typecode %02X"%tc)
            element = Preset.Element()
            element.resource = tgi_list.get_resource(s.u8())
            element.name = read_complate_string(s)
            element.variable = read_complate_string(s)

            for i in range(s.i32()):
                name = read_complate_string(s)
                value = read_typecode(s,tgi_list)
                element.values[name] =value
            element.patterns = [read_element(s,tgi_list) for i in range(s.i32())]
            return element
        s = StreamReader(stream)
        unk = s.i16()
        preset_tgi = TGIList(use_length=True)
        preset_tgi.begin_read(stream)
        element = read_element(s,preset_tgi)
        preset_tgi.end_read(stream)
        complate = ComplateElement()
        complate.preset = element
        complate.priority = unk
        return complate