#! /usr/bin/python3

import struct
import zlib
import sys
import traceback
import math
try:
    from .bones import *
    from .polygrid import PolyCell, PolyGrid
    from .util import Data
    from .geomesh import GeoMesh, GeoFace, GeoVertex
except:
    from bones import *
    from polygrid import PolyCell, PolyGrid
    from util import Data
    from geomesh import GeoMesh, GeoFace, GeoVertex

#Ver 0 .geo pre-header:
#Offset	Size	Description
#0	4	'ziplen' ? Compressed header data size + 4
#4	4	Header size (Must be non-zero for old formats.)
#8	variable	zlib Compressed header data
#variable	4	Dummy data?

#Version 2+ .geo pre-header:
#Offset	Size	Description
#0	4	'ziplen' ? Compressed header data size + 12
#4	4	Legacy header size (Must be 0 for new file formats.)
#8	4	Version number 2 to 5, and 7 to 8
#12	4	Header size
#16	variable	zlib Compressed header data



#.geo header
#Offset	Size	Description
#0	4	i32: gld->datasize
#4	4	i32: texname_blocksize
#8	4	i32: objname_blocksize
#12	4	i32: texidx_blocksize
#16	4	i32: lodinfo_blocksize (only present in version 2 to 6)
#?	texname_blocksize	PackNames block of texture names
#?	objname_blocksize	objnames
#?	texidx_blocksize	TexID[]: texidx_block,
#?	lodinfo_blocksize	lodinfo (only present in version 2 to 6)
#?	ModelHeader	???


#PackNames block:
#Size	Description
#4	name_count
#4*name_count	offset of the name, relative to the start of name_block
#variable	name_block (ASCIIZ?)

#ModelHeader:
#Size	Description
#124	ASCIIZ name.
#4	Model pointer (0 in file?)
#4	Float track length (technically a fallback if not specified elsewhere?)
#4	Pointer to an array of Model pointers (-1 in file?)
#*note: pointers aren't really needed.

#Model:
#version 0 to 2: (struct ModelFormatOnDisk_v2: "Common/seq/anim.c" )
#Offset	Size	Description
#0	4	u32: Flags
#4	4	f32: radius
#8	4	ptr: VBO?
#12	4	i32: tex_count
#16	2	i16: id  ("I am this bone" ?)
#18	1	u8: blend_mode
#19	1	u8: loadstate
#20	4	ptr(BoneInfo)
#24	4	ptr(TrickNode)
#28	4	i32: vert_count
#32	4	i32: tri_count
#36	4	ptr: TexID
#40	32	PolyGrid: polygrid
#72	4	ptr(CTri): ctris ?
#76	4	ptr(i32): tags
#80	4	ptr(char): name
#84	4	ptr(AltPivotInfo): api
#88	4	ptr(ModelExtra): extra
#92	12	Vec3: scale
#104	12	Vec3: min
#116	12	Vec3: max
#120	4	ptr(GeoLoadData): gld
#124	84	PackBlockOnDisk
#208

#version 3+: "Common/seq/anim.c"
#	Offset	Size	Description
#	0	4	i32: size
#	4	4	f32: radius
#	8	4	i32: tex_count, The number of TexID entries in the texidx_block.
#	12	4	ptr(BoneInfo): boneinfo ?
#	16	4	i32: vert_count
#	20	4	i32: tri_count
#ver 8+	24	4	i32: reflection_quad_count
#	+4	4	ptr(TexID): tex_idx, Byte offset in the texidx_block to the first TexID for this model.
#	+4	32	PolyGrid: grid
#	+32	4	ptr(char): name
#	+4	4	ptr(AltPivotInfo):
#	+4	12	Vec3: scale
#	+12	12	Vec3: min
#	+12	12	Vec3: max
#	+12	12	PackData: pack.tris
#	+12	12	PackData: pack.verts
#	+12	12	PackData: pack.norms
#	+12	12	PackData: pack.sts
#	+12	12	PackData: pack.sts3
#	+12	12	PackData: pack.weights
#	+12	12	PackData: pack.matidxs
#	+12	12	PackData: pack.grid
#Ver 4	+12	12	PackData: pack.lmap_utransforms
#Ver 4	+12	12	PackData: pack.lmap_vtransforms
#Ver 7+	+12	12	PackData: pack.reductions
#Ver 8+	+12	12	PackData: pack.reflection_quads
#Ver 7+	+12	12	f32[3]: autolod_dists
#	+12	2	i16: id

#PackBlockOnDisk: "Common/seq/anim.c"
#Offset	Size	Description
#0	12	PackData: tris
#12	12	PackData: verts
#24	12	PackData: norms
#36	12	PackData: sts
#48	12	PackData: weights
#60	12	PackData: matidxs
#72	12	PackData: grid
#84

#PackData:
#Offset	Size	Description
#0	4	i32: packsize, The compressed size of this data block. 0 if this is uncompressed.
#4	4	u32: unpacksize, The size of this data block when uncompressed.
#8	4	ptr(u8): data, The offset of this block of data inside the .geo's main data block. 
#12

#TexID:
#Offset	Size	Description
#0	2	u16: id, Index to the texture name in the texture name list.
#2	2	u16: count, Number of tris using this texture.

#struct PolyGrid: "libs/UtilitiesLib/components/gridpoly.h"
#Offset	Size	Description
#0	4	ptr(PolyCell): cell
#4	12	Vec3: pos
#16	4	f32: size
#20	4	f32: inv_size
#24	4	i32: tag
#28	4	i32: num_bits
#32


#PolyCell:
#Offset	Size	Description
#0	4	ptr(ptr(PolyCell)): children
#4	4	ptr(u16): tri_idxs, Triangle indexes.
#8	4	i32: tri_count

#BoneInfo
#Offset Size	Description
#0	4	i32: numbones
#4	4*15	i32[15]: bone_ID, Bones used by this geometry.
#64

#Reductions
#Size	Description
#4	int: num_reductions
#num_reductions*4	int[]:num_tris_left
#num_reductions*4	int[]:error_values
#num_reductions*4	int[]:remap_counts
#num_reductions*4	int[]:changes_counts
#4	int: total_remaps
#total_remaps*4 	int[]:remaps
#4	int: total_remap_tris
#total_remap_tris*4	int[]:remap_tris
#4	int: total_changes
#total_changes*4	int[]:changes
#4	int: positions_delta_length
#positions_delta_length	byte[]: compressDelta(positions, 3, total_changes, "f", 0x8000)
#4	int: total_changes_delta_length
#total_changes_delta_length	byte[]: compressDelta(changes, 2, total_changes, "f", 0x1000)

ZERO_BYTE = struct.pack("B", 0)
#def unbyte(v):
#    return struct.unpack("B", v)[0]
if sys.version_info[0] < 3:
    byte = chr
    unbyte = ord
else:
    def byte(v):
        #return struct.pack("B", v)
        return bytes((v,))
    def unbyte(v):
        return v

