"Go" "Topsy cocos2d-x 23" multithreading and synchronization 03-picture asynchronous loading

original works, reproduced please indicate : http://blog.csdn.net/jackystudio/article/details/15334159

Cocos2d-x and Android,windows are the same, if the main thread to deal with some time-consuming operation, then the main thread will appear blocking phenomenon, performance in the interface is stuck, not responding and so on. To avoid this, we need to open up working threads in the background to process the data, and then use messaging or other forms to notify the main thread of UI changes. The most common situation is the loading before the game enters.

1. Asynchronous loading of images

In the first introduction of multithreading and synchronization to the use of the Pthread library, it is said that because Ccautoreleasepool is not thread-safe, it is not possible to introduce COCOS2D-X-related APIs in worker threads (not all APIs are not available). But Cocos2d-x obviously took this issue into account, so it helped us encapsulate an API, avoiding the embarrassment of manually introducing the Pthread library.

[CPP]View Plaincopy

1. void Cctexturecache::addimageasync (const char *path, ccobject *target, Sel_callfunco selector)

Where path is the location of the picture, selector is the callback function when loading is complete. Handy, if you need to load a lot of pictures, do callback processing for each, then update the UI in update.

asynchronous loading of 2.plist

However, due to memory reasons, most of the pieces will be synthesized and packaged and brought into the plist. How to do the asynchronous loading of the picture at this time? At this time, we need to further explore the source code of Addimageasync.

2.1. What is the time-consuming?

The first thing to understand is what the time-consuming action is, and the asynchronous load only makes sense if the time-consuming work is really caught and thrown onto the worker thread. We know that the image in memory is in the form of texture, and the loading of the picture, in layman's terms, is the generation of textures, which is the reason for time-consuming. What did the Cctexurecache AddImage (synchronous loading) and ADDIMAGEAYSNC (asynchronous loading) do separately?

(1) AddImage

It can be seen that AddImage uses synchronization to generate textures, which is a time-consuming load operation in the main thread.

[CPP]View Plaincopy

2. ... cocos2d-x maintains a global texture that determines whether a texture already exists
4. if (! Texture)
6. {
8. Do
10. {
12. //... Determine image format
16. Pimage = new Ccimage ();
18. cc_break_if (NULL = = pimage);
22. bool BRet = Pimage->initwithimagefile (Fullpath.c_str (), Eimageformat);
24. Cc_break_if (!bret);
28. Texture = new cctexture2d (); //Open texture space
32. if (Texture &&
34. Texture->initwithimage (pimage)) //Initialize texture with ccimage
36. {
38. #if Cc_enable_cache_texture_data
40. //cache The texture file name
42. Volatiletexture::addimagetexture (texture, fullpath.c_str (), Eimageformat);
44. #endif
46. M_ptextures->setobject (texture, pathkey.c_str ());
48. Texture->release ();
50. }
52. Else
54. {
56. Cclog ("cocos2d:couldn ' t create texture for file:%s in Cctexturecache", path);
58. }
60. } while (0);
62. }
64. //... Releasing resources, returning textures

(2) Addimageasync

The Addimageasync is to load the picture in the worker thread and then transform the texture through the scheduler.

[CPP]View Plaincopy

2. Create a worker thread to load a picture in the background
4. Pthread_create (&s_loadingthread, NULL, loadimage, NULL);
8. Create a schedule queue that is used to transform textures based on loaded pictures
10. Ccdirector::shareddirector ()->getscheduler ()->scheduleselector (Schedule_selector (CCTextureCache::  Addimageasynccallback), this , 0, false);
14. void Cctexturecache::addimageasynccallback (float DT)
16. {
18. //...  
20. Cctexture2d *texture = new Cctexture2d (); //Open texture space
22. #if 0//todo: (cc_target_platform = = Cc_platform_ios)
24. Texture->initwithimage (Pimage, Kccresolutioniphone);
26. #else
28. Texture->initwithimage (Pimage); //Use Ccimage to initialize textures
30. #endif
34. #if Cc_enable_cache_texture_data
38. Volatiletexture::addimagetexture (texture, filename, pimageinfo->imagetype);
40. #endif
42. //... will join Autorelease, make the call of the loaded callback function, release the related resources
44. }

