spriter动画编辑器的cocos2d-x接口修正强化

 

 

 

http://blog.csdn.net/xiadasong007/article/details/8163001

 

 

 

 

 

目前我的cocos2d-x编辑器的动画部分接口采用的是spriter动画编辑器提供的接口，spriter动画编辑器虽然简陋，但一般的需求基本上能够满足。可以在http://www.brashmonkey.com/spriter.htm下载，另外cocos2d-x的接口可以在论坛http://www.brashmonkey.com/forum/viewtopic.php?f=3&t=870下载。

接口导入进来之后，一切都很正常，然而在采用该接口进行开发时，发现有几个比较严重的问题。

问题1：资源采用多文件夹形式存储，渲染效率低

问题2：一个png只能有一个ccsprite，在编辑器是正常的，然而采用论坛那个接口导入到cocos2d-x就有问题。

问题3：精灵不能flip

问题4：不支持scale变换

陆续修改了上述4个问题

资源采用Sprite Frame实现

png的bug线性实现，时间复杂度O（1）

flip的实现参考cocos2d-x源码中CCTransitionFlipX的实现——摄像头换位

scale参考angle的变换就OK了

代码如下：

（代码中掺杂了编辑器部分的代码，精力有限，本代码仅供参考）

头文件：

[cpp] view plaincopyprint?

1. //------------------------------------------------------------------------
2. //
3. // SCMLAnimator : KickStarter project Spriter renderer for cocos2d-x.
4. //
5. // Spriter website : http://www.kickstarter.com/projects/539087245/spriter
6. //
7. // Licensed under the BSD license, see LICENSE in root for details.
8. //
9. // Copyright (c) 2012 James Hui (a.k.a. Dr.Watson)
10. //
11. // For latest updates, please visit http://jameshui.com
12. //
13. //------------------------------------------------------------------------
16. #ifndef _CC_SPRITER_X_H_
17. #define _CC_SPRITER_X_H_
19. #include <vector>
20. #include <string>
21. #include "JEvent.h"
22. #include "cocos2d.h"
23. #include "TouchSprite.h"
24. #include "tinyxml.h"
27. class CCSpriterX;
28. #define FILE_SPRITE_SIZE 128
30. namespace SCMLHelper
31. {
33. struct File
34. {
35. File();
36. ~File();
38. void Init(TiXmlNode *node);
40. int id;
41. std::string name;
42. float width;
43. float height;
44. //一个文件可能有多个关联
45. cocos2d::CCSprite* sprites[FILE_SPRITE_SIZE];
47. };
49. class Folder
50. {
51. public:
52. Folder();
53. ~Folder();
55. void Init(TiXmlNode *node);
57. int GetFileCount();
58. File *GetFile(int index);
60. private:
61. int mId;
62. std::string mName;
64. std::vector <File *> mFiles;
66. };
68. struct ObjectRef
69. {
70. void Init(TiXmlNode *node);
72. int id;
73. int timeline;
74. int key;
75. int z_index;
76. };
78. struct Object
79. {
80. void Init(TiXmlNode *node, CCSpriterX *animator, int timelineId);
82. int folder;
83. int file;
84. float x;
85. float y;
86. float angle;
87. float scaleX;
88. float scaleY;
89. float pivot_x;
90. float pivot_y;
91. int z_index;
93. cocos2d::CCSprite *sprite;
95. };
97. class Key
98. {
99. public:
100. Key();
101. ~Key();
103. void Init(TiXmlNode *node, CCSpriterX *animator, int timelineId);
105. int GetObjectRefCount();
106. ObjectRef *GetObjectRef(int index);
108. int GetObjectCount();
109. Object *GetObject(int index);
111. float GetTime();
113. bool IsSpinCounterClockwise();
115. private:
116. int mId;
117. float mTime;
118. bool mSpinCounterClockwise;
120. std::vector <Object *> mObjects;
121. std::vector <ObjectRef *> mObjectRefs;
122. // will have bones later
124. };
126. class Timeline
127. {
128. public:
129. Timeline();
130. ~Timeline();
132. void Init(TiXmlNode *node, CCSpriterX *animator);
133. int GetKeyframeCount();
134. Key *GetKeyframe(int index);
136. private:
137. int mId;
138. std::vector <Key *> mKeyframes;
139. };
142. class Animation
143. {
144. public:
145. CC_SYNTHESIZE(JEvent *, event, Event);
146. CC_SYNTHESIZE(std::string, afterAction, AfterAction);
147. CCSpriterX * spr;
148. public:
149. void Restart();
150. Animation(CCSpriterX * spr);
151. ~Animation();
153. void Update(float dt);
154. void Init(TiXmlNode *node, CCSpriterX *animator);
156. void Render();
158. bool IsDone();
160. public:
161. std::string getName(){return mName;}
162. private:
163. int mId;
164. std::string mName;
165. float mLength;
166. bool mLooping;
167. bool mDone;
169. Timeline *mMainline;
170. int mCurrKeyframe;
172. std::vector <Timeline *> mTimelines;
174. float mTimer;
176. cocos2d::CCPoint mPosition;
178. };
181. class Entity
182. {
183. private:
184. CCSpriterX * spr;
185. public:
186. Entity(CCSpriterX * spr);
187. ~Entity();
188. void StartWithEvent(const char * name, JEvent * event);
189. std::string CurrentAction();
190. void Update(float dt);
191. void Render();
192. void Start(const char * name,const char* _afterAction);
193. void SetId(int id);
194. void SetName(const char *name);
195. void AddAnimation(Animation *animation);
197. void NextAnimation();
200. private:
202. int mId;
203. std::string mName;
205. std::vector <Animation *> mAnimations;
207. int mCurrAnimation;
209. };
211. }
214. class CCSpriterX : public TouchSprite
215. {
216. private:
217. struct Pit{
218. int fileId;
219. int id;
220. int folderId;
221. };
222. Pit fileSprites[FILE_SPRITE_SIZE];
223. CC_SYNTHESIZE(ccColor3B, colorX, ColorX);
224. public:
225. CCSpriterX();
226. ~CCSpriterX();
227. virtual void setFlipX(bool bFlipX);
228. bool initWithFile(const char *filename);
229. std::string CurrentAction();
230. virtual void draw(void);
231. virtual void update(float dt);
233. static CCSpriterX * create(const char *filename);
234. cocos2d::CCSprite * getSprite(int folderId, int fileId, int timelineId);
235. void PlayNext();
236. void PlayWithEvent(const char * name, JEvent * event);
237. void Play(const char* name,const char* _afterAction = 0);
239. private:
240. std::vector <SCMLHelper::Folder *> mFolders;
241. std::vector <SCMLHelper::Entity *> mEntities;
243. int mCurrEntity;
244. };
248. #endif