def unpackNames(data):
    """Extract strings from data, as layed out as a PackNames structure."""
    (length, ) = struct.unpack("<i", data[0:4])
    strings = []
    data_strings = data[length * 4 + 4:]
    for i in range(length):
        #todo: scan string for zero
        (offset, ) = struct.unpack("<i", data[i * 4 + 4: i * 4 + 4 + 4])
        for j in range(offset, len(data_strings)):
            if unbyte(data_strings[j]) == 0:
                strings.append(data_strings[offset:j])
                break
            pass
        pass
    return strings
def packNames(strings):
    """Convert a sequence of strings into a PackNames structure."""
    data_strings = b""
    data = struct.pack("<i", len(strings))
    for s in strings:
        data += struct.pack("<i", len(data_strings))
        data_strings += s + ZERO_BYTE
    return data + data_strings

def unpackStrings(data):
    """Convert a block of ASCIIZ strings into list of strings."""
    strings = []
    start = 0
    for i in range(len(data)):
        if unbyte(data[i]) == 0:
            strings.append(data[start:i])
            start = i + 1
            pass
        pass
    return strings
def packStrings(strings):
    """Convert a list of strings into a block of ASCIIZ strings"""
    data = b""
    for s in strings:
        data += s + ZERO_BYTE
    return data

def extractString(data, offset = 0):
    """Extract an ASCIIZ string from a fixed length buffer."""
    for i in range(offset, len(data)):
        if unbyte(data[i]) == 0:
            return data[offset : i]
        pass
    return data
def storeString(string, length):
    """Store an ASCIIZ string into a fixed length buffer. If the string is longer than the buffer the output will be truncated, with \\x00 character guarenteed at the end."""
    if len(string) >= length:
        return string[0 : length - 1] + ZERO_BYTE
    else:
        return string + ZERO_BYTE * (length - len(string))

def uncompressDeltas(src, stride, count, pack_type):
    """Expand a list a delta compressed with deltas

src: Source data containg 3 parts:
  - delta codes: Contain 'count' * 'stride' 2 bit size code fields. The end of the block is padded to the byte boundary.
  - float scale: A byte with the exponent for scaling floating point deltas. This part is present with integer types, but unused.
  - byte data: This is read and processed according to the codes specified in the delta codes block.
stride: the number of channels in the data (1 to 3)
count: the number off elements in the data
pack_type: Is a character indicating the type of packing. Valid values are "f" (float32), "H" (unsigned16), "I" (unsigned32) (these match the struct modules types).
The returned data is an array of arrays, with the inner most arrays being 'stride' long, and the outer array being 'count' in length.
"""
    if len(src) <= 0:
        return None
    #Compute offset to the byte data after all the bit fields.
    byte_offset = int((2 * count * stride + 7) / 8)
    #print("stride: %d  count: %d  pack_type: %s" % (stride, count, pack_type))
    #print("src:%s" % ([src],))
    float_scale = float(1 << unbyte(src[byte_offset]))
    float_scale_inv = 1.0 / float_scale
    byte_offset += 1
    current_bit = 0
    if pack_type in "f":
        fLast = [0.0] * stride
    else:
        iLast = [0] * stride
    out_data = []
    for i in range(count):
        row_data = []
        for j in range(stride):
            code = (unbyte(src[current_bit >> 3]) >> (current_bit & 0x7)) & 0x3
            current_bit += 2
            if code == 0:
                iDelta = 0
            elif code == 1:
                iDelta = unbyte(src[byte_offset]) - 0x7f
                byte_offset += 1
            elif code == 2:
                iDelta = (
                    unbyte(src[byte_offset]) |
                    (unbyte(src[byte_offset + 1]) << 8)
                ) - 0x7fff
                byte_offset += 2
            elif code == 3:
                (iDelta, ) = struct.unpack("<i", src[byte_offset : byte_offset + 4])
                byte_offset += 4
            if pack_type == "f":
                if code == 3:
                    (fDelta, ) = struct.unpack("<f", src[byte_offset - 4 : byte_offset])
                else:
                    fDelta = iDelta * float_scale_inv
                fLast[j] += fDelta
                row_data.append(fLast[j])
            elif pack_type == "I":
                iLast[j] += iDelta + 1
                iLast[j] &= 0xffffffff
                row_data.append(iLast[j])
            elif pack_type == "H":
                iLast[j] += iDelta + 1
                iLast[j] &= 0xffff
                row_data.append(iLast[j])
        out_data.append(row_data)
    return out_data

def quantF32(v, float_scale, float_scale_inv):
    i = int(v * float_scale)
    i &= ~1
    return i * float_scale_inv
def compressDeltas(src, stride, count, pack_type, float_scale):
    if float_scale != 0:
        float_scale_inv = 1.0 / float_scale
    else:
        float_scale_inv = 1.0
    codes = [0] * (stride * count + 3) #over fill it by 3 for easier conversion into byte data
    float_scale_byte = byte(int(math.log(float_scale, 2)))
    bytes_data = b""
    if pack_type in "f":
        fLast = [0.0] * stride
    else:
        iLast = [0] * stride
        if pack_type == "I":
            iMask = 0xffffffff
        else:
            iMask = 0xffff

    k = 0
    for i in range(count):
        for j in range(stride):
            if pack_type == "f":
                fDelta = quantF32(src[i][j], float_scale, float_scale_inv) - fLast[j]
                val8 = int(fDelta * float_scale + 0x7f)
                val16 = int(fDelta * float_scale + 0x7fff)
            else:
                t = src[i][j]
                iDelta = t - iLast[j] - 1
                iLast[j] = t
                val8 = iDelta + 0x7f
                val16 = iDelta + 0x7fff
                val32 = iDelta;
            if val8 == 0x7f:
                codes[k] = 0
            elif val8 & ~0xff == 0:
                codes[k] = 1
                bytes_data += byte(val8)
                if pack_type == "f":
                    fLast[j] = (val8 - 0x7f) * float_scale_inv + fLast[j];
            elif pack_type == "H" or val16 & ~0xffff == 0:
                codes[k] = 2
                bytes_data += struct.pack("<H", val16)
                if pack_type == "f":
                    fLast[j] = (val16 - 0x7fff) * float_scale_inv + fLast[j];
            elif pack_type == "I":
                codes[k] = 3
                bytes_data += struct.pack("<I", val32 & iMask)
            else:
                codes[k] = 3
                bytes_data += struct.pack("<f", fDelta)
                fLast[j] = fDelta + fLast[j]
            k += 1
                
        
    code_data = b""
    for i in range(0, stride * count, 4):
        v = ((codes[i + 0] << 0) |
             (codes[i + 1] << 2) |
             (codes[i + 2] << 4) |
             (codes[i + 3] << 6))
        code_data += byte(v)
    return code_data + float_scale_byte + bytes_data

