Cocos2d-x added texture auto recovery mechanism

1. It is not a complete module, so it does not provide completeCode, Only provides ideas and core code. The idea is simple. Maintain a life cycle and the last rendering time for each texture, update the rendering time for each rendering, and traverse the current texture set every certain time (15 seconds) in cctexturecache, if a texture is not rendered after the specified time in the lifecycle, the texture is released. The getname function in cctexture2d is a good way to update the rendering time and release the texture reload entry. Because cctexture2d needs to provide a reload image mechanism, it is best to provide an initwithfile interface and do not forget to record some special OpenGL labels, when you reload the texture, you need to set these flags for the texture, such as the call to gltexparameteri.

2. The MMO solution is not very advanced. Many game engines provide similar or even more advanced features, and it is not necessary for small games (because it is just a little resource in total, fully loaded into the memory does not consume much)

3. The advantage is that a non-rendered texture is automatically released based on the texture used, and the texture is loaded again when needed. This saves memory and saves the trouble of maintaining the texture lifecycle.

Note: the release of ccsprite will not be released to the texture data, and it still exists in the memory. Manually call cctexturecache: removeunusedtextures at the right time to release unused textures. Or call cctexturecache: removetextureforkey to release the specified texture. For an MMO, this is likely to become a cumbersome operation, or even evolve into a trap. (For example, a specified texture is released in a scenario, but it is used in another place, for example, ccspriteframecache ).

Through an automatic "Garbage Collection", externalProgramMembers can ignore the texture lifecycle, and some interfaces will not cause too many problems if they forget to release the texture, because when the texture has been released, the remaining ccsprite does not occupy the memory, and ccspriteframe does.

4. The side effect is that the image loading may cause a transient lag. This requires logical control in the code. For example, some images that wish to stay in the memory are set to no garbage collection.

5. Because of the side effects mentioned in 4, the image packaging process is not as large as possible. Instead, it tends to look at relatively small images, such as 128*128 or 256*256. This ensures the loading speed. You can also use the image to load the image to avoid meaningless duplicate loading operations.

The code is very simple:

[CPP] View plaincopyprint?

2. VoidCctexturecache: processtexturecache ()
4. {
6. If(Timeget ()-m_lastchecktime <2000 ){
8. Return;
10. }
14. M_lastchecktime = timeget ();
18. Uint32 currenttime = timeget ();
20. Ccdictelement * pelement = NULL;
22. Ccdict_foreach (m_ptextures, pelement)
24. {
26. Cctexture2d * ptexture = (cctexture2d *) pelement-> GetObject ();
28. If(Ptexture & ptexture-> isautogc () & currenttime-ptexture-> getlastupdatetime ()> ptexture-> getlivetime ())
30. {
32. Ptexture-> releasetexture ();
34. }
36. }
38. }

Void cctexturecache: processtexturecache () {If (timeget ()-m_lastchecktime <2000) {return;} m_lastchecktime = timeget (); uint32 currenttime = timeget (); ccdictelement * pelement = NULL; values (m_ptextures, pelement) {cctexture2d * ptexture = (cctexture2d *) pelement-> GetObject (); If (ptexture & ptexture-> isautogc () & currenttime-ptexture-> getlastupdatetime ()> ptexture-> getlivetime () {ptexture-> releasetexture ();}}}
 

[CPP] View plaincopyprint?

1. gluint cctexture2d: getname ()
2. {
3. # If cc_enable_texture_auto_gc
4. If (m_uname =-1) {
5. reloadtexture ();
6. }
8. m_lastupdatetime = timeget ();
9. # endif
10. return m_uname;
11. }