joybox 0.0.5 → 0.0.6

data/vendor/vendor-osx/cocos_2d/cocos_2d_include/CCTexture2D.h

@@ -0,0 +1,349 @@
+/*
+
+===== IMPORTANT =====
+
+This is sample code demonstrating API, technology or techniques in development.
+Although this sample code has been reviewed for technical accuracy, it is not
+final. Apple is supplying this information to help you plan for the adoption of
+the technologies and programming interfaces described herein. This information
+is subject to change, and software implemented based on this sample code should
+be tested with final operating system software and final documentation. Newer
+versions of this sample code may be provided with future seeds of the API or
+technology. For information about updates to this and other developer
+documentation, view the New & Updated sidebars in subsequent documentation
+seeds.
+
+=====================
+
+File: Texture2D.h
+Abstract: Creates OpenGL 2D textures from images or text.
+
+Version: 1.6
+
+Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Inc.
+("Apple") in consideration of your agreement to the following terms, and your
+use, installation, modification or redistribution of this Apple software
+constitutes acceptance of these terms.  If you do not agree with these terms,
+please do not use, install, modify or redistribute this Apple software.
+
+In consideration of your agreement to abide by the following terms, and subject
+to these terms, Apple grants you a personal, non-exclusive license, under
+Apple's copyrights in this original Apple software (the "Apple Software"), to
+use, reproduce, modify and redistribute the Apple Software, with or without
+modifications, in source and/or binary forms; provided that if you redistribute
+the Apple Software in its entirety and without modifications, you must retain
+this notice and the following text and disclaimers in all such redistributions
+of the Apple Software.
+Neither the name, trademarks, service marks or logos of Apple Inc. may be used
+to endorse or promote products derived from the Apple Software without specific
+prior written permission from Apple.  Except as expressly stated in this notice,
+no other rights or licenses, express or implied, are granted by Apple herein,
+including but not limited to any patent rights that may be infringed by your
+derivative works or by other works in which the Apple Software may be
+incorporated.
+
+The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+COMBINATION WITH YOUR PRODUCTS.
+
+IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR
+DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF
+CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
+APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Copyright (C) 2008 Apple Inc. All Rights Reserved.
+
+*/
+
+#import <Foundation/Foundation.h> //	for NSObject
+
+#import "ccTypes.h"
+#import "ccMacros.h"
+
+#import "Platforms/CCGL.h" // OpenGL stuff
+#import "Platforms/CCNS.h" // Next-Step stuff
+
+//CONSTANTS:
+
+/** @typedef CCTexture2DPixelFormat
+ Possible texture pixel formats
+ */
+typedef enum {
+	//! 32-bit texture: RGBA8888
+	kCCTexture2DPixelFormat_RGBA8888,
+	//! 32-bit texture without Alpha channel. Don't use it.
+	kCCTexture2DPixelFormat_RGB888,
+	//! 16-bit texture without Alpha channel
+	kCCTexture2DPixelFormat_RGB565,
+	//! 8-bit textures used as masks
+	kCCTexture2DPixelFormat_A8,
+	//! 8-bit intensity texture
+	kCCTexture2DPixelFormat_I8,
+	//! 16-bit textures used as masks
+	kCCTexture2DPixelFormat_AI88,
+	//! 16-bit textures: RGBA4444
+	kCCTexture2DPixelFormat_RGBA4444,
+	//! 16-bit textures: RGB5A1
+	kCCTexture2DPixelFormat_RGB5A1,
+	//! 4-bit PVRTC-compressed texture: PVRTC4
+	kCCTexture2DPixelFormat_PVRTC4,
+	//! 2-bit PVRTC-compressed texture: PVRTC2
+	kCCTexture2DPixelFormat_PVRTC2,
+
+	//! Default texture format: RGBA8888
+	kCCTexture2DPixelFormat_Default = kCCTexture2DPixelFormat_RGBA8888,
+
+} CCTexture2DPixelFormat;
+
+
+@class CCGLProgram;
+
+/** CCTexture2D class.
+ * This class allows to easily create OpenGL 2D textures from images, text or raw data.
+ * The created CCTexture2D object will always have power-of-two dimensions.
+ * Depending on how you create the CCTexture2D object, the actual image area of the texture might be smaller than the texture dimensions i.e. "contentSize" != (pixelsWide, pixelsHigh) and (maxS, maxT) != (1.0, 1.0).
+ * Be aware that the content of the generated textures will be upside-down!
+ */
+@interface CCTexture2D : NSObject
+{
+	GLuint						_name;
+	CGSize						_size;
+	NSUInteger					_width,
+								_height;
+	CCTexture2DPixelFormat		_format;
+	GLfloat						_maxS,
+								_maxT;
+	BOOL						_hasPremultipliedAlpha;
+	BOOL						_hasMipmaps;
+
+	ccResolutionType			_resolutionType;
+
+	// needed for drawAtRect, drawInPoint
+	CCGLProgram					*_shaderProgram;
+
+}
+/** Initializes with a texture2d with data */
+- (id) initWithData:(const void*)data pixelFormat:(CCTexture2DPixelFormat)pixelFormat pixelsWide:(NSUInteger)width pixelsHigh:(NSUInteger)height contentSize:(CGSize)size;
+
+/** These functions are needed to create mutable textures */
+- (void) releaseData:(void*)data;
+- (void*) keepData:(void*)data length:(NSUInteger)length;
+
+/** pixel format of the texture */
+@property(nonatomic,readonly) CCTexture2DPixelFormat pixelFormat;
+/** width in pixels */
+@property(nonatomic,readonly) NSUInteger pixelsWide;
+/** hight in pixels */
+@property(nonatomic,readonly) NSUInteger pixelsHigh;
+
+/** texture name */
+@property(nonatomic,readonly) GLuint name;
+
+/** returns content size of the texture in pixels */
+@property(nonatomic,readonly, nonatomic) CGSize contentSizeInPixels;
+
+/** texture max S */
+@property(nonatomic,readwrite) GLfloat maxS;
+/** texture max T */
+@property(nonatomic,readwrite) GLfloat maxT;
+/** whether or not the texture has their Alpha premultiplied */
+@property(nonatomic,readonly) BOOL hasPremultipliedAlpha;
+
+/** shader program used by drawAtPoint and drawInRect */
+@property(nonatomic,readwrite,retain) CCGLProgram *shaderProgram;
+
+/** Returns the resolution type of the texture.
+ Is it a RetinaDisplay texture, an iPad texture, a Mac, a Mac RetinaDisplay or an standard texture ?
+
+ Should be a readonly property. It is readwrite as a hack.
+
+ @since v1.1
+ */
+@property (nonatomic, readwrite) ccResolutionType resolutionType;
+
+
+/** returns the content size of the texture in points */
+-(CGSize) contentSize;
+
+
+@end
+
+/**
+Drawing extensions to make it easy to draw basic quads using a CCTexture2D object.
+These functions require GL_TEXTURE_2D and both GL_VERTEX_ARRAY and GL_TEXTURE_COORD_ARRAY client states to be enabled.
+*/
+@interface CCTexture2D (Drawing)
+/** draws a texture at a given point */
+- (void) drawAtPoint:(CGPoint)point;
+/** draws a texture inside a rect */
+- (void) drawInRect:(CGRect)rect;
+@end
+
+/**
+Extensions to make it easy to create a CCTexture2D object from an image file.
+Note that RGBA type textures will have their alpha premultiplied - use the blending mode (GL_ONE, GL_ONE_MINUS_SRC_ALPHA).
+*/
+@interface CCTexture2D (Image)
+/** Initializes a texture from a CGImage object */
+- (id) initWithCGImage:(CGImageRef)cgImage resolutionType:(ccResolutionType)resolution;
+@end
+
+/**
+Extensions to make it easy to create a CCTexture2D object from a string of text.
+Note that the generated textures are of type A8 - use the blending mode (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).
+*/
+@interface CCTexture2D (Text)
+/** Initializes a texture from a string with dimensions, alignment, line break mode, font name and font size
+ Supported lineBreakModes:
+	- iOS: all UILineBreakMode supported modes
+	- Mac: Only NSLineBreakByWordWrapping is supported.
+ @since v1.0
+ */
+- (id) initWithString:(NSString*)string fontName:(NSString*)name fontSize:(CGFloat)size dimensions:(CGSize)dimensions hAlignment:(CCTextAlignment)alignment vAlignment:(CCVerticalTextAlignment) vertAlignment lineBreakMode:(CCLineBreakMode)lineBreakMode ;
+/** Initializes a texture from a string with dimensions, alignment, font name and font size */
+- (id) initWithString:(NSString*)string fontName:(NSString*)name fontSize:(CGFloat)size dimensions:(CGSize)dimensions hAlignment:(CCTextAlignment)alignment vAlignment:(CCVerticalTextAlignment) vertAlignment;
+/** Initializes a texture from a string with font name and font size */
+- (id) initWithString:(NSString*)string fontName:(NSString*)name fontSize:(CGFloat)size;
+@end
+
+
+/**
+ Extensions to make it easy to create a CCTexture2D object from a PVRTC file
+ Note that the generated textures don't have their alpha premultiplied - use the blending mode (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).
+ */
+@interface CCTexture2D (PVRSupport)
+/** Initializes a texture from a PVR file.
+
+ Supported PVR formats:
+ - BGRA 8888
+ - RGBA 8888
+ - RGBA 4444
+ - RGBA 5551
+ - RBG 565
+ - A 8
+ - I 8
+ - AI 8
+ - PVRTC 2BPP
+ - PVRTC 4BPP
+
+ By default PVR images are treated as if they alpha channel is NOT premultiplied. You can override this behavior with this class method:
+ - PVRImagesHavePremultipliedAlpha:(BOOL)haveAlphaPremultiplied;
+
+ IMPORTANT: This method is only defined on iOS. It is not supported on the Mac version.
+
+ */
+-(id) initWithPVRFile: (NSString*) file;
+
+/** treats (or not) PVR files as if they have alpha premultiplied.
+ Since it is impossible to know at runtime if the PVR images have the alpha channel premultiplied, it is
+ possible load them as if they have (or not) the alpha channel premultiplied.
+
+ By default it is disabled.
+
+ @since v0.99.5
+ */
++(void) PVRImagesHavePremultipliedAlpha:(BOOL)haveAlphaPremultiplied;
+@end
+
+/**
+ Extension to set the Min / Mag filter
+ */
+typedef struct _ccTexParams {
+	GLuint	minFilter;
+	GLuint	magFilter;
+	GLuint	wrapS;
+	GLuint	wrapT;
+} ccTexParams;
+
+@interface CCTexture2D (GLFilter)
+/** sets the min filter, mag filter, wrap s and wrap t texture parameters.
+ If the texture size is NPOT (non power of 2), then in can only use GL_CLAMP_TO_EDGE in GL_TEXTURE_WRAP_{S,T}.
+ 
+ @warning Calling this method could allocate additional texture memory.
+
+ @since v0.8
+ */
+-(void) setTexParameters: (ccTexParams*) texParams;
+
+/** sets antialias texture parameters:
+  - GL_TEXTURE_MIN_FILTER = GL_LINEAR
+  - GL_TEXTURE_MAG_FILTER = GL_LINEAR
+ 
+ @warning Calling this method could allocate additional texture memory.
+
+ @since v0.8
+ */
+- (void) setAntiAliasTexParameters;
+
+/** sets alias texture parameters:
+  - GL_TEXTURE_MIN_FILTER = GL_NEAREST
+  - GL_TEXTURE_MAG_FILTER = GL_NEAREST
+
+ @warning Calling this method could allocate additional texture memory.
+
+ @since v0.8
+ */
+- (void) setAliasTexParameters;
+
+
+/** Generates mipmap images for the texture.
+ It only works if the texture size is POT (power of 2).
+ @since v0.99.0
+ */
+-(void) generateMipmap;
+
+
+@end
+
+@interface CCTexture2D (PixelFormat)
+/** sets the default pixel format for CGImages that contains alpha channel.
+ If the CGImage contains alpha channel, then the options are:
+	- generate 32-bit textures: kCCTexture2DPixelFormat_RGBA8888 (default one)
+	- generate 16-bit textures: kCCTexture2DPixelFormat_RGBA4444
+	- generate 16-bit textures: kCCTexture2DPixelFormat_RGB5A1
+	- generate 24-bit textures: kCCTexture2DPixelFormat_RGB888 (no alpha)
+	- generate 16-bit textures: kCCTexture2DPixelFormat_RGB565 (no alpha)
+	- generate 8-bit textures: kCCTexture2DPixelFormat_A8 (only use it if you use just 1 color)
+
+ How does it work ?
+   - If the image is an RGBA (with Alpha) then the default pixel format will be used (it can be a 8-bit, 16-bit or 32-bit texture)
+   - If the image is an RGB (without Alpha) then: If the default pixel format is RGBA8888 then a RGBA8888 (32-bit) will be used. Otherwise a RGB565 (16-bit texture) will be used.
+
+ This parameter is not valid for PVR / PVR.CCZ images.
+
+ @since v0.8
+ */
++(void) setDefaultAlphaPixelFormat:(CCTexture2DPixelFormat)format;
+
+/** returns the alpha pixel format
+ @since v0.8
+ */
++(CCTexture2DPixelFormat) defaultAlphaPixelFormat;
+
+/** returns the bits-per-pixel of the in-memory OpenGL texture
+ @since v1.0
+ */
+-(NSUInteger) bitsPerPixelForFormat;
+
+/** returns the pixel format in a NSString.
+ @since v2.0
+ */
+-(NSString*) stringForFormat;
+
+
+/** Helper functions that returns bits per pixels for a given format.
+ @since v2.0
+ */
++(NSUInteger) bitsPerPixelForFormat:(CCTexture2DPixelFormat)format;
+
+@end
+
+
+
+
+

