aboutsummaryrefslogtreecommitdiff
path: root/creditcards/Alameda.py
diff options
context:
space:
mode:
Diffstat (limited to 'creditcards/Alameda.py')
-rw-r--r--creditcards/Alameda.py975
1 files changed, 975 insertions, 0 deletions
diff --git a/creditcards/Alameda.py b/creditcards/Alameda.py
new file mode 100644
index 0000000..1c8db69
--- /dev/null
+++ b/creditcards/Alameda.py
@@ -0,0 +1,975 @@
+from pyglet import clock, window
+from pyglet.gl import *
+from pyglet.image import *
+
+
+import sys
+sys.path.append('../Common')
+from Struct import Struct
+import pywii as wii
+
+def LZ77Decompress(data):
+ inp = 0
+ dlen = len(data)
+ data += '\0' * 16
+
+ ret = []
+
+ while inp < dlen:
+ bitmask = ord(data[inp])
+ inp += 1
+
+ for i in xrange(8):
+ if bitmask & 0x80:
+ rep = ord(data[inp])
+ repLength = (rep >> 4) + 3
+ inp += 1
+ repOff = ord(data[inp]) | ((rep & 0x0F) << 8)
+ inp += 1
+
+ assert repOff <= len(ret)
+
+ while repLength > 0:
+ ret.append(ret[-repOff - 1])
+ repLength -= 1
+ else:
+ ret.append(data[inp])
+ inp += 1
+
+ bitmask <<= 1
+
+ return ''.join(ret)
+
+class U8(object):
+ class U8Header(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Tag = Struct.string(4)
+ self.RootNode = Struct.uint32
+ self.HeaderSize = Struct.uint32
+ self.DataOffset = Struct.uint32
+ self.Zeroes = Struct.uint8[0x10]
+
+ class U8Node(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Type = Struct.uint16
+ self.NameOffset = Struct.uint16
+ self.DataOffset = Struct.uint32
+ self.Size = Struct.uint32
+
+ def __init__(self, data=None):
+ self.Files = {}
+
+ if data != None:
+ self.Unpack(data)
+
+ def Unpack(self, data):
+ pos = 0
+ u8 = self.U8Header()
+ u8.unpack(data[pos:pos+len(u8)])
+ pos += len(u8)
+
+ assert u8.Tag == 'U\xAA8-'
+ pos += u8.RootNode - 0x20
+
+ root = self.U8Node()
+ root.unpack(data[pos:pos+len(root)])
+ pos += len(root)
+
+ children = []
+ for i in xrange(root.Size - 1):
+ child = self.U8Node()
+ child.unpack(data[pos:pos+len(child)])
+ pos += len(child)
+ children.append(child)
+
+ stringTable = data[pos:pos + u8.DataOffset - len(u8) - root.Size * len(root)]
+ pos += len(stringTable)
+
+ currentOffset = u8.DataOffset
+
+ path = ['.']
+ pathDepth = [root.Size - 1]
+ for offset,child in enumerate(children):
+ name = stringTable[child.NameOffset:].split('\0', 1)[0]
+ if child.Type == 0x0100:
+ path.append(name)
+ pathDepth.append(child.Size-offset-1)
+ elif child.Type == 0:
+ name = '/'.join(path + [name])
+
+ if currentOffset < child.DataOffset:
+ diff = child.DataOffset - currentOffset
+ assert diff <= 32
+
+ pos += diff
+ currentOffset += diff
+
+ currentOffset += child.Size
+
+ self.Files[name] = data[pos:pos+child.Size]
+ pos += child.Size
+
+ pathDepth[-1] -= 1
+ if pathDepth[-1] == 0:
+ path = path[:-1]
+ pathDepth = pathDepth[:-1]
+
+class IMD5Header(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Tag = Struct.string(4)
+ self.Size = Struct.uint32
+ self.Zeroes = Struct.uint8[8]
+ self.MD5 = Struct.uint8[0x10]
+
+def IMD5(data):
+ imd5 = IMD5Header()
+ imd5.unpack(data[:len(imd5)])
+ assert imd5.Tag == 'IMD5'
+ pos = len(imd5)
+
+ if data[pos:pos+4] == 'LZ77':
+ return LZ77Decompress(data[pos+8:])
+ else:
+ return data[pos:]
+
+class TPL(object):
+ class TPLHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Magic = Struct.string(4)
+ self.Count = Struct.uint32
+ self.Size = Struct.uint32
+
+ class TexOffsets(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.HeaderOff = Struct.uint32
+ self.PaletteOff = Struct.uint32
+
+ class TexHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Size = Struct.uint16[2]
+ self.Format = Struct.uint32
+ self.DataOff = Struct.uint32
+ self.Wrap = Struct.uint32[2]
+ self.Filter = Struct.uint32[2]
+ self.LODBias = Struct.float
+ self.EdgeLOD = Struct.uint8
+ self.LOD = Struct.uint8[2]
+ self.Unpacked = Struct.uint8
+
+ class PalHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Count = Struct.uint16
+ self.Unpacked = Struct.uint8
+ self.Pad = Struct.uint8
+ self.Format = Struct.uint32
+ self.DataOff = Struct.uint32
+
+ def __init__(self, data=None):
+ self.Textures = []
+
+ if data != None:
+ self.Unpack(data)
+
+ def Unpack(self, data):
+ header = self.TPLHeader()
+ header.unpack(data[:len(header)])
+ pos = len(header)
+
+ assert header.Magic == '\x00\x20\xAF\x30'
+ assert header.Size == 0xc
+
+ for i in xrange(header.Count):
+ offs = self.TexOffsets()
+ offs.unpack(data[pos:pos+len(offs)])
+ pos += len(offs)
+
+ self.Textures.append(self.ParseTexture(data, offs))
+
+ def ParseTexture(self, data, offs):
+ texHeader = self.TexHeader()
+ texHeader.unpack(data[offs.HeaderOff:offs.HeaderOff+len(texHeader)])
+ format = texHeader.Format
+ self.format = format
+ rgba = None
+ if format == 0:
+ rgba = self.I4(data[texHeader.DataOff:], texHeader.Size)
+ elif format == 1:
+ rgba = self.I8(data[texHeader.DataOff:], texHeader.Size)
+ elif format == 2:
+ rgba = self.IA4(data[texHeader.DataOff:], texHeader.Size)
+ elif format == 4:
+ rgba = self.RGB565(data[texHeader.DataOff:], texHeader.Size)
+ elif format == 5:
+ rgba = self.RGB5A3(data[texHeader.DataOff:], texHeader.Size)
+ elif format == 14:
+ rgba = self.S3TC(data[texHeader.DataOff:], texHeader.Size)
+ else:
+ print 'Unknown texture format', format
+
+ if rgba == None:
+ rgba = '\0\0\0\0' * texHeader.Size[0] * texHeader.Size[1]
+
+ image = ImageData(texHeader.Size[1], texHeader.Size[0], 'RGBA', rgba)
+ print format
+ return image
+
+ def I4(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ outp = 0
+ inp = 0
+ for i in xrange(0, y, 8):
+ for j in xrange(0, x, 8):
+ ofs = 0
+ for k in xrange(8):
+ off = min(x - j, 8)
+ for sub in xrange(0, off, 2):
+ texel = ord(data[inp])
+ high, low = texel >> 4, texel & 0xF
+ out[outp + ofs + sub] = (high << 4) | (high << 20) | (high << 12) | 0xFF<<24
+
+ if sub + 1 < off:
+ out[outp + ofs + sub + 1] = (low << 4) | (low << 20) | (low << 12) | 0xFF<<24
+
+ inp += 1
+
+ ofs += x
+ inp += (8 - off) / 2
+ outp += off
+ outp += x * 7
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+ def I8(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ outp = 0
+ inp = 0
+ for i in xrange(0, y, 4):
+ for j in xrange(0, x, 4):
+ ofs = 0
+ for k in xrange(4):
+ off = min(x - j, 4)
+ for sub in xrange(off):
+ texel = ord(data[inp])
+ out[outp + ofs + sub] = (texel << 24) | (texel << 16) | (texel << 8) | 0xFF
+ inp += 1
+
+ ofs += x
+ inp += 4 - off * 2
+ outp += off
+ outp += x * 3
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+ def RGB565(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ outp = 0
+ inp = 0
+ for i in xrange(0, y, 4):
+ for j in xrange(0, x, 4):
+ ofs = 0
+ for k in xrange(4):
+ off = min(x - j, 4)
+ for sub in xrange(off):
+ texel = ord(data[inp])
+ #out[outp + ofs + sub] = (texel << 24) | (texel << 16) | (texel << 8) | 0xFF
+ b = (texel&0x1f)<<3
+ g = ((texel>>5)&0x3f)<<2
+ r = ((texel>>11)&0x1f)<<3
+ b |= b>>5
+ g |= g>>6
+ r |= r>>5
+ if (outp + ofs + sub) < (x*y):
+ out[outp + ofs + sub] = (0xff<<24) | (b<<16) | (g<<8) | r
+ inp += 1
+
+ ofs += x
+ inp += 4 - off * 2
+ outp += off
+ outp += x * 3
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+ def IA4(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ outp = 0
+ inp = 0
+ for i in xrange(0, y, 4):
+ for j in xrange(0, x, 8):
+ ofs = 0
+ for k in xrange(4):
+ off = min(x - j, 8)
+ for sub in xrange(off):
+ texel = ord(data[inp])
+ alpha, inte = texel >> 4, texel & 0xF
+ if (outp + ofs + sub) < (x*y):
+ out[outp + ofs + sub] = (inte << 4) | (inte << 12) | (inte << 20) | (alpha << 28)
+ inp += 1
+
+ ofs += x
+ inp += 8 - off
+ outp += off
+ outp += x * 3
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+ def RGB5A3(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ outp = 0
+ inp = 0
+ for i in xrange(0, y, 4):
+ for j in xrange(0, x, 4):
+ ofs = 0
+ for k in xrange(4):
+ off = min(x - j, 4)
+ for sub in xrange(off):
+ texel = Struct.uint16(data[inp:inp + 2], endian='>')
+ if texel & 0x8000:
+ p = ((texel >> 10) & 0x1F) << 3
+ p |= ((texel >> 5) & 0x1F) << 11
+ p |= ( texel & 0x1F) << 19
+ p |= 0xFF<<24
+ else:
+ p = ((texel >> 12) & 0x07) << 29
+ p |= ((texel >> 8) & 0x0F) << 4
+ p |= ((texel >> 4) & 0x0F) << 12
+ p |= (texel & 0x0F) << 20
+ out[outp + ofs + sub] = p
+ inp += 2
+
+ ofs += x
+ inp += (4 - off) * 2
+ outp += off
+ outp += x * 3
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+ def unpack_rgb565(self,texel):
+ b = (texel&0x1f)<<3
+ g = ((texel>>5)&0x3f)<<2
+ r = ((texel>>11)&0x1f)<<3
+ b |= b>>5
+ g |= g>>6
+ r |= r>>5
+ return (0xff<<24) | (b<<16) | (g<<8) | r
+ def icolor(self,a,b,fa,fb,fc):
+ c = 0
+ for i in xrange(0,32,8):
+ xa = (a>>i)&0xff
+ xb = (b>>i)&0xff
+ xc = min(255,max(0,int((xa*fa + xb*fb)/fc)))
+ c |= xc<<i
+ return c
+
+ def S3TC(self, data, (y, x)):
+ out = [0 for i in xrange(x * y)]
+ TILE_WIDTH = 8
+ TILE_HEIGHT = 8
+ inp = 0
+ outp = 0
+ for i in xrange(0, y, TILE_HEIGHT):
+ for j in xrange(0, x, TILE_WIDTH):
+ maxw = min(x - j,TILE_WIDTH)
+ for k in xrange(2):
+ for l in xrange(2):
+ rgb = [0,0,0,0]
+ texel1 = Struct.uint16(data[inp:inp + 2], endian='>')
+ texel2 = Struct.uint16(data[inp + 2:inp + 4], endian='>')
+ rgb[0] = self.unpack_rgb565(texel1)
+ rgb[1] = self.unpack_rgb565(texel2)
+
+ if texel1 > texel2:
+ rgb[2] = self.icolor (rgb[0], rgb[1], 2, 1, 3) | 0xff000000
+ rgb[3] = self.icolor (rgb[1], rgb[0], 2, 1, 3) | 0xff000000
+ else:
+ rgb[2] = self.icolor (rgb[0], rgb[1], 0.5, 0.5, 1) | 0xff000000
+ rgb[3] = 0
+
+ # color selection (00, 01, 10, 11)
+ cm = map(ord,data[inp+4:inp+8])
+ ofs = l*4
+ for n in range(4):
+ if (ofs + outp)<(x*y):
+ # one row (4 texels)
+ if maxw > (0 + l*4):
+ out[ofs + 0 + outp] = rgb[(cm[n] & 0xc0) >> 6];
+ if maxw > (1 + l*4):
+ out[ofs + 1 + outp] = rgb[(cm[n] & 0x30) >> 4];
+ if maxw > (2 + l*4):
+ out[ofs + 2 + outp] = rgb[(cm[n] & 0x0c) >> 2];
+ if maxw > (3 + l*4):
+ out[ofs + 3 + outp] = rgb[(cm[n] & 0x03) >> 0];
+ ofs += x
+ inp += 8
+ outp += x * 4
+ outp += maxw - x * 8
+ outp += x * (TILE_HEIGHT - 1)
+
+ return ''.join(Struct.uint32(p) for p in out)
+
+class ValueFader(object):
+ def __init__(self, Type, parent, triplets, loop):
+ self.Type = Type
+ self.Parent = parent
+ self.Triplets = triplets
+ self.Loop = loop
+ self.Reset()
+ def Reset(self):
+ self.Pos = 0
+ self.Value = self.Triplets[0][1]
+ self.Framecount = 0
+ self.Frame = 0
+ self.Complete = False
+ def Do(self):
+ cframe, cval, cacc = self.Triplets[self.Pos]
+ if self.Frame >= cframe and self.Pos < len(self.Triplets)-1:
+ nframe = cframe
+ nval = cval
+ nacc = cacc
+ while nframe == cframe and self.Pos < len(self.Triplets)-1:
+ cframe, cval, cacc = self.Triplets[self.Pos]
+ self.Value = cval
+ self.Pos += 1
+ if self.Pos == len(self.Triplets) - 1:
+ print 'ZOMG'
+ nframe, nval, nacc = self.Triplets[self.Pos]
+
+ print "Starting ValueFader(%s) for %s:"%(self.Type,self.Parent.Name),cframe,cval,cacc,nframe,nval,nacc
+ self.Framecount = nframe - cframe
+ if self.Framecount > 0:
+ self.dValue = (nval - cval)/self.Framecount
+ else:
+ self.Value = nval
+ if self.Framecount > 0:
+ self.Framecount -= 1
+ self.Value += self.dValue
+ elif self.Pos == len(self.Triplets) - 1:
+ if self.Loop:
+ self.Reset()
+ else:
+ self.Complete = True
+
+ self.Frame += 1
+ return self.Value
+
+
+class Object(object):
+ def __init__(self, name):
+ self.Frame = 0
+ self.rlvc = None
+ self.rlpa = None
+ self.rlmc = None
+ self.rlts = None
+ self.Name = name
+ self.Alpha = 255
+ self.Animations = 0
+ def RLPA(self, triplets, loop):
+ if len(triplets) > 1:
+ if self.rlpa != None:
+ self.Animations -= 1
+ self.rlpa = ValueFader("RLPA", self, triplets, loop)
+ self.Animations += 1
+ def RLVC(self, triplets, loop):
+ if len(triplets) > 1:
+ if self.rlvc != None:
+ self.Animations -= 1
+ self.rlvc = ValueFader("RLVC", self, triplets, loop)
+ self.Animations += 1
+ def RLTS(self, triplets, loop):
+ if len(triplets) > 1:
+ if self.rlts != None:
+ self.Animations -= 1
+ self.rlts = ValueFader("RLTS", self, triplets, loop)
+ self.Animations += 1
+ def RLMC(self, triplets, loop):
+ if len(triplets) > 1:
+ if self.rlmc != None:
+ self.Animations -= 1
+ self.rlmc = ValueFader("RLMC", self, triplets, loop)
+ self.Animations += 1
+ def Animate(self):
+ if self.rlpa is not None:
+ self.Coords[1] = self.rlpa.Do()
+ if self.rlpa.Complete:
+ self.rlpa = None
+ self.Animations -= 1
+ if self.rlvc is not None:
+ self.Alpha = self.rlvc.Do()
+ if self.rlvc.Complete:
+ self.rlvc = None
+ self.Animations -= 1
+ if self.rlts is not None:
+ self.Coords[1] = self.rlts.Do()
+ if self.rlts.Complete:
+ self.rlts = None
+ self.Animations -= 1
+ if self.rlmc is not None:
+ self.Alpha = self.rlmc.Do()
+ if self.rlmc.Complete:
+ self.rlmc = None
+ self.Animations -= 1
+ def __str__(self):
+ return self.Name
+
+ def AnimDone(self):
+ return self.Animations == 0
+
+class Pane(Object):
+ def __init__(self, name, coords=None):
+ Object.__init__(self, name)
+ self.Coords = coords
+ self.Children = []
+ self.Enabled = True
+ def Add(self, child):
+ self.Children.append(child)
+
+ def AnimDone(self):
+ if not Object.AnimDone(self):
+ return False
+
+ for child in self.Children:
+ if not child.AnimDone():
+ return False
+
+ return True
+
+class Picture(Object):
+ def __init__(self, name, material, coords):
+ Object.__init__(self, name)
+ self.Material = material
+ self.Coords = coords
+ self.Enabled = True
+
+class Brlyt(object):
+ class BrlytHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Magic = Struct.string(4)
+ self.Unk = Struct.uint32
+ self.Size = Struct.uint32
+ self.UnkCount = Struct.uint16
+ self.AtomCount = Struct.uint16
+
+ class BrlytAtom(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.FourCC = Struct.string(4)
+ self.Size = Struct.uint32
+
+ def __init__(self, archive, data):
+ self.Archive = archive
+ self.Textures = []
+ self.Materials = []
+ self.RootPane = None
+ self.RootPaneName = None
+ self.Objects = {}
+ self.PanePath = []
+ self.PaneId = 0
+ self.Language = "ENG"
+
+ if data != None:
+ self.Unpack(data)
+
+ def Unpack(self, data):
+ pos = 0
+ header = self.BrlytHeader()
+ header.unpack(data[:len(header)])
+ pos += len(header)
+
+ assert header.Magic == 'RLYT'
+
+ for i in xrange(header.AtomCount):
+ atom = self.BrlytAtom()
+ atom.unpack(data[pos:pos+len(atom)])
+
+ atomdata = data[pos:pos+atom.Size]
+ if atom.FourCC == 'txl1':
+ self.TXL1(atomdata)
+ elif atom.FourCC == 'mat1':
+ self.MAT1(atomdata)
+ elif atom.FourCC == 'pan1':
+ self.PAN1(atomdata)
+ elif atom.FourCC == 'pas1':
+ self.PAS1(atomdata)
+ elif atom.FourCC == 'pae1':
+ self.PAE1(atomdata)
+ elif atom.FourCC == 'pic1':
+ self.PIC1(atomdata)
+ elif atom.FourCC == "grp1":
+ self.GRP1(atomdata)
+ else:
+ print "Unknown FOURCC:",atom.FourCC
+ wii.chexdump(atomdata)
+
+ pos += atom.Size
+
+ def TXL1(self, data):
+ pos = 8
+ texCount = Struct.uint16(data[pos:pos+2], endian='>')
+ pos += 4
+
+ for i in xrange(texCount):
+ fnOff = Struct.uint32(data[pos:pos+4], endian='>')
+ pos += 8
+
+ fn = data[fnOff+0xC:].split('\0', 1)[0]
+ tex = TPL(self.Archive.Files['./arc/timg/' + fn]).Textures[0]
+ self.Textures.append((fn, tex))
+ print fn
+
+ def ApplyMask(self, image, mask):
+ print "Making mask:",image,mask
+ print image.width,image.height,mask.width,mask.height
+ if image.height != mask.height or image.width != mask.width:
+ raise ValueError("Mask dimensions must be equal to mask dimensions")
+ newdata = [0 for x in xrange(image.height * image.width * 4)]
+
+ for pix in xrange(image.height * image.width):
+ newdata[pix*4 + 0] = image.data[pix*4 + 0]
+ newdata[pix*4 + 1] = image.data[pix*4 + 1]
+ newdata[pix*4 + 2] = image.data[pix*4 + 2]
+ newdata[pix*4 + 3] = mask.data[pix*4 + 0]
+
+ return ImageData(image.width, image.height, 'RGBA', ''.join(newdata))
+
+ def MAT1(self, data):
+ pos = 8
+ matCount = Struct.uint16(data[pos:pos+2], endian='>')
+ pos += 4
+
+ for i in xrange(matCount):
+ nameOff = Struct.uint32(data[pos:pos+4], endian='>')
+ pos += 4
+
+ name = data[nameOff:].split('\0', 1)[0]
+ wii.chexdump(data[nameOff:nameOff+0x60])
+ texid = Struct.uint16(data[nameOff + 0x40:nameOff + 0x42], endian='>')
+ texid2 = Struct.uint16(data[nameOff + 0x44:nameOff + 0x46], endian='>')
+ colorA = [Struct.uint16(data[nameOff + 0x1c + x:nameOff + 0x20 + x], endian='>')/255.0 for x in range(0,8,2)]
+ colorB = [Struct.uint16(data[nameOff + 0x22 + x:nameOff + 0x24 + x], endian='>')/255.0 for x in range(0,8,2)]
+ flags = Struct.uint32(data[nameOff + 0x3c:nameOff + 0x40], endian='>')
+
+ numtex = 1 # Hardcoded for her pleasure #(flags>>8) & 0xf #guess
+ if numtex == 1:
+ img = self.Textures[texid]
+ tex = img[1].create_texture(Texture)
+ print 'Material 0x%02x (%s) maps to texture %s' % (i, name, img[0])
+ elif numtex == 2:
+ img = self.Textures[texid]
+ alpha = self.Textures[texid2]
+ combo = self.ApplyMask(img[1],alpha[1])
+ tex = combo.create_texture(Texture)
+ print 'Material 0x%02x (%s) maps to texture %s and mask %s' % (i, name, img[0], alpha[0])
+ else:
+ print "Bad num textures: %d"%numtex
+
+ self.Materials.append((name, tex, (colorA,colorB)))
+
+
+ def PAN1(self, data):
+ wii.chexdump(data)
+ name = data[0xC:].split('\0', 1)[0]
+ x = Struct.float(data[0x24:0x28], endian='>')
+ y = Struct.float(data[0x28:0x2C], endian='>')
+ a = Struct.float(data[0x3C:0x40], endian='>')
+ b = Struct.float(data[0x40:0x44], endian='>')
+ xs = Struct.float(data[0x44:0x48], endian='>')
+ ys = Struct.float(data[0x48:0x4C], endian='>')
+ coords = [x, y, xs, ys]
+ print 'Pane %s:' % name, coords+[a,b]
+ self.CurPane = Pane(name, coords)
+
+ def PAS1(self, data):
+ if self.CurPane is None:
+ self.CurPane = Pane("_pane%d" % self.PaneId)
+ self.PaneId += 1
+ if self.RootPane is None:
+ self.RootPane = self.CurPane
+ else:
+ assert len(self.PanePath) != 0
+ self.PanePath[-1].Add(self.CurPane)
+ self.PanePath.append(self.CurPane)
+ self.Objects[self.CurPane.Name] = self.CurPane
+ print "Pane start:",'.'.join(map(str,self.PanePath))
+ self.CurPane = None
+
+ def PAE1(self, data):
+ print "Pane end:",'.'.join(map(str,self.PanePath))
+ self.PanePath = self.PanePath[:-1]
+
+ def PIC1(self, data):
+ wii.chexdump(data)
+ name = data[0xC:].split('\0', 1)[0]
+ mat = Struct.uint16(data[0x5C:0x5E], endian='>')
+ mat = self.Materials[mat]
+ xs = Struct.float(data[0x44:0x48], endian='>')
+ ys = Struct.float(data[0x48:0x4C], endian='>')
+ x = Struct.float(data[0x24:0x28], endian='>')
+ y = Struct.float(data[0x28:0x2C], endian='>')
+ print 'Picture %s maps to material %s' % (name, mat[0])
+ print '\t%fx%f (%f, %f)' % (xs, ys, x, y)
+
+ p=Picture(name, mat, [x, y, xs, ys])
+ self.PanePath[-1].Add(p)
+ self.Objects[name] = p
+ def GRP1(self, data):
+ wii.chexdump(data)
+ if len(data) < 0x1c:
+ pass
+ lang = data[0x8:0x18].split('\0', 1)[0]
+ nitems = Struct.uint16(data[0x18:0x1a], endian='>')
+ p = 0x1c
+ items = []
+ for i in xrange(nitems):
+ items.append(data[p:].split('\0', 1)[0])
+ p += 0x10
+ for i in items:
+ if lang != self.Language:
+ self.Objects[i].Enabled = False
+ else:
+ self.Objects[i].Enabled = True
+
+class Brlan(object):
+ class BrlanHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Magic = Struct.string(4)
+ self.Unk = Struct.uint32
+ self.Size = Struct.uint32
+ self.AnimCount = Struct.uint16
+ self.AtomCount = Struct.uint16
+
+ class BrlanAtom(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.FourCC = Struct.string(4)
+ self.Size = Struct.uint32
+
+ def __init__(self, data, brlyt, loop=False):
+ self.Loop = loop
+ self.brlyt = brlyt
+ if data != None:
+ self.Unpack(data)
+
+ def Unpack(self, data):
+ header = self.BrlanHeader()
+ header.unpack(data[:len(header)])
+ pos = len(header)
+
+ assert header.Magic == 'RLAN'
+
+ for i in xrange(header.AtomCount):
+ atom = self.BrlanAtom()
+ atom.unpack(data[pos:pos+len(atom)])
+ atomdata = data[pos:pos+atom.Size]
+ pos += atom.Size
+
+ if atom.FourCC == 'pai1':
+ self.PAI1(atomdata)
+
+ class PAI1Header(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.UnkOff = Struct.uint16
+ self.Unk = Struct.uint16
+ self.Count = Struct.uint32
+ self.Off = Struct.uint32
+
+ def PAI1(self, data):
+ pos = 8
+ header = self.PAI1Header()
+ header.unpack(data[pos:pos+len(header)])
+ pos = header.Off
+
+ for i in xrange(header.Count):
+ off = nameOff = Struct.uint32(data[pos:pos+4], endian='>')
+ pos += 4
+
+ name = data[off:].split('\0', 1)[0]
+
+ off += 0x14
+ numAtoms = ord(data[off])
+ off += 4
+
+ print name
+
+ for i in xrange(numAtoms):
+ sub = Struct.uint32(data[off:off+4], endian='>')
+ off += 4
+ fourcc = data[nameOff+sub:nameOff+sub+4]
+
+ #if fourcc == 'RLTS':
+ # print 'RLTS unknown'
+ #else:
+ self.Atom(name, fourcc, data[nameOff+sub:])
+
+ def Atom(self, name, fourcc, data):
+ print '\t' + fourcc
+
+ count = Struct.uint16(data[0x10:0x12], endian='>')
+
+ # file('rlat/%s.%s' % (name, fourcc), 'wb').write(data[:0x18])
+ triplets = []
+
+ # Calculate offset to triplets (added by dasda).
+ off = Struct.uint16(data[4:6], endian='<') * 8 + 16;
+
+ for i in xrange(count):
+ af = Struct.float(data[off:off+4], endian='>')
+ bf = Struct.float(data[off+4:off+8], endian='>')
+ cf = Struct.float(data[off+8:off+0xC], endian='>')
+
+ triplets.append((af, bf, cf))
+ off += 0xC
+
+ if fourcc == 'RLPA':
+ self.brlyt.Objects[name].RLPA(triplets, self.Loop)
+ elif fourcc == 'RLVC':
+ self.brlyt.Objects[name].RLVC(triplets, self.Loop)
+ elif fourcc == 'RLTS':
+ self.brlyt.Objects[name].RLTS(triplets, self.Loop)
+ elif fourcc == 'RLMC':
+ self.brlyt.Objects[name].RLMC(triplets, self.Loop)
+ else:
+ for trip in triplets:
+ print '\t\tTriplet: %f %f %f' % trip
+
+class BannerWindow(window.Window):
+ def on_resize(self, width, height):
+ glViewport(0, 0, width, height)
+ glMatrixMode(GL_PROJECTION)
+ glLoadIdentity()
+ glOrtho(-width/2, width/2, -height/2, height/2, -1, 1)
+ glMatrixMode(GL_MODELVIEW)
+
+
+class Renderer(object):
+ def __init__(self):
+ self.Width, self.Height = 640, 480
+ self.Window = BannerWindow(self.Width, self.Height)
+ self.Window.set_exclusive_mouse(False)
+ self.Brlyt = None
+
+ glClearColor(0.0, 0.0, 0.0, 0.0)
+ glClearDepth(1.0)
+ glDepthFunc(GL_LEQUAL)
+ glEnable(GL_DEPTH_TEST)
+
+ glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
+ glEnable(GL_BLEND)
+
+ glEnable(GL_TEXTURE_2D)
+
+ clock.set_fps_limit(60)
+
+ def Render(self, item, wireframe=False):
+ item.Animate()
+ if not item.Enabled:
+ return
+ if isinstance(item, Pane):
+ if item.Coords is not None:
+ x, y, xs, ys = item.Coords
+ else:
+ x = y = 0
+ xs = ys = 1
+ glPushMatrix()
+ glTranslatef(x, y, 0)
+ for child in item.Children:
+ self.Render(child,wireframe)
+ glPopMatrix()
+ elif isinstance(item, Picture):
+
+ mat = item.Material
+ texture, colors = mat[1:]
+ x, y, xs, ys = item.Coords
+ xc, yc = x-(xs/2),y-(ys/2)
+
+ if not wireframe:
+ glBindTexture(texture.target, texture.id)
+ col = list(colors[0])
+ col[3] = col[3] * item.Alpha / 255.0
+ glColor4f(*col)
+ texture.blit(xc,yc+ys,0,xs,-ys)
+ glBindTexture(texture.target, 0)
+ else:
+
+ glColor3f(1,0,0)
+ glBegin(GL_LINE_STRIP)
+ glVertex2f(xc,yc)
+ glVertex2f(xc+xs,yc)
+ glVertex2f(xc+xs,yc+ys)
+ glVertex2f(xc,yc+ys)
+ glVertex2f(xc,yc)
+ glColor3f(1,1,1)
+ glEnd()
+ pass
+
+ def MainLoop(self, loop):
+ while not self.Window.has_exit:
+ self.Window.dispatch_events()
+ self.Window.clear()
+
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+ glLoadIdentity()
+ glColor4f(1.0, 1.0, 1.0, 1.0)
+
+ self.Render(self.Brlyt.RootPane,False)
+ #self.Render(self.Brlyt.RootPane,True)
+
+ self.Window.flip()
+
+ if not loop and self.Brlyt.RootPane.AnimDone():
+ return True
+
+class Alameda(object):
+ class IMETHeader(Struct):
+ __endian__ = Struct.BE
+ def __format__(self):
+ self.Zeroes = Struct.uint8[0x40]
+ self.IMET = Struct.string(4)
+ self.Fixed = Struct.uint8[8]
+ self.Sizes = Struct.uint32[3]
+ self.Flag1 = Struct.uint32
+ self.Names = Struct.string(0x2A<<1, encoding='utf-16-be', stripNulls=True)[7]
+ self.Zeroes = Struct.uint8[0x348]
+ self.Crypto = Struct.uint8[0x10]
+
+ def __init__(self, fn, type='icon'):
+ renderer = Renderer()
+
+ fp = file(fn, 'rb')
+
+ imet = self.IMETHeader()
+ imet.unpack(fp.read(len(imet)))
+ if imet.IMET != 'IMET':
+ fp.seek(0x40)
+ imet.unpack(fp.read(len(imet)))
+ assert imet.IMET == 'IMET'
+
+ print 'English title: %s' % imet.Names[1]
+
+ root = U8(fp.read())
+ if type == 'icon':
+ banner = U8(IMD5(root.Files['./meta/icon.bin']))
+ brlyt = Brlyt(banner, banner.Files['./arc/blyt/icon.brlyt'])
+ startAnim = Brlan(banner.Files['./arc/anim/icon.brlan'], brlyt, loop=True)
+ loop = True
+ else:
+ banner = U8(IMD5(root.Files['./meta/banner.bin']))
+ brlyt = Brlyt(banner, banner.Files['./arc/blyt/banner.brlyt'])
+ startAnim = Brlan(banner.Files['./arc/anim/banner_Start.brlan'], brlyt, loop=False)
+ loop = False
+
+ renderer.Brlyt = brlyt
+ if renderer.MainLoop(loop) and type == 'banner':
+ loopAnim = Brlan(banner.Files['./arc/anim/banner_Loop.brlan'], brlyt, loop=True)
+ renderer.MainLoop(True)
+
+if __name__=='__main__':
+ Alameda(*sys.argv[1:])
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-29 18:38:12 +0000