From 9cd57b731ab1c666d4a1cb725538fdc137763d12 Mon Sep 17 00:00:00 2001 From: Starla Insigna Date: Sat, 30 Jul 2011 11:19:14 -0400 Subject: Initial commit (version 0.2.1) --- libs/cocos2d/CCTextureAtlas.m | 369 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 369 insertions(+) create mode 100755 libs/cocos2d/CCTextureAtlas.m (limited to 'libs/cocos2d/CCTextureAtlas.m') diff --git a/libs/cocos2d/CCTextureAtlas.m b/libs/cocos2d/CCTextureAtlas.m new file mode 100755 index 0000000..7c7df75 --- /dev/null +++ b/libs/cocos2d/CCTextureAtlas.m @@ -0,0 +1,369 @@ +/* + * cocos2d for iPhone: http://www.cocos2d-iphone.org + * + * Copyright (c) 2008-2010 Ricardo Quesada + * Copyright (c) 2011 Zynga Inc. + * + * 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. + * + */ + + +// cocos2d +#import "CCTextureAtlas.h" +#import "ccMacros.h" +#import "CCTexture2D.h" +#import "CCTextureCache.h" + + +@interface CCTextureAtlas (Private) +-(void) initIndices; +@end + +//According to some tests GL_TRIANGLE_STRIP is slower, MUCH slower. Probably I'm doing something very wrong + +@implementation CCTextureAtlas + +@synthesize totalQuads = totalQuads_, capacity = capacity_; +@synthesize texture = texture_; +@synthesize quads = quads_; + +#pragma mark TextureAtlas - alloc & init + ++(id) textureAtlasWithFile:(NSString*) file capacity: (NSUInteger) n +{ + return [[[self alloc] initWithFile:file capacity:n] autorelease]; +} + ++(id) textureAtlasWithTexture:(CCTexture2D *)tex capacity:(NSUInteger)n +{ + return [[[self alloc] initWithTexture:tex capacity:n] autorelease]; +} + +-(id) initWithFile:(NSString*)file capacity:(NSUInteger)n +{ + // retained in property + CCTexture2D *tex = [[CCTextureCache sharedTextureCache] addImage:file]; + if( tex ) + return [self initWithTexture:tex capacity:n]; + + // else + { + CCLOG(@"cocos2d: Could not open file: %@", file); + [self release]; + return nil; + } +} + +-(id) initWithTexture:(CCTexture2D*)tex capacity:(NSUInteger)n +{ + if( (self=[super init]) ) { + + capacity_ = n; + totalQuads_ = 0; + + // retained in property + self.texture = tex; + + // Re-initialization is not allowed + NSAssert(quads_==nil && indices_==nil, @"CCTextureAtlas re-initialization is not allowed"); + + quads_ = calloc( sizeof(quads_[0]) * capacity_, 1 ); + indices_ = calloc( sizeof(indices_[0]) * capacity_ * 6, 1 ); + + if( ! ( quads_ && indices_) ) { + CCLOG(@"cocos2d: CCTextureAtlas: not enough memory"); + if( quads_ ) + free(quads_); + if( indices_ ) + free(indices_); + return nil; + } + +#if CC_USES_VBO + // initial binding + glGenBuffers(2, &buffersVBO_[0]); + dirty_ = YES; +#endif // CC_USES_VBO + + [self initIndices]; + } + + return self; +} + +- (NSString*) description +{ + return [NSString stringWithFormat:@"<%@ = %08X | totalQuads = %i>", [self class], self, totalQuads_]; +} + +-(void) dealloc +{ + CCLOGINFO(@"cocos2d: deallocing %@",self); + + free(quads_); + free(indices_); + +#if CC_USES_VBO + glDeleteBuffers(2, buffersVBO_); +#endif // CC_USES_VBO + + + [texture_ release]; + + [super dealloc]; +} + +-(void) initIndices +{ + for( NSUInteger i=0;i< capacity_;i++) { +#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP + indices_[i*6+0] = i*4+0; + indices_[i*6+1] = i*4+0; + indices_[i*6+2] = i*4+2; + indices_[i*6+3] = i*4+1; + indices_[i*6+4] = i*4+3; + indices_[i*6+5] = i*4+3; +#else + indices_[i*6+0] = i*4+0; + indices_[i*6+1] = i*4+1; + indices_[i*6+2] = i*4+2; + + // inverted index. issue #179 + indices_[i*6+3] = i*4+3; + indices_[i*6+4] = i*4+2; + indices_[i*6+5] = i*4+1; +// indices_[i*6+3] = i*4+2; +// indices_[i*6+4] = i*4+3; +// indices_[i*6+5] = i*4+1; +#endif + } + +#if CC_USES_VBO + glBindBuffer(GL_ARRAY_BUFFER, buffersVBO_[0]); + glBufferData(GL_ARRAY_BUFFER, sizeof(quads_[0]) * capacity_, quads_, GL_DYNAMIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffersVBO_[1]); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices_[0]) * capacity_ * 6, indices_, GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +#endif // CC_USES_VBO +} + +#pragma mark TextureAtlas - Update, Insert, Move & Remove + +-(void) updateQuad:(ccV3F_C4B_T2F_Quad*)quad atIndex:(NSUInteger) n +{ + NSAssert(n < capacity_, @"updateQuadWithTexture: Invalid index"); + + totalQuads_ = MAX( n+1, totalQuads_); + + quads_[n] = *quad; + +#if CC_USES_VBO + dirty_ = YES; +#endif +} + + +-(void) insertQuad:(ccV3F_C4B_T2F_Quad*)quad atIndex:(NSUInteger)index +{ + NSAssert(index < capacity_, @"insertQuadWithTexture: Invalid index"); + + totalQuads_++; + NSAssert( totalQuads_ <= capacity_, @"invalid totalQuads"); + + // issue #575. index can be > totalQuads + NSInteger remaining = (totalQuads_-1) - index; + + // last object doesn't need to be moved + if( remaining > 0) + // tex coordinates + memmove( &quads_[index+1],&quads_[index], sizeof(quads_[0]) * remaining ); + + quads_[index] = *quad; + +#if CC_USES_VBO + dirty_ = YES; +#endif +} + + +-(void) insertQuadFromIndex:(NSUInteger)oldIndex atIndex:(NSUInteger)newIndex +{ + NSAssert(newIndex < totalQuads_, @"insertQuadFromIndex:atIndex: Invalid index"); + NSAssert(oldIndex < totalQuads_, @"insertQuadFromIndex:atIndex: Invalid index"); + + if( oldIndex == newIndex ) + return; + + NSUInteger howMany = labs( oldIndex - newIndex); + NSUInteger dst = oldIndex; + NSUInteger src = oldIndex + 1; + if( oldIndex > newIndex) { + dst = newIndex+1; + src = newIndex; + } + + // tex coordinates + ccV3F_C4B_T2F_Quad quadsBackup = quads_[oldIndex]; + memmove( &quads_[dst],&quads_[src], sizeof(quads_[0]) * howMany ); + quads_[newIndex] = quadsBackup; + +#if CC_USES_VBO + dirty_ = YES; +#endif +} + +-(void) removeQuadAtIndex:(NSUInteger) index +{ + NSAssert(index < totalQuads_, @"removeQuadAtIndex: Invalid index"); + + NSUInteger remaining = (totalQuads_-1) - index; + + + // last object doesn't need to be moved + if( remaining ) + // tex coordinates + memmove( &quads_[index],&quads_[index+1], sizeof(quads_[0]) * remaining ); + + totalQuads_--; + +#if CC_USES_VBO + dirty_ = YES; +#endif +} + +-(void) removeAllQuads +{ + totalQuads_ = 0; +} + +#pragma mark TextureAtlas - Resize + +-(BOOL) resizeCapacity: (NSUInteger) newCapacity +{ + if( newCapacity == capacity_ ) + return YES; + + // update capacity and totolQuads + totalQuads_ = MIN(totalQuads_,newCapacity); + capacity_ = newCapacity; + + void * tmpQuads = realloc( quads_, sizeof(quads_[0]) * capacity_ ); + void * tmpIndices = realloc( indices_, sizeof(indices_[0]) * capacity_ * 6 ); + + if( ! ( tmpQuads && tmpIndices) ) { + CCLOG(@"cocos2d: CCTextureAtlas: not enough memory"); + if( tmpQuads ) + free(tmpQuads); + else + free(quads_); + + if( tmpIndices ) + free(tmpIndices); + else + free(indices_); + + indices_ = nil; + quads_ = nil; + capacity_ = totalQuads_ = 0; + return NO; + } + + quads_ = tmpQuads; + indices_ = tmpIndices; + + [self initIndices]; + +#if CC_USES_VBO + dirty_ = YES; +#endif + return YES; +} + +#pragma mark TextureAtlas - Drawing + +-(void) drawQuads +{ + [self drawNumberOfQuads: totalQuads_ fromIndex:0]; +} + +-(void) drawNumberOfQuads: (NSUInteger) n +{ + [self drawNumberOfQuads:n fromIndex:0]; +} + +-(void) drawNumberOfQuads: (NSUInteger) n fromIndex: (NSUInteger) start +{ + // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY + // Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY + // Unneeded states: - + + glBindTexture(GL_TEXTURE_2D, [texture_ name]); +#define kQuadSize sizeof(quads_[0].bl) +#if CC_USES_VBO + glBindBuffer(GL_ARRAY_BUFFER, buffersVBO_[0]); + + // XXX: update is done in draw... perhaps it should be done in a timer + if (dirty_) { + glBufferSubData(GL_ARRAY_BUFFER, sizeof(quads_[0])*start, sizeof(quads_[0]) * n , &quads_[start] ); + dirty_ = NO; + } + + // vertices + glVertexPointer(3, GL_FLOAT, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, vertices)); + + // colors + glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, colors)); + + // tex coords + glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, texCoords)); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffersVBO_[1]); +#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP + glDrawElements(GL_TRIANGLE_STRIP, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(indices_[0])) ); +#else + glDrawElements(GL_TRIANGLES, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(indices_[0])) ); +#endif // CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP + + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +#else // ! CC_USES_VBO + + NSUInteger offset = (NSUInteger)quads_; + // vertex + NSUInteger diff = offsetof( ccV3F_C4B_T2F, vertices); + glVertexPointer(3, GL_FLOAT, kQuadSize, (GLvoid*) (offset + diff) ); + // color + diff = offsetof( ccV3F_C4B_T2F, colors); + glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*)(offset + diff)); + + // tex coords + diff = offsetof( ccV3F_C4B_T2F, texCoords); + glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*)(offset + diff)); + +#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP + glDrawElements(GL_TRIANGLE_STRIP, n*6, GL_UNSIGNED_SHORT, indices_ + start * 6 ); +#else + glDrawElements(GL_TRIANGLES, n*6, GL_UNSIGNED_SHORT, indices_ + start * 6 ); +#endif + +#endif // CC_USES_VBO +} +@end -- cgit 1.4.1