Subversion Repositories spk

// TextureFile.cpp: implementation of the CTextureFile class.

//

//////////////////////////////////////////////////////////////////////

#include "TextureFile.h"

#include <stdlib.h>

#include <stdio.h>

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CTextureFile::CTextureFile( bool editor )

{

	m_data			= NULL;

	m_numData		= 0;

	m_height		= 0;

	m_width			= 0;

	m_frames.x		= 0;

	m_frames.y		= 0;

	m_frames.rows	= 1; 

	m_frames.cols	= 1; 

	m_alpha			= false;

	m_alphamap[0]	= 0;

	m_alphamap[1]	= 0;

	m_alphamap[2]	= 0;

	m_animNum		= 0;

	m_anim			= NULL;

	m_collisionMap	= false;

	m_collisionData = NULL;

	m_numframes		= 0;

	m_framebounds	= NULL;

	m_editor		= editor;

}

CTextureFile::~CTextureFile()

{

	if ( m_data )

		delete[] m_data;

	if ( m_collisionData )

		delete[] m_collisionData;

	if ( m_anim )

	{

		for ( int i = 0; i < m_animNum; i++ )

		{

			if ( m_anim[i].frames )

				delete[] m_anim[i].frames;

			if ( m_anim[i].name )

				delete[] m_anim[i].name;

		}

		if ( m_editor )

			free ( m_anim );

		else

			delete[] m_anim;

	}

	//if ( m_framebounds )

	//	delete [] m_framebounds;

}

STextureData *CTextureFile::CreateData(int width, int height, STextureSize *size )

{

	if ( (!height) || (!width) )

		return NULL;

	size->height  = height;

	size->width   = width;

	size->num = (height * width);

	STextureData *data = new STextureData[size->num];

	for ( int i = 0; i < size->num; i++ )

	{

		data[i].r = 0;

		data[i].g = 0;

		data[i].b = 0;

		data[i].alpha = 255;

	}

	return data;

}

int CTextureFile::LoadTextureTGA(const char *filename )

{

	STextureSize *size = new STextureSize;

	int error;

	m_data = LoadTGA ( filename, size, &error );

	if ( error == TEXTURELOAD_OK )

	{

		m_height = size->height;

		m_width = size->width;

		m_numData = size->num;

	}

	else

	{

		delete [] m_data;

		m_data = NULL;

	}

	if ( m_collisionData )

		delete [] m_collisionData;

	m_collisionMap = false;

	delete [] size;

	return error;

}

int CTextureFile::LoadCollisionTGA(const char *filename )

{

	STextureSize *size = new STextureSize;

	int error;

	STextureData *data = LoadTGA ( filename, size, &error );

	if ( error == TEXTURELOAD_OK )

	{

		if ( (size->height != m_height) || (size->width != m_width) )

			error = TEXTURELOAD_SIZEMISMATCH;

		else

		{

			if ( m_collisionData )

				delete [] m_collisionData;

			m_collisionData = new bool[size->num];

			for ( int i = 0; i < size->num; i++ )

				m_collisionData[i] = (data[i].alpha) ? false : true;

			m_collisionMap = true;

		}

	}

	delete [] data;

	delete [] size;

	return error;

}

bool CTextureFile::SaveTGA ( const char *filename )

{

	FILE *fileID = NULL;

	unsigned char header[18];

	unsigned char *imagedata;

	int i;

	int num;

#ifdef CY_USESECURE

	if ( fopen_s ( &fileID, filename, "wb" ) )

		return false;

#else

	fileID = fopen ( filename, "wb" );

	if ( !fileID )

		return false;

#endif

	for ( i = 0; i < 18; i++ ) //initilise header to all 0's

		header[i] = 0;

	// setup header

	header[2] = 2;

	header[12] = m_width % 256;

	header[13] = (int) (m_width / 256);

	header[14] = m_height % 256;

	header[15] = (int) (m_height / 256);

	header[16] = 32; // 32 bit

	int bitSize = header[16] / 8;

	fwrite(header, sizeof (unsigned char), 22, fileID);   // write header to the file

	imagedata = (unsigned char *)malloc(sizeof(unsigned char) * (m_width * m_height * bitSize));

	num = 0;

	// write colour data

	for ( i = 0; i < (m_width * m_height); i++)

	{

		imagedata[num]		= m_data[i].b;

		imagedata[num +	1]	= m_data[i].g;

		imagedata[num + 2]	= m_data[i].r;

		if ( bitSize == 4 )

			imagedata[num + 3]	= (unsigned char) m_data[i].alpha;

		num += bitSize;

	}

	fwrite ( imagedata, sizeof (unsigned char), m_width * m_height * bitSize, fileID );

	fclose ( fileID );

	return true;

}

