axmol/cocos2dx/textures/CCTextureAtlas.cpp

381 lines
9.8 KiB
C++
Raw Normal View History

/****************************************************************************
Copyright (c) 2010 cocos2d-x.org
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "Cocos2dDefine.h"
// cocos2d
#include "CCTextureAtlas.h"
#include "CCTextureCache.h"
#include "ccMacros.h"
// support
#include "CCTexture2D.h"
#include <math.h>
//According to some tests GL_TRIANGLE_STRIP is slower, MUCH slower. Probably I'm doing something very wrong
// implementation CCTextureAtlas
2010-08-04 15:46:12 +08:00
namespace cocos2d {
CCTextureAtlas::CCTextureAtlas()
{
}
CCTextureAtlas::~CCTextureAtlas()
{
CCLOGINFO("cocos2d: deallocing CCTextureAtlas.");
CCX_SAFE_FREE(m_pQuads)
CCX_SAFE_FREE(m_pIndices)
#if CC_TEXTURE_ATLAS_USES_VBO
glDeleteBuffers(2, m_pBuffersVBO);
#endif // CC_TEXTURE_ATLAS_USES_VBO
2010-09-04 15:24:26 +08:00
CCX_SAFE_RELEASE(m_pTexture);
}
unsigned int CCTextureAtlas::getTotalQuads()
{
return m_uTotalQuads;
}
unsigned int CCTextureAtlas::getCapacity()
{
return m_uCapacity;
}
CCTexture2D* CCTextureAtlas::getTexture()
{
return m_pTexture;
}
void CCTextureAtlas::setTexture(CCTexture2D * var)
{
m_pTexture = var;
2010-09-04 15:24:26 +08:00
CCX_SAFE_RETAIN(m_pTexture);
}
ccV3F_C4B_T2F_Quad* CCTextureAtlas::getQuads()
{
return m_pQuads;
}
void CCTextureAtlas::setQuads(ccV3F_C4B_T2F_Quad *var)
{
m_pQuads = var;
}
// TextureAtlas - alloc & init
CCTextureAtlas * CCTextureAtlas::textureAtlasWithFile(const char* file, unsigned int capacity)
{
CCTextureAtlas * pTextureAtlas = new CCTextureAtlas();
if(pTextureAtlas && pTextureAtlas->initWithFile(file, capacity))
{
pTextureAtlas->autorelease();
return pTextureAtlas;
}
CCX_SAFE_DELETE(pTextureAtlas);
return NULL;
}
2010-08-06 14:32:32 +08:00
CCTextureAtlas * CCTextureAtlas::textureAtlasWithTexture(CCTexture2D *texture, unsigned int capacity)
{
CCTextureAtlas * pTextureAtlas = new CCTextureAtlas();
if (pTextureAtlas && pTextureAtlas->initWithTexture(texture, capacity))
{
pTextureAtlas->autorelease();
return pTextureAtlas;
}
CCX_SAFE_DELETE(pTextureAtlas);
return NULL;
}
bool CCTextureAtlas::initWithFile(const char * file, unsigned int capacity)
{
// retained in property
2010-08-06 14:32:32 +08:00
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(file);
2010-08-06 14:32:32 +08:00
return initWithTexture(texture, capacity);
}
bool CCTextureAtlas::initWithTexture(CCTexture2D *texture, unsigned int capacity)
{
assert(texture != NULL);
m_uCapacity = capacity;
m_uTotalQuads = 0;
// retained in property
2010-08-06 14:32:32 +08:00
this->m_pTexture = texture;
2010-09-04 15:24:26 +08:00
CCX_SAFE_RETAIN(m_pTexture);
m_pQuads = (ccV3F_C4B_T2F_Quad*)calloc( sizeof(ccV3F_C4B_T2F_Quad) * m_uCapacity, 1 );
m_pIndices = (GLushort *)calloc( sizeof(GLushort) * m_uCapacity * 6, 1 );
if( ! ( m_pQuads && m_pIndices) ) {
CCLOG("cocos2d: CCTextureAtlas: not enough memory");
CCX_SAFE_FREE(m_pQuads)
CCX_SAFE_FREE(m_pIndices)
return false;
}
#if CC_TEXTURE_ATLAS_USES_VBO
// initial binding
glGenBuffers(2, &m_pBuffersVBO[0]);
#endif // CC_TEXTURE_ATLAS_USES_VBO
this->initIndices();
return true;
}
2010-08-06 16:05:19 +08:00
char * CCTextureAtlas::description()
{
2010-08-06 16:05:19 +08:00
char *ret = new char[100];
sprintf(ret, "<CCTextureAtlas | totalQuads = %u>", m_uTotalQuads);
return ret;
}
void CCTextureAtlas::initIndices()
{
for( unsigned int i=0; i < m_uCapacity; i++)
{
#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
m_pIndices[i*6+0] = i*4+0;
m_pIndices[i*6+1] = i*4+0;
m_pIndices[i*6+2] = i*4+2;
m_pIndices[i*6+3] = i*4+1;
m_pIndices[i*6+4] = i*4+3;
m_pIndices[i*6+5] = i*4+3;
#else
m_pIndices[i*6+0] = i*4+0;
m_pIndices[i*6+1] = i*4+1;
m_pIndices[i*6+2] = i*4+2;
// inverted index. issue #179
m_pIndices[i*6+3] = i*4+3;
m_pIndices[i*6+4] = i*4+2;
m_pIndices[i*6+5] = i*4+1;
// m_pIndices[i*6+3] = i*4+2;
// m_pIndices[i*6+4] = i*4+3;
// m_pIndices[i*6+5] = i*4+1;
#endif
}
#if CC_TEXTURE_ATLAS_USES_VBO
glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);
2010-07-21 11:13:32 +08:00
glBufferData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0]) * m_uCapacity, m_pQuads, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);
2010-07-21 11:13:32 +08:00
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_pIndices[0]) * m_uCapacity * 6, m_pIndices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#endif // CC_TEXTURE_ATLAS_USES_VBO
}
// TextureAtlas - Update, Insert, Move & Remove
void CCTextureAtlas::updateQuad(ccV3F_C4B_T2F_Quad *quad, unsigned int index)
{
NSAssert( index >= 0 && index < m_uCapacity, "updateQuadWithTexture: Invalid index");
m_uTotalQuads = max( index+1, m_uTotalQuads);
m_pQuads[index] = *quad;
}
void CCTextureAtlas::insertQuad(ccV3F_C4B_T2F_Quad *quad, unsigned int index)
{
NSAssert( index >= 0 && index < m_uCapacity, "insertQuadWithTexture: Invalid index");
m_uTotalQuads++;
NSAssert( m_uTotalQuads <= m_uCapacity, "invalid totalQuads");
// issue #575. index can be > totalQuads
int remaining = (m_uTotalQuads-1) - index;
// last object doesn't need to be moved
if( remaining > 0) {
2010-08-06 14:32:32 +08:00
// texture coordinates
2010-07-21 11:13:32 +08:00
memmove( &m_pQuads[index+1],&m_pQuads[index], sizeof(m_pQuads[0]) * remaining );
}
m_pQuads[index] = *quad;
}
void CCTextureAtlas::insertQuadFromIndex(unsigned int oldIndex, unsigned int newIndex)
{
NSAssert( newIndex >= 0 && newIndex < m_uTotalQuads, "insertQuadFromIndex:atIndex: Invalid index");
NSAssert( oldIndex >= 0 && oldIndex < m_uTotalQuads, "insertQuadFromIndex:atIndex: Invalid index");
if( oldIndex == newIndex )
return;
unsigned int howMany = std::abs( oldIndex - newIndex);
int dst = oldIndex;
int src = oldIndex + 1;
if( oldIndex > newIndex) {
dst = newIndex+1;
src = newIndex;
}
2010-08-06 14:32:32 +08:00
// texture coordinates
ccV3F_C4B_T2F_Quad quadsBackup = m_pQuads[oldIndex];
2010-07-21 11:13:32 +08:00
memmove( &m_pQuads[dst],&m_pQuads[src], sizeof(m_pQuads[0]) * howMany );
m_pQuads[newIndex] = quadsBackup;
}
void CCTextureAtlas::removeQuadAtIndex(unsigned int index)
{
NSAssert( index >= 0 && index < m_uTotalQuads, "removeQuadAtIndex: Invalid index");
unsigned int remaining = (m_uTotalQuads-1) - index;
// last object doesn't need to be moved
if( remaining ) {
2010-08-06 14:32:32 +08:00
// texture coordinates
2010-07-21 11:13:32 +08:00
memmove( &m_pQuads[index],&m_pQuads[index+1], sizeof(m_pQuads[0]) * remaining );
}
m_uTotalQuads--;
NSAssert( m_uTotalQuads >= 0, "invalid totalQuads");
}
void CCTextureAtlas::removeAllQuads()
{
m_uTotalQuads = 0;
}
// TextureAtlas - Resize
bool CCTextureAtlas::resizeCapacity(unsigned int newCapacity)
{
if( newCapacity == m_uCapacity )
return true;
// update capacity and totolQuads
m_uTotalQuads = min(m_uTotalQuads, newCapacity);
m_uCapacity = newCapacity;
2010-07-21 11:13:32 +08:00
void * tmpQuads = realloc( m_pQuads, sizeof(m_pQuads[0]) * m_uCapacity );
void * tmpIndices = realloc( m_pIndices, sizeof(m_pIndices[0]) * m_uCapacity * 6 );
if( ! ( tmpQuads && tmpIndices) ) {
CCLOG("cocos2d: CCTextureAtlas: not enough memory");
if( tmpQuads )
free(tmpQuads);
else
free(m_pQuads);
if( tmpIndices )
free(tmpIndices);
else
free(m_pIndices);
m_pQuads = NULL;
m_pIndices = NULL;
m_uCapacity = m_uTotalQuads = 0;
return false;
}
m_pQuads = (ccV3F_C4B_T2F_Quad *)tmpQuads;
m_pIndices = (GLushort *)tmpIndices;
this->initIndices();
return true;
}
// TextureAtlas - Drawing
void CCTextureAtlas::drawQuads()
{
this->drawNumberOfQuads(m_uTotalQuads);
}
void CCTextureAtlas::drawNumberOfQuads(unsigned int n)
{
glBindTexture(GL_TEXTURE_2D, m_pTexture->getName());
2010-07-21 17:40:10 +08:00
2010-07-21 11:13:32 +08:00
#define kQuadSize sizeof(m_pQuads[0].bl)
#if CC_TEXTURE_ATLAS_USES_VBO
glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);
// XXX: update is done in draw... perhaps it should be done in a timer
2010-07-21 11:13:32 +08:00
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(m_pQuads[0]) * n, m_pQuads);
// vertices
glVertexPointer(3, GL_FLOAT, kQuadSize, (void*) offsetof( ccV3F_C4B_T2F, vertices));
// colors
glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (void*) offsetof( ccV3F_C4B_T2F, colors));
2010-08-06 14:32:32 +08:00
// texture coords
glTexCoordPointer(2, GL_FLOAT, kQuadSize, (void*) offsetof( ccV3F_C4B_T2F, texCoords));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);
#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
glDrawElements(GL_TRIANGLE_STRIP, n*6, GL_UNSIGNED_SHORT, (void*)0);
#else
glDrawElements(GL_TRIANGLES, n*6, GL_UNSIGNED_SHORT, (void*)0);
#endif // CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#else // ! CC_TEXTURE_ATLAS_USES_VBO
2010-07-21 17:40:10 +08:00
2010-07-30 16:35:07 +08:00
int offset = (int)m_pQuads;
// vertex
int diff = offsetof( ccV3F_C4B_T2F, vertices);
glVertexPointer(3, GL_FLOAT, kQuadSize, (void*) (offset + diff) );
// color
diff = offsetof( ccV3F_C4B_T2F, colors);
glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (void*)(offset + diff));
2010-08-06 14:32:32 +08:00
// texture coords
diff = offsetof( ccV3F_C4B_T2F, texCoords);
glTexCoordPointer(2, GL_FLOAT, kQuadSize, (void*)(offset + diff));
#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
glDrawElements(GL_TRIANGLE_STRIP, n*6, GL_UNSIGNED_SHORT, m_pIndices);
#else
glDrawElements(GL_TRIANGLES, n*6, GL_UNSIGNED_SHORT, m_pIndices);
#endif
#endif // CC_TEXTURE_ATLAS_USES_VBO
}
2010-08-04 15:46:12 +08:00
}//namespace cocos2d