XeNTaX

Code: Select all

from inc_noesis import *
import noesis
import rapi

def registerNoesisTypes():
	handle = noesis.register("Xenosaga XTX Texture", ".xtx")
	noesis.setHandlerTypeCheck(handle, xtxCheckType)
	noesis.setHandlerLoadRGBA(handle, xtxGetRGBA)
	return 1
	
XTX_TAG = 0x00585458 # XTX.
	
def xtxCheckType(data):
	if len(data) < 0x50:#If the file is smaller than the header size, quit.
		return 0
	bs = NoeBitStream(data)

	if bs.readInt() != XTX_TAG:#if the header tag is wrong, quit.
		return 0
		
	return 1

def xtxGetRGBA(data, texList):
	bs = NoeBitStream(data)
	
	#tag
	bs.readInt()
	#start of pixels
	imageOffset = int(bs.readByte())
	
	#unknown
	bs.readBytes(11)
	
	#width
	w = int(bs.readUShort())
	#swizzel indicator...?
	swiz = int(bs.readUShort())
	#height
	h = int(bs.readUShort())
	
	imgPix = data[imageOffset:]
	
	if (swiz != 0x04):#if this is not 0x04, the only value I've found that is raw RGBA32, quit.
		return 0
	
	#This next loop takes care of the half size alpha channel. The files max alpha at 0x80 instead of 0xFF
	#this is here to spread the values so they max at 0xFF for fully opaque
	#if there is a better way to do this, let me know.
	
	for i in range(0,w*h):#For each pixel
		if imgPix[((i+1)*4)-1] > 0:#if the alpha is not 0 (this is needed due to overflow of 0 - 1 = FF)
			imgPix[((i+1)*4)-1] = ((imgPix[((i+1)*4)-1] * 2)-1)&0xFF #Every fourth byte, perform operations to roughly double the value, then cap it to 8 bits
	
	pix32 = rapi.imageDecodeRaw(imgPix, w, h, "r8g8b8a8")
	
	texList.append(NoeTexture("xtx", w, h, pix32, noesis.NOESISTEX_RGBA32))
	return 1

Code: Select all

from inc_noesis import *
def registerNoesisTypes():
	handle = noesis.register("Xenosaga TXY Image", ".txy")
	noesis.setHandlerTypeCheck(handle, txyCheckType)
	noesis.setHandlerLoadRGBA(handle, txyLoadRGBA)
	return 1

def txyGetImageCut(texPage, pageWidth, pageHeight, ofsX, ofsY, width, height):
	r = bytes()
	for i in range(0, pageHeight):
		imgOfs = ofsY*pageWidth + i*pageWidth + ofsX
		r += texPage[imgOfs:imgOfs+width]
	return r

def txyRetile8(pix, pixW, pixH):
	dst = bytearray(pixW*pixH)
	for y in range(0, pixH):
		for x in range(0, pixW):
			blockOfs = (y & ~15)*pixW + (x & ~15)*2
			sw = (((y+2)>>2) & 1) * 4
			ofsY = (((y & ~3)>>1) + (y & 1)) & 7
			colOfs = ofsY*pixW*2 + ((x+sw) & 7) * 4
			ofsX = ((y>>1) & 1) + ((x>>2) & 2)
			dst[blockOfs+colOfs+ofsX] = pix[y*pixW + x];
	return dst

class TXYFile:
	def __init__(self, reader):
		self.reader = reader

	def loadImageInfo(self):
		reader = self.reader
		if reader.dataSize <= 20:
			return 0
		id = reader.readInt()
		ver = reader.readInt()
		fsize = reader.readInt()
		if id != 0x797874 or ver != 1 or fsize > reader.dataSize:
			return 0
		reader.seek(16, NOESEEK_ABS)
		self.infoOfs = reader.readInt()
		if self.infoOfs <= 0 or self.infoOfs >= reader.dataSize:
			return 0
		reader.seek(self.infoOfs, NOESEEK_ABS)
		self.hx = reader.readInt()
		self.bd = reader.readInt()
		self.pageW = reader.readInt()
		self.pageH = reader.readInt()
		reader.seek(4, NOESEEK_REL)
		self.numSlices = reader.readInt()
		self.numBlocks = reader.readInt()
		if self.numSlices <= 0 or self.numBlocks <= 0:
			return 0
		reader.seek(4, NOESEEK_REL)
		self.slicesOfs = reader.tell()
		return 1

	def loadPage(self):
		reader = self.reader
		slices = bytes()
		slicesH = 0
		self.bitsPP = 8
		for i in range(0, self.numSlices):
			reader.seek(self.slicesOfs + i*32, NOESEEK_ABS)
			pixOfs = reader.readInt()
			rofs = reader.readInt()
			sliceW = reader.readInt() * 2
			sliceH = reader.readInt() * 2
			reader.seek(pixOfs+32, NOESEEK_ABS)
			imgSize = sliceW*sliceH if self.bitsPP >= 8 else (sliceW*sliceH)//2
			pix = reader.readBytes(imgSize)
			pix = rapi.imageUntwiddlePS2(pix, sliceW, sliceH, self.bitsPP)
			for j in range(0, sliceH):
				row = pix[j*sliceW:j*sliceW + sliceW]
				row += bytes([0])*(self.pageW-sliceW)
				slices += row
			slicesH += sliceH
		self.pageH = slicesH
		self.texPage = slices

	def getPaletteBlock(self, palX, palY):
		pal = bytearray(1024)
		idxCut = txyGetImageCut(self.texPage, self.pageW, self.pageH, palX, palY, 32, 32)
		return rapi.imageScaleRGBA32(txyRetile8(idxCut, 32, 32), (1.0, 1.0, 1.0, 2.0), 16, 16)

	def loadTextures(self, texList):
		reader = self.reader
		reader.seek(self.infoOfs+288, NOESEEK_ABS)
		texInfos = []
		for i in range(0, self.numBlocks):
			texInfo = {}
			texInfo["ofsa"] = reader.readInt()
			texInfo["na"] = reader.readInt()
			texInfo["width"] = reader.readInt()
			texInfo["height"] = reader.readInt()
			texInfo["ofsx"] = reader.readInt()
			texInfo["ofsy"] = reader.readInt()
			texInfo["ofsb"] = reader.readInt()
			reader.seek(4, NOESEEK_REL)
			texInfo["palx"] = reader.readInt()*2
			texInfo["paly"] = reader.readInt()*2
			reader.seek(24, NOESEEK_REL)
			texInfo["name"] = noeStrFromBytes(reader.readBytes(32))
			texInfos.append(texInfo)
		for texInfo in texInfos:
			pal = self.getPaletteBlock(texInfo["palx"], texInfo["paly"])
			idxCut = txyGetImageCut(self.texPage, self.pageW, self.pageH, texInfo["ofsx"], texInfo["ofsy"], texInfo["width"], texInfo["height"])
			pix = rapi.imageDecodeRawPal(idxCut, pal, texInfo["width"], texInfo["height"], self.bitsPP, "r8g8b8a8", noesis.DECODEFLAG_PS2SHIFT)
			texList.append(NoeTexture(texInfo["name"], texInfo["width"], texInfo["height"], pix, noesis.NOESISTEX_RGBA32))
			

def txyCheckType(data):
	txy = TXYFile(NoeBitStream(data))
	if txy.loadImageInfo() == 0:
		return 0
	return 1

def txyLoadRGBA(data, texList):
	txy = TXYFile(NoeBitStream(data))
	if txy.loadImageInfo() == 0:
		return 0

	txy.loadPage()
	txy.loadTextures(texList)
	return 1