data/vendor/vendor-osx/cocos_2d/cocos_2d_include/CCTextureAtlas.h

@@ -0,0 +1,188 @@
+/*
+ * 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.
+ *
+ */
+
+#import "CCTexture2D.h"
+#import "ccTypes.h"
+#import "ccConfig.h"
+
+/** A class that implements a Texture Atlas.
+ Supported features:
+   * The atlas file can be a PVRTC, PNG or any other format supported by Texture2D
+   * Quads can be updated in runtime
+   * Quads can be added in runtime
+   * Quads can be removed in runtime
+   * Quads can be re-ordered in runtime
+   * The TextureAtlas capacity can be increased or decreased in runtime
+   * OpenGL component: V3F, C4B, T2F.
+ The quads are rendered using an OpenGL ES VBO.
+ To render the quads using an interleaved vertex array list, you should modify the ccConfig.h file
+ */
+@interface CCTextureAtlas : NSObject
+{
+	NSUInteger			_totalQuads;
+	NSUInteger			_capacity;
+	ccV3F_C4B_T2F_Quad	*_quads;	// quads to be rendered
+	GLushort			*_indices;
+	CCTexture2D			*_texture;
+	
+	GLuint				_buffersVBO[2]; //0: vertex  1: indices
+	BOOL				_dirty;			//indicates whether or not the array buffer of the VBO needs to be updated
+
+#if CC_TEXTURE_ATLAS_USE_VAO
+	GLuint				_VAOname;
+#endif
+}
+
+/** quantity of quads that are going to be drawn */
+@property (nonatomic,readonly) NSUInteger totalQuads;
+/** quantity of quads that can be stored with the current texture atlas size */
+@property (nonatomic,readonly) NSUInteger capacity;
+/** Texture of the texture atlas */
+@property (nonatomic,retain) CCTexture2D *texture;
+/** Quads that are going to be rendered */
+@property (nonatomic,readwrite) ccV3F_C4B_T2F_Quad *quads;
+
+/** creates a TextureAtlas with an filename and with an initial capacity for Quads.
+ * The TextureAtlas capacity can be increased in runtime.
+ */
++(id) textureAtlasWithFile:(NSString*)file capacity:(NSUInteger)capacity;
+
+/** initializes a TextureAtlas with a filename and with a certain capacity for Quads.
+ * The TextureAtlas capacity can be increased in runtime.
+ *
+ * WARNING: Do not reinitialize the TextureAtlas because it will leak memory (issue #706)
+ */
+-(id) initWithFile: (NSString*) file capacity:(NSUInteger)capacity;
+
+/** creates a TextureAtlas with a previously initialized Texture2D object, and
+ * with an initial capacity for n Quads.
+ * The TextureAtlas capacity can be increased in runtime.
+ */
++(id) textureAtlasWithTexture:(CCTexture2D *)tex capacity:(NSUInteger)capacity;
+
+/** initializes a TextureAtlas with a previously initialized Texture2D object, and
+ * with an initial capacity for Quads.
+ * The TextureAtlas capacity can be increased in runtime.
+ *
+ * WARNING: Do not reinitialize the TextureAtlas because it will leak memory (issue #706)
+ */
+-(id) initWithTexture:(CCTexture2D *)tex capacity:(NSUInteger)capacity;
+
+/** updates a Quad (texture, vertex and color) at a certain index
+ * index must be between 0 and the atlas capacity - 1
+ @since v0.8
+ */
+-(void) updateQuad:(ccV3F_C4B_T2F_Quad*)quad atIndex:(NSUInteger)index;
+
+/** Inserts a Quad (texture, vertex and color) at a certain index
+ index must be between 0 and the atlas capacity - 1
+ @since v0.8
+ */
+-(void) insertQuad:(ccV3F_C4B_T2F_Quad*)quad atIndex:(NSUInteger)index;
+
+/** Inserts a c array of quads at a given index
+ index must be between 0 and the atlas capacity - 1
+ this method doesn't enlarge the array when amount + index > totalQuads
+ @since v1.1
+*/
+-(void) insertQuads:(ccV3F_C4B_T2F_Quad*)quads atIndex:(NSUInteger)index amount:(NSUInteger)amount;
+
+/** Removes the quad that is located at a certain index and inserts it at a new index
+ This operation is faster than removing and inserting in a quad in 2 different steps
+ @since v0.7.2
+*/
+-(void) insertQuadFromIndex:(NSUInteger)fromIndex atIndex:(NSUInteger)newIndex;
+
+/** removes a quad at a given index number.
+ The capacity remains the same, but the total number of quads to be drawn is reduced in 1
+ @since v0.7.2
+ */
+-(void) removeQuadAtIndex:(NSUInteger) index;
+
+/** removes a amount of quads starting from index
+	@since 1.1
+ */
+- (void) removeQuadsAtIndex:(NSUInteger) index amount:(NSUInteger) amount;
+
+/** removes all Quads.
+ The TextureAtlas capacity remains untouched. No memory is freed.
+ The total number of quads to be drawn will be 0
+ @since v0.7.2
+ */
+-(void) removeAllQuads;
+
+/** resize the capacity of the CCTextureAtlas.
+ * The new capacity can be lower or higher than the current one
+ * It returns YES if the resize was successful.
+ * If it fails to resize the capacity it will return NO with a new capacity of 0.
+ */
+-(BOOL) resizeCapacity: (NSUInteger) n;
+
+/**
+ Used internally by CCParticleBatchNode
+ don't use this unless you know what you're doing
+ @since 1.1
+*/
+- (void) increaseTotalQuadsWith:(NSUInteger) amount;
+
+/** Moves an amount of quads from oldIndex at newIndex
+ @since v1.1
+ */
+-(void) moveQuadsFromIndex:(NSUInteger)oldIndex amount:(NSUInteger) amount atIndex:(NSUInteger)newIndex;
+
+/**
+ Moves quads from index till totalQuads to the newIndex
+ Used internally by CCParticleBatchNode
+ This method doesn't enlarge the array if newIndex + quads to be moved > capacity
+ @since 1.1
+*/
+- (void) moveQuadsFromIndex:(NSUInteger) index to:(NSUInteger) newIndex;
+
+/**
+ Ensures that after a realloc quads are still empty
+ Used internally by CCParticleBatchNode
+ @since 1.1
+*/
+- (void) fillWithEmptyQuadsFromIndex:(NSUInteger) index amount:(NSUInteger) amount;
+
+/** draws n quads
+ * n can't be greater than the capacity of the Atlas
+ */
+
+-(void) drawNumberOfQuads: (NSUInteger) n;
+
+/** draws n quads from an index (offset).
+ n + start can't be greater than the capacity of the atlas
+
+ @since v1.0
+ */
+-(void) drawNumberOfQuads: (NSUInteger) n fromIndex: (NSUInteger) start;
+
+/** draws all the Atlas's Quads
+ */
+-(void) drawQuads;
+
+@end

