alameda

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:])