def inferSizes(size, pack_list, other_list):
    """Infer the size of the blocks in 'other_list' as infered by the total size and items in 'pack_list'."""
    starts = []
    for p in pack_list:
        s = p[2]
        if s in starts:
            continue
        starts.append(s)
    for o in other_list:
        if o in starts:
            continue
        starts.append(o)
    starts.sort()
    output = []
    for o in other_list:
        if o == 0:
            output.append( (0, 0, 0) )
            continue
        i = starts.index(o) + 1
        if i < 0 or i >= len(starts):
            output.append( (0, 0, o) )
            continue
        output.append( (0, starts[i] - o, o) )
        
    return tuple(output)


class Reductions:
    def __init__(self, model):
        self.model = model
    def decode(self, data):
        (self.num_reductions, ) = data.decode("<i")
        self.num_tris_left = data.decode("<" + "i" * self.num_reductions)
        self.error_values = data.decode("<" + "f" * self.num_reductions)
        self.remap_counts = data.decode("<" + "i" * self.num_reductions)
        self.changes_counts = data.decode("<" + "i" * self.num_reductions)
        (self.total_remaps, ) = data.decode("<i")
        self.remaps = data.decode("<" + "i" * (self.total_remaps * 3))
        (self.total_remap_tris, ) = data.decode("<i")
        self.remap_tris = data.decode("<" + "i" * self.total_remap_tris)
        (self.total_changes, ) = data.decode("<i")
        self.changes = data.decode("<" + "i" * self.total_changes)
        (positions_delta_length, ) = data.decode("<i")
        #print("positions_delta_length: %s" % (positions_delta_length, ))
        #print("data remaining: %s" %([data.data[data.offset : ]], ))
        #self.dump()
        self.positions = uncompressDeltas(data.read(positions_delta_length), 3, self.total_changes, "f")
        (tex1s_delta_length, ) = data.decode("<i")
        self.tex1s = uncompressDeltas(data.read(tex1s_delta_length), 2, self.total_changes, "f")
        #print("data remaining: %s" %([data.data[data.offset : ]], ))
    def encode(self):
        data = b""
        data += struct.pack("<i", self.num_reductions)
        data += struct.pack("<" + "i" * self.num_reductions, *self.num_tris_left)
        data += struct.pack("<" + "f" * self.num_reductions, *self.error_values)
        data += struct.pack("<" + "i" * self.num_reductions, *self.remap_counts)
        data += struct.pack("<" + "i" * self.num_reductions, *self.changes_counts)
        data += struct.pack("<i", self.total_remaps)
        data += struct.pack("<" + "i" * (self.total_remaps * 3), *self.remaps)
        data += struct.pack("<i", self.total_remap_tris)
        data += struct.pack("<" + "i" * self.total_remap_tris, *self.remap_tris)
        data += struct.pack("<i", self.total_changes)
        data += struct.pack("<" + "i" * self.total_changes, *self.changes)
        d = compressDeltas(self.positions, 3, self.total_changes, "f", 0x8000)
        data += struct.pack("<i", len(d))
        data += d
        d = compressDeltas(self.tex1s, 2, self.total_changes, "f", 0x1000)
        data += struct.pack("<i", len(d))
        data += d
        return data
    def dump(self):
        print("    reductions:")
        print("        num_reductions: %s" % (self.num_reductions, ))
        print("        num_tris_left: %s" % (self.num_tris_left, ))
        print("        error_values: %s" % (self.error_values, ))
        print("        remap_counts: %s" % (self.remap_counts, ))
        print("        changes_counts: %s" % (self.changes_counts, ))
        print("        total_remaps: %s" % (self.total_remaps, ))
        print("        remaps: %s" % (self.remaps, ))
        print("        total_remap_tris: %s" % (self.total_remap_tris, ))
        print("        remap_tris: %s" % (self.remap_tris, ))
        print("        total_changes: %s" % (self.total_changes, ))
        print("        changes: %s" % (self.changes, ))
        print("        positions: %s" % (self.positions, ))
        print("        tex1s: %s" % (self.tex1s, ))

