void AnimationTests::release() {
CIndieLib* iLib = CIndieLib::instance();
//Release all variables from indieLib before exiting
for (int i = 0; i < _testedEntities; ++i) {
iLib->_animationManager->remove(_animations[i]);
iLib->_entity2dManager->remove(_entities[i]);
}
DISPOSEARRAY(_animations);
DISPOSEARRAY(_entities);
}
void SurfaceTests_wrap::release() {
CIndieLib* iLib = CIndieLib::instance();
//Release all variables from indieLib before exiting
for (int i = 0; i < _testedEntities; ++i) {
iLib->_surfaceManager->remove(_surfaces[i]);
iLib->_entity2dManager->remove(_entities[i]);
}
DISPOSEARRAY(_surfaces);
DISPOSEARRAY(_entities);
}
/**
* This function returns 1 (true) if the 3d Mesh object passed as parameter exists and is
* deleted from the manager successfully.
* @param pMe Pointer to an 3d Mesh object.
*/
bool IND_3dMeshManager::remove(IND_3dMesh *pMe) {
g_debug->header("Freeing 3d Mesh", 5);
if (!_ok || !pMe) {
writeMessage();
return 0;
}
// Search object
bool mIs = 0;
list <IND_3dMesh *>::iterator _listIter;
for (_listIter = _list3dMesh->begin();
_listIter != _list3dMesh->end();
_listIter++) {
if ((*_listIter) == pMe) {
mIs = 1;
break;
}
}
// Not found
if (!mIs) {
writeMessage();
return 0;
}
// ----- Free object -----
g_debug->header("Freeing 3d mesh:", 3);
g_debug->dataChar(pMe->GetMeshName(), 1);
// Quit from list
delFromlist(pMe);
// Free mesh
if (pMe->_3dMesh._animController) {
pMe->_3dMesh._animController->Release();
pMe->_3dMesh._animController = 0;
}
// free hierarchy
if (pMe->_3dMesh._frameRoot) {
// Create a mesh heirarchy class to control the removal of memory for the frame heirarchy
XMeshHierarchy memoryAllocator;
D3DXFrameDestroy(pMe->_3dMesh._frameRoot, &memoryAllocator);
pMe->_3dMesh._frameRoot = 0;
}
// Free bones
if (pMe->_3dMesh._boneMatrices) {
DISPOSEARRAY(pMe->_3dMesh._boneMatrices);
}
// Free the pointer
DISPOSE(pMe);
g_debug->header("Ok", 6);
return 1;
}
/**
* Sets the text that is going to be shown on screen.
* Default: "" (Empty String).
* @param pText Text to draw in the screen.
*/
void IND_Entity2d::setText(const char *pText) {
if (pText) {
DISPOSEARRAY(_text);
size_t textSize = strlen(pText);
//Reallocate text on heap memory. Characters in string +1 (line ending)
_text = new char [textSize + 1];
//Cooy string contents
strcpy(_text,pText);
}
}
IND_Entity2d::~IND_Entity2d() {
if (_listBoundingCollision) {
list<BOUNDING_COLLISION*>::iterator itr;
for (itr = _listBoundingCollision->begin(); itr != _listBoundingCollision->end();++itr) {
delete (*itr);
}
}
DISPOSE(_listBoundingCollision);
DISPOSEARRAY(_text);
}
/**
* Delete manager variables.
*/
void IND_3dMeshManager::freeVars() {
// Deletes all the manager entities
list <IND_3dMesh *>::iterator _listIter;
for (_listIter = _list3dMesh->begin();
_listIter != _list3dMesh->end();
_listIter++) {
g_debug->header("Freeing 3d mesh:", 3);
g_debug->dataChar((*_listIter)->GetMeshName(), 1);
// Free mesh
if ((*_listIter)->_3dMesh._animController) {
(*_listIter)->_3dMesh._animController->Release();
(*_listIter)->_3dMesh._animController = 0;
}
// Free heirarchy
if ((*_listIter)->_3dMesh._frameRoot) {
// Create a mesh heirarchy class to control the removal of memory for the frame heirarchy
XMeshHierarchy memoryAllocator;
D3DXFrameDestroy((*_listIter)->_3dMesh._frameRoot, &memoryAllocator);
(*_listIter)->_3dMesh._frameRoot = 0;
}
// Free bones
if ((*_listIter)->_3dMesh._boneMatrices) {
DISPOSEARRAY((*_listIter)->_3dMesh._boneMatrices);
}
}
// Clear list
_list3dMesh->clear();
// Free list
DISPOSE(_list3dMesh);
}
bool OpenGLTextureBuilder::createNewTexture(IND_Surface *pNewSurface,
IND_Image *pImage,
int pBlockSizeX,
int pBlockSizeY) {
#ifdef _DEBUG
GLboolean enabled;
glGetBooleanv(GL_TEXTURE_2D,&enabled);
if (GL_FALSE == enabled){
g_debug->header("GL Textures not enabled!!", DebugApi::LogHeaderError);
return false;
}
#endif
// ----- Cutting blocks -----
INFO_SURFACE mI;
_cutter->fillInfoSurface(pImage, &mI, pBlockSizeX, pBlockSizeY);
pNewSurface->freeTextureData(); //Guard against using same texture data all over again in same surface
pNewSurface->_surface = new SURFACE(mI._numBlocks,mI._numVertices);
pNewSurface->_surface->_attributes._type = mI._type;
pNewSurface->_surface->_attributes._quality = mI._quality;
pNewSurface->_surface->_attributes._blocksX = mI._blocksX;
pNewSurface->_surface->_attributes._blocksY = mI._blocksY;
pNewSurface->_surface->_attributes._spareX = mI._spareX;
pNewSurface->_surface->_attributes._spareY = mI._spareY;
pNewSurface->_surface->_attributes._numBlocks = mI._numBlocks;
pNewSurface->_surface->_attributes._numTextures = mI._numBlocks;
pNewSurface->_surface->_attributes._isHaveGrid = 0;
pNewSurface->_surface->_attributes._widthBlock = mI._widthBlock;
pNewSurface->_surface->_attributes._heightBlock = mI._heightBlock;
pNewSurface->_surface->_attributes._width = mI._widthImage;
pNewSurface->_surface->_attributes._height = mI._heightImage;
pNewSurface->_surface->_attributes._isHaveSurface = 1;
assert(pNewSurface->_surface->_texturesArray); //Should have allocated textures array!
glGenTextures(mI._numBlocks,pNewSurface->_surface->_texturesArray);
GLenum glerror = glGetError();
if (glerror) {
g_debug->header("OpenGL error while creating textures ", DebugApi::LogHeaderError);
return false;
}
GLint mInternalFormat, mFormat, mType;
//Get format and type of surface (image) in GL types (and check for compatibilities)
getGLFormat(pNewSurface,pImage,&mInternalFormat,&mFormat,&mType);
// ----- Vertex creation -----
// Current position of the vertex
int mPosX = 0;
int mPosY = mI._heightImage;
int mPosZ = 0;
// Position in wich we are storing a vertex
int mPosVer = 0;
// Position in wich we are storing a texture
int mCont = 0;
// Image pointer
unsigned char *mPtrBlock = pImage->getPointer();
// Vars
int mActualWidthBlockX (0);
int mActualHeightBlockY (0);
float mActualU (0);
float mActualV (0);
int mActualSpareX (0);
int mActualSpareY (0);
int mSrcBytespp = pImage->getBytespp();
// ----- Cutting blocks -----
// We iterate the blocks starting from the lower row
// We MUST draw the blocks in this order, because the image starts drawing from the lower-left corner
//LOOP - All blocks (Y coords)
for (int i = mI._blocksY; i > 0; i--) {
//LOOP - All blocks (X coords)
for (int j = 1; j < mI._blocksX + 1; j++) {
// ----- Vertices position of the block -----
// There are 4 types of blocks: the ones of the right column, the ones of the upper row,
// the one of the upper-right corner and the rest of blocks.
// Depending on the block, we store the vertices one way or another.
// Normal block
if (i != 1 && j != mI._blocksX) {
mActualWidthBlockX = mI._widthBlock;
mActualHeightBlockY = mI._heightBlock;
mActualU = 1.0f;
mActualV = 1.0f;
mActualSpareX = 0;
mActualSpareY = 0;
}
// The ones of the right column
if (i != 1 && j == mI._blocksX) {
mActualWidthBlockX = mI._widthSpareImage;
mActualHeightBlockY = mI._heightBlock;
mActualU = (float) mI._widthSpareImage / mI._widthBlock;
mActualV = 1.0f;
mActualSpareX = mI._spareX;
mActualSpareY = 0;
}
// The ones of the upper row
if (i == 1 && j != mI._blocksX) {
mActualWidthBlockX = mI._widthBlock;
mActualHeightBlockY = mI._heightSpareImage;
mActualU = 1.0f;
mActualV = (float) mI._heightSpareImage / mI._heightBlock;
mActualSpareX = 0;
mActualSpareY = mI._spareY;
}
// The one of the upper-right corner
if (i == 1 && j == mI._blocksX) {
mActualWidthBlockX = mI._widthSpareImage;
mActualHeightBlockY = mI._heightSpareImage;
mActualU = (float) mI._widthSpareImage / mI._widthBlock;
mActualV = (float) mI._heightSpareImage / mI._heightBlock;
mActualSpareX = mI._spareX;
mActualSpareY = mI._spareY;
}
// ----- Block creation (using the position, uv coordiantes and texture) -----
// We push into the buffer the 4 vertices of the block
push4Vertices(pNewSurface->_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
mPosX, // x
mPosY, // y
mPosZ, // z
mActualWidthBlockX, // Block width
mActualHeightBlockY, // Block height
mActualU, // U mapping coordinate
mActualV); // V mapping coordinate
// Cuts a block from the image (bitmap)
unsigned char *mTempBlock = 0;
_cutter->cutBlock(mPtrBlock,
mI._widthImage,
mI._widthBlock,
mI._heightBlock,
mActualSpareX,
mActualSpareY,
mSrcBytespp,
&mTempBlock);
// We create a texture using the cut bitmap block
glBindTexture(GL_TEXTURE_2D,pNewSurface->_surface->_texturesArray[mCont]);
glTexImage2D(GL_TEXTURE_2D,
0,
mInternalFormat,
mI._widthBlock,
mI._heightBlock,
0,
mFormat,
mType,
mTempBlock);
// Free the bitmap cutted block
DISPOSEARRAY(mTempBlock);
GLenum glerror = glGetError();
if (glerror) {
g_debug->header("OpenGL error while assigning texture to buffer", DebugApi::LogHeaderError);
//TODO: Test error and mem. leaks
return false;
}
// ----- Advance -----
// Increase in 4 vertices the position (we have already stored a quad)
mPosVer += 4;
// Increase the texture counter (we have alread stored one texture)
mCont++;
// ----- Column change -----
// We point to the next block (memory and screen)
mPosX += mI._widthBlock;
mPtrBlock += mI._widthBlock * mSrcBytespp;
}//LOOP END - All blocks (Y coords)
// ----- Row change -----
// We point to the next block (memory and screen)
mPosX = 0;
mPtrBlock -= mI._spareX * mSrcBytespp;
// If this block is in the last row, we take in count the spare areas.
if (i == 1) {
mPosY -= mI._spareY;
mPtrBlock += (mI._widthImage * mSrcBytespp) * (mI._spareY - 1);
} else {
mPosY -= mI._heightBlock;
mPtrBlock += (mI._widthImage * mSrcBytespp) * (mI._heightBlock - 1);
}
} //LOOP END - All blocks (Y coords)
return true;
}
IND_Entity2d::~IND_Entity2d() {
DISPOSE(_listBoundingCollision);
DISPOSEARRAY(_text);
}
/**
* Sets a grid to the ::IND_Surface object. A grid is just a mesh which vertices
* can be moved in order to deform the graphical object. You can set grids of different levels
* of tesselation.
*
* Using grids you can apply lot of different morphing effects to your sprites or animations
* (waves, bubble animation, etc). It is also possible to change the position of all the vertices
* so it would be possible to create for example a "snake" sprite that could simulate the crawling
* when moving.
*
* There is a restriction: the amount of horizontal and vertical blocks should be power of two.
*
* Example:
* - SetGrid ( 4, 4) => Correct!
* - SetGrid (16, 2) => Correct!
* - SetGrid ( 1, 8) => Correct!
* - SetGrid ( 1, 3) => Incorrect!
*
* @param pNumBlocksX Number of horizontal blocks.
* @param pNumBlocksY Number of vertical blocks.
*/
bool IND_Surface::setGrid(int pNumBlocksX, int pNumBlocksY) {
// At least one block
if (pNumBlocksX < 1 || pNumBlocksY < 1) return 0;
// Only power of two values allowed
IND_Math mMath;
if (!mMath.isPowerOfTwo(pNumBlocksX) || !mMath.isPowerOfTwo(pNumBlocksY)) return 0;
// Only 1-texture-IND_Surfaces allowed
if (getNumTextures() != 1) return 0;
// Reset attributes
_surface->_attributes._isHaveGrid = 1;
_surface->_attributes._blocksX = pNumBlocksX;
_surface->_attributes._blocksY = pNumBlocksY;
_surface->_attributes._widthBlock = (_surface->_attributes._width / _surface->_attributes._blocksX);
_surface->_attributes._heightBlock = (_surface->_attributes._height / _surface->_attributes._blocksY);
_surface->_attributes._numBlocks = _surface->_attributes._blocksX * _surface->_attributes._blocksY;
// Reset the vertex array
DISPOSEARRAY(_surface->_vertexArray);
_surface->_vertexArray = new CUSTOMVERTEX2D [_surface->_attributes._blocksX * _surface->_attributes._blocksY * 4];
// Current position of the vertex
int _posX = 0;
int _posY = _surface->_attributes._height;
int mPosZ = 0;
// Position in which we are storing a vertex
int mPosVer = 0;
// Create the new vertex array
// We iterate the blocks starting from the lower row
// We MUST draw the blocks in this order, because the image starts drawing from the lower-left corner
for (int i = getBlocksY(); i > 0; i--) {
for (int j = 1; j < getBlocksX() + 1; j++) {
// ----- Block creation (using the position, uv coordiantes and texture) -----
// We push into the buffer the 4 vertices of the block
// Normal block
if (i != 1 && j != getBlocksX()) {
push4Vertices(_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
_posX, // x
_posY, // y
mPosZ, // z
_surface->_attributes._widthBlock, // Block width
_surface->_attributes._heightBlock, // Block height
_surface->_attributes._width, // U mapping coordinate
_surface->_attributes._height); // V mapping coordinate
}
// The ones of the right column
if (i != 1 && j == getBlocksX()) {
push4Vertices(_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
_posX, // x
_posY, // y
mPosZ, // z
_surface->_attributes._widthBlock, // Block width
_surface->_attributes._heightBlock, // Block height
_surface->_attributes._width, // U mapping coordinate
_surface->_attributes._height); // V mapping coordinate
}
// The ones of the upper row
if (i == 1 && j != getBlocksX()) {
push4Vertices(_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
_posX, // x
_posY, // y
mPosZ, // z
_surface->_attributes._widthBlock, // Block width
_surface->_attributes._heightBlock, // Block height
_surface->_attributes._width, // U mapping coordinate
_surface->_attributes._height); // V mapping coordinate
}
// The one of the upper-right corner
if (i == 1 && j == getBlocksX()) {
push4Vertices(_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
_posX, // x
_posY, // y
mPosZ, // z
_surface->_attributes._widthBlock, // Block width
_surface->_attributes._heightBlock, // Block height
_surface->_attributes._width, // U mapping coordinate
_surface->_attributes._height); // V mapping coordinate
}
// ----- Advance -----
// Increase the vertex's position by 4
mPosVer += 4;
// ----- Column change -----
// We point to the next block
_posX += _surface->_attributes._widthBlock;
}
// ----- Row change -----
// We point to the next block
_posX = 0;
_posY -= _surface->_attributes._heightBlock;
}
return 1;
}
bool DirectXTextureBuilder::createNewTexture(IND_Surface *pNewSurface,
IND_Image *pImage,
int pBlockSizeX,
int pBlockSizeY) {
//pType and pQuality are the requested texture parameters, not the actual image type.
bool success = false;
// ----- Check IND_Type and IND_Quality of the image and choose a D3D source and destination format -----
// ----- Source and destination DirectX format ------
D3DFORMAT mSrcFormat, mDstFormat;
getSourceAndDestinationFormat(pImage,&mSrcFormat,&mDstFormat);
// ----- Cutting blocks -----
// ----- Obtaining info in order to store the image -----
INFO_SURFACE mI;
_cutter->fillInfoSurface(pImage, &mI, pBlockSizeX, pBlockSizeY);
// Fill attributes
pNewSurface->_surface->_attributes._type = mI._type;
pNewSurface->_surface->_attributes._quality = mI._quality;
pNewSurface->_surface->_attributes._blocksX = mI._blocksX;
pNewSurface->_surface->_attributes._blocksY = mI._blocksY;
pNewSurface->_surface->_attributes._spareX = mI._spareX;
pNewSurface->_surface->_attributes._spareY = mI._spareY;
pNewSurface->_surface->_attributes._numBlocks = mI._blocksX * mI._blocksY;
pNewSurface->_surface->_attributes._numTextures = mI._blocksX * mI._blocksY;
pNewSurface->_surface->_attributes._isHaveGrid = 0;
pNewSurface->_surface->_attributes._widthBlock = mI._widthBlock;
pNewSurface->_surface->_attributes._heightBlock = mI._heightBlock;
pNewSurface->_surface->_attributes._width = mI._widthImage;
pNewSurface->_surface->_attributes._height = mI._heightImage;
pNewSurface->_surface->_attributes._isHaveSurface = 1;
// Allocate space for the vertex buffer
// This buffer will be used for drawing the IND_Surface using DrawPrimitiveUp
pNewSurface->_surface->_vertexArray = new CUSTOMVERTEX2D [mI._numVertices];
// Each block, needs a texture. We use an array of textures in order to store them.
pNewSurface->_surface->_texturesArray = new TEXTURE [mI._blocksX * mI._blocksY];
// Current position of the vertex
int mPosX = 0;
int mPosY = mI._heightImage;
int mPosZ = 0;
// Position in wich we are storing a vertex
int mPosVer = 0;
// Position in wich we are storing a texture
int mCont = 0;
// Image pointer
BYTE *mPtrBlock = pImage->getPointer();
// Vars
int mActualWidthBlockX (0);
int mActualHeightBlockY (0);
float mActualU (0.0f);
float mActualV (0.0f);
int mActualSpareX (0);
int mActualSpareY (0);
int mSrcBytespp = pImage->getBytespp();
// ----- Cutting blocks -----
// We iterate the blocks starting from the lower row
// We MUST draw the blocks in this order, because the image starts drawing from the lower-left corner
//LOOP - All blocks (Y coords)
for (int i = mI._blocksY; i > 0; i--) {
//LOOP - All blocks (X coords)
for (int j = 1; j < mI._blocksX + 1; j++) {
// ----- Vertices position of the block -----
// There are 4 types of blocks: the ones of the right column, the ones of the upper row,
// the one of the upper-right corner and the rest of blocks.
// Depending on the block, we store the vertices one way or another.
// Normal block
if (i != 1 && j != mI._blocksX) {
mActualWidthBlockX = mI._widthBlock;
mActualHeightBlockY = mI._heightBlock;
mActualU = 1.0f;
mActualV = 1.0f;
mActualSpareX = 0;
mActualSpareY = 0;
}
// The ones of the right column
if (i != 1 && j == mI._blocksX) {
mActualWidthBlockX = mI._widthSpareImage;
mActualHeightBlockY = mI._heightBlock;
mActualU = (float) mI._widthSpareImage / mI._widthBlock;
mActualV = 1.0f;
mActualSpareX = mI._spareX;
mActualSpareY = 0;
}
// The ones of the upper row
if (i == 1 && j != mI._blocksX) {
mActualWidthBlockX = mI._widthBlock;
mActualHeightBlockY = mI._heightSpareImage;
mActualU = 1.0f;
mActualV = (float) mI._heightSpareImage / mI._heightBlock;
mActualSpareX = 0;
mActualSpareY = mI._spareY;
}
// The one of the upper-right corner
if (i == 1 && j == mI._blocksX) {
mActualWidthBlockX = mI._widthSpareImage;
mActualHeightBlockY = mI._heightSpareImage;
mActualU = (float) mI._widthSpareImage / mI._widthBlock;
mActualV = (float) mI._heightSpareImage / mI._heightBlock;
mActualSpareX = mI._spareX;
mActualSpareY = mI._spareY;
}
// ----- Block creation (using the position, uv coordiantes and texture) -----
// We push into the buffer the 4 vertices of the block
push4Vertices(pNewSurface->_surface->_vertexArray, // Pointer to the buffer
mPosVer, // Position in wich we are storing a vertex
mPosX, // x
mPosY, // y
mPosZ, // z
mActualWidthBlockX, // Block width
mActualHeightBlockY, // Block height
mActualU, // U mapping coordinate
mActualV); // V mapping coordinate
// Cuts a block from the image (bitmap)
BYTE *mTempBlock = 0;
_cutter->cutBlock(mPtrBlock,
mI._widthImage,
mI._widthBlock,
mI._heightBlock,
mActualSpareX,
mActualSpareY,
mSrcBytespp,
&mTempBlock);
// We create a texture using the cut bitmap block
pNewSurface->_surface->_texturesArray [mCont]._texture = createTexture(mTempBlock,
mI._widthBlock,
mI._heightBlock,
mSrcBytespp,
mSrcFormat,
mDstFormat);
// Free the bitmap cutted block
DISPOSEARRAY(mTempBlock);
// ----- Advance -----
// Increase in 4 vertices the position (we have already stored a quad)
mPosVer += 4;
// Increase the texture counter (we have alread stored one texture)
mCont++;
// ----- Column change -----
// We point to the next block (memory and screen)
mPosX += mI._widthBlock;
mPtrBlock += mI._widthBlock * mSrcBytespp;
}//LOOP END - All blocks (Y coords)
// ----- Row change -----
// We point to the next block (memory and screen)
mPosX = 0;
mPtrBlock -= mI._spareX * mSrcBytespp;
// If this block is in the last row, we take in count the spare areas.
if (i == 1) {
mPosY -= mI._spareY;
mPtrBlock += (mI._widthImage * mSrcBytespp) * (mI._spareY - 1);
} else {
mPosY -= mI._heightBlock;
mPtrBlock += (mI._widthImage * mSrcBytespp) * (mI._heightBlock - 1);
}
}//LOOP END - All blocks (Y coords)
success = true;
return success;
}