STextureData *CTextureFile::LoadTGA(const char *filename, STextureSize *tsize, int *error )

{

    unsigned char type[4];

    unsigned char info[7];

    unsigned char *imageData = NULL;

    int imageWidth, imageHeight;

    int imageBits, size;

	FILE *fileID;

	// open the filename

#ifdef CY_USESECURE

    if ( fopen_s ( &fileID, filename, "r+bt") )

	{

        *error = TEXTURELOAD_NOFILE;

		return NULL;

	}

#else

    if (!(fileID = fopen (filename, "r+bt")))

	{

        *error = TEXTURELOAD_NOFILE;

		return NULL;

	}

#endif

	// get the heading data

    fread (&type, sizeof (char), 3, fileID); // read in colormap info and image type

    fseek (fileID, 12, SEEK_SET);			// seek past the header

    fread (&info, sizeof (char), 6, fileID);

	/*

    if (type[1] != 0 || (type[2] != 2 && type[2] != 3))

	{

		fclose ( fileID );

		return false;

	}*/

	// convert heading to data

    imageWidth = info[0] + info[1] * 256; // get image size from the header

    imageHeight = info[2] + info[3] * 256;

    imageBits =	info[4]; 

    size = imageWidth * imageHeight;  // number of bits in image file

	// check for right format to load

    if ( (imageBits != 32) && (imageBits != 24) ) // invalid format

	{

		*error = TEXTURELOAD_INVALIDFORMAT;

		fclose ( fileID );

		return false;

	}

/*	if ( imageBits != 32 )

	{

		fclose ( fileID );

		*error = TEXTURELOAD_INVALIDFORMAT;

		return NULL;

	}*/

	int bitSize = (imageBits / 8);

	// read the data

    imageData = (unsigned char *)malloc (size * bitSize); 

    if (imageData == NULL)

	{

		fclose ( fileID );

		*error = TEXTURELOAD_INVALIDFORMAT;

		return NULL;

	}

    if ( (int)fread (imageData, sizeof (unsigned char), size * bitSize, fileID) != (int)(size * bitSize) )

	{

        free (imageData);

        *error = TEXTURELOAD_INVALIDFORMAT;

		return NULL;

    }

	// dont use greyscale ?

	// create the data storage

	STextureData *data = CreateData ( imageWidth, imageHeight, tsize );

	if ( !data )

	{

        free (imageData);

        *error = TEXTURELOAD_INVALIDFORMAT;

		return NULL;

	}

	// copy to data storage

	int tempI;

	for ( int i = 0; i < size; i++ )

	{

		tempI = i * bitSize;

		data[i].b = imageData[tempI];

		data[i].g = imageData[tempI + 1];

		data[i].r = imageData[tempI + 2];

		if ( imageBits == 32 )

			data[i].alpha = imageData[tempI + 3];

	}

	free ( imageData );

    fclose (fileID);	

	*error = TEXTURELOAD_OK;

	return data;

}

#ifdef DIRECT3D

LPDIRECT3DTEXTURE9 CTextureFile::CreateTexture(LPDIRECT3DDEVICE9 device)