class Model:
    def __init__(self, geo):
        self.geo = geo
        self.radius = None
        self.tex_count = None
        self.vert_count = None
        self.tri_count = None
        self.reflection_quad_count = None
        self.tex_idx = None
        self.name = b""
        self.textures = []
        pass
    def parseHeaderDataV2(self):
        (self.flags, ) = self.geo.getHeaderElement("<I")
        (self.radius, ) = self.geo.getHeaderElement("<f")
        self.geo.header_offset += 4 #ptr(VBO)
        #print("VBO: %s" % (self.geo.getHeaderElement("<i"), ))
        (self.tex_count, ) = self.geo.getHeaderElement("<i")
        (self.id, blend_mode, loadstate) = self.geo.getHeaderElement("<hBB")
        #print("blend_mode, loadstate: %d, %d" % (blend_mode, loadstate))
        (self.boneinfo_ptr, ) = self.geo.getHeaderElement("<i")
        self.geo.header_offset += 4 #ptr(TrickNode)
        #print("TrickNode: %s" % (self.geo.getHeaderElement("<i"), ))
        (self.vert_count, self.tri_count) = self.geo.getHeaderElement("<ii")
        (self.tex_idx_ptr, ) = self.geo.getHeaderElement("<i")
        self.grid_header = self.geo.getHeaderElement("<ifffffii")
        self.geo.header_offset += 4 #ptr(CTri)
        self.geo.header_offset += 4 #ptr(tags)
        #print("CTri: %s" % (self.geo.getHeaderElement("<i"), ))
        #print("Tags: %s" % (self.geo.getHeaderElement("<i"), ))
        (self.name_ptr, self.api_ptr) = self.geo.getHeaderElement("<ii")
        #print("???: %s" % (self.geo.getHeaderElement("<f"), ))
        self.geo.header_offset += 4 #ptr(ModelExtra)
        self.scale = list(self.geo.getHeaderElement("<fff"))
        self.min = list(self.geo.getHeaderElement("<fff"))
        self.max = list(self.geo.getHeaderElement("<fff"))
        self.geo.header_offset += 4 #ptr(GeoLoadData)
        #print("GeoLoadData: %s" % (self.geo.getHeaderElement("<i"), ))
        self.pack_tris = self.geo.getHeaderElement("<iii")
        self.pack_verts = self.geo.getHeaderElement("<iii")
        self.pack_norms = self.geo.getHeaderElement("<iii")
        self.pack_sts = self.geo.getHeaderElement("<iii")
        self.pack_sts3 = (0, 0, 0)
        self.pack_weights = self.geo.getHeaderElement("<iii")
        self.pack_matidxs = self.geo.getHeaderElement("<iii")
        self.pack_grid = self.geo.getHeaderElement("<iii")
        self.pack_reductions = (0, 0, 0)
        self.pack_reflection_quads = (0, 0, 0)

        self.name = extractString(self.geo.header_objname_data, self.name_ptr)
        self.autolod_dists = [-1, -1, -1]
        self.skipped_data = None
        #self.dump()
    def parseHeaderData(self):
        if self.geo.version <= 2:
            self.parseHeaderDataV2()
            return
        (size, ) = struct.unpack("<i", self.geo.header_data[self.geo.header_offset: self.geo.header_offset + 4])
        final_offset = self.geo.header_offset + size
        self.geo.header_offset += 4
        (self.radius, ) = self.geo.getHeaderElement("<f")
        (self.tex_count, self.boneinfo_ptr) = self.geo.getHeaderElement("<ii")
        (self.vert_count, self.tri_count) = self.geo.getHeaderElement("<ii")
        if self.geo.version >= 8:
            (self.reflection_quad_count, ) = self.geo.getHeaderElement("<i")
        (self.tex_idx_ptr, ) = self.geo.getHeaderElement("<i")
        self.grid_header = self.geo.getHeaderElement("<ifffffii")
        (self.name_ptr, self.api_ptr) = self.geo.getHeaderElement("<ii")
        self.scale = list(self.geo.getHeaderElement("<fff"))
        self.min = list(self.geo.getHeaderElement("<fff"))
        self.max = list(self.geo.getHeaderElement("<fff"))
        self.pack_tris = self.geo.getHeaderElement("<iii")
        self.pack_verts = self.geo.getHeaderElement("<iii")
        self.pack_norms = self.geo.getHeaderElement("<iii")
        self.pack_sts = self.geo.getHeaderElement("<iii")
        self.pack_sts3 = self.geo.getHeaderElement("<iii")
        self.pack_weights = self.geo.getHeaderElement("<iii")
        self.pack_matidxs = self.geo.getHeaderElement("<iii")
        self.pack_grid = self.geo.getHeaderElement("<iii")
        if self.geo.version == 4:
            #pack.lmap_utransforms, pack.lmap_vtransforms
            self.geo.header_offset += 12 * 2
        if self.geo.version >= 7:
            self.pack_reductions = self.geo.getHeaderElement("<iii")
        else:
            self.pack_reductions = (0, 0, 0)
        if self.geo.version >= 8:
            self.pack_reflection_quads = self.geo.getHeaderElement("<iii")
        else:
            self.pack_reflection_quads = (0, 0, 0)
        #pack_list = [
        #    self.pack_tris,
        #    self.pack_verts,
        #    self.pack_norms,
        #    self.pack_sts,
        #    self.pack_sts3,
        #    self.pack_weights,
        #    self.pack_matidxs,
        #    self.pack_grid,
        #    #pack.lmap_utransforms, pack.lmap_vtransforms
        #    self.pack_reductions,
        #    self.pack_reflection_quads,
        #]
        #other_list = [
        #    self.boneinfo_ptr,
        #    self.name_ptr,
        #    self.api_ptr,
        #]
        #(self.pack_boneinfo, self.pack_name, self.pack_api) = inferSizes(self.geo.main_data_size, pack_list, other_list)
        self.name = extractString(self.geo.header_objname_data, self.name_ptr)

        #self.geo.header_offset = final_offset - 12 - 2
        if self.geo.version <= 7:
            #lightmap_size
            self.geo.header_offset += 4
        if self.geo.version >= 7:
            self.autolod_dists = list(self.geo.getHeaderElement("<fff"))
        else:
            self.autolod_dists = [-1, -1, -1]
        #(self.mystery, ) = self.geo.getHeaderElement("<f")
        (self.id, ) = self.geo.getHeaderElement("<h")
        #self.mystery = self.geo.getHeaderElement("<fh")
        #print("automatic offset: %d  final offset: %d" % (self.geo.header_offset, final_offset))
        self.skipped_data = self.geo.header_data[self.geo.header_offset : final_offset]
        self.geo.header_offset = final_offset

    def parseData(self):
        self.tex_idx = []
        texidx_data = self.geo.header_texidx_data
        texidx_data.seek(self.tex_idx_ptr)
        c = 0
        for i in range(self.tex_count):
            self.tex_idx.append(texidx_data.decode("<HH"))
            c += self.tex_idx[-1][1]
        #todo: assert(c == self.tri_count)

        self.altpivotinfo = []
        if self.api_ptr != 0:
            self.geo.seekMainData(self.api_ptr)
            (self.altpivotinfo_count, ) = self.geo.getMainElement("<i")
            for i in range(self.altpivotinfo_count):
                self.altpivotinfo.append([])
                for j in range(4):
                    self.altpivotinfo[i].append(list(self.geo.getMainElement("<fff")))
        self.altpivotinfo_count = len(self.altpivotinfo)

        self.tris_data = self.geo.getDataBlock(self.pack_tris)
        self.verts_data = self.geo.getDataBlock(self.pack_verts)
        self.norms_data = self.geo.getDataBlock(self.pack_norms)
        self.sts_data = self.geo.getDataBlock(self.pack_sts)
        self.sts3_data = self.geo.getDataBlock(self.pack_sts3)
        self.weights_data = self.geo.getDataBlock(self.pack_weights)
        self.matidxs_data = self.geo.getDataBlock(self.pack_matidxs)
        self.grid_data = self.geo.getDataBlock(self.pack_grid)
        self.reductions_data = self.geo.getDataBlock(self.pack_reductions)
        self.reflection_quads_data = self.geo.getDataBlock(self.pack_reflection_quads)

        self.tris = uncompressDeltas(self.tris_data, 3, self.tri_count, "I")
        self.verts = uncompressDeltas(self.verts_data, 3, self.vert_count, "f")
        self.norms = uncompressDeltas(self.norms_data, 3, self.vert_count, "f")
        self.sts = uncompressDeltas(self.sts_data, 2, self.vert_count, "f")
        self.sts3 = uncompressDeltas(self.sts3_data, 2, self.vert_count, "f")

        if self.boneinfo_ptr != 0:
            self.geo.seekMainData(self.boneinfo_ptr)
            (self.bone_count, ) = self.geo.getMainElement("<i")
            self.bone_ids = self.geo.getMainElement("<" + ("i" * 15))
        else:
            self.bone_count = 0
            self.bone_ids = [0] * 15
        if len(self.weights_data) == 0:
            self.weights = None
            self.weight_bones = None
        else:
            self.weights = []
            self.weight_bones = []
            for i in range(self.vert_count):
                w = unbyte(self.weights_data[i]) / 255.0
                b = self.matidxs_data[i * 2 : i * 2 + 2]
                b1 = self.bone_ids[unbyte(b[0]) // 3]
                b2 = self.bone_ids[unbyte(b[1]) // 3]
                self.weights.append([w, 1 - w])
                self.weight_bones.append([b1, b2])

        if len(self.grid_data) == 0:
            self.polygrid = None
        else:
            self.polygrid = PolyGrid(self)
            self.polygrid.parsePolyGridData(self.grid_data, self.grid_header)

        if len(self.reductions_data) == 0:
            self.reductions = None
        else:
            #self.reductions = None
            #self.dump()
            self.reductions = Reductions(self)
            self.reductions.decode(Data(self.reductions_data))
        if len(self.reflection_quads_data) == 0:
            self.reflection_quads = None
        else:
            #todo:
            self.reflection_quads = None
        #if self.geo.version <= 2:
        #    self.dump()

    def packDeltas(self, data, stride, count, pack_type):
        deltas = compressDeltas(data, stride, count, pack_type)
        pack = self.geo.encodeMainDataPacked(deltas)
    def rebuildWeightsAndBones(self):
        self.weights_data = b""
        self.matidxs_data = b""
        if self.weights is None or len(self.weights) == 0:
            self.bone_count = 0
            self.bone_ids = [0] * 15
            return
        self.bone_ids = []
        bone_lookup = {}
        for wb in self.weight_bones:
            for wbx in wb:
                if wbx not in bone_lookup:
                    bone_lookup[wbx] = len(self.bone_ids)
                    self.bone_ids.append(wbx)
        #print(self.weights)
        for i in range(len(self.weights)):
            #Copy values to avoid corruption.
            w = self.weights[i][:]
            wb = self.weight_bones[i][:]
            if len(w) > 2:
                #.geos only support 2 weights per vertex.
                #todo: get only largest weights?
                w = w[0 : 2]
                wb = wb[0 : 2]
            if len(w) == 1 or wb[0] == wb[1]:
                self.weights_data += byte(255)
                self.matidxs_data += byte(bone_lookup[wb[0]] * 3) + ZERO_BYTE
                continue
            if w[0] + w[1] == 0:
                w[0] = 0.5
                w[1] = 0.5
            w[0] = w[0] / float(w[0] + w[1])
            if w[0] < 0:
                w[0] = 0.0
            elif w[0] > 1:
                w[0] = 1.0
            #print("weights: %s -> %s" % (self.weights[i], w))
            self.weights_data += byte(int(math.floor(255 * w[0] + 0.5)))
            self.matidxs_data += byte(bone_lookup[wb[0]] * 3) +byte(bone_lookup[wb[1]] * 3)
        self.bone_count = len(self.bone_ids)
        self.bone_ids += [0] * (15 - self.bone_count)
    def encode(self):
        #Regenerate dynamic data
        if self.verts is not None and len(self.verts) > 0:
            self.polygrid = PolyGrid(self)
            self.grid_data = self.polygrid.encode()
            self.grid_header = self.polygrid.grid_header
            self.radius = self.polygrid.radius
            self.min = self.polygrid.aabb.min.data
            self.max = self.polygrid.aabb.max.data
        else:
            self.polygrid = None
            self.grid_data = b""
            self.grid_header = (0, 0.0, 0.0, 0.0, 1.0, 1.0, 0, 0)
            self.radius = 0
            self.min = [0, 0, 0]
            self.max = [0, 0, 0]
        if self.geo.version >= 7:
            #todo: build reductions
            if self.reductions is not None:
                self.reductions_data = self.reductions.encode()
            else:
                self.reductions_data = b""
            pass
        self.rebuildWeightsAndBones()

        #Encode data into the main block.
        #note: PackData should go first, otherwise other ptr types might point to the start of the data block, which would result in a 0 point, which is treated as not present.
        self.pack_tris = self.geo.encodeMainDataPackedDeltas(self.tris, 3, self.tris and len(self.tris), "I", 1)
        self.pack_verts = self.geo.encodeMainDataPackedDeltas(self.verts, 3, self.verts and len(self.verts), "f", 0x8000)
        self.pack_norms = self.geo.encodeMainDataPackedDeltas(self.norms, 3, self.norms and len(self.norms), "f", 0x100)
        self.pack_sts = self.geo.encodeMainDataPackedDeltas(self.sts, 2, self.sts and len(self.sts), "f", 0x1000)
        self.pack_sts3 = self.geo.encodeMainDataPackedDeltas(self.sts3, 2, self.sts3 and len(self.sts3), "f", 0x8000)
        self.pack_weights = self.geo.encodeMainDataPacked(self.weights_data)
        self.pack_matidxs = self.geo.encodeMainDataPacked(self.matidxs_data)
        self.pack_grid = self.geo.encodeMainDataPacked(self.grid_data)
        self.pack_reductions = self.geo.encodeMainDataPacked(self.reductions_data)
        self.pack_reflection_quads = self.geo.encodeMainDataPacked(self.reflection_quads_data)
        if self.bone_count > 0:
            bone_data = struct.pack("<" + "i" * (1 + 15), self.bone_count, *self.bone_ids)
            bone_data += struct.pack("<ii", 0, 0) #weights_ptr and matidx_ptr place holders, needed by the game
            self.boneinfo_ptr = self.geo.encodeMainData(bone_data)
        else:
            self.boneinfo_ptr

        api_data = b""
        if len(self.altpivotinfo) > 0:
            api_data = struct.pack("<i", len(self.altpivotinfo))
            for i in range(len(self.altpivotinfo)):
                for j in range(len(self.altpivotinfo[i])):
                    api_data += struct.pack("<fff", *self.altpivotinfo[i][j])
            for i in range(15 - len(self.altpivotinfo)):
                api_data += struct.pack("<fff", 0, 0, 0) * 4
        if len(api_data) > 0:
            self.api_ptr = self.geo.encodeMainData(api_data)
        else:
            self.api_ptr = 0

        #Encode shared header data
        self.texidx_ptr = len(self.geo.header_texidx_data)
        texidx_data = self.geo.header_texidx_data
        texidx_data.seekEnd()
        for t in self.tex_idx:
            texidx_data.encode("<HH", *t)
        self.tex_count = len(self.tex_idx)
        self.vert_count = self.verts and len(self.verts) or 0
        self.tri_count = self.tris and len(self.tris) or 0
        self.name_ptr = len(self.geo.header_objname_data)
        self.geo.header_objname_data += self.name + ZERO_BYTE
        self.geo.header_objnames.append(self.name)
        
        #Encode the header
        self.header_data = b""
        self.header_data += struct.pack("<f", self.radius)
        self.header_data += struct.pack("<i", self.tex_count)
        self.header_data += struct.pack("<i", self.boneinfo_ptr)
        self.header_data += struct.pack("<i", self.vert_count)
        self.header_data += struct.pack("<i", self.tri_count)
        if self.geo.version >= 8:
            if self.reflection_quads is None or len(self.reflection_quads):
                self.reflection_quads_count = 0
            else:
                self.reflection_quads_count = len(self.reflection_quads)
            self.header_data += struct.pack("<i", self.reflection_quads_count)
            pass
        self.header_data += struct.pack("<i", self.texidx_ptr)
        self.header_data += struct.pack("<ifffffii", *self.grid_header)
        self.header_data += struct.pack("<i", self.name_ptr)
        self.header_data += struct.pack("<i", self.api_ptr)
        self.header_data += struct.pack("<fff", *self.scale)
        self.header_data += struct.pack("<fff", *self.min)
        self.header_data += struct.pack("<fff", *self.max)
        self.header_data += struct.pack("<iii", *self.pack_tris)
        self.header_data += struct.pack("<iii", *self.pack_verts)
        self.header_data += struct.pack("<iii", *self.pack_norms)
        self.header_data += struct.pack("<iii", *self.pack_sts)
        self.header_data += struct.pack("<iii", *self.pack_sts3)
        self.header_data += struct.pack("<iii", *self.pack_weights)
        self.header_data += struct.pack("<iii", *self.pack_matidxs)
        self.header_data += struct.pack("<iii", *self.pack_grid)
        if self.geo.version == 4:
            #pack.lmap_utransforms, pack.lmap_vtransforms
            self.header_data += struct.pack("<iiiiii", 0, 0, 0, 0, 0, 0)
        if self.geo.version >= 7:
            self.header_data += struct.pack("<iii", *self.pack_reductions)
            pass
        if self.geo.version >= 8:
            self.header_data += struct.pack("<iii", *self.pack_reflection_quads)
            pass
        self.header_data += struct.pack("<fff", *self.autolod_dists)
        self.header_data += struct.pack("<h", self.id)

        if self.geo.version >= 8:
            #Pad to match the alignment of "ModelFormatOnDisk_v8" produced by "GetVrml/output.c"
            self.header_data += struct.pack("<h", 0)

        self.header_data = struct.pack("<i", len(self.header_data) + 4) + self.header_data
        pass
    def encodeHeader(self):
        self.geo.header_data += self.header_data

    def getBoneRoot(self):
        if self.bone_count <= 0:
            return None
        #todo: find the root properly. For now it just grabs the lowest bone id and hopes it's right.
        #print("getBoneRoot():")
        bid = self.bone_ids[0]
        for i in range(self.bone_count):
            b = self.bone_ids[i]
            #print("   %s : %s" % (bid, b))
            if b < bid:
                bid = b
        return BONES_LIST[bid]
    def dump(self):
        print("    radius: %s" % self.radius)
        print("    tex_count: %s" % self.tex_count)
        print("    boneinfo_ptr: %s" % self.boneinfo_ptr)
        print("    vert_count: %s" % self.vert_count)
        print("    tri_count: %s" % self.tri_count)
        print("    name_ptr: %s" % self.name_ptr)
        print("    api_ptr: %s" % self.api_ptr)
        print("    grid: %s" % (self.grid_header, ))
        print("    scale: %s" % self.scale)
        print("    min: %s" % self.min)
        print("    max: %s" % self.max)
        print("    pack_tris: %s" % (self.pack_tris, ))
        print("    pack_verts: %s" % (self.pack_verts, ))
        print("    pack_norms: %s" % (self.pack_norms, ))
        print("    pack_sts: %s" % (self.pack_sts, ))
        print("    pack_sts3: %s" % (self.pack_sts3, ))
        print("    pack_weights: %s" % (self.pack_weights, ))
        print("    pack_matidxs: %s" % (self.pack_matidxs, ))
        print("    pack_grid: %s" % (self.pack_grid, ))
        #print("    pack_boneinfo: %s" % (self.pack_boneinfo, ))
        #print("    pack_name: %s" % (self.pack_name, ))
        #print("    pack_api: %s" % (self.pack_api, ))
        print("    autolod_dists: %s" % (self.autolod_dists, ))
        print("    id: %s" % (self.id, ))
        #print("    mystery: %s" % (self.mystery, ))
        print("    skipped_data: %s" % ([self.skipped_data], ))

        print("    name: %s" % self.name)
        #print("    tris_data: %s" % ([self.tris_data], ))
        #print("    verts_data: %s" % ([self.verts_data], ))
        #print("    sts_data: %s" % ([self.sts_data], ))
        #print("    sts3_data: %s" % ([self.sts3_data], ))
        #print("    weights_data: %s" % ([self.weights_data], ))
        #print("    matidxs_data: %s" % ([self.matidxs_data], ))
        #print("    grid_data: %s" % ([self.grid_data], ))
        #print("    reductions_data: %s" % ([self.reductions_data], ))
        print("    reflection_quads_data: %s" % ([self.reflection_quads_data], ))

        print("    tex_idx: %s" % ([self.tex_idx]))
        print("    tris: %s" % ([self.tris], ))
        print("    verts: %s" % ([self.verts], ))
        print("    norms: %s" % ([self.norms], ))
        print("    weights: %s" % ([self.weights], ))
        print("    weight_bones (matidxs): %s" % ([self.weight_bones], ))
        if self.polygrid == None:
            print("    grid: None")
        else:
            print("    grid:")
            self.polygrid.dump()
        if self.reductions == None:
            print("    reductions: None")
        else:
            self.reductions.dump()
            
        print("    sts: %s" % ([self.sts], ))
        print("    sts3: %s" % ([self.sts3], ))

        print("    bone_count: %d" % self.bone_count)
        print("    bone_ids: %s" % (self.bone_ids, ))

        print("    altpivotinfo: %s" % (self.altpivotinfo, ))
        for i in range(self.bone_count):
            print("        : %s" % (BONES_LIST[self.bone_ids[i]], ))

    def saveToGeoMesh(self):
        geomesh = GeoMesh()
        geomesh.have_uvs = self.sts is not None
        geomesh.have_weights = self.weights is not None
        for i in range(len(self.verts)):
            coord = self.verts[i]
            normal = self.norms[i]
            if geomesh.have_uvs:
                uv = self.sts[i]
            else:
                uv = (0, 0)
            if geomesh.have_weights:
                weights = []
                #print("verts #: %s  weights #: %s  weight bones #: %s" % (len(self.verts), len(self.weights), len(self.weight_bones)))
                #for k, w in enumerate(self.weights):
                w = self.weights[i]
                w_bones = self.weight_bones[i]
                for j, b in enumerate(w_bones):
                    if w[j] == 0:
                        continue
                    #print("vertex_idx: %s weight_bones: %s" % (i, b, ))
                    #print("  bone_id: %s" % (self.bone_ids[b], ))
                    w_name = BONES_LIST[b]
                    #weights.append((geomesh.getWeightIndex(w_name), w[j]))
                    geomesh.getWeightIndex(w_name)
                    weights.append([w_name, w[j]])
            else:
                weights = []
            #print("   weights: %s" % (weights, ))
            v = GeoVertex(coord, normal, uv, weights)
            geomesh.getGeoVertexIndexNew(v)
        texture_indexes = []
        for t in self.tex_idx:
            texture_indexes += [geomesh.getTextureIndex(self.geo.header_texnames[t[0]])] * t[1]
        #print("len(self.verts): %s" % (len(self.verts), ))
        #print("len(geomesh.geovertex): %s" % (len(geomesh.geovertex), ))
        #print("%s" % (self.tex_idx, ))
        #print("%s" % (texture_indexes, ))
        for i, t in enumerate(self.tris):
            #print("  - %s: %s" % (i, t))
            geomesh.addFace([geomesh.geovertex[t[0]], geomesh.geovertex[t[1]], geomesh.geovertex[t[2]]], texture_indexes[i])
        return geomesh
    def loadFromGeoMesh(self, geomesh):
        self.tris = [] #uncompressDeltas(self.tris_data, 3, self.tri_count, "I")
        self.verts = [] #uncompressDeltas(self.verts_data, 3, self.vert_count, "f")
        self.norms = [] #uncompressDeltas(self.norms_data, 3, self.vert_count, "f")
        self.sts = [] #uncompressDeltas(self.sts_data, 2, self.vert_count, "f")
        self.sts3 = None #uncompressDeltas(self.sts3_data, 2, self.vert_count, "f")
        self.tex_idx = []
        self.reductions = None
        self.reflection_quads_data = None
        self.reflection_quads = None
        self.altpivotinfo = []
        self.scale = [1.0, 1.0, 1.0]
        self.autolod_dists = [-1, -1, -1]
        self.id = -2

        if geomesh.have_weights:
            self.weights = []
            self.weight_bones = []
        else:
            self.weights = None
            self.weight_bones = None
        geomesh.sortFaces()
        #Determine the remap for converting geomesh textures indexes to geo texture indexes.
        texture_remap = []
        for i in range(len(geomesh.textures)):
            texture_remap.append(self.geo.getTextureIndex(geomesh.textures[i]))
        #Determine the remap for converting geomesh weight/bones indexes to geo weight/bone indexes.
        geomesh.rebuildWeightsList()
        weight_remap = {}
        for i in range(len(geomesh.weights)):
            #weight_remap.append(BONES_LOOKUP.get(geomesh.weights[i], 0))
            weight_remap[geomesh.weights[i]] = BONES_LOOKUP.get(geomesh.weights[i], 0)
            #print("   '%s' -> %s" % (geomesh.weights[i], weight_remap[geomesh.weights[i]]))
        #if len(weight_remap) <= 0:
        #    weight_remap.append(0)
        #Convert vetices to: positions, normals, uvs, weights
        for i, v in enumerate(geomesh.geovertex):
            self.verts.append(v.coord)
            self.norms.append(v.normal)
            self.sts.append(v.uv)
            if geomesh.have_weights:
                weights = v.selectWeights(2)
                #print(weights)
                if len(weights) == 0:
                    self.weights.append([1, 0])
                    self.weight_bones.append([weight_remap[0], weight_remap[0]])
                elif len(weights) == 1:
                    self.weights.append([weights[0][1], 0])
                    self.weight_bones.append([weight_remap[weights[0][0]], weight_remap[weights[0][0]]])
                else:
                    self.weights.append([weights[0][1], weights[1][1]])
                    self.weight_bones.append([weight_remap[weights[0][0]], weight_remap[weights[1][0]]])
        #Convert faces
        texture_index = None
        texture_count = 0
        for i, t in enumerate(geomesh.face):
            self.tris.append(t.vert_indexes)
            if texture_index != t.texture_index:
                if texture_index is not None:
                    self.tex_idx.append((texture_remap[texture_index], texture_count))
                texture_count = 0
                texture_index = t.texture_index
            texture_count += 1
        if texture_count != 0:
            self.tex_idx.append((texture_remap[texture_index], texture_count))
        print("self.tex_idx: %s" % (self.tex_idx, ))


class Geo:
    def __init__(self):
        self.data = b""
        self.offset = 0
        self.version = -1
        self.models = []
        self.header_texnames = []
        self.header_modelheader_tracklength = 0
        pass
    def loadFromData(self, data):
        self.data = data
        self.offset = 0
        self.parseData()
        pass
    def loadFromFile(self, filein):
        self.data = filein.read()
        self.offset = 0
        self.parseData()
        pass
    def saveToData(self):
        self.encode()
        return self.data
    def saveToFile(self, fileout):
        self.encode()
        fileout.write(self.data)
    def parseData(self):
        (ziplen, self.header_size) = struct.unpack("<ii", self.data[self.offset : self.offset + 8])
        if self.header_size != 0:
            self.version = 0
            self.offset += 8
            ziplen -= 4
        else:
            (self.version,
             self.header_size) = struct.unpack("<ii", self.data[self.offset + 8: self.offset + 8 + 8])
            ziplen -= 12
            self.offset += 16
        #print("%s" % [self.data[self.offset : self.offset + ziplen]])
        self.header_data = zlib.decompress(self.data[self.offset : self.offset + ziplen])#, bufsize = self.header_size)
        self.offset += ziplen
        if self.version == 0:
            self.offset += 4

        self.header_offset = 0
        (self.main_data_size,
         self.texname_blocksize,
         self.objname_blocksize,
         self.texidx_blocksize) = struct.unpack("<iiii", self.header_data[self.header_offset : self.header_offset + 16])
        self.header_offset += 16
        if self.version >= 2 and self.version <= 6:
            (self.lodinfo_blocksize, ) = struct.unpack("<i", self.header_data[self.header_offset : self.header_offset + 4])
            self.header_offset += 4
        else:
            self.lodinfo_blocksize = 0
        self.header_texname_data = self.header_data[self.header_offset : self.header_offset + self.texname_blocksize]
        self.header_offset += self.texname_blocksize
        self.header_objname_data = self.header_data[self.header_offset : self.header_offset + self.objname_blocksize]
        self.header_offset += self.objname_blocksize
        self.header_texidx_data = Data(self.header_data[self.header_offset : self.header_offset + self.texidx_blocksize])
        self.header_offset += self.texidx_blocksize
        self.header_lodinfo_data = self.header_data[self.header_offset : self.header_offset + self.lodinfo_blocksize]
        self.header_offset += self.lodinfo_blocksize

        self.header_modelheader_data = self.header_data[self.header_offset : self.header_offset + 124 + 4 + 4 + 4 + 4]
        self.header_offset += 124 + 4 + 4 + 4 + 4

        self.header_texnames = unpackNames(self.header_texname_data)
        self.header_objnames = unpackStrings(self.header_objname_data)
        self.header_modelheader_name = extractString(self.header_modelheader_data[0:124])
        (self.header_modelheader_tracklength, ) = struct.unpack("<f", self.header_modelheader_data[124 + 4: 124 + 4 + 4])
        (self.header_modelheader_modelcount, ) = struct.unpack("<i", self.header_modelheader_data[124 + 4 + 4 + 4: 124 + 4 + 4 + 4 + 4])
        #print("main offset: %d 0x%x" % (self.offset, self.offset))
        self.main_data = self.data[self.offset : self.offset + self.main_data_size]
        #print(" %s" % [self.main_data])
        self.models = []
        #self.dump()
        for i in range(self.header_modelheader_modelcount):
            self.models.append(Model(self))
            self.models[-1].parseHeaderData()
            self.models[-1].parseData()
            #if i < len(self.header_objnames):
            #    self.models[-1].name = self.header_objnames[i]

    def getHeaderElement(self, fmt):
        size = struct.calcsize(fmt)
        data = struct.unpack(fmt, self.header_data[self.header_offset : self.header_offset + size])
        self.header_offset += size
        return data
    def getDataBlock(self, tup):
        #print("%s" % (tup, ))
        (packsize, unpacksize, offset) = tup
        if packsize == 0:
            return self.main_data[offset : offset + unpacksize]
        rawdata = self.main_data[offset : offset + packsize]
        #print("%s" % [rawdata])
        try:
            data = zlib.decompress(rawdata)
        except Exception as e:
            print("%s" % (tup, ))
            print("%s" % [rawdata])
            traceback.print_exc()
            #data = rawdata
            raise e
        #todo: sanity check size?
        return data

    def getTextureIndex(self, texture_name):
        if isinstance(texture_name, str):
            texture_name = bytes(texture_name, "utf-8")
        for i in range(len(self.header_texnames)):
            if texture_name == self.header_texnames[i]:
                return i
        i = len(self.header_texnames)
        self.header_texnames.append(texture_name)
        return i

    def encode(self):
        self.data = None
        self.version = 8
        self.main_data = b""
        self.header_data = b""
        self.header_objnames = []
        self.header_objname_data = b""
        self.lodinfo_data = b""
        self.header_texidx_data = Data()
        #Encode models into main data
        for m in self.models:
            m.encode()
        #Convert remaining data
        self.header_texname_data = packNames(self.header_texnames)
        #Encode information into header data.
        self.header_data += struct.pack("<iiii", len(self.main_data), len(self.header_texname_data), len(self.header_objname_data), len(self.header_texidx_data))
        if self.version >= 2 and self.version <= 6:
            self.header_data += struct.pack("<i", len(self.lodinfo_data))
        self.header_data += self.header_texname_data + self.header_objname_data + self.header_texidx_data.data
        if self.version >= 2 and self.version <= 6:
            self.header_data += self.lodinfo_data
        #Encode the main model header.
        self.header_data += storeString(self.header_modelheader_name, 124)
        self.header_data += struct.pack("<ifii", 0, self.header_modelheader_tracklength, -1, len(self.models))
        #Encode model headers into header data.
        for m in self.models:
            m.encodeHeader()
        zheader_data = zlib.compress(self.header_data)
        if self.version == 0:
            preheader = struct.pack("<ii", len(zheader_data) + 4, len(self.header_data))
        else:
            preheader = struct.pack("<iiii", len(zheader_data) + 12, 0, self.version, len(self.header_data))
        if self.version == 0:
            zheader += struct.pack("<i", 0)
        self.data = preheader + zheader_data + self.main_data
    def encodeObjName(self, name):
        o = len(self.header_objname_data)
        self.header_objname_data += name + ZERO_BYTE
        self.header_objnames.append(name)
        return o
    def encodeMainData(self, data):
        o = len(self.main_data)
        self.main_data += data
        return o
    def encodeMainDataPacked(self, data):
        o = len(self.main_data)
        if data is None or len(data) <= 0:
            return (0, 0, o)
        #todo: minimum compression?
        d = zlib.compress(data)
        if len(d) >= len(data):
            self.main_data += data
            return (0, len(data), o)
        else:
            self.main_data += d
            return (len(d), len(data), o)
    def encodeMainDataPackedDeltas(self, data, stride, count, pack_type, float_scale):
        if data is None:
            return (0, 0, 0)
        deltas = compressDeltas(data, stride, count, pack_type, float_scale)
        pack = self.encodeMainDataPacked(deltas)
        return pack

    def dump(self):
        print("version: %d" % self.version)
        print("header_size: expected: %d  actual: %d" % (self.header_size, len(self.header_data)))
        #print("header_data: %s" % [self.header_data])
        print("main_data_size: %d" % self.main_data_size)
        print("header_data sizes: texname: %d  objname: %d  texidx: %d  lodinfo: %d" % (self.texname_blocksize, self.objname_blocksize, self.texidx_blocksize, self.lodinfo_blocksize))
        print("header_texname_data: %s" % [self.header_texname_data])
        print("header_texnames: %s" % [self.header_texnames])
        print("header_objname_data: %s" % [self.header_objname_data])
        print("header_objnames: %s" % [self.header_objnames])
        print("header_texidx_data: %s" % [self.header_texidx_data])
        print("header_lodinfo_data: %s" % [self.header_lodinfo_data])
        print("header_modelheader_name: %s" % [self.header_modelheader_name])
        print("header_modelheader_tracklength: %s" % self.header_modelheader_tracklength)
        print("header_modelheader_modelcount: %s" % self.header_modelheader_modelcount)
        print("header_modelheader_data: %s" % [self.header_modelheader_data[124:]])
        print("header remaining: %d" % ((len(self.header_data) - self.header_offset), ))
        print("header remaining: %s" %  ([self.header_data[self.header_offset:]], ))

        #%d  objname: %d  texidx: %d  lodinfo: %d" % (self.texname_blocksize, self.objname_blocksize, self.texidx_blocksize, self.lodinfo_blocksize)
        for i in range(len(self.models)):
            print("Model %d:" % (i, ))
            self.models[i].dump()

    def seekMainData(self, offset):
        self.main_data_offset = offset
    def skipMainData(self, skip):
        if type(skip) is int:
            self.main_data_offset += skip
        else:
            self.main_data_offset += struct.calcsize(skip)
    def getMainElement(self, fmt):
        size = struct.calcsize(fmt)
        data = struct.unpack(fmt, self.main_data[self.main_data_offset : self.main_data_offset + size])
        self.main_data_offset += size
        return data
    def getElement(self, offset, fmt):
        size = struct.calcsize(fmt)
        data = struct.unpack(fmt, self.main_data[offset : offset + size])
        return data

    def setName(self, name):
        if isinstance(name, str):
            name = bytes(name, "utf-8")
        self.header_modelheader_name = name
    def addModel(self, name):
        if isinstance(name, str):
            name = bytes(name, "utf-8")
        self.models.append(Model(self))
        self.models[-1].name = name
        return self.models[-1]

if __name__ == "__main__":
    if len(sys.argv) <= 1 or len(sys.argv) > 3:
        print("Usage:")
        print("   %s <file_in> [<file_out>]" % (sys.argv[0], ))
        print("Test loads a .geo file, dumps its content, and optionally writes its content out.")
        exit(0)
    fh = open(sys.argv[1], "rb")
    geo = Geo()
    geo.loadFromFile(fh)
    fh.close()
    #print(sys.argv)
    if len(sys.argv) <= 2:
        fho = None
    else:
        fho = open(sys.argv[2], "wb")
    if fho is not None:
        data = geo.saveToData()
        #geo.dump()
        fho.write(data)
    else:
        geo.dump()
    #print("%s" % [geo.header_data])