mirror of
https://github.com/grp/Wii.py.git
synced 2025-06-18 23:05:48 -04:00
1430 lines
48 KiB
Python
Executable File
1430 lines
48 KiB
Python
Executable File
#!/usr/bin/python
|
|
|
|
import sys, struct, re, hashlib, os
|
|
|
|
''' STOLEN FROM COMEX '''
|
|
def nullterm(str_plus):
|
|
z = str_plus.find('\0')
|
|
if z != -1:
|
|
return str_plus[:z]
|
|
else:
|
|
return str_plus
|
|
|
|
def unnullterm(var, size):
|
|
if len(var) > size:
|
|
raise Exception('unnullterm: "%s" too long' % var)
|
|
return var.ljust(size, '\0')
|
|
|
|
def bit_extract(num, start, end=None):
|
|
if end is None:
|
|
end = start
|
|
mask = (2**(31 - start + 1) - 1) - (2**(31 - end) - 1)
|
|
ret = (num & mask) >> (31 - end)
|
|
|
|
return ret
|
|
|
|
def bit_place(num, start, end=None):
|
|
# Just for sanity
|
|
if end is None:
|
|
end = start
|
|
assert num <= 2**(end - start)
|
|
return num << (31 - end)
|
|
|
|
def untv(name):
|
|
#assert '\0' not in name
|
|
lex = len(name) + 16
|
|
lex -= lex % 16
|
|
return name.ljust(lex, '\0')
|
|
''' END THEFT FROM COMEX '''
|
|
|
|
class BRLYT_Numoffs:
|
|
def __init__(self):
|
|
self.number = 0x00
|
|
self.offset = 0x00
|
|
def eat_numoffs(self, file, offset):
|
|
self.number, self.offset = struct.unpack('>HH', file[offset:offset+4])
|
|
return
|
|
def show_numoffs(self):
|
|
print "Number: %04x" % self.number
|
|
print "Offset: %04x" % self.offset
|
|
return
|
|
def add(self):
|
|
self.number = self.number + 1
|
|
return
|
|
def get_length(self):
|
|
templength = 2 + 2
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>H', self.number))
|
|
file.write(struct.pack('>H', self.offset))
|
|
|
|
class BRLYT_SignedColor:
|
|
def __init__(self):
|
|
self.color1 = 255
|
|
self.color2 = 255
|
|
self.color3 = 255
|
|
self.color4 = 255
|
|
def eat_signedcolor(self, file, offset):
|
|
self.color1, self.color2, self.color3, self.color4 = struct.unpack('>hhhh', file[offset:offset+8])
|
|
return
|
|
def show_signedcolor(self):
|
|
print "\tColor: %d" % self.color1
|
|
print "\tColor: %d" % self.color2
|
|
print "\tColor: %d" % self.color3
|
|
print "\tColor: %d" % self.color4
|
|
return
|
|
def get_length(self):
|
|
templength = 2 + 2 + 2 + 2
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>h', self.color1))
|
|
file.write(struct.pack('>h', self.color2))
|
|
file.write(struct.pack('>h', self.color3))
|
|
file.write(struct.pack('>h', self.color4))
|
|
return
|
|
|
|
class BRLYT_Color:
|
|
def __init__(self):
|
|
self.color1 = 0xFFFFFFFF
|
|
self.color2 = 0xFFFFFFFF
|
|
self.color3 = 0xFFFFFFFF
|
|
self.color4 = 0xFFFFFFFF
|
|
def eat_color(self, file, offset):
|
|
self.color1, self.color2, self.color3, self.color4 = struct.unpack('>IIII', file[offset:offset+16])
|
|
return
|
|
def show_color(self):
|
|
print "\tColor: %08x" % self.color1
|
|
print "\tColor: %08x" % self.color2
|
|
print "\tColor: %08x" % self.color3
|
|
print "\tColor: %08x" % self.color4
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>I', self.color1))
|
|
file.write(struct.pack('>I', self.color2))
|
|
file.write(struct.pack('>I', self.color3))
|
|
file.write(struct.pack('>I', self.color4))
|
|
return
|
|
|
|
class BRLYT_Coordinates:
|
|
def __init__(self):
|
|
self.coord1 = 0.0
|
|
self.coord2 = 0.0
|
|
self.coord3 = 1.0
|
|
self.coord4 = 0.0
|
|
self.coord5 = 0.0
|
|
self.coord6 = 1.0
|
|
self.coord7 = 1.0
|
|
self.coord8 = 1.0
|
|
def eat_coordinates(self, file, offset):
|
|
self.coord1, self.coord2, self.coord3, self.coord4, self.coord5, self.coord6, self.coord7, self.coord8 = struct.unpack('>8f', file[offset:offset+32])
|
|
return
|
|
def show_coordinates(self):
|
|
print "Coordinate: %f , %f" % ( self.coord1 , self.coord2 )
|
|
print "Coordinate: %f , %f" % ( self.coord3 , self.coord4 )
|
|
print "Coordinate: %f , %f" % ( self.coord5 , self.coord6 )
|
|
print "Coordinate: %f , %f" % ( self.coord7 , self.coord8 )
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>f', self.coord1))
|
|
file.write(struct.pack('>f', self.coord2))
|
|
file.write(struct.pack('>f', self.coord3))
|
|
file.write(struct.pack('>f', self.coord4))
|
|
file.write(struct.pack('>f', self.coord5))
|
|
file.write(struct.pack('>f', self.coord6))
|
|
file.write(struct.pack('>f', self.coord7))
|
|
file.write(struct.pack('>f', self.coord8))
|
|
return
|
|
|
|
class BRLYT_Uab:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x05
|
|
self.byte4 = 0x00
|
|
def eat_uab(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_uab(self):
|
|
print "UAb: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Uaa:
|
|
def __init__(self):
|
|
self.byte1 = 0x77
|
|
self.byte2 = 0x00
|
|
self.byte3 = 0x00
|
|
self.byte4 = 0x00
|
|
def eat_uaa(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_uaa(self):
|
|
print "UAa: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Ua9:
|
|
def __init__(self):
|
|
self.byte01 = 0x00
|
|
self.byte02 = 0x00
|
|
self.byte03 = 0x00
|
|
self.byte04 = 0x00
|
|
self.byte05 = 0x00
|
|
self.byte06 = 0x00
|
|
self.byte07 = 0x00
|
|
self.byte08 = 0x00
|
|
self.byte09 = 0x00
|
|
self.byte10 = 0x00
|
|
def eat_ua9(self, file, offset):
|
|
self.byte01, self.byte02, self.byte03, self.byte04, self.byte05, self.byte06, self.byte07, self.byte08, self.byte09, self.byte10 = struct.unpack('>10B', file[offset:offset+10])
|
|
return
|
|
def show_ua9(self):
|
|
print "UA9: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x" % ( self.byte01, self.byte02, self.byte03, self.byte04, self.byte05, self.byte06, self.byte07, self.byte08, self.byte09, self.byte10 )
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte01))
|
|
file.write(struct.pack('>B', self.byte02))
|
|
file.write(struct.pack('>B', self.byte03))
|
|
file.write(struct.pack('>B', self.byte04))
|
|
file.write(struct.pack('>B', self.byte05))
|
|
file.write(struct.pack('>B', self.byte06))
|
|
file.write(struct.pack('>B', self.byte07))
|
|
file.write(struct.pack('>B', self.byte08))
|
|
file.write(struct.pack('>B', self.byte09))
|
|
file.write(struct.pack('>B', self.byte10))
|
|
return
|
|
|
|
class BRLYT_Ua8:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x05
|
|
self.byte4 = 0x00
|
|
def eat_ua8(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_ua8(self):
|
|
print "UA8: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Ua7:
|
|
def __init__(self):
|
|
self.a = 0x00000000
|
|
self.b = 0x00000000
|
|
self.c = 0.0
|
|
self.d = 0.0
|
|
self.e = 0.0
|
|
def eat_ua7(self, file, offset):
|
|
self.a, self.b, self.c, self.d, self.e = struct.unpack('>IIfff', file[offset:offset+20])
|
|
return
|
|
def show_ua7(self):
|
|
print "UA7: %08x %08x %f %f %f" % ( self.a , self.b , self.c , self.d , self.e )
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>I', self.a))
|
|
file.write(struct.pack('>I', self.b))
|
|
file.write(struct.pack('>f', self.c))
|
|
file.write(struct.pack('>f', self.d))
|
|
file.write(struct.pack('>f', self.e))
|
|
return
|
|
|
|
class BRLYT_Ua6:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x05
|
|
self.byte4 = 0x00
|
|
def eat_ua6(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_ua6(self):
|
|
print "UA6: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Ua5:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x05
|
|
self.byte4 = 0x00
|
|
def eat_ua5(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_ua5(self):
|
|
print "UA5: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Ua4:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x05
|
|
self.byte4 = 0x00
|
|
def eat_ua4(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_ua4(self):
|
|
print "UA4: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
return
|
|
|
|
class BRLYT_Ua3:
|
|
def __init__(self):
|
|
self.byte1 = 0x01
|
|
self.byte2 = 0x04
|
|
self.byte3 = 0x1e
|
|
self.byte4 = 0x00
|
|
def eat_ua3(self, file, offset):
|
|
self.byte1, self.byte2, self.byte3, self.byte4 = struct.unpack('BBBB', file[offset:offset+4])
|
|
return
|
|
def show_ua3(self):
|
|
print "UA3: %02x %02x %02x %02x" % ( self.byte1, self.byte2, self.byte3, self.byte4)
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.byte1))
|
|
file.write(struct.pack('>B', self.byte2))
|
|
file.write(struct.pack('>B', self.byte3))
|
|
file.write(struct.pack('>B', self.byte4))
|
|
|
|
class BRLYT_TextureMap:
|
|
def __init__(self):
|
|
self.x1 = 0.0
|
|
self.y1 = 0.0
|
|
self.angle = 0.0
|
|
self.x2 = 1.0
|
|
self.y2 = 1.0
|
|
def eat_texturemap(self, file, offset):
|
|
self.x1, self.y1, self.angle, self.x2, self.y2 = struct.unpack('>fffff', file[offset:offset+20])
|
|
return
|
|
def show_texturemap(self):
|
|
print "Coordinate 1: %f %f" % ( self.x1 , self.y1 )
|
|
print "Angle: %f" % self.angle
|
|
print "Coordinate 2: %f %f" % ( self.x2 , self.y2 )
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>f', self.x1))
|
|
file.write(struct.pack('>f', self.y1))
|
|
file.write(struct.pack('>f', self.angle))
|
|
file.write(struct.pack('>f', self.x2))
|
|
file.write(struct.pack('>f', self.y2))
|
|
return
|
|
|
|
class BRLYT_TexRef:
|
|
def __init__(self):
|
|
self.texture_offset = 0x0000
|
|
self.wrap_s = 0x00
|
|
self.wrap_t = 0x00
|
|
def eat_texref(self, file, offset):
|
|
self.texture_offset, self.wrap_s, self.wrap_t = struct.unpack('>HBB', file[offset:offset+4])
|
|
return
|
|
def show_texref(self):
|
|
print "Texture Offset: %04x" % self.texture_offset
|
|
print "Wrap_S: %02x" % self.wrap_s
|
|
print "Wrap_T: %02x" % self.wrap_t
|
|
return
|
|
def set_texture(self, texture, wrap_s=0, wrap_t=0):
|
|
setl.texture_offset = texture
|
|
self.wrap_s = wrap_s
|
|
self.wrap_s = wrap_t
|
|
def get_length(self):
|
|
templength = 2 + 1 + 1
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>H', self.texture_offset))
|
|
file.write(struct.pack('>B', self.wrap_s))
|
|
file.write(struct.pack('>B', self.wrap_t))
|
|
return
|
|
|
|
class BRLYT_Material:
|
|
def __init__(self):
|
|
self.name = "material00"
|
|
self.forecolor = BRLYT_SignedColor()
|
|
self.backcolor = BRLYT_SignedColor()
|
|
self.unknowncolor = BRLYT_SignedColor()
|
|
self.tevcolor = BRLYT_Color()
|
|
self.flags = 0x00000000
|
|
self.texrefs = { }
|
|
self.texturemaps = { }
|
|
self.ua3s = { }
|
|
self.ua4s = { }
|
|
self.ua5s = { }
|
|
self.ua6s = { }
|
|
self.ua7s = { }
|
|
self.ua8s = { }
|
|
self.ua9s = { }
|
|
self.uaas = { }
|
|
self.uabs = { }
|
|
def eat_material(self, file, offset):
|
|
dummy, self.name = struct.unpack('>I20s', file[offset-4:offset+20])
|
|
self.forecolor.eat_signedcolor(file, offset+20)
|
|
self.backcolor.eat_signedcolor(file, offset+28)
|
|
self.unknowncolor.eat_signedcolor(file, offset+36)
|
|
self.tevcolor.eat_color(file, offset+44)
|
|
dummy, self.flags = struct.unpack('>II', file[offset+60-4:offset+60+4])
|
|
file_offset = offset + 64
|
|
for x in range(bit_extract(self.flags, 28, 31)):
|
|
self.texrefs[x] = BRLYT_TexRef()
|
|
self.texrefs[x].eat_texref(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 24, 27)):
|
|
self.texturemaps[x] = BRLYT_TextureMap()
|
|
self.texturemaps[x].eat_texturemap(file, file_offset)
|
|
file_offset = file_offset + 20
|
|
for x in range(bit_extract(self.flags, 20, 23)):
|
|
self.ua3s[x] = BRLYT_Ua3()
|
|
self.ua3s[x].eat_ua3(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 6)):
|
|
self.ua4s[x] = BRLYT_Ua4()
|
|
self.ua4s[x].eat_ua4(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 4)):
|
|
self.ua5s[x] = BRLYT_Ua5()
|
|
self.ua5s[x].eat_ua5(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 19)):
|
|
self.ua6s[x] = BRLYT_Ua6()
|
|
self.ua6s[x].eat_ua6(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 17, 18)):
|
|
self.ua7s[x] = BRLYT_Ua7()
|
|
self.ua7s[x].eat_ua7(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 14, 16)):
|
|
self.ua8s[x] = BRLYT_Ua8()
|
|
self.ua8s[x].eat_ua8(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 9, 13)):
|
|
self.ua9s[x] = BRLYT_Ua9()
|
|
self.ua9s[x].eat_ua9(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 8)):
|
|
self.uaas[x] = BRLYT_Uaa()
|
|
self.uaas[x].eat_uaa(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
for x in range(bit_extract(self.flags, 7)):
|
|
self.uabs[x] = BRLYT_Uab()
|
|
self.uabs[x].eat_uab(file, file_offset)
|
|
file_offset = file_offset + 4
|
|
return
|
|
def show_material(self):
|
|
print "Name: %s" % self.name.rstrip('\x00')
|
|
print "Forecolor: "
|
|
self.forecolor.show_signedcolor()
|
|
print "Backcolor: "
|
|
self.backcolor.show_signedcolor()
|
|
print "Unknown Color: "
|
|
self.unknowncolor.show_signedcolor()
|
|
print "Tev Color: "
|
|
self.tevcolor.show_color()
|
|
print "Flags: %08x" % self.flags
|
|
for x in range(bit_extract(self.flags, 28, 31)):
|
|
self.texrefs[x].show_texref()
|
|
for x in range(bit_extract(self.flags, 24, 27)):
|
|
self.texturemaps[x].show_texturemap()
|
|
for x in range(bit_extract(self.flags, 20, 23)):
|
|
self.ua3s[x].show_ua3()
|
|
for x in range(bit_extract(self.flags, 6)):
|
|
self.ua4s[x].show_ua4()
|
|
for x in range(bit_extract(self.flags, 4)):
|
|
self.ua5s[x].show_ua5()
|
|
for x in range(bit_extract(self.flags, 19)):
|
|
self.ua6s[x].show_ua6()
|
|
for x in range(bit_extract(self.flags, 17, 18)):
|
|
self.ua7s[x].show_ua7()
|
|
for x in range(bit_extract(self.flags, 14, 16)):
|
|
self.ua8s[x].show_ua8()
|
|
for x in range(bit_extract(self.flags, 9, 13)):
|
|
self.ua9s[x].show_ua9()
|
|
for x in range(bit_extract(self.flags, 8)):
|
|
self.uaas[x].show_uaa()
|
|
for x in range(bit_extract(self.flags, 7)):
|
|
self.uabs[x].show_uab()
|
|
return
|
|
def set_texture(self, texture, wrap_s=0, wrap_t=0):
|
|
self.texrefs[0] = BRLYT_TexRef()
|
|
self.texrefs[0].set_texture(texture, wrap_s, wrap_t)
|
|
def get_length(self):
|
|
templength = 20 + self.forecolor.get_length() + self.backcolor.get_length()
|
|
templength = templength + self.unknowncolor.get_length() + self.tevcolor.get_length() + 4
|
|
for x in range(len(self.texrefs)):
|
|
templength = templength + self.texrefs[x].get_length()
|
|
for x in range(len(self.texturemaps)):
|
|
templength = templength + self.texturemaps[x].get_length()
|
|
for x in range(len(self.ua3s)):
|
|
templength = templength + self.ua3s[x].get_length()
|
|
for x in range(len(self.ua4s)):
|
|
templength = templength + self.ua4s[x].get_length()
|
|
for x in range(len(self.ua5s)):
|
|
templength = templength + self.ua5s[x].get_length()
|
|
for x in range(len(self.ua6s)):
|
|
templength = templength + self.ua6s[x].get_length()
|
|
for x in range(len(self.ua7s)):
|
|
templength = templength + self.ua7s[x].get_length()
|
|
for x in range(len(self.ua8s)):
|
|
templength = templength + self.ua8s[x].get_length()
|
|
for x in range(len(self.ua9s)):
|
|
templength = templength + self.ua9s[x].get_length()
|
|
for x in range(len(self.uaas)):
|
|
templength = templength + self.uaas[x].get_length()
|
|
for x in range(len(self.uabs)):
|
|
templength = templength + self.uabs[x].get_length()
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>20s', self.name))
|
|
self.forecolor.write_to_file(file)
|
|
self.backcolor.write_to_file(file)
|
|
self.unknowncolor.write_to_file(file)
|
|
self.tevcolor.write_to_file(file)
|
|
file.write(struct.pack('>I', self.flags))
|
|
for x in range(bit_extract(self.flags, 28, 31)):
|
|
self.texrefs[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 24, 27)):
|
|
self.texturemaps[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 20, 23)):
|
|
self.ua3s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 6)):
|
|
self.ua4s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 4)):
|
|
self.ua5s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 19)):
|
|
self.ua6s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 17, 18)):
|
|
self.ua7s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 14, 16)):
|
|
self.ua8s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 9, 13)):
|
|
self.ua9s[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 8)):
|
|
self.uaas[x].write_to_file(file)
|
|
for x in range(bit_extract(self.flags, 7)):
|
|
self.uabs[x].write_to_file(file)
|
|
return
|
|
|
|
class BRLYT_Pane:
|
|
def __init__(self):
|
|
self.orientation1 = 0x01
|
|
self.orientation2 = 0x04
|
|
self.alpha1 = 0xff
|
|
self.alpha2 = 0x00
|
|
self.name = "RootPane"
|
|
self.x = 0.0
|
|
self.y = 0.0
|
|
self.z = 0.0
|
|
self.flipx = 0.0
|
|
self.flipy = 0.0
|
|
self.angle = 0.0
|
|
self.xmag = 1.0
|
|
self.ymag = 1.0
|
|
self.width = 608.0
|
|
self.height = 456.0
|
|
def eat_pane(self, file, offset):
|
|
self.orientation1, self.orientation2, self.alpha1, self.alpha2 = struct.unpack('BBBB', file[offset:offset+4])
|
|
self.name, self.x, self.y, self.z = struct.unpack('>24sfff', file[offset+0x04:offset+0x04+36])
|
|
self.flipx, self.flipy, self.angle = struct.unpack('>fff', file[offset+0x28:offset+0x28+12])
|
|
self.xmag, self.ymag = struct.unpack('>ff', file[offset+0x34:offset+0x34+8])
|
|
self.width, self.height = struct.unpack('>ff', file[offset+0x3C:offset+0x3C+8])
|
|
return
|
|
def show_pane(self):
|
|
print "Orientation: %02x %02x" % (self.orientation1 , self.orientation2)
|
|
print "Alpha: %02x %02x" % (self.alpha1 , self.alpha2)
|
|
print "Name: %s" % self.name.rstrip('\x00')
|
|
print "X: %f" % self.x
|
|
print "y: %f" % self.y
|
|
print "z: %f" % self.z
|
|
print "flip x: %f" % self.flipx
|
|
print "flip y: %f" % self.flipy
|
|
print "angle: %f" % self.angle
|
|
print "x zoom: %f" % self.xmag
|
|
print "y zoom: %f" % self.ymag
|
|
print "width: %f" % self.width
|
|
print "height: %f" % self.height
|
|
return
|
|
def get_length(self):
|
|
templength = 1 + 1 + 1 + 1 + 24 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.orientation1))
|
|
file.write(struct.pack('>B', self.orientation2))
|
|
file.write(struct.pack('>B', self.alpha1))
|
|
file.write(struct.pack('>B', self.alpha2))
|
|
file.write(struct.pack('>24s', self.name))
|
|
file.write(struct.pack('>f', self.x))
|
|
file.write(struct.pack('>f', self.y))
|
|
file.write(struct.pack('>f', self.z))
|
|
file.write(struct.pack('>f', self.flipx))
|
|
file.write(struct.pack('>f', self.flipy))
|
|
file.write(struct.pack('>f', self.angle))
|
|
file.write(struct.pack('>f', self.xmag))
|
|
file.write(struct.pack('>f', self.ymag))
|
|
file.write(struct.pack('>f', self.width))
|
|
file.write(struct.pack('>f', self.height))
|
|
return
|
|
|
|
class BRLYT_gre1:
|
|
def __init__(self):
|
|
self.magic = "gre1"
|
|
self.length = 0x08
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
return
|
|
|
|
class BRLYT_grs1:
|
|
def __init__(self):
|
|
self.magic = "grs1"
|
|
self.length = 0x08
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
return
|
|
|
|
class BRLYT_grp1:
|
|
def __init__(self):
|
|
self.magic = "grp1"
|
|
self.length = 0x00000000
|
|
self.name = "RootGroup"
|
|
self.numsubs = 0x0000
|
|
self.unknown = 0x0000
|
|
self.subs = []
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.name, self.numsubs, self.unknown = struct.unpack('>16sHH', file[offset+0x08:offset+0x08+20])
|
|
for x in range(self.numsubs):
|
|
dummy, subname = struct.unpack('>I16s', file[offset+0x1C+16*x-4:offset+0x1C+16*x+16])
|
|
self.subs.append(subname)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
print "Name: %s" % self.name.rstrip('\x00')
|
|
print "Number of Subs: %04x" % self.numsubs
|
|
print "Unknown: %04x" % self.unknown
|
|
for x in self.subs:
|
|
print "Sub: %s" % x.rstrip('\x00')
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4 + 16 + 2 + 2 + self.numsubs * 16
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
file.write(struct.pack('>16s', self.name))
|
|
file.write(struct.pack('>H', self.numsubs))
|
|
file.write(struct.pack('>H', self.unknown))
|
|
for x in self.subs:
|
|
file.write(struct.pack('>16s', x))
|
|
return
|
|
|
|
class BRLYT_txt1:
|
|
def __init__(self):
|
|
self.magic = "txt1"
|
|
self.pane = BRLYT_Pane()
|
|
len1 = 0x0000
|
|
len2 = 0x0000
|
|
mat_off = 0x0000
|
|
font = 0x0000
|
|
unknown = 0x00
|
|
padding1 = 0
|
|
padding2 = 0
|
|
padding3 = 0
|
|
name_offs = 0x00000000
|
|
color1 = 0xFFFFFFFF
|
|
color2 = 0x00000000
|
|
font_size_x = 32.0
|
|
font_size_y = 32.0
|
|
char_space = 32.0
|
|
line_space = 32.0
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.pane.eat_pane(file, offset+8)
|
|
self.len1, self.len2, self.mat_off, self.font = struct.unpack('>HHHH', file[offset+0x08:offset+0x08+8])
|
|
self.unknown, self.padding1, self.padding2, self.padding3 = struct.unpack('>BBBB', file[offset+0x10:offset+0x10+4])
|
|
self.name_offs, self.color1, self.color2 = struct.unpack('>III', file[offset+0x14:offset+0x14+12])
|
|
self.font_size_x, self.font_size_y = struct.unpack('>ff', file[offset+0x20:offset+0x20+8])
|
|
self.char_space, self.line_space = struct.unpack('>ff', file[offset+0x28:offset+0x28+8])
|
|
text = file[offset+0x30:offset+0x30+self.len2]
|
|
self.text = unicode(text, 'utf_16_be').rstrip('\x00')
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.pane.show_pane()
|
|
print "Length: %04x %04x" % ( self.len1 , self.len2 )
|
|
print "Material: %04x" % self.mat_off
|
|
print "Font: %04x" % self.font
|
|
print "Unknown: %02x" % self.unknown
|
|
print "Padding: %02x %02x %02x" % ( self.padding1 , self.padding2 , self.padding3 )
|
|
print "Name offset: %08x" % self.name_offs
|
|
print "Color1: %08x" % self.color1
|
|
print "Color2: %08x" % self.color2
|
|
print "Font Size X: %f" % self.font_size_x
|
|
print "Font Size Y: %f" % self.font_size_y
|
|
print "Character Spacing: %f" % self.char_space
|
|
print "Line Spacing: %f" % self.line_space
|
|
print "Text: ", self.text # N E E D S S O M E W O R K
|
|
return
|
|
def get_text_length(self):
|
|
return len(self.text)
|
|
def get_length(self):
|
|
templength = 4 + 4 + self.pane.get_length()
|
|
templength = templength + 2 + 2 + 2 + 2 + 1 + 1 + 1 + 1
|
|
templength = templength + 4 + 4 + 4 + 4 + 4 + 4 + 4
|
|
templength = templength + self.get_text_length()
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.pane.write_to_file(file)
|
|
file.write(struct.pack('>H', self.len1))
|
|
file.write(struct.pack('>H', self.len2))
|
|
file.write(struct.pack('>H', self.mat_off))
|
|
file.write(struct.pack('>H', self.font))
|
|
file.write(struct.pack('>B', self.unknown))
|
|
file.write(struct.pack('>B', self.padding1))
|
|
file.write(struct.pack('>B', self.padding2))
|
|
file.write(struct.pack('>B', self.padding3))
|
|
file.write(struct.pack('>I', self.name_offs))
|
|
file.write(struct.pack('>I', self.color1))
|
|
file.write(struct.pack('>I', self.color2))
|
|
file.write(struct.pack('>f', self.font_size_x))
|
|
file.write(struct.pack('>f', self.font_size_y))
|
|
file.write(struct.pack('>f', self.char_space))
|
|
file.write(struct.pack('>f', self.line_space))
|
|
text = untv(unicode(self.text).encode('utf_16_be'))
|
|
file.write(text)
|
|
return
|
|
|
|
class BRLYT_pic1:
|
|
def __init__(self):
|
|
self.magic = "pic1"
|
|
self.length = 0x0000000
|
|
self.pane = BRLYT_Pane()
|
|
self.vtx_color1 = 0xFFFFFFFF
|
|
self.vtx_color2 = 0xFFFFFFFF
|
|
self.vtx_color3 = 0xFFFFFFFF
|
|
self.vtx_color4 = 0xFFFFFFFF
|
|
self.mat_off = 0x0000
|
|
self.num_coordinates = 0x01
|
|
self.padding = 0x00
|
|
self.coordinates = { }
|
|
self.coordinates[0] = BRLYT_Coordinates()
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.pane.eat_pane(file, offset+8)
|
|
self.vtx_color1, self.vtx_color2, self.vtx_color3, self.vtx_color4 = struct.unpack('>IIII', file[offset+0x4C:offset+0x4C+16])
|
|
self.mat_off, self.num_coordinates, self.padding = struct.unpack('>HBB', file[offset+0x5C:offset+0x5C+4])
|
|
for x in range(self.num_coordinates):
|
|
self.coordinates[x] = BRLYT_Coordinates()
|
|
self.coordinates[x].eat_coordinates(file, offset+0x60+x*32)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.pane.show_pane()
|
|
print "Vertex Colors: %08x %08x %08x %08x" % (self.vtx_color1, self.vtx_color2, self.vtx_color3, self.vtx_color4)
|
|
print "Material Offset: %04x" % self.mat_off
|
|
print "Number of Coordinates: %02x" % self.num_coordinates
|
|
print "Padding: %02x" % self.padding
|
|
for x in range(len(self.coordinates)):
|
|
self.coordinates[x].show_coordinates()
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + self.pane.get_length()
|
|
templength = templength + 4 + 4 + 4 + 2 + 1 + 1
|
|
for x in range(len(self.coordinates)):
|
|
templength = templength + self.coordinates[x].get_length()
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.pane.write_to_file(file)
|
|
file.write(struct.pack('>I', self.vtx_color1))
|
|
file.write(struct.pack('>I', self.vtx_color2))
|
|
file.write(struct.pack('>I', self.vtx_color3))
|
|
file.write(struct.pack('>I', self.vtx_color4))
|
|
file.write(struct.pack('>H', self.mat_off))
|
|
file.write(struct.pack('>B', self.num_coordinates))
|
|
file.write(struct.pack('>B', self.padding))
|
|
for x in range(len(self.coordinates)):
|
|
self.coordinates[x].write_to_file(file)
|
|
return
|
|
|
|
class BRLYT_WindowAddon3:
|
|
def __init__(self):
|
|
self.unknown1 = 0x0000
|
|
self.unknown2 = 0x0000
|
|
def eat_windowaddon3(self, file, offset):
|
|
self.unknown1, self.unknown2 = struct.unpack('>HH', file[offset:offset+4])
|
|
return
|
|
def show_windowaddon3(self):
|
|
print "Unknown: %04x %04x" % ( self.unknown1 , self.unknown2 )
|
|
return
|
|
def get_length(self):
|
|
templength = 2 + 2
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>H', self.unknown1))
|
|
file.write(struct.pack('>H', self.unknown2))
|
|
return
|
|
|
|
class BRLYT_WindowAddon2:
|
|
def __init__(self):
|
|
self.unknown1 = 0x00000000
|
|
self.unknown2 = 0x00000000
|
|
self.unknown3 = 0x00000000
|
|
self.unknown4 = 0x00000000
|
|
def eat_windowaddon2(self, file, offset):
|
|
self.unknown1, self.unknown2, self.unknown3, self.unknown4 = struct.unpack('>IIII', file[offset:offset+16])
|
|
return
|
|
def show_windowaddon2(self):
|
|
print "Unknown: %08x %08x %08x %08x" % ( self.unknown1, self.unknown2, self.unknown3, self.unknown4 )
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>I', self.unknown1))
|
|
file.write(struct.pack('>I', self.unknown2))
|
|
file.write(struct.pack('>I', self.unknown3))
|
|
file.write(struct.pack('>I', self.unknown4))
|
|
return
|
|
|
|
class BRLYT_WindowAddon1:
|
|
def __init__(self):
|
|
self.unknown1 = 0.0
|
|
self.unknown2 = 0.0
|
|
self.unknown3 = 0.0
|
|
self.unknown4 = 0.0
|
|
self.count = 0x01
|
|
self.padding1 = 0x00
|
|
self.padding2 = 0x00
|
|
self.padding3 = 0x00
|
|
self.offset1 = 0x00000068
|
|
self.offset2 = 0x0000007C
|
|
def eat_windowaddon1(self, file, offset):
|
|
self.unknown1, self.unknown2, self.unknown3, self.unknown4 = struct.unpack('>ffff', file[offset:offset+16])
|
|
self.count, self.padding1, self.padding2, self.padding3 = struct.unpack('>BBBB', file[offset+0x10:offset+0x10+4])
|
|
self.offset1, self.offset2 = struct.unpack('>II', file[offset+0x14:offset+0x14+8])
|
|
return
|
|
def show_windowaddon1(self):
|
|
print "Unknown: %f %f %f %f" % ( self.unknown1, self.unknown2, self.unknown3, self.unknown4 )
|
|
print "Count: %02x" % self.count
|
|
print "Padding %02x %02x %02x" % ( self.padding1, self.padding2, self.padding3 )
|
|
print "Offset 1: %08x" % self.offset1
|
|
print "Offset 2: %08x" % self.offset2
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + 4 + 1 + 1 + 1 + 1 + 4 + 4
|
|
return templength
|
|
def write_to_file(self, file):
|
|
file.write(struct.pack('>B', self.count))
|
|
file.write(struct.pack('>B', self.padding1))
|
|
file.write(struct.pack('>B', self.padding2))
|
|
file.write(struct.pack('>B', self.padding3))
|
|
file.write(struct.pack('>I', self.offset1))
|
|
file.write(struct.pack('>I', self.offset2))
|
|
return
|
|
|
|
class BRLYT_wnd1:
|
|
def __init__(self):
|
|
self.magic = "wnd1"
|
|
self.pane = BRLYT_Pane()
|
|
self.addon1 = BRLYT_WindowAddon1()
|
|
self.addon2 = BRLYT_WindowAddon2()
|
|
self.addon3 = BRLYT_WindowAddon3()
|
|
self.offsets = []
|
|
self.materials = []
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.pane.eat_pane(file, offset+8)
|
|
self.addon1.eat_windowaddon1(file, offset+0x4c)
|
|
self.addon2.eat_windowaddon2(file, offset+0x4c+28)
|
|
self.addon3.eat_windowaddon3(file, offset+0x4c+44)
|
|
if self.addon1.offset1 == 0x9c:
|
|
self.addon4 = BRLYT_Coordinates()
|
|
self.addon4.eat_coordinates(file, offset+0x4c+48)
|
|
for x in range(self.addon1.count):
|
|
dummy, offs = struct.unpack('>II', file[offset+0x4c+48+32-4:offset+0x4c+48+32+4])
|
|
self.offsets.append(offs)
|
|
for x in range(self.addon1.count):
|
|
dummy, mat = struct.unpack('>II', file[offset+0x4c+48+32+self.addon1.count*4-4:offset+0x4c+48+32+self.addon1.count*4+4])
|
|
self.materials.append(mat)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.pane.show_pane()
|
|
self.addon1.show_windowaddon1()
|
|
self.addon2.show_windowaddon2()
|
|
self.addon3.show_windowaddon3()
|
|
if self.addon1.offset1 == 0x9c:
|
|
self.addon4.show_coordinates()
|
|
for x in range(self.addon1.count):
|
|
print "Offset: %08x" % self.offsets[x]
|
|
print "Material: %08x" % self.materials[x]
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + self.addon1.get_length() + self.addon2.get_length() + self.addon3.get_length()
|
|
if self.addon1.offset1 == 0x9c:
|
|
templength = templength + self.addon4.get_length()
|
|
templength = templength + self.addon1.count * 8
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.pane.write_to_file(file)
|
|
self.addon1.write_to_file(file)
|
|
self.addon2.write_to_file(file)
|
|
self.addon3.write_to_file(file)
|
|
if self.addon1.offset1 == 0x9c:
|
|
self.addon4.write_to_file(file)
|
|
tempOffset = self.addon1.count * 4
|
|
for x in range(self.addon1.count):
|
|
file.write(struct.pack('>I', tempOffset))
|
|
self.offsets[x] = tempOffset
|
|
for x in self.materials:
|
|
file.write(struct.pack('>I', x))
|
|
return
|
|
|
|
class BRLYT_bnd1:
|
|
def __init__(self):
|
|
self.magic = "bnd1"
|
|
self.pane = BRLYT_Pane()
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.pane.eat_pane(file, offset+8)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.pane.show_pane()
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4 + self.pane.get_length()
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.pane.write_to_file(file)
|
|
return
|
|
|
|
class BRLYT_pae1:
|
|
def __init__(self):
|
|
self.magic = "pae1"
|
|
self.length = 0x08
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
return
|
|
|
|
class BRLYT_pas1:
|
|
def __init__(self):
|
|
self.magic = "pas1"
|
|
self.length = 0x08
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
return
|
|
|
|
class BRLYT_pan1:
|
|
def __init__(self):
|
|
self.magic = "pan1"
|
|
self.pane = BRLYT_Pane()
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.pane.eat_pane(file, offset+8)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.pane.show_pane()
|
|
return
|
|
def get_length(self):
|
|
self.length = 4 + 4 + self.pane.get_length()
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.pane.write_to_file(file)
|
|
return
|
|
|
|
class BRLYT_mat1:
|
|
def __init__(self):
|
|
self.magic = "mat1"
|
|
self.numoffs = BRLYT_Numoffs()
|
|
self.offsets = []
|
|
self.materials = { }
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.numoffs.eat_numoffs(file, offset+8)
|
|
for x in range(self.numoffs.number):
|
|
dummy, offs = struct.unpack('>II', file[offset+0x0C+4*x-4:offset+0x0C+4*x+4])
|
|
self.offsets.append(offs)
|
|
self.materials[x] = BRLYT_Material()
|
|
self.materials[x].eat_material(file, offset+self.offsets[x])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.numoffs.show_numoffs()
|
|
for x in range(self.numoffs.number):
|
|
print "Offsets[%d]: %08x" % ( x , self.offsets[x] )
|
|
self.materials[x].show_material()
|
|
return
|
|
def add_material(self, material, texture):
|
|
self.materials[self.numoffs.number] = BRLYT_Material()
|
|
self.numoffs.add()
|
|
self.materials[self.numoffs.number].name = material
|
|
self.materials[self.numoffs.number].set_texture(texture)
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + self.numoffs.number * 4
|
|
for x in range(self.numoffs.number):
|
|
templength = templength + self.materials[x].get_length()
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.numoffs.write_to_file(file)
|
|
tempOffset = self.numoffs.number * 4
|
|
for x in range(self.numoffs.number):
|
|
file.write(struct.pack('>I', tempOffset))
|
|
#self.offsets[x] = tempOffset
|
|
tempOffset = tempOffset + self.materials[x].get_length()
|
|
for x in range(len(self.materials)):
|
|
self.materials[x].write_to_file(file)
|
|
return
|
|
|
|
class BRLYT_fnl1:
|
|
def __init__(self):
|
|
self.magic = "fnl1"
|
|
self.numoffs = BRLYT_Numoffs()
|
|
self.offsets = []
|
|
self.fonts = []
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.numoffs.eat_numoffs(file, offset+8)
|
|
for x in range(self.numoffs.number):
|
|
''' Grab font name '''
|
|
offs, unknown = struct.unpack('>II', file[offset+8+4+x*8:offset+8+4+x*8+8])
|
|
self.offsets.append(offs)
|
|
font = nullterm(file[offset+12+self.offsets[x]:])
|
|
self.fonts.append(font)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.numoffs.show_numoffs()
|
|
for x in range(len(self.fonts)):
|
|
print "Font: %s offset: %08x" % ( self.fonts[x] , self.offsets[x] )
|
|
return
|
|
def add_font(self, font):
|
|
self.fonts.append(font)
|
|
self.numoffs.add()
|
|
if len(self.fonts) > 1:
|
|
self.offsets.append(self.offsets[-1] + len(self.textures[-2]) + 1)
|
|
else:
|
|
self.offsets.appen(4)
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + self.numoffs.number * 8
|
|
for x in self.fonts:
|
|
templength = templength + len(x) + 1
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.numoffs.write_to_file(file)
|
|
tempOffset = self.numoffs.number * 4
|
|
for x in range(len(self.offsets)):
|
|
file.write(struct.pack('>I', tempOffset))
|
|
self.offsets[x] = tempOffset
|
|
tempOffset = tempOffset + len(self.fonts[x]) + 1
|
|
for x in self.fonts:
|
|
file.write(x)
|
|
file.write(struct.pack('s', '\x00'))
|
|
return
|
|
|
|
class BRLYT_txl1:
|
|
def __init__(self):
|
|
self.magic = "txl1"
|
|
self.numoffs = BRLYT_Numoffs()
|
|
self.offsets = []
|
|
self.textures = []
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.numoffs.eat_numoffs(file, offset+8)
|
|
for x in range(self.numoffs.number):
|
|
''' Grab texture name '''
|
|
offs, unknown = struct.unpack('>II', file[offset+8+4+x*8:offset+8+4+x*8+8])
|
|
self.offsets.append(offs)
|
|
texture = nullterm(file[offset+12+self.offsets[x]:])
|
|
self.textures.append(texture)
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
self.numoffs.show_numoffs()
|
|
for x in range(len(self.textures)):
|
|
print "Texture: %s offset: %08x" % ( self.textures[x] , self.offsets[x] )
|
|
return
|
|
def add_texture(self, texture):
|
|
self.textures.append(texture)
|
|
self.numoffs.add()
|
|
if len(self.textures) > 1:
|
|
self.offsets.append(self.offsets[-1] + len(self.textures[-2]) + 1)
|
|
else:
|
|
self.offsets.append(4)
|
|
return
|
|
def get_length(self):
|
|
templength = 4 + 4 + 4 + self.numoffs.number * 8
|
|
for x in self.textures:
|
|
templength = templength + len(x) + 1
|
|
self.length = templength
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
self.numoffs.write_to_file(file)
|
|
tempOffset = self.numoffs.number * 4
|
|
for x in range(len(self.offsets)):
|
|
file.write(struct.pack('>I', tempOffset))
|
|
self.offsets[x] = tempOffset
|
|
tempOffset = tempOffset + len(self.textures[x]) + 1
|
|
for x in self.textures:
|
|
file.write(x)
|
|
file.write(struct.pack('s', "\0"))
|
|
return
|
|
|
|
class BRLYT_lyt1:
|
|
def __init__(self):
|
|
self.magic = "lyt1"
|
|
self.length = 0x14
|
|
self.a = 1
|
|
self.pad1 = 0
|
|
self.pad2 = 0
|
|
self.pad3 = 0
|
|
self.width = 608.0
|
|
self.height = 456.0
|
|
def eat_tag(self, file, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', file[offset:offset+8])
|
|
self.a, self.pad1, self.pad2, self.pad3 = struct.unpack('>4B', file[offset+0x08:offset+0x08+4])
|
|
self.width, self.height = struct.unpack('>ff', file[offset+0x0C:offset+0x0C+8])
|
|
return
|
|
def show_tag(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
print "a: %02x" % self.a
|
|
print "width: %f" % self.width
|
|
print "height: %f" % self.height
|
|
return
|
|
def get_texoffset(self, texture):
|
|
texoffset = -1
|
|
for x in range(len(self.textures)):
|
|
if self.textures[x] == texture:
|
|
texoffset = x - 1
|
|
return texoffset
|
|
def get_length(self):
|
|
self.length = 4 + 4 + 1 + 1 + 1 + 1 + 4 + 4
|
|
return self.length
|
|
def write_to_file(self, file):
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.length))
|
|
file.write(struct.pack('>B', self.a))
|
|
file.write(struct.pack('>B', self.pad1))
|
|
file.write(struct.pack('>B', self.pad2))
|
|
file.write(struct.pack('>B', self.pad3))
|
|
file.write(struct.pack('>f', self.width))
|
|
file.write(struct.pack('>f', self.width))
|
|
return
|
|
|
|
class BRLYT_Header:
|
|
def __init__(self):
|
|
self.data = []
|
|
def eat_header(self, buffer, offset):
|
|
self.magic, self.length = struct.unpack('>4sI', buffer[offset:offset+8])
|
|
return
|
|
def show_header(self, offset):
|
|
print "Offset: %08x" % offset
|
|
print "Magic: %s" % self.magic
|
|
print "Length: %08x" % self.length
|
|
return
|
|
|
|
class BRLYT:
|
|
def __init__(self):
|
|
self.tags_filled = 0
|
|
self.data = []
|
|
self.magic = "RLYT"
|
|
self.version = 0xfeff0101
|
|
self.offset = 0x10
|
|
self.chunks = 0x0000
|
|
self.tags = { }
|
|
def grab_brlyt(self, file):
|
|
for x in file:
|
|
self.data.append(x)
|
|
return
|
|
def eat_brlyt(self, file):
|
|
file_offset = 0
|
|
self.magic, self.version = struct.unpack('>4sI', file[0x00:0x08])
|
|
self.length, self.offset, self.count = struct.unpack('>IHH', file[0x08:0x10])
|
|
file_offset = 0x10
|
|
tempHeader = BRLYT_Header()
|
|
for x in range(self.count):
|
|
tempHeader.eat_header(file, file_offset)
|
|
''' DO BIG CASE IF FOR TYPE '''
|
|
if tempHeader.magic == "lyt1":
|
|
self.tags[x] = BRLYT_lyt1()
|
|
elif tempHeader.magic == "txl1":
|
|
self.tags[x] = BRLYT_txl1()
|
|
elif tempHeader.magic == "fnl1":
|
|
self.tags[x] = BRLYT_fnl1()
|
|
elif tempHeader.magic == "mat1":
|
|
self.tags[x] = BRLYT_mat1()
|
|
elif tempHeader.magic == "pan1":
|
|
self.tags[x] = BRLYT_pan1()
|
|
elif tempHeader.magic == "pas1":
|
|
self.tags[x] = BRLYT_pas1()
|
|
elif tempHeader.magic == "pae1":
|
|
self.tags[x] = BRLYT_pae1()
|
|
elif tempHeader.magic == "wnd1":
|
|
self.tags[x] = BRLYT_wnd1()
|
|
elif tempHeader.magic == "bnd1":
|
|
self.tags[x] = BRLYT_bnd1()
|
|
elif tempHeader.magic == "pic1":
|
|
self.tags[x] = BRLYT_pic1()
|
|
elif tempHeader.magic == "txt1":
|
|
self.tags[x] = BRLYT_txt1()
|
|
elif tempHeader.magic == "grp1":
|
|
self.tags[x] = BRLYT_grp1()
|
|
elif tempHeader.magic == "grs1":
|
|
self.tags[x] = BRLYT_grs1()
|
|
elif tempHeader.magic == "gre1":
|
|
self.tags[x] = BRLYT_gre1()
|
|
else:
|
|
print "BAD TAG"
|
|
break
|
|
self.tags[x].eat_tag(file, file_offset)
|
|
file_offset = file_offset + self.tags[x].length
|
|
self.tags_filled = self.chunks
|
|
return
|
|
def get_texoffset(self, texture):
|
|
texoffset = self.tags[1].get_texoffset(texture)
|
|
return texofffset
|
|
def add_material(self, material, texture):
|
|
texoffset = self.get_texoffset(texture)
|
|
if texoffset == -1:
|
|
print "texture not found in txl1"
|
|
return
|
|
for x in range(self.tags_filled):
|
|
if isinstance(self.tags[x], BRLYT_mat1):
|
|
self.tags[x].add_material(material, texoffset)
|
|
return
|
|
def add_grp1(self):
|
|
self.tags[self.tags_filled] = BRLYT_grp1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_txt1(self):
|
|
self.tags[self.tags_filled] = BRLYT_txt1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_pic1(self):
|
|
self.tags[self.tags_filled] = BRLYT_pic1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_pae1(self):
|
|
self.tags[self.tags_filled] = BRLYT_pae1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_pas1(self):
|
|
self.tags[self.tags_filled] = BRLYT_pas1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_pan1(self):
|
|
self.tags[self.tags_filled] = BRLYT_pan1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_mat1(self):
|
|
self.tags[self.tags_filled] = BRLYT_mat1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
def add_txl1(self):
|
|
self.tags[self.tags_filled] = BRLYT_txl1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
return
|
|
def add_lyt1(self):
|
|
self.tags[self.tags_filled] = BRLYT_lyt1()
|
|
self.tags_filled = self.tags_filled + 1
|
|
return
|
|
def add_texture(self, texture):
|
|
self.tags[1].add_texture(texture)
|
|
return
|
|
def add_font(self, font):
|
|
self.tags[2].add_font(font)
|
|
return
|
|
def write_brlyt(self, filename):
|
|
templength = 4 + 4 + 4 + 2 + 2
|
|
for x in range(self.tags_filled):
|
|
templength = templength + self.tags[x].get_length()
|
|
self.length = templength
|
|
file = open(filename, 'wb')
|
|
if file:
|
|
file.write(self.magic)
|
|
file.write(struct.pack('>I', self.version))
|
|
file.write(struct.pack('>I', self.length))
|
|
file.write(struct.pack('>H', self.offset))
|
|
file.write(struct.pack('>H', self.chunks))
|
|
for x in range(len(self.tags)):
|
|
self.tags[x].write_to_file(file)
|
|
file.close()
|
|
else:
|
|
print "could not open file for write"
|
|
return
|
|
def show_brlyt(self):
|
|
print "Magic: %s" % self.magic
|
|
print "Version: %08x" % self.version
|
|
print "File size: %08x" % self.length
|
|
print "Header size: %04x" % self.offset
|
|
print "Chunk count: %04x" % self.count
|
|
for x in range(len(self.tags)):
|
|
self.tags[x].show_tag()
|
|
print
|
|
return
|
|
|
|
if len(sys.argv) != 2:
|
|
print 'Usage: python brlyt.py <filename>'
|
|
sys.exit(1)
|
|
|
|
f = open(sys.argv[1], 'rb')
|
|
if f:
|
|
rlyt = f.read()
|
|
f.close()
|
|
else:
|
|
print "could not open file"
|
|
|
|
brlyt = BRLYT()
|
|
brlyt.eat_brlyt(rlyt)
|
|
brlyt.show_brlyt()
|
|
brlyt.write_brlyt("testout.brlyt")
|
|
|
|
''' TEST FOR WRITING A BRLYT FROM SCRATCH ''' '''
|
|
brlyt2 = BRLYT()
|
|
brlyt2.add_lyt1()
|
|
brlyt2.add_txl1()
|
|
brlyt2.add_texture("texture1.tpl")
|
|
brlyt2.add_mat1()
|
|
brlyt2.add_material("material1", "texture1.tpl")
|
|
brlyt2.add_pan1()
|
|
brlyt2.add_pas1()
|
|
brlyt2.add_pic1()
|
|
brlyt2.add_pae1()
|
|
brlyt2.add_grp1()
|
|
brlyt2.write_brlyt("testout.brlyt")
|
|
''' '''END TEST FOR BRLYT WRITING '''
|