// Header file for STOS to PSX sprites
// Coded by Scott Evans
// Defines types, macros and functions used by sprconv.c

// Define types for 8 bit (byte), 16 bit (word), 32 (long) bit values

typedef unsigned __int8 _byte;
typedef unsigned __int16 _word;
typedef unsigned __int32 _long;

// PSX sprite file format as follows

// Header
// CLUTs
// Parameter blocks
// Sprite image data

// Structure of PSX sprite file header

typedef struct
{
	_word nsprs;		// The number of sprites in the file
	_word npal;			// The number of CLUTs in the file
	_long paloff;		// Address of 1st CLUT = header+paloff;
	_long pblkoff;		// Address of 1st parameter block = header+pblkoff
}SprHeader;

// Structure of PSX sprite parameter block

typedef struct
{
	_byte w,h;			// The width and height of the sprite 
	_word CLUTid;		// Which CLUT sprite is using
	_long imgoff;		// Offset to sprite image data = parameterblock+pblkoff
}SprPblk;

// Size in bytes of above structures

#define _SprHeaderSize	(sizeof(SprHeader))
#define _SprPblkSize	(sizeof(SprPblk))

// Define read/write to memory macros

#define _peekByte(addr)	(*(_byte *)(addr))
#define _peekWord(addr)	(*(_word *)(addr))
#define _peekLong(addr) (*(_long *)(addr))

#define _pokeByte(addr,value)	*(_byte *)(addr)=(value)
#define _pokeWord(addr,value)	*(_word *)(addr)=(value)
#define _pokeLong(addr,value)	*(_long *)(addr)=(value)

// Correct byte ordering from STE (big-endian) to PC/PSX (little-endian)

#define _STEtoPCword(n)	(((n&0xff)<<8)|((n&0xff00)>>8))
#define _STEtoPClong(n)	(((n&0xff)<<24)|((n&0xff00)<<8)|((n&0xff0000)>>8)|((n&0xff000000)>>24))

// Test a bit and set a bit macros

#define _btst(n,v)	((1<<(n))&(v) ? 1 : 0)
#define _bset(n,v)	(v)=(1<<(n))|(v)

#define _4bitCLUTSIZE	32	// Palette size in bytes (4 bit CLUT = 16 colours)
#define STOSpalSize		32  // Size in bytes of STOS palette (16 colours, 1 colour = 1 word)

// Load a file into memory
//	fname - name of file to load
//	Returns address of loaded file or NULL for error

void *LoadFile(_byte *fname)
{
	_long fsize,nobytes;
	FILE *fh=fopen(fname,"rb");

	if(fh)
	{
		// Get some space for file

		void *addr=malloc(fsize=_filelength(_fileno(fh)));

		// Read file data into memory

		if((nobytes=fread(addr,1,fsize,fh))==fsize)
		{
			fclose(fh);
			return(addr);
		}
	}
	
	return(NULL);
}

// Write memory to file
//	fname - name of file to save
//	addr  - buffer to save, size of buffer
//  Retruns number of bytes saved or 0 for error

_long SaveFile(_byte *fname,_byte *addr,_long size)
{
	_long nobytes;
	FILE *fh=fopen(fname,"wb");

	// Save data from memory to file

	if(fh && (nobytes=fwrite(addr,1,size,fh))==size)
	{
		fclose(fh);
		return(nobytes);
	}

	return(0);
}

// Convert STOS sprite palette to PSX 4 bit CLUT
//	oldpal - pointer to old palette (32 bytes)
//	newpal - pointer to 32 byte buffer

void PalTo4bitCLUT(_word *oldpal,_word *newpal)
{
	_word col;
	_byte i;

	// Convert colour and set semi transparency bit

	for(i=0;i<16;i++)
	{
		newpal[i]=((col=_STEtoPCword(oldpal[i]))&0xf)<<10|(col&0xf0)<<1|(col&0xf00)>>8;
		
		// Don't set transparency bit for black

		if(newpal[i]!=0)
			newpal[i]|=0x8000;
	}

#ifdef PrintValues
	for(i=0;i<16;i++)
		printf("Colour %2d (%3x) : %4x\n",i,_STEtoPCword(oldpal[i]),newpal[i]);
#endif
}

// Convert a pixel
//	pixel    - number of pixel to convert
//	bitplane - address of bit planes
//	Returns new pixel value (4 bits)

_byte ConvertPixel(_byte pixel,_word *bitplane)
{
	_byte i,newpixel=0;

	for(i=0;i<4;i++)
		if(_btst(15-pixel,bitplane[i]))
			_bset(i,newpixel);

	return(newpixel);
}

// Convert a STOS sprite to Playstation format
//	data   - pointer to bit planes
//	buffer - pointer to buffer for converted sprite image data
//	w,h    - width and height of STOS sprite 

void ConvertSprite(_word *data,_long *buffer,_byte w,_byte h)
{
	_byte n,i,j,k=0,pixel;
	_word bitplanes[4];
	_long newpixels=0;

	// Width of STOS sprites given 16 pixel chunks
	// n gives total number of words to convert

	n=h*w;

	for(i=0;i<n;i++)
	{
		// Get 4 bit planes (16 pixels)

		for(j=0;j<4;j++)
			bitplanes[j]=_STEtoPCword(_peekWord(data+j));

		// Convert 16 pixels

		for(j=0;j<16;j++)
		{
			pixel=ConvertPixel(j,bitplanes);
			newpixels|=((_long)pixel)<<4*k++;
			
			// When filled 32 bits save them to buffer

			if((k%=8)==0)
				_pokeLong(buffer++,newpixels),newpixels=0;
		}

		// Next lot of bit planes

		data+=4;
	}
}

// Calculate the size needed by converted sprites
//	pblk - address of 1st STOS sprite parameter
//	n    - number of sprites
//	Returns size of buffer needed

_long CalcSprSize(_long pblk,_word n)
{
	_long total=0;

	// Sprite width in chunks, 2 pixels per byte so multiply width of each sprite by 8

	while(total+=(_peekByte(pblk+4)<<3)*_peekByte(pblk+5),pblk+=8,n-->0);
	return(total);
}