Merge branch 'master' of git@github.com:icefire/Wii.py

TPL.py

@@ -12,9 +12,9 @@ from common import *
 class TPL():
 	"""This is the class to generate TPL texutres from PNG images, and to convert TPL textures to PNG images. The parameter file specifies the filename of the source, either a PNG image or a TPL image.
 	
-	Currently supported are the following formats to convert from TPL: RGBA8, RGB565, RGB5A3, I4, I8, IA4, IA8. Currently not supported are: CI4, CI8, CMP.
+	Currently supported are the following formats to convert from TPL: RGBA8, RGB565, RGB5A3, CI4, CI8, I4, I8, IA4, IA8. Currently not supported are: CMP, CI14X2.
 	
-	Currently support to convert to TPL: RGBA8. Currently not supported are: RGB565, RGB5A3, I4, I8, IA4, IA8, CI4, CI8, CMP.
+	Currently support to convert to TPL: RGBA8. Currently not supported are: RGB565, RGB5A3, I4, I8, IA4, IA8, CI4, CI8, CMP, CI14X2.
 	
 	There are still some bugs in either the RGBA8 conversion to or from TPL. This causes stretched and distorted images with some files and images dimensions."""
 	
@@ -28,7 +28,7 @@ class TPL():
 		__endian__ = Struct.BE
 		def __format__(self):
 			self.header_offset = Struct.uint32
-			self.pallete_offset = Struct.uint32
+			self.palette_offset = Struct.uint32
 	class TPLTextureHeader(Struct):
 		__endian__ = Struct.BE
 		def __format__(self):
@@ -43,8 +43,21 @@ class TPL():
 			self.min_lod = Struct.uint8
 			self.max_lod = Struct.uint8
 			self.unpacked = Struct.uint8
+	class TPLPaletteHeader(Struct):
+		__endian__ = Struct.BE
+		def __format__(self):
+			self.nitems = Struct.uint16
+			self.unpacked = Struct.uint8
+			self.pad = Struct.uint8
+			self.format = Struct.uint32
+			self.offset = Struct.uint32
 	def __init__(self, file):
