CCTextureCache（加载纹理到缓存）

1.  加载图片 方法 

CCTexture2D* addImage(const char* fileimage);

        同步加载一个图片，返回 一个 CCTexture2D对象。这个文件名还可以做 key.  后续可以调用  

CCTexture2D* textureForKey(const char* key); 方法来获得这个文件名所对应的CCTexture2D对象，如果这个Key对应的图片不存在，那么就返回NULL.

2.  异步加载图片方法 

     void addImageAsync(const char *path, CCObject *target, SEL_CallFuncOselector);

    加载之后会回调，一般用来程序启动的时候预加载图片资源。

   例如： CCTextureCache::sharedTextureCache()->addImageAsync("Images/blocks.png", this,callfuncO_selector(TextureCacheTest::loadingCallBack)); 

3. 获得图片的方法

   可以使用  CCTexture2D* textureForKey(const char* key); 方法来获得这个文件名所对应的CCTexture2D对象，如果这个Key对应的图片不存在，那么就返回NULL.

   也可以使用  CCTexture2D* addImage(const char* fileimage); 因为之前如果已经加载，那么会直接返回图片缓存，不会重新加载图片。

4. 图片缓存的释放

    在退出界面的时候，可以调用  void removeAllTextures();

    方法来将所以的缓存移除，防止资源占用过多。

 

   void removeUnusedTextures();  用来移除哪些暂时没用到的纹理图。 It is convenient to call this method after when starting a new Scene . 意思是新开始一个场景界面的时候，可以调用很方便。

首先是最底层也最有效的纹理缓存CCTextureCache，这里缓存的是加载到内存中的纹理资源，也就是图片资源。其原理是对加入缓存的纹理资源进行一次引用，使其引用计数加一，保持不被清除，而Cocos2d-x的渲染机制是可以重复使用同一份纹理在不同的场合进行绘制，从而达到重复使用，降低内存和GPU运算资源的开销的目的。常用的是如下所示的3个接口：

在这3个接口中，CCTextureCache屏蔽了加载纹理的许多细节；addImage函数会返回一个纹理CCTexture2D的引用，可能是新加载到内存的，也可能是之前已经存在的；而removeUnusedTextures则会释放当前所有引用计数为1的纹理，即目前没有被使用的纹理。后面会看到，引用计数的内存管理方式为缓存的设计带来了很大的便利。

实际上，我们很少需要调用addImage这个接口，因为引擎内部所有的纹理加载都是通过这个缓存进行的，换句话说，载入的每一张图片都被缓存了，所以我们更需要关心什么时候清理缓存。引擎会在设备出现内存警告时自动清理缓存，但是这显然在很多情况下已经为时过晚了。一般情况下，我们应该在切换场景时清理缓存中的无用纹理，因为不同场景间使用的纹理是不同的。如果确实存在着共享的纹理，将其加入一个标记数组来保持其引用计数，以避免被清理了。

#ifndef __CCTEXTURE_CACHE_H__

#define __CCTEXTURE_CACHE_H__

#include "cocoa/CCObject.h"

#include "cocoa/CCDictionary.h"

#include "textures/CCTexture2D.h"

#include <string>

#if CC_ENABLE_CACHE_TEXTURE_DATA

    #include "platform/CCImage.h"

    #include <list>

#endif

NS_CC_BEGIN

class CCLock;

class CCImage;

/**

 * @addtogroup textures

 * @{

 */

/** @brief 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

*/

class CC_DLL CCTextureCache : public CCObject

{

protected:

    CCDictionary* m_pTextures;

    //pthread_mutex_t                *m_pDictLock;

private:

    /// todo: void addImageWithAsyncObject(CCAsyncObject* async);

    void addImageAsyncCallBack(float dt);

public:

    CCTextureCache();

    virtual ~CCTextureCache();

    const char* description(void);

    CCDictionary* snapshotTextures();

    /** Returns the shared instance of the cache */

    static CCTextureCache * sharedTextureCache();

    /** purges the cache. It releases the retained instance.

    @since v0.99.0

    */

    static 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(const char* fileimage);

    /* Returns a Texture2D object given a file image

    * If the file image was not previously loaded, it will create a new CCTexture2D object and it will return 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 from the main thread, so it is safe to create any cocos2d object from the callback.

    * Supported image extensions: .png, .jpg

    * @since v0.8

    */

    

    void addImageAsync(const char *path, CCObject *target, SEL_CallFuncO selector);

    /* 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

    */

    // todo: CGImageRef CCTexture2D* addCGImage(CGImageRef image, string &  key);

    /** Returns a Texture2D object given an UIImage 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.

    */

    CCTexture2D* addUIImage(CCImage *image, const char *key);

    /** Returns an already created texture. Returns nil if the texture doesn't exist.

    @since v0.99.5

    */

    CCTexture2D* textureForKey(const char* 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* texture);

    /** Deletes a texture from the cache given a its key name

    @since v0.99.4

    */

    void removeTextureForKey(const char *textureKeyName);

    /** 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();

    

    /** 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(const char* filename);

    

    /** Returns a Texture2D object given an ETC 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* addETCImage(const char* filename);

    /** Reload all textures

    It's only useful when the value of CC_ENABLE_CACHE_TEXTURE_DATA is 1

    */

    static void reloadAllTextures();

};

#if CC_ENABLE_CACHE_TEXTURE_DATA

class VolatileTexture

{

typedef enum {

    kInvalid = 0,

    kImageFile,

    kImageData,

    kString,

    kImage,

}ccCachedImageType;

public:

    VolatileTexture(CCTexture2D *t);

    ~VolatileTexture();

    static void addImageTexture(CCTexture2D *tt, const char* imageFileName, CCImage::EImageFormat format);

    static void addStringTexture(CCTexture2D *tt, const char* text, const CCSize& dimensions, CCTextAlignment alignment, 

                                 CCVerticalTextAlignment vAlignment, const char *fontName, float fontSize);

    static void addDataTexture(CCTexture2D *tt, void* data, CCTexture2DPixelFormat pixelFormat, const CCSize& contentSize);

    static void addCCImage(CCTexture2D *tt, CCImage *image);

    static void setTexParameters(CCTexture2D *t, ccTexParams *texParams);

    static void removeTexture(CCTexture2D *t);

    static void reloadAllTextures();

public:

    static std::list<VolatileTexture*> textures;

    static bool isReloading;

    

private:

    // find VolatileTexture by CCTexture2D*

    // if not found, create a new one

    static VolatileTexture* findVolotileTexture(CCTexture2D *tt);

protected:

    CCTexture2D *texture;

    

    CCImage *uiImage;

    ccCachedImageType m_eCashedImageType;

    void *m_pTextureData;

    CCSize m_TextureSize;

    CCTexture2DPixelFormat m_PixelFormat;

    std::string m_strFileName;

    CCImage::EImageFormat m_FmtImage;

    ccTexParams     m_texParams;

    CCSize          m_size;

    CCTextAlignment m_alignment;

    CCVerticalTextAlignment m_vAlignment;

    std::string     m_strFontName;

    std::string     m_strText;

    float           m_fFontSize;

};

#endif

// end of textures group

/// @}

NS_CC_END

#endif //__CCTEXTURE_CACHE_H__