//------------------------------------------------------------------------
//
//	SCMLAnimator : KickStarter project Spriter renderer for cocos2d-x.
//
//	Spriter website : http://www.kickstarter.com/projects/539087245/spriter
//
//	Licensed under the BSD license, see LICENSE in root for details.
// 
//	Copyright (c) 2012 James Hui (a.k.a. Dr.Watson)
// 
//	For latest updates, please visit http://jameshui.com
//
//------------------------------------------------------------------------
#ifndef _CC_SPRITER_X_H_
#define _CC_SPRITER_X_H_
#include <vector>
#include <string>
#include "JEvent.h"
#include "cocos2d.h"
#include "TouchSprite.h"
#include "tinyxml.h"
class CCSpriterX;
#define FILE_SPRITE_SIZE 128
namespace SCMLHelper
{
	struct File
	{
		File();
		~File();
		void Init(TiXmlNode *node);
		int id;
		std::string name;
		float width;
		float height;
		//一个文件可能有多个关联
		cocos2d::CCSprite* sprites[FILE_SPRITE_SIZE];
	};
	class Folder
	{
	public:
		Folder();
		~Folder();
		
		void Init(TiXmlNode *node);
		
		int GetFileCount();
		File *GetFile(int index);
	private:
		int mId;
		std::string mName;
		std::vector <File *> mFiles;
	};
	struct ObjectRef
	{
		void Init(TiXmlNode *node);
		int id;
		int timeline;
		int key;
		int z_index;
	};
	struct Object
	{
		void Init(TiXmlNode *node, CCSpriterX *animator, int timelineId);
		
		int folder;
		int file;
		float x;
		float y;
		float angle;
		float scaleX;
		float scaleY;
		float pivot_x;
		float pivot_y;
		int z_index;
		cocos2d::CCSprite *sprite;
	};
	class Key
	{
	public:
		Key();
		~Key();
		
		void Init(TiXmlNode *node, CCSpriterX *animator, int timelineId);
		
		int GetObjectRefCount();
		ObjectRef *GetObjectRef(int index);
		