{

	if ( m_numData < 1 )

		return NULL;

	LPDIRECT3DTEXTURE9 texture;

	if ( FAILED (D3DXCreateTexture ( device, m_width, m_height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture )) )

		return NULL;

    D3DSURFACE_DESC surfDesc;

	texture->GetLevelDesc( 0, &surfDesc );

	int h = surfDesc.Height;

    D3DLOCKED_RECT LockedRect;

    texture->LockRect( 0, &LockedRect, NULL, 0 );

    DWORD* pBits;

    for( DWORD iTexelZ=0; iTexelZ < surfDesc.Height; iTexelZ++ )

    {

        pBits = (DWORD*) ((BYTE*)LockedRect.pBits + (LockedRect.Pitch * iTexelZ));

        for( DWORD iTexelX = 0; iTexelX < surfDesc.Width; iTexelX++ )

        {

			int num = m_numData - ((iTexelZ * surfDesc.Width) + (surfDesc.Width - iTexelX));

            DWORD nRed   = (DWORD)  m_data[num].r;

            DWORD nGreen = (DWORD)  m_data[num].g;

            DWORD nBlue  = (DWORD)  m_data[num].b;

            DWORD nAlpha = (DWORD)  m_data[num].alpha;

			if ( m_alpha )

			{

				if ( (m_data[num].r == m_alphamap[0]) && (m_data[num].g == m_alphamap[1]) && (m_data[num].b == m_alphamap[2]) )

					nAlpha = 0;

			}

            if( nRed > 0xFF )

                nRed = 0xFF;

            if( nGreen > 0xFF )

                nGreen = 0xFF;

            if( nBlue > 0xFF )

                nBlue = 0xFF;

            if( nAlpha > 0xFF )

                nAlpha = 0xFF;

            *pBits = (nAlpha << 24) + (nRed << 16) + (nGreen << 8) + (nBlue << 0);

            pBits++;

		}

	}

	texture->UnlockRect ( 0 );

	return texture;

}

LPDIRECT3DTEXTURE9 CTextureFile::CreateCollisionTexture(LPDIRECT3DDEVICE9 device, DWORD nRed, DWORD nGreen, DWORD nBlue)

{

	if ( (m_numData < 1) || (!m_collisionMap) || (!m_collisionData) )

		return NULL;

	LPDIRECT3DTEXTURE9 texture;

	if ( FAILED (D3DXCreateTexture ( device, m_width, m_height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture )) )

		return NULL;

    D3DSURFACE_DESC surfDesc;

	texture->GetLevelDesc( 0, &surfDesc );

	int h = surfDesc.Height;

    D3DLOCKED_RECT LockedRect;

    texture->LockRect( 0, &LockedRect, NULL, 0 );

    DWORD* pBits;

    for( DWORD iTexelZ=0; iTexelZ < surfDesc.Height; iTexelZ++ )

    {

        pBits = (DWORD*) ((BYTE*)LockedRect.pBits + (LockedRect.Pitch * iTexelZ));

        for( DWORD iTexelX = 0; iTexelX < surfDesc.Width; iTexelX++ )

        {

			int num = m_numData - ((iTexelZ * surfDesc.Width) + (surfDesc.Width - iTexelX));

			DWORD nAlpha = 0xFF;

			if ( m_collisionData[num] )

				nAlpha = 0x00;

            if( nRed > 0xFF )

                nRed = 0xFF;

            if( nGreen > 0xFF )

                nGreen = 0xFF;

            if( nBlue > 0xFF )

                nBlue = 0xFF;

            if( nAlpha > 0xFF )

                nAlpha = 0xFF;

            *pBits = (nAlpha << 24) + (nRed << 16) + (nGreen << 8) + (nBlue << 0);

            pBits++;

		}

	}

	texture->UnlockRect ( 0 );

	return texture;

}

#endif

bool CTextureFile::Save(const char *filename)