data/vendor/vendor-osx/cocos_2d/cocos_2d_include/CCTextureCache.h

@@ -0,0 +1,146 @@
+/*
+ * 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.
+ *
+ */
+
+#import "ccMacros.h"
+
+#ifdef __CC_PLATFORM_IOS
+#import <CoreGraphics/CGImage.h>
+#endif
+
+#import <Foundation/Foundation.h>
+
+@class CCTexture2D;
+
+/** Singleton that handles the loading of textures
+ * Once the texture is loaded, the next time it will return
+ * a reference of the previously loaded texture reducing GPU & CPU memory
+ */
+@interface CCTextureCache : NSObject
+{
+	NSMutableDictionary *_textures;
+
+	dispatch_queue_t _loadingQueue;
+	dispatch_queue_t _dictQueue;
+}
+
+/** Retruns ths shared instance of the cache */
++ (CCTextureCache *) sharedTextureCache;
+
+/** purges the cache. It releases the retained instance.
+ @since v0.99.0
+ */
++(void)purgeSharedTextureCache;
+
+
+/** Returns a Texture2D object given an file image
+ * If the file image was not previously loaded, it will create a new CCTexture2D
+ *  object and it will return it. It will use the filename as a key.
+ * Otherwise it will return a reference of a previously loaded image.
+ * Supported image extensions: .png, .bmp, .tiff, .jpeg, .pvr, .gif
+ */
+-(CCTexture2D*) addImage: (NSString*) fileimage;
+
+/** Asynchronously, load a texture2d from a file.
+ * If the file image was previously loaded, it will use it.
+ * Otherwise it will load a texture in a new thread, and when the image is loaded, the callback will be called with the Texture2D as a parameter.
+ * The callback will be called in the cocos2d thread, so it is safe to create any cocos2d object from the callback.
+ * Supported image extensions: .png, .bmp, .tiff, .jpeg, .pvr, .gif
+ * @since v0.8
+ */
+-(void) addImageAsync:(NSString*) filename target:(id)target selector:(SEL)selector;
+
+/** Asynchronously, load a texture2d from a file.
+ * If the file image was previously loaded, it will use it.
+ * Otherwise it will load a texture in a new thread, and when the image is loaded, the block will be called.
+ * The callback will be called in the cocos2d thread, so it is safe to create any cocos2d object from the callback.
+ * Supported image extensions: .png, .bmp, .tiff, .jpeg, .pvr, .gif
+ * @since v2.0
+ */
+-(void) addImageAsync:(NSString*) filename withBlock:(void(^)(CCTexture2D *tex))block;
+
+
+/** Returns a Texture2D object given an CGImageRef image
+ * If the image was not previously loaded, it will create a new CCTexture2D object and it will return it.
+ * Otherwise it will return a reference of a previously loaded image
+ * The "key" parameter will be used as the "key" for the cache.
+ * If "key" is nil, then a new texture will be created each time.
+ * @since v0.8
+ */
+-(CCTexture2D*) addCGImage: (CGImageRef) image forKey: (NSString *)key;
+
+/** Returns an already created texture. Returns nil if the texture doesn't exist.
+ @since v0.99.5
+ */
+-(CCTexture2D *) textureForKey:(NSString *)key;
+
+/** Purges the dictionary of loaded textures.
+ * Call this method if you receive the "Memory Warning"
+ * In the short term: it will free some resources preventing your app from being killed
+ * In the medium term: it will allocate more resources
+ * In the long term: it will be the same
+ */
+-(void) removeAllTextures;
+
+/** Removes unused textures
+ * Textures that have a retain count of 1 will be deleted
+ * It is convenient to call this method after when starting a new Scene
+ * @since v0.8
+ */
+-(void) removeUnusedTextures;
+
+/** Deletes a texture from the cache given a texture
+ */
+-(void) removeTexture: (CCTexture2D*) tex;
+
+/** Deletes a texture from the cache given a its key name
+ @since v0.99.4
+ */
+-(void) removeTextureForKey: (NSString*) textureKeyName;
+
+@end
+
+
+@interface CCTextureCache (PVRSupport)
+
+/** Returns a Texture2D object given an PVR filename.
+ * If the file image was not previously loaded, it will create a new CCTexture2D
+ *  object and it will return it. Otherwise it will return a reference of a previously loaded image
+ *
+ */
+-(CCTexture2D*) addPVRImage:(NSString*) filename;
+
+@end
+
+
+@interface CCTextureCache (Debug)
+/** Output to CCLOG the current contents of this CCTextureCache
+ * This will attempt to calculate the size of each texture, and the total texture memory in use
+ *
+ * @since v1.0
+ */
+-(void) dumpCachedTextureInfo;
+
+@end