		int GetObjectCount();
		Object *GetObject(int index);
		float GetTime();
		bool IsSpinCounterClockwise();
	private:
		int mId;
		float mTime;
		bool mSpinCounterClockwise;
		std::vector <Object *> mObjects;
		std::vector <ObjectRef *> mObjectRefs;
		// will have bones later
	};
	class Timeline
	{
	public:
		Timeline();
		~Timeline();
		void Init(TiXmlNode *node, CCSpriterX *animator);
		int GetKeyframeCount();
		Key *GetKeyframe(int index);
	private:
		int mId;
		std::vector <Key *> mKeyframes;
	};
	class Animation
	{
    public:
		CC_SYNTHESIZE(JEvent *, event, Event);
        CC_SYNTHESIZE(std::string, afterAction, AfterAction);
        CCSpriterX * spr;
	public:
		void Restart();
		Animation(CCSpriterX * spr);
		~Animation();
        
		void Update(float dt);
		void Init(TiXmlNode *node, CCSpriterX *animator);
        
		void Render();
		bool IsDone(); 
	public:
		std::string getName(){return mName;}
	private:
		int mId;
		std::string mName;
		float mLength;
		bool mLooping;
		bool mDone;
		Timeline *mMainline;
		int mCurrKeyframe;
		std::vector <Timeline *> mTimelines;
		float mTimer;
		cocos2d::CCPoint mPosition;
	};
	class Entity
	{
    private:
        CCSpriterX * spr;
	public:
		Entity(CCSpriterX * spr);
		~Entity();
		void StartWithEvent(const char * name, JEvent * event);
		std::string CurrentAction();
		void Update(float dt);
		void Render();
		void Start(const char * name,const char* _afterAction);
		void SetId(int id);
		void SetName(const char *name);
		void AddAnimation(Animation *animation);
		void NextAnimation();
	private:
		int mId;
		std::string mName;
		std::vector <Animation *> mAnimations;
		int mCurrAnimation;
	};
}
class CCSpriterX : public TouchSprite
{ 
private:
	struct Pit{
		int fileId;
		int id;
		int folderId;
	};
	Pit fileSprites[FILE_SPRITE_SIZE];
	CC_SYNTHESIZE(ccColor3B, colorX, ColorX);
public:
	CCSpriterX();
	~CCSpriterX(); 
	virtual void setFlipX(bool bFlipX); 
	bool initWithFile(const char *filename); 
	std::string CurrentAction(); 
	virtual void draw(void); 
	virtual void update(float dt); 
	static CCSpriterX * create(const char *filename); 
	cocos2d::CCSprite * getSprite(int folderId, int fileId, int timelineId); 
	void PlayNext(); 
	void PlayWithEvent(const char * name, JEvent * event); 
	void Play(const char* name,const char* _afterAction = 0); 
private:
	std::vector <SCMLHelper::Folder *> mFolders;
	std::vector <SCMLHelper::Entity *> mEntities;
	int mCurrEntity;
};
#endif

源文件：

[cpp] view plaincopyprint?