the principle of 2.2.plist loading

The previous use of plist is this:

[CPP]View Plaincopy

1. void Ccspriteframecache::addspriteframeswithfile (const char *pszplist)//incoming plist files can be

In its implementation, it was discovered that:

[CPP]View Plaincopy

1. Cctexture2d *ptexture = Cctexturecache::sharedtexturecache ()->addimage (Texturepath.c_str ());

It turns out that addspriteframeswithfile will look for textures first, otherwise it will look for a picture with the same name in the. plist directory, and then call the synchronized AddImage function to generate the texture. This is why only the plist is loaded, and the texture exists.

2.3. Asynchronous load Plist

Know this, then let Addspriteframeswithfile call asynchronous Addimageasync function can, of course, do not need to change the source, because Ccspriteframecache also provides the following plist loading mode:

[CPP]View Plaincopy

1. void Ccspriteframecache::addspriteframeswithfile (const char *pszplist, cctexture2d *pobtexture)

So we can manually generate the texture asynchronously, and in the callback function and. plist into the addspriteframeswithfile, done! Do you remember the first selector? The resulting texture is passed into this callback function as a parameter, perfect!

2.4. Note

One thing to note is that when using a small image in any plist, the engine does not generate a texture for each small image, but instead uses the texture of the large image, specifying the coordinates and the length and width of the small picture.

3. Example

Where Ui_text.png is the big picture, Raffle_b_friend.png and raffle_b_diamond.png are two small pictures.

[CPP]View Plaincopy

2. BOOL Ctestlayer::init ()
4. {
6. bool bret=false;
8. Do
10. {
12. CC_BREAK_IF (! Cclayer::init ());
16. create a texture in//addimage or Addimageasync
18. Cctexturecache::sharedtexturecache ()->addimageasync ("Ui_text.png",this,callfunco_selector (  Ctestlayer::showsprite));
22. Bret=true;
24. } while (0);
26. return bRet;
28. }
32. void Ctestlayer::showsprite (ccobject* obj)
34. {
36. cctexture2d* texture_ui_text= (cctexture2d*) obj; //The incoming obj is an asynchronously generated texture
38. Ccspriteframecache::sharedspriteframecache ()->addspriteframeswithfile ("Ui_text.plist", texture_ui_text); Adding Ccspriteframecache through textures and. plist Files
40. ccsprite* raffle_b_friend=ccsprite::createwithspriteframename ("raffle_b_friend.png"); Use the small picture.
42. Raffle_b_friend->setposition (CCP (100,100));
44. This->addchild (raffle_b_friend);
48. //error, can only get texture of ui_text.png
50. //cctexture2d* Raffle_b_diamond_texture=cctexturecache::sharedtexturecache ()->textureforkey ("Raffle_b_  Diamond.png ");
52. //Correct, you can use this to get the sprite frame first, then get the ui_text texture from the sprite frame, and the size, to build the Ccsprite
54. ccspriteframe* Raffle_b_diamond_spriteframe=ccspriteframecache::sharedspriteframecache ()->spriteFrameByName (  "Raffle_b_diamond.png");
56. cctexture2d* texture=raffle_b_diamond_spriteframe->gettexture ();
58. Ccrect Rect=raffle_b_diamond_spriteframe->getrect ();
60. ccsprite* raffle_b_diamond=ccsprite::createwithtexture (Texture,rect); //If the texture needs to be rotated, setrotation it
62. Raffle_b_diamond->setrotation (false);
64. Raffle_b_diamond->setposition (CCP (300,100));
66. This->addchild (Raffle_b_diamond);
68. }

4. Effectsuse asynchronous load plist to handle:

5. Source code Download

http://download.csdn.net/detail/jackyvincefu/6533293

"Go" "Topsy cocos2d-x 23" multithreading and synchronization 03-picture asynchronous loading