-		self.file = file
+		if(os.path.isfile(file)):
+			self.file = file
+			self.data = None
+		else:
+			self.file = None
+			self.data = file
 	def toTPL(self, outfile, width = 0, height = 0): #single texture only
 		"""This converts a PNG image into a TPL. The PNG image is specified as the file parameter to the class initializer, while the output filename is specified here as the parameter outfile. Width and height are optional parameters and specify the size to resize the image to, if needed. Returns the output filename.
 		
@@ -125,7 +138,10 @@ class TPL():
 		"""This converts a TPL texture to a PNG image. You specify the input TPL filename in the initializer, and you specify the output filename in the outfile parameter to this method. Returns the output filename.
 		
 		This only supports single textured TPL images."""
-		data = open(self.file, "rb").read()
+		if(self.file):
+			data = open(self.file, "rb").read()
+		else:
+			data = self.data
 		
 		header = self.TPLHeader()
 		textures = []
@@ -134,11 +150,15 @@ class TPL():
 		header.unpack(data[pos:pos + len(header)])
 		pos += len(header)
 		
+		palette_offsets = []
+		
 		for i in range(header.ntextures):
 			tmp = self.TPLTexture()
 			tmp.unpack(data[pos:pos + len(tmp)])
 			textures.append(tmp)
 			pos += len(tmp)
+			if(tmp.palette_offset > 0):
+				palette_offsets.append(tmp.palette_offset)
 		
 		if(header.ntextures > 1):
 			raise ValueError("Only one texture supported. Don't touch me!")
@@ -175,6 +195,44 @@ class TPL():
 				tpldata = struct.unpack(">" + str(w * h * 2) + "H", data[tex.data_off:tex.data_off + (w * h * 4)])
 				rgbdata = self.RGBA8((w, h), tpldata)
 				
+			elif(tex.format == 8 or tex.format == 9 or tex.format == 10):
+				palhead = self.TPLPaletteHeader()
+				offs = palette_offsets.pop(0)
+				palhead.unpack(data[offs:offs + len(palhead)])
+
+				tpldata = struct.unpack(">" + str(palhead.nitems) + "H", data[palhead.offset:palhead.offset + (palhead.nitems * 2)])
+				if(palhead.format == 0):
+					palette_data = self.IA8((palhead.nitems, 1), tpldata)[0]
+				elif(palhead.format == 1):
+					palette_data = self.RGB565((palhead.nitems, 1), tpldata)[0]
+				elif(palhead.format == 2):
+					palette_data = self.RGB5A3((palhead.nitems, 1), tpldata)[0]
+				
+				paldata = []
+				for i in range(0, palhead.nitems * 4, 4):
+					tmp = 0
+					tmp |= palette_data[i + 0] << 24
+					tmp |= palette_data[i + 1] << 16
+					tmp |= palette_data[i + 2] << 8
+					tmp |= palette_data[i + 3] << 0
+					paldata.append(tmp)
+				
+				if(tex.format == 8):
+					tpldata = struct.unpack(">" + str((w * h) / 2) + "B", data[tex.data_off:tex.data_off + ((w * h) / 2)])
+					rgbdata = self.CI4((w, h), tpldata, paldata)
+				if(tex.format == 9):
+					tpldata = struct.unpack(">" + str(w * h) + "B", data[tex.data_off:tex.data_off + (w * h * 1)])
+					rgbdata = self.CI8((w, h), tpldata, paldata)
+				if(tex.format == 10):
+					tpldata = struct.unpack(">" + str(w * h) + "H", data[tex.data_off:tex.data_off + (w * h * 2)])
+					rgbdata = self.CI14X2((w, h), tpldata, paldata)
+			elif(tex.format == 14):
+				sz = ((w + 7) >> 3) * ((w + 7) >> 3) * 32
+				#print sz
+				#print len(data[tex.data_off:])
+				tpldata = struct.unpack(">" + str(sz / 2) + "H", data[tex.data_off:tex.data_off + sz])
+				
+				rgbdata = self.CMP((w, h), tpldata)
 			else:
 				raise TypeError("Unsupported TPL Format: " + str(tex.format))
 		
@@ -403,4 +461,176 @@ class TPL():
 						out[y1][(x1 * 4) + 2] = b
 						out[y1][(x1 * 4) + 3] = a
 		return out
+	def CI4(self, (w, h), jar, pal):
+		out = [[0 for i in range(w * 4)] for i in range(h)]
+		i = 0
+		for y in range(0, h, 8):
+			for x in range(0, w, 8):
+				for y1 in range(y, y + 8):
+					for x1 in range(x, x + 8, 2):
+						if(y1 >= h or x1 >= w):
+							continue
+						pixel = jar[i]
+						
+						r = (pal[pixel] & 0xFF000000) >> 24
+						g = (pal[pixel] & 0x00FF0000) >> 16
+						b = (pal[pixel] & 0x0000FF00) >> 8
+						a = (pal[pixel] & 0x000000FF) >> 0
 
+						out[y1][(x1 * 4) + 0] = r
+						out[y1][(x1 * 4) + 1] = g
+						out[y1][(x1 * 4) + 2] = b
+						out[y1][(x1 * 4) + 3] = a
+						
+						if(y1 >= h or x1 >= w):
+							continue
+						pixel = jar[i]
+						i += 1
+						
+						r = (pal[pixel] & 0xFF000000) >> 24
+						g = (pal[pixel] & 0x00FF0000) >> 16
+						b = (pal[pixel] & 0x0000FF00) >> 8
+						a = (pal[pixel] & 0x000000FF) >> 0
+
+						out[y1][((x1 + 1) * 4) + 0] = r
+						out[y1][((x1 + 1) * 4) + 1] = g
+						out[y1][((x1 + 1) * 4) + 2] = b
+						out[y1][((x1 + 1) * 4) + 3] = a
+		return out
+	def CI8(self, (w, h), jar, pal):
+		out = [[0 for i in range(w * 4)] for i in range(h)]
+		i = 0
+		for y in range(0, h, 4):
+			for x in range(0, w, 8):
+				for y1 in range(y, y + 4):
+					for x1 in range(x, x + 8):
+						if(y1 >= h or x1 >= w):
+							continue
+						pixel = jar[i]
+						i += 1
+						
+						r = (pal[pixel] & 0xFF000000) >> 24
+						g = (pal[pixel] & 0x00FF0000) >> 16
+						b = (pal[pixel] & 0x0000FF00) >> 8
+						a = (pal[pixel] & 0x000000FF) >> 0
+
+						out[y1][(x1 * 4) + 0] = r
+						out[y1][(x1 * 4) + 1] = g
+						out[y1][(x1 * 4) + 2] = b
+						out[y1][(x1 * 4) + 3] = a
+		return out
+	def icolor(self, a, b, fa, fb, fc):
+		c = 0
+		for i in range(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 single565(self, pixel):
+		r = ((pixel >> 11) & 0x1F) << 3
+		g = ((pixel >> 5) & 0x3F) << 2
+		b = ((pixel >> 0) & 0x1F) << 3
+		a = 255
+		return (r << 24) | (g << 16) | (b << 8) | (a << 0)
+	def CMP(self, (w, h), jar):
+		out = [[0 for i in range(w * 4)] for i in range(h)]
+		
+		pos = 0
+		ofs = 0
+		
+		rgb = [0 for i in range(4)]
+		dst = [0 for i in range(w * h)]
+		for y in range(0, h, 8):
+			for x in range(0, w, 8):
+				maxw = min(w - x, 8)
+				for k in range(2):
+					for l in range(2):	
+						rgb[0] = self.single565(jar[pos])
+						pos += 1
+						rgb[1] = self.single565(jar[pos])
+						pos += 1
+
+						if(jar[pos + 0] > jar[pos + 1]):
+							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] = self.icolor(rgb[1], rgb[0], 2, 1, 3) & ~0xFF000000
+							rgb[3] = 0
+							
+						# color selection (00, 01, 10, 11)
+						cm = jar[pos:pos + 2]
+						pixels = []
+						for pix in cm:
+							pixels.append(pix >> 8)
+							pixels.append(pix & 0xFF)
+						pos += 2
+						
+						for n in range(4):
+							# one row (4 texels)
+							if(ofs < (w * h)):
+								if(maxw > 0 + l * 4):
+									dst[ofs] = rgb[(pixels[n] & 0xc0) >> 6]
+									ofs += 1
+								if(maxw > 1 + l * 4):
+									dst[ofs] = rgb[(pixels[n] & 0x30) >> 4]
+									ofs += 1
+								if(maxw > 2 + l * 4):
+									dst[ofs] = rgb[(pixels[n] & 0x0c) >> 2]
+									ofs += 1
+								if(maxw > 3 + l * 4):
+									dst[ofs] = rgb[(pixels[n] & 0x03) >> 0]
+									ofs += 1
+
+		num_rows = 0
+		num_tiles = 0
+		for i in range(w * h):
+			pixel = dst[i]
+			
+			tile_offset = i % 16 # where are we in the tile?
+			if(i % 16 == 0 and i != 0): # if we are at the end of a tile...
+				num_tiles += 1 # ...move on to the next one!
+
+			if(num_tiles != 0 and (w / 4) == num_tiles): # if we are at the end of a row of tiles...
+				num_tiles = 0 # ...reset!
+				tile_offset = 0 # ...reset!
+				num_rows += 4 # plus four because each tile is four high
+				
+			x = (tile_offset % 4) + (num_tiles * 4) # num_tiles part to not overwrite tiles earlier in this row, tile_offset to find how far on the x we are in this row in the tile
+			y = (num_rows) + (tile_offset / 4) # num_rows to not overwrite tiles above, tile_offset to show how many rows in the current tile we are
+			
+			#print "tile %u of %u on row %u of %u (%u, %u): 0x%08x" % (num_tiles + 1, w / 4, (num_rows / 4) + 1, h / 4, x, y, pixel)
+			
+			r = (pixel & 0xFF000000) >> 24
+			g = (pixel & 0x00FF0000) >> 16
+			b = (pixel & 0x0000FF00) >> 8
+			a = (pixel & 0x000000FF) >> 0
+		
+			out[y][(x * 4) + 0] = r
+			out[y][(x * 4) + 1] = g
+			out[y][(x * 4) + 2] = b
+			out[y][(x * 4) + 3] = a		
+		return out
+	def CI14X2(self, (w, h), jar):
+		out = [[0 for i in range(w * 4)] for i in range(h)]
+		i = 0
+		for y in range(0, h, 4):
+			for x in range(0, w, 4):
+				for y1 in range(y, y + 4):
+					for x1 in range(x, x + 4):
+						if(y1 >= h or x1 >= w):
+							continue
+						pixel = jar[i]
+						i += 1
+						
+						r = (pal[pixel & 0x3FFF] & 0xFF000000) >> 24
+						g = (pal[pixel & 0x3FFF] & 0x00FF0000) >> 16
+						b = (pal[pixel & 0x3FFF] & 0x0000FF00) >> 8
+						a = (pal[pixel & 0x3FFF] & 0x000000FF) >> 0
+
+						out[y1][(x1 * 4) + 0] = r
+						out[y1][(x1 * 4) + 1] = g
+						out[y1][(x1 * 4) + 2] = b
+						out[y1][(x1 * 4) + 3] = a
+		return out