{

	// create header

	SFileHeader header;

	ClearHeader ( &header );

	// open file

	FILE *id;

#ifdef CY_USESECURE

	if ( fopen_s ( &id, filename, "wb" )  )

		return false;

#else

	if ( (id = fopen ( filename, "wb" )) == NULL )

		return false;

#endif

	// write version numbers (used incase header needs to change in later versions)

	float version = (float) TEXTUREFILE_VERSION;

	fwrite ( &version, sizeof ( float ), 1, id );

	// write header to file

	header.width		= m_width;

	header.height		= m_height;

	header.frames		= false;

	header.alpha		= m_alpha;

	header.alphamap[0]	= m_alphamap[0];

	header.alphamap[1]	= m_alphamap[1];

	header.alphamap[2]	= m_alphamap[2];

	if ( m_animNum )

		header.frames = true;

	fwrite ( &header, sizeof ( SFileHeader ), 1, id );

	// * Added since verison 1.20

	fwrite ( &m_collisionMap, sizeof ( bool ), 1, id );

	// write all the data

	fwrite ( m_data, sizeof ( STextureData ), m_numData, id );

	// write frames data

	fwrite ( &m_frames, sizeof ( STextureFrames ), 1, id );

	int animNum = 0;

	int i;

	for ( i = 0; i < m_animNum; i++ )

	{

		if ( !m_anim[i].remove )

			animNum++;

	}

	fwrite ( &animNum, sizeof ( int ), 1, id );

	SAnimation *anim;

	for ( i = 0; i < m_animNum; i++ )

	{

		anim = &m_anim[i];

		if ( !anim->remove )

		{

			int size = (int)strlen ( anim->name ) + 1;

			fwrite ( &size, sizeof ( int ), 1, id );

			fwrite ( anim->name, sizeof ( char ), size, id );

			fwrite ( &anim->amt, sizeof ( int ), 1, id );

			fwrite ( &anim->delay, sizeof ( int ), 1, id );

			fwrite ( &anim->cont, sizeof ( bool ), 1, id );

			fwrite ( anim->frames, sizeof ( int ), anim->amt, id );

		}

	}

	if ( m_collisionMap )

		fwrite ( m_collisionData, sizeof ( bool ), m_numData, id );

	fclose ( id );

	return true;

}

void CTextureFile::ClearHeader(SFileHeader *header)

{

	header->alpha = false;

	header->alphamap[0] = 0;

	header->alphamap[1] = 0;

	header->alphamap[2] = 0;

	header->frames = false;

	header->height = 0;

	header->width = 0;

}

bool CTextureFile::Load(const char *filename)

{

	// create header

	SFileHeader header;

	ClearHeader ( &header );

	// open file

	FILE *id;

#ifdef CY_USESECURE

	if ( fopen_s ( &id, filename, "rb" ) )

		return false;

#else

	if ( (id = fopen ( filename, "rb" )) == NULL )

		return false;

#endif

	// read version numbers (used incase header needs to change in later versions)

	float version;

	fread ( &version, sizeof ( float ), 1, id );

	if ( version < 1.00 )

		return false;

	// read header from file

	fread ( &header, sizeof ( SFileHeader ), 1, id );

	m_width			= header.width;

	m_height		= header.height;

	m_numData		= m_width * m_height;

	m_alpha			= header.alpha;

	m_alphamap[0]   = header.alphamap[0];

	m_alphamap[1]   = header.alphamap[1];

	m_alphamap[2]   = header.alphamap[2];

	m_alpha			= header.alpha;

	// * Added since version 1.20

	if ( version > 1.20 )

		fread ( &m_collisionMap, sizeof ( bool ), 1, id );

	// read all the data

	m_data = new STextureData[m_numData];	

	if ( fread ( m_data, sizeof ( STextureData ), m_numData, id ) != m_numData )

		return false;

	fread ( &m_frames, sizeof ( STextureFrames ), 1, id );

	if ( (version >= 1.1) && (header.frames) )

	{

		// read number of animations

		int fnum, size;

		fread ( &fnum, sizeof ( int ), 1, id );

		if ( m_anim )

		{

			if ( m_editor )

				free ( m_anim );

			else

				delete []m_anim;

		}

		if ( !fnum )

			m_anim = NULL;

		else

		{

			if ( m_editor )

				m_anim = (SAnimation *)malloc(sizeof ( SAnimation ) * fnum);

			else

				m_anim = new SAnimation[fnum];

		}

		SAnimation *anim;

		for ( int i = 0; i < fnum; i++ )

		{

			anim = &m_anim[i];

			fread ( &size, sizeof ( int ), 1, id );

			anim->name = new char[size];

			fread ( anim->name, sizeof ( char ), size, id );

			fread ( &anim->amt, sizeof ( int ), 1, id );

			fread ( &anim->delay, sizeof ( int ), 1, id );

			fread ( &anim->cont, sizeof ( bool ), 1, id );

			anim->remove = false;

			anim->frames = new int[anim->amt];

			fread ( anim->frames, sizeof ( int ), anim->amt, id );

		}

		m_animNum = fnum;

	}

	if ( m_collisionMap )

	{

		m_collisionData = new bool[m_numData];	

		if ( fread ( m_collisionData, sizeof ( bool ), m_numData, id ) != m_numData )

			return false;

	}

	fclose ( id );

	m_numframes = m_frames.x * m_frames.y;

	m_framebounds = new SFrameBounds[m_numframes];

	for ( int i = 0; i < m_numframes; i++ )

	{

		m_framebounds[i].minx = ComputeMinAlphaX ( i );

		m_framebounds[i].maxx = ComputeMaxAlphaX ( i );

		m_framebounds[i].miny = ComputeMinAlphaY ( i );

		m_framebounds[i].maxy = ComputeMaxAlphaY ( i );

	}

	return true;

}