1. //------------------------------------------------------------------------
2. //
3. // CCSpriterX : KickStarter project Spriter renderer for cocos2d-x.
4. //
5. // Spriter website : http://www.kickstarter.com/projects/539087245/spriter
6. //
7. // Licensed under the BSD license, see LICENSE in root for details.
8. //
9. // Copyright (c) 2012 James Hui (a.k.a. Dr.Watson)
10. //
11. // For latest updates, please visit http://jameshui.com
12. //
13. //------------------------------------------------------------------------
15. #include "CCSpriterX.h"
16. #include "Common.h"
17. #include "jerror.h"
19. USING_NS_CC;
22. namespace SCMLHelper
23. {
25. ///////////////////////////////////////////////////////////////////////////////////
27. File::File()
28. {
29. for(size_t i=0; i<FILE_SPRITE_SIZE; ++i){
30. sprites[i] = 0;
31. }
32. }
35. File::~File()
36. {
37. for(size_t i=0; i<FILE_SPRITE_SIZE; ++i){
38. if(sprites[i] != NULL){
39. sprites[i]->release();
40. }
41. }
42. }
44. void File::Init(TiXmlNode *node)
45. {
46. TiXmlElement *element = node->ToElement();
47. if (element)
48. {
49. int intValue;
50. float floatValue;
52. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
53. id = intValue;
54. else
55. id = 0;
57. name = element->Attribute("name");
59. if (element->QueryFloatAttribute("width", &floatValue) == TIXML_SUCCESS)
60. width = floatValue;
61. else
62. width = 0;
64. if (element->QueryFloatAttribute("height", &floatValue) == TIXML_SUCCESS)
65. height = floatValue;
66. else
67. height = 0;
69. if (name.size()>0)
70. {
71. //资源全部放到scml目录中！
72. std::string path = workPath+gConfig->read<std::string>("res")+"/";
74. //sprite = CCSprite::create((path+"scml/"+name).c_str());
75. sprites[0] = CCSprite::createWithSpriteFrameName(name.c_str());
76. sprites[0]->retain();
77. }
79. }
81. }
83. ///////////////////////////////////////////////////////////////////////////////////
85. Folder::Folder()
86. : mId(0)
87. {
88. mFiles.reserve(50);
89. }
92. Folder::~Folder()
93. {
94. int count = mFiles.size();
95. for (int i=0;i<count;i++)
96. CC_SAFE_DELETE(mFiles[i]);
98. mFiles.clear();
100. }
103. int Folder::GetFileCount()
104. {
105. return mFiles.size();
107. }
110. File *Folder::GetFile(int index)
111. {
112. if (index < (int)mFiles.size())
113. return mFiles[index];
115. return NULL;
117. }
120. void Folder::Init(TiXmlNode *node)
121. {
122. TiXmlElement *element = node->ToElement();
123. if (element)
124. {
125. int intValue;
127. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
128. mId= intValue;
130. mName = element->Attribute("name")==0?".":element->Attribute("name");
132. for (TiXmlNode* fileNode = node->FirstChild(); fileNode; fileNode = fileNode->NextSibling())
133. {
134. File *file = new File();
135. file->Init(fileNode);
137. mFiles.push_back(file);
138. }
140. }
142. }
144. ///////////////////////////////////////////////////////////////////////////////////
146. void ObjectRef::Init(TiXmlNode *node)
147. {
148. TiXmlElement *element = node->ToElement();
149. if (element)
150. {
151. int intValue;
153. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
154. id = intValue;
155. else
156. id = 0;
158. if (element->QueryIntAttribute("timeline", &intValue) == TIXML_SUCCESS)
159. timeline = intValue;
160. else
161. timeline = 0;
163. if (element->QueryIntAttribute("key", &intValue) == TIXML_SUCCESS)
164. key = intValue;
165. else
166. key = 0;
168. if (element->QueryIntAttribute("z_index", &intValue) == TIXML_SUCCESS)
169. z_index = intValue;
170. else
171. z_index = 0;
173. }
174. }
177. ///////////////////////////////////////////////////////////////////////////////////
179. void Object::Init(TiXmlNode *node, CCSpriterX *animator, int timelineId)
180. {
181. sprite = NULL;
183. float scaleFactor = CCDirector::sharedDirector()->getContentScaleFactor();
185. TiXmlElement *element = node->ToElement();
186. if (element)
187. {
188. int intValue;
189. float floatValue;
191. if (element->QueryIntAttribute("folder", &intValue) == TIXML_SUCCESS)
192. folder = intValue;
193. else
194. folder = 0;
196. if (element->QueryIntAttribute("file", &intValue) == TIXML_SUCCESS)
197. file = intValue;
198. else
199. file = 0;
201. if (element->QueryFloatAttribute("x", &floatValue) == TIXML_SUCCESS)
202. x = floatValue/scaleFactor;
203. else
204. x = 0;
206. if (element->QueryFloatAttribute("y", &floatValue) == TIXML_SUCCESS)
207. y = floatValue/scaleFactor;
208. else
209. y = 0;
211. if (element->QueryFloatAttribute("angle", &floatValue) == TIXML_SUCCESS)
212. angle = floatValue;
213. else
214. angle = 0;
216. if (element->QueryFloatAttribute("scale_x", &floatValue) == TIXML_SUCCESS)
217. scaleX = floatValue;
218. else
219. scaleX = 1;
220. if(scaleX < 1){
221. jlog("shit");
222. }
224. if (element->QueryFloatAttribute("scale_y", &floatValue) == TIXML_SUCCESS)
225. scaleY = floatValue;
226. else
227. scaleY = 1;
229. if (element->QueryFloatAttribute("pivot_x", &floatValue) == TIXML_SUCCESS)
230. pivot_x = floatValue;
231. else
232. pivot_x = 0;
234. if (element->QueryFloatAttribute("pivot_y", &floatValue) == TIXML_SUCCESS)
235. pivot_y = floatValue;
236. else
237. pivot_y = 1;
239. if (element->QueryIntAttribute("z_index", &intValue) == TIXML_SUCCESS)
240. z_index = intValue;
241. else
242. z_index = 0;
244. sprite = animator->getSprite(folder, file, timelineId);
245. }
246. }
247. ///////////////////////////////////////////////////////////////////////////////////
249. Key::Key()
250. : mId(0)
251. , mTime(0)
252. , mSpinCounterClockwise(true)
253. {
254. mObjects.reserve(50);
255. mObjectRefs.reserve(50);
256. }
259. Key::~Key()
260. {
261. int count = mObjects.size();
262. for (int i=0;i<count;i++)
263. CC_SAFE_DELETE(mObjects[i]);
265. mObjects.clear();
267. count = mObjectRefs.size();
268. for (int i=0;i<count;i++)
269. CC_SAFE_DELETE(mObjectRefs[i]);
271. mObjectRefs.clear();
273. }
276. int Key::GetObjectRefCount()
277. {
278. return mObjectRefs.size();
280. }
283. ObjectRef *Key::GetObjectRef(int index)
284. {
285. if (index < (int)mObjectRefs.size())
286. return mObjectRefs[index];
288. return NULL;
290. }
293. int Key::GetObjectCount()
294. {
295. return mObjects.size();
297. }
300. Object *Key::GetObject(int index)
301. {
302. if (index < (int)mObjects.size())
303. return mObjects[index];
305. return NULL;
307. }
310. float Key::GetTime()
311. {
312. return mTime;
313. }
316. bool Key::IsSpinCounterClockwise()
317. {
318. return mSpinCounterClockwise;
320. }
323. void Key::Init(TiXmlNode *node, CCSpriterX *animator, int timelineId)
324. {
325. TiXmlElement *element = node->ToElement();
326. if (element)
327. {
328. int intValue;
329. float floatValue;
330. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
331. mId = intValue;
333. float time = 0;
334. if (element->QueryFloatAttribute("time", &floatValue) == TIXML_SUCCESS) // was in milliseconds, convert to seconds instead
335. time = floatValue/1000.0f;
336. mTime = time;
338. if (element->QueryIntAttribute("spin", &intValue) == TIXML_SUCCESS)
339. mSpinCounterClockwise = !(intValue == -1);
341. for (TiXmlNode* objNode = node->FirstChild(); objNode; objNode = objNode->NextSibling())
342. {
343. element = objNode->ToElement();
344. const char *tabObj = element->Value();
346. if (strcmp(tabObj, "object_ref")==0)
347. {
348. ObjectRef *ref = new ObjectRef();
349. ref->Init(objNode);
350. mObjectRefs.push_back(ref);
352. }
353. else if (strcmp(tabObj, "object")==0)
354. {
355. Object *obj = new Object();
356. obj->Init(objNode, animator, timelineId);
358. mObjects.push_back(obj);
359. }
360. }
361. }
363. }
366. ///////////////////////////////////////////////////////////////////////////////////
368. Timeline::Timeline()
369. : mId(0)
370. {
371. mKeyframes.reserve(50);
372. }
375. Timeline::~Timeline()
376. {
377. int count = mKeyframes.size();
378. for (int i=0;i<count;i++)
379. {
380. CC_SAFE_DELETE(mKeyframes[i]);
382. }
384. }
387. int Timeline::GetKeyframeCount()
388. {
389. return mKeyframes.size();
391. }
394. Key *Timeline::GetKeyframe(int index)
395. {
396. if (index < (int)mKeyframes.size())
397. {
398. return mKeyframes[index];
399. }
401. return NULL;
403. }
405. void Timeline::Init(TiXmlNode *node, CCSpriterX *animator)
406. {
407. int intValue;
409. TiXmlElement *element = node->ToElement();
411. if (element)
412. {
413. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
414. mId = intValue;
416. for (TiXmlNode* keyNode = node->FirstChild(); keyNode; keyNode = keyNode->NextSibling())
417. {
418. element = keyNode->ToElement();
419. if (element)
420. {
421. Key *keyframe = new Key();
423. keyframe->Init(keyNode, animator, mId);
425. mKeyframes.push_back(keyframe);
426. }
427. }
429. }
431. }
433. ///////////////////////////////////////////////////////////////////////////////////
435. Animation::Animation(CCSpriterX * _spr)
436. : mId(0)
437. , spr(_spr)
438. , mCurrKeyframe(0)
439. , mMainline(NULL)
440. , mDone(false)
441. , mTimer(0)
442. ,event(0),afterAction("")
443. {
444. mTimelines.reserve(50);
446. }
448. Animation::~Animation()
449. {
450. int count = mTimelines.size();
451. for (int i=0;i<count;i++)
452. CC_SAFE_DELETE(mTimelines[i]);
454. mTimelines.clear();
456. }
459. void Animation::Init(TiXmlNode *node, CCSpriterX *animator)
460. {
461. int intValue;
462. float floatValue;
464. TiXmlElement *element = node->ToElement();
466. if (element)
467. {
468. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
469. mId = intValue;
471. mName = element->Attribute("name");
473. if (element->QueryFloatAttribute("length", &floatValue) == TIXML_SUCCESS)
474. mLength = floatValue/1000.0f; // was in milliseconds, convert to seconds instead
476. const char *looping = element->Attribute("looping"); // was set to "false" in alpha, but in fact looping all the time
477. mLooping = true;
479. for (TiXmlNode* lineNode = node->FirstChild(); lineNode; lineNode = lineNode->NextSibling())
480. {
481. element = lineNode->ToElement();
483. const char *tabLine = element->Value();
484. if (strcmp(tabLine, "mainline")==0) // 1 mainline only
485. {
486. mMainline = new Timeline();
487. mMainline->Init(lineNode, animator);
489. }
490. else if (strcmp(tabLine, "timeline")==0)
491. {
492. Timeline *timeline = new Timeline();
493. timeline->Init(lineNode, animator);
495. mTimelines.push_back(timeline);
496. }
497. }
498. }
500. }
503. bool Animation::IsDone()
504. {
505. return mDone;
507. }
509. void Animation::Restart()
510. {
511. mDone = false;
512. mTimer = 0;
513. mCurrKeyframe = 0;
515. }
517. float lerp(float a, float b, float t){
518. return a+(b-a)*t;
519. }
521. void Animation::Update(float dt)
522. {
524. mTimer += dt;
525. if (mTimer >= mLength)
526. {
527. mDone = true;
529. Restart(); // always looping for now
531. }
533. int count = mMainline->GetKeyframeCount();
534. Key *keyframe = mMainline->GetKeyframe(mCurrKeyframe);
535. float currTime = keyframe->GetTime();
537. Key *keyframeNext = NULL;
539. int next = mCurrKeyframe+1;
541. if (next > count-1) // looping
542. next = 0;
544. keyframeNext = mMainline->GetKeyframe(next);
546. if (keyframeNext)
547. {
548. float nextTime = keyframeNext->GetTime();
549. if (next == 0)
550. nextTime = mLength;
552. if (mTimer >= nextTime)
553. {
555. mCurrKeyframe = next;
557. keyframe = keyframeNext;
558. currTime = keyframe->GetTime();
560. next = mCurrKeyframe+1;
561. if (next > count-1) // looping
562. next = 0;
564. keyframeNext = mMainline->GetKeyframe(next);
565. if (keyframeNext == NULL)
566. return;
568. nextTime = keyframeNext->GetTime();
569. if (next == 0)
570. nextTime = mLength;
572. }
575. float t = (mTimer-currTime)/(nextTime-currTime);
577. int count = keyframe->GetObjectRefCount();
578. for (int i=0;i<count;i++)
579. {
580. ObjectRef *ref = keyframe->GetObjectRef(i);
582. ObjectRef *refNext = keyframeNext->GetObjectRef(i);
584. if (ref && refNext)
585. {
587. Key *keyRef = mTimelines[ref->timeline]->GetKeyframe(ref->key);
588. Object *obj = keyRef->GetObject(0); // should be only 1 object
590. Key *keyRefNext = mTimelines[refNext->timeline]->GetKeyframe(refNext->key);
591. Object *objNext = keyRefNext->GetObject(0);
593. float x = lerp(obj->x, objNext->x, t);
594. float y = lerp(obj->y, objNext->y, t);
596. float scaleX = lerp(obj->scaleX, objNext->scaleX, t);
597. float scaleY = lerp(obj->scaleY, objNext->scaleY, t);
599. float angle = objNext->angle-obj->angle;
600. if (keyRef->IsSpinCounterClockwise())
601. {
602. if (angle < 0)
603. angle = (objNext->angle+360)-obj->angle;
604. }
605. else
606. {
607. if (angle > 0)
608. {
609. angle = (objNext->angle-360)-obj->angle;
610. }
612. }
614. if (ref->timeline != refNext->timeline)
615. t = 0;
617. angle = obj->angle+(angle)*t;
619. if (angle >= 360)
620. angle -= 360;
622. float px = obj->pivot_x+(objNext->pivot_x-obj->pivot_x)*t;
623. float py = obj->pivot_y+(objNext->pivot_y-obj->pivot_y)*t;
625. CCPoint newPos = ccp(x, y);
626. obj->sprite->setPosition(newPos);
627. obj->sprite->setRotation(-angle);
628. obj->sprite->setScaleX(scaleX);
629. obj->sprite->setScaleY(scaleY);
630. obj->sprite->setAnchorPoint(ccp(px, py));
632. }
635. }
636. }
639. }
643. void Animation::Render()
644. {
645. Key *keyframe = mMainline->GetKeyframe(mCurrKeyframe);
647. int count = keyframe->GetObjectRefCount();
648. for (int i=0;i<count;i++)
649. {
650. ObjectRef *ref = keyframe->GetObjectRef(i);
652. if (ref)
653. {
655. Key *keyRef = mTimelines[ref->timeline]->GetKeyframe(ref->key);
656. Object *obj = keyRef->GetObject(0); // should be only 1 object
657. obj->sprite->setColor(spr->getColorX());
658. obj->sprite->visit();
659. }
660. }
662. }
665. ///////////////////////////////////////////////////////////////////////////////////
667. Entity::Entity(CCSpriterX * _spr)
668. : mCurrAnimation(0)
669. , mId(0)
670. , spr(_spr)
671. {
672. mAnimations.reserve(50);
673. };
676. Entity::~Entity()
677. {
678. int count = mAnimations.size();
679. for (int i=0;i<count;i++)
680. CC_SAFE_DELETE(mAnimations[i]);
682. mAnimations.clear();
684. }
687. void Entity::Update(float dt)
688. {
689. Animation *animation = mAnimations[mCurrAnimation];
690. animation->Update(dt);
691. }
693. std::string Entity::CurrentAction()
694. {
695. return mAnimations[mCurrAnimation]->getName();
696. }
698. void Entity::StartWithEvent(const char * name, JEvent * event)
699. {
700. for(size_t i=0; i<mAnimations.size(); ++i){
701. if(mAnimations[i]->getName() == std::string(name)){
702. mCurrAnimation = i;
703. mAnimations[i]->setEvent(event);
704. mAnimations[i]->Restart();
705. }
706. }
707. }
709. void Entity::Start(const char * name, const char * _afterAction)
710. {
711. for(size_t i=0; i<mAnimations.size(); ++i){
712. if(mAnimations[i]->getName() == std::string(name)){
713. mCurrAnimation = i;
714. mAnimations[i]->setAfterAction(_afterAction);
715. mAnimations[i]->Restart();
716. }
717. }
718. }
721. void Entity::Render()
722. {
723. Animation *animation = mAnimations[mCurrAnimation];
724. animation->Render();
726. }
729. void Entity::NextAnimation()
730. {
731. mCurrAnimation++;
732. if (mCurrAnimation >= (int)mAnimations.size())
733. mCurrAnimation = 0;
735. Animation *animation = mAnimations[mCurrAnimation];
736. animation->Restart();
738. }
741. void Entity::SetId(int id)
742. {
743. mId = id;
745. }
748. void Entity::SetName(const char *name)
749. {
750. mName = name;
752. }
755. void Entity::AddAnimation(Animation *animation)
756. {
757. mAnimations.push_back(animation);
758. }
760. }
762. ///////////////////////////////////////////////////////////////////////////////////
764. using namespace SCMLHelper;
767. CCSpriterX::CCSpriterX()
768. {
769. mFolders.reserve(50);
770. mEntities.reserve(50);
771. for(int i=0; i<FILE_SPRITE_SIZE; ++i){
772. fileSprites[i].fileId = -1;
773. fileSprites[i].id = -1;
774. fileSprites[i].folderId = -1;
775. }
776. }
779. CCSpriterX::~CCSpriterX()
780. {
781. }
784. CCSpriterX *CCSpriterX::create(const char *filename)
785. {
786. CCSpriterX *animator = new CCSpriterX();
787. animator->type = SCML;
788. animator->m_state = kLivingStateUngrabbed;
789. if (animator && animator->initWithFile(filename))
790. {
791. //由于是动画层，没有大小，这里设置大小，使之能够拾取
792. animator->setContentSize(CCSizeMake(100, 100));
793. animator->autorelease();
794. return animator;
795. }
796. CC_SAFE_DELETE(animator);
797. return NULL;
798. }
801. void CCSpriterX::update(float dt)
802. {
803. if (dt > 0.0167f)
804. dt = 0.0167f;
806. Entity *entity = mEntities[mCurrEntity];
807. entity->Update(dt);
808. }
811. void CCSpriterX::draw(void)
812. {
813. Entity *entity = mEntities[mCurrEntity];
814. entity->Render();
815. }
816. std::string CCSpriterX::CurrentAction()
817. {
818. Entity *entity = mEntities[mCurrEntity];
819. return entity->CurrentAction();
820. }
822. void CCSpriterX::PlayWithEvent(const char * name, JEvent * event)
823. {
824. Entity *entity = mEntities[mCurrEntity];
825. entity->StartWithEvent(name, event);
826. }
828. void CCSpriterX::Play(const char* name, const char * _afterAction)
829. {
830. Entity *entity = mEntities[mCurrEntity];
831. entity->Start(name, _afterAction == 0?"":_afterAction);
832. }
834. void CCSpriterX::PlayNext()
835. {
836. Entity *entity = mEntities[mCurrEntity];
837. entity->NextAnimation();
838. }
840. CCSprite *CCSpriterX::getSprite(int folderId, int fileId, int timelineId)
841. {
842. if (folderId < (int)mFolders.size())
843. {
844. Folder *folder = mFolders[folderId];
846. if (folder)
847. {
848. File *file = folder->GetFile(fileId);
850. if (file){
851. int id = this->fileSprites[timelineId].id;
852. if(id == -1){
853. for(int i=0; i<FILE_SPRITE_SIZE; ++i){
854. if(fileSprites[i].fileId == fileId && fileSprites[i].folderId == folderId){
855. ++id;
856. }
857. }
858. id += 1;
859. fileSprites[timelineId].folderId = folderId;
860. fileSprites[timelineId].fileId = fileId;
861. fileSprites[timelineId].id = id;
862. }
864. if(file->sprites[id] == 0){
865. file->sprites[id] = CCSprite::createWithSpriteFrameName(file->name.c_str());
866. file->sprites[id]->retain();
867. }
868. return file->sprites[id];
869. }
871. }
872. }
874. return NULL;
875. }
877. void CCSpriterX::setFlipX(bool bFlipX)
878. {
879. if(bFlipX != m_bFlipX){
880. float ex,ey,ez;
881. this->getCamera()->getEyeXYZ(&ex, &ey, &ez);
882. this->getCamera()->setEyeXYZ(ex, ey, bFlipX?-fabs(ez):fabs(ez));
883. this->m_bFlipX = bFlipX;
884. }
885. }
887. bool CCSpriterX::initWithFile(const char *filename)
888. {
889. char cfilename[256];
890. strcpy(cfilename, filename);
891. string name = strtok(cfilename, ".");
892. string suffix = strtok(cfilename, ".");
894. mCurrEntity = 0;
896. unsigned long filesize;
897. string path = workPath+gConfig->read<string>("res")+"/"+filename;
898. char *buffer = (char *)CCFileUtils::sharedFileUtils()->getFileData(path.c_str(), "rb", &filesize);
900. if (buffer == NULL)
901. return false;
903. //加载大图
904. string sfplist = workPath+gConfig->read<string>("res")+"/scml/"+name+".plist";
905. string sfpng = workPath+gConfig->read<string>("res")+"/scml/"+name+".png";
906. CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(sfplist.c_str(), sfpng.c_str());
908. TiXmlDocument doc;
910. doc.Parse(buffer);
912. TiXmlNode *root = doc.FirstChild("spriter_data");
913. if (root)
914. {
916. TiXmlElement *element = root->ToElement();
918. const char *version = element->Attribute("scml_version");
919. const char *generator = element->Attribute("generator");
920. const char *generatorVersion = element->Attribute("generator_version");
924. for (TiXmlNode* entityNode = root->FirstChild(); entityNode; entityNode = entityNode->NextSibling())
925. {
926. element = entityNode->ToElement();
928. if (element)
929. {
930. const char *tab = element->Value();
932. if (strcmp(tab, "folder")==0)
933. {
934. Folder *folder = new Folder();
936. folder->Init(entityNode);
938. mFolders.push_back(folder);
940. }
941. else if (strcmp(tab, "entity")==0)
942. {
943. int intValue;
944. Entity *entity = new Entity(this);
946. if (element->QueryIntAttribute("id", &intValue) == TIXML_SUCCESS)
947. entity->SetId(intValue);
949. entity->SetName(element->Attribute("name"));
951. for (TiXmlNode* animationNode = entityNode->FirstChild(); animationNode; animationNode = animationNode->NextSibling())
952. {
953. Animation *animation = new Animation(this);
954. animation->Init(animationNode, this);
956. entity->AddAnimation(animation);
958. }
960. mEntities.push_back(entity);
961. }
962. }
963. }
964. }
966. CC_SAFE_DELETE_ARRAY(buffer);
968. this->scheduleUpdate();
970. return true;
972. }

//------------------------------------------------------------------------
//
//	CCSpriterX : KickStarter project Spriter renderer for cocos2d-x.
//
//	Spriter website : http://www.kickstarter.com/projects/539087245/spriter
//
//	Licensed under the BSD license, see LICENSE in root for details.
// 
//	Copyright (c) 2012 James Hui (a.k.a. Dr.Watson)
// 
//	For latest updates, please visit http://jameshui.com
//
//------------------------------------------------------------------------
#include "CCSpriterX.h"
#include "Common.h"
#include "jerror.h" 
USING_NS_CC;
代码不完整， 完整查看原文