void CTextureFile::SetFrameSize(int width, int height)

{

	m_frames.x = width;

	m_frames.y = height;

}

const STextureFrames *CTextureFile::GetFrames()

{

	return &m_frames;

}

int CTextureFile::GetFrameWidth()

{

	return m_frames.x;

}

int CTextureFile::GetFrameHeight()

{

	return m_frames.y;

}

void CTextureFile::SetFrames(int rows, int cols)

{

	m_frames.rows = rows;

	m_frames.cols = cols;

}

void CTextureFile::EnableAlphamap(bool enable)

{

	m_alpha = enable;

}

bool CTextureFile::GetAlphaMap()

{

	return m_alpha;

}

void CTextureFile::SetAlphaMap(int red, int green, int blue)

{

	m_alphamap[0] = red;

	m_alphamap[1] = green;

	m_alphamap[2] = blue;

}

bool CTextureFile::GetAlphaMap(int *red, int *green, int *blue)

{

	*red   = m_alphamap[0];

	*green = m_alphamap[1];

	*blue  = m_alphamap[2];

	return m_alpha;

}

SAnimation * CTextureFile::AddNewAnimation(const char *name)

{

	SAnimation *anim = NULL;

	// first, find if theres any free slots

	for ( int i = 0; i < m_animNum; i++ )

	{

		// found a free slot

		if ( m_anim[i].remove )

		{

			anim = &m_anim[i];

			// make sure old data is cleared before using

			if ( anim->frames )

				delete []anim->frames;

			if ( anim->name )

				delete []anim->name;

			break;

		}

	}

	// no free slot ? add a new one to the end of the array

	if ( !anim )

	{

		++m_animNum;

		m_anim = (SAnimation *)realloc(m_anim, sizeof ( SAnimation ) * m_animNum);

		anim = &m_anim[m_animNum - 1];

	}

	// set default data for animation

	anim->amt = 1;

	anim->frames = new int[1];

	anim->remove = false;

	anim->frames[0] = 1;

	anim->cont = false;

	anim->delay = 1;

	anim->name = new char[strlen (name) + 1];

#ifdef CY_USESECURE

	strcpy_s ( anim->name, strlen (name) + 1, name );

#else

	strcpy ( anim->name, name );

#endif

	// return pointer to created animation

	return anim;

}

int CTextureFile::GetAnimationNum()

{

	return m_animNum;

}	

SAnimation * CTextureFile::FindAnimation(const char *search)

{

	Utils::String sSearch(search);

	for ( int i = 0; i < m_animNum; i++ ) {

		if ( !m_anim[i].remove ) {

			if ( sSearch.Compare(m_anim[i].name) ) {

				return &m_anim[i];

			}

		}

	}

	return NULL;

}

SAnimation * CTextureFile::GetAnimation(int num)

{

	if ( (m_animNum < num) || (num < 0) )

		return NULL;

	return &m_anim[num];

}

void CTextureFile::SetEditor()

{

	m_editor = true;

}

void IncAnimationFrame ( SPlayAnimation *anim, int *times )

{

	IncAnimationFrame ( anim, false, times );

}

void IncAnimationFrame ( SPlayAnimation *anim, bool endstop, int *times )

{

	if ( !anim )

		return;

	if ( !anim->anim )

		return;

	++anim->delay;

	if ( anim->delay >= anim->anim->delay )

	{

		anim->delay = 0;

		++anim->curframe;

		if ( anim->curframe > anim->anim->amt )

		{

			if ( anim->anim->cont )

			{

				anim->curframe = 1;

				if ( times )

					++(*times);

			}

			else if ( endstop )

				--anim->curframe;

			else

				anim->anim = NULL;

		}

	}

}

void DecAnimationFrame ( SPlayAnimation *anim, int *times )

{

	DecAnimationFrame ( anim, false, times );

}

void DecAnimationFrame ( SPlayAnimation *anim, bool endstop, int *times )

{

	if ( !anim )

		return;

	if ( !anim->anim )

		return;

	++anim->delay;

	if ( anim->delay >= anim->anim->delay )

	{

		anim->delay = 0;

		--anim->curframe;

		if ( anim->curframe < 1 )

		{

			if ( anim->anim->cont )

			{

				anim->curframe = anim->anim->amt;

				if ( times )

					++(*times);

			}

			else if ( endstop )

				anim->curframe = 1;

			else

				anim->anim = NULL;

		}

	}

}

void ResetAnimation ( SPlayAnimation *anim )

{

	if ( !anim )

		return;

	anim->anim = NULL;

	anim->delay = 0;

	anim->curframe = 1;

	anim->reverse = false;

}

void DoAnimation ( SPlayAnimation *anim, bool endstopinc, bool endstopdec, int *times )

{

	if ( !anim )

		return;

	if ( anim->reverse )

		DecAnimationFrame ( anim, endstopdec, times );

	else

		IncAnimationFrame ( anim, endstopinc, times );

}

bool CTextureFile::CheckAlpha(int x, int y, int frame, bool inccollisionmap)

{

	int row = ((frame - 1) / m_frames.cols) + 1;

	int col = frame % m_frames.cols;

	if ( col == 0)

		col = m_frames.cols;

	int newx = ((col - 1) * m_frames.x) + x;

	int newy = ((row - 1) * m_frames.y) + y;

	int num = (newy * m_width) + newx;

	if ( (num < 0) || (num > (m_width * m_height)) )

		return false;

	if ( (inccollisionmap) && (m_collisionMap) && (m_collisionData) )

		return m_collisionData[num];

	int r = m_data[num].r;

	int g = m_data[num].g;

	int b = m_data[num].b;

	int a = m_data[num].alpha;

	if ( m_data[num].alpha == 0 )

		return true;

	if ( m_alpha )

	{

		if ( (m_data[num].r == m_alphamap[0]) && (m_data[num].g == m_alphamap[1]) && (m_data[num].b == m_alphamap[2]) )

			return true;

	}

	return false;

}

std::string CTextureFile::GetErrorText ( int error )

{

	switch ( error )

	{

		case TEXTURELOAD_OK:

			return "";

		case TEXTURELOAD_NOFILE:

			return "unable to open file";

		case TEXTURELOAD_SIZEMISMATCH:

			return "size mismatch";

		case TEXTURELOAD_INVALIDFORMAT:

			return "Invalid Format";

	}

	return "Unknown Error";

}

int CTextureFile::ComputeMinAlphaX ( int frame )

{

	for ( unsigned int x = 0; x < m_frames.x; x++ )

	{

		for ( unsigned int y = 0; y < m_frames.y; y++ )

		{

			if ( !CheckAlpha ( x, y, frame ) )

				return x;

		}

	}

	return 0;

}

int CTextureFile::ComputeMaxAlphaX ( int frame )

{

	for ( unsigned int x = m_frames.x - 1; x >= 0; x-- )

	{

		for ( unsigned int y = 0; y < m_frames.y; y++ )

		{

			if ( !CheckAlpha ( x, y, frame ) )

				return x;

		}

	}

	return m_frames.x - 1;

}

int CTextureFile::ComputeMinAlphaY ( int frame )

{

	for ( unsigned int y = 0; y < m_frames.y; y++ )

	{

		for ( unsigned int x = 0; x < m_frames.x; x++ )

		{

			if ( !CheckAlpha ( x, y, frame ) )

				return y;

		}

	}

	return 0;

}

int CTextureFile::ComputeMaxAlphaY ( int frame )

{

	for ( unsigned int y = m_frames.y - 1; y >= 0; y-- )

	{

		for ( unsigned int x = 0; x < m_frames.x; x++ )

		{

			if ( !CheckAlpha ( x, y, frame ) )

				return y;

		}

	}

	return m_frames.y - 1;

}