RUQCoreLayer.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408
  1. #include "RUQCoreLayer.h"
  2. #include "RUQCoreBtn.h"
  3. #include "RUUtils.h"
  4. NS_RU_BEGIN
  5. void QCoreLayerDelegate::completedAnimationSequenceNamed(const char *name, int seqId,int tag)
  6. {
  7. if (_completedAniCallBack) {
  8. _completedAniCallBack(string(name));
  9. }
  10. }
  11. void QCoreLayerDelegate::registerCompletedAniCallBack(std::function<void(string name)> callback)
  12. {
  13. _completedAniCallBack = callback;
  14. }
  15. int QCoreLayer::_count = 0;
  16. QCoreLayer * QCoreLayer::Layer(const string& file, bool batchReader)
  17. {
  18. auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
  19. lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
  20. lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
  21. redream::REDReader *reader = new redream::REDReader(lib);
  22. reader->setBatchNode(batchReader);
  23. QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
  24. node->setAnimManager(reader->getAnimationManagers());
  25. node->_ccbName = file;
  26. reader->release();
  27. return node;
  28. }
  29. QCoreLayer* QCoreLayer::LayerBatchReader(string file,unordered_set<string> plistSt){
  30. auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
  31. lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
  32. lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
  33. redream::REDReader *reader = new redream::REDReader(lib);
  34. reader->setPlist(plistSt,plistSt);
  35. reader->setBatchNode(true);
  36. QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
  37. node->setAnimManager(reader->getAnimationManagers());
  38. node->_ccbName = file;
  39. reader->release();
  40. return node;
  41. }
  42. QCoreLayer* QCoreLayer::LayerBatchReader(string file,unordered_set<string> plistSt,unordered_set<string> repleacPlistSt){
  43. auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
  44. lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
  45. lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
  46. redream::REDReader *reader = new redream::REDReader(lib);
  47. reader->setPlist(plistSt,repleacPlistSt);
  48. reader->setBatchNode(true);
  49. QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
  50. node->setAnimManager(reader->getAnimationManagers());
  51. node->_ccbName = file;
  52. reader->release();
  53. return node;
  54. }
  55. QCoreLayer::QCoreLayer()
  56. {
  57. _mAnimCtrl=nullptr;
  58. _count++;
  59. _aniDelegate = new QCoreLayerDelegate();
  60. _aniDelegate->autorelease();
  61. _aniDelegate->retain();
  62. }
  63. QCoreLayer::~QCoreLayer()
  64. {
  65. _aniDelegate->release();
  66. if (_mAnimCtrl!=nullptr) {
  67. _mAnimCtrl->setDelegate(nullptr);
  68. }
  69. CC_SAFE_RELEASE_NULL(_mAnimCtrl);
  70. _count--;
  71. }
  72. void QCoreLayer::onExit()
  73. {
  74. if (_cbOnExit != nullptr) {
  75. _cbOnExit(_ccbName, this);
  76. }
  77. Layer::onExit();
  78. }
  79. std::function<void(const string&, QCoreLayer*)> QCoreLayer::setCbOnExit(std::function<void(const string&, QCoreLayer*)> cb)
  80. {
  81. auto t = _cbOnExit;
  82. _cbOnExit = cb;
  83. return t;
  84. }
  85. void QCoreLayer::setCcbiName(const string& name)
  86. {
  87. _ccbName = name;
  88. }
  89. bool QCoreLayer::setCBSpriteName(string spriteName,string spriteFrameName)
  90. {
  91. if(!hasChileByName(spriteName)){
  92. return false;
  93. }
  94. Sprite* temp = getSprite(spriteName);
  95. if (temp!= nullptr) {
  96. SpriteFrame * spf = SpriteFrameCache::getInstance()->getSpriteFrameByName(spriteFrameName);
  97. if (spf == nullptr){
  98. Texture2D * texture = Director::getInstance()->getTextureCache()->addImage(spriteFrameName);
  99. if ( texture != nullptr ){
  100. Size sz = texture->getContentSize();
  101. spf = SpriteFrame::createWithTexture(texture, Rect(0, 0, sz.width, sz.height));
  102. }
  103. }
  104. if (spf != nullptr) {
  105. temp->setSpriteFrame(spf);
  106. return true;
  107. }
  108. }
  109. return false;
  110. }
  111. bool QCoreLayer::onAssignREDMemberVariable(cocos2d::Ref* pTarget, const char* pMemberVariableName, Node* pNode)
  112. {
  113. if (pTarget == this&&pNode != this&&strcmp(pMemberVariableName,"")!=0)
  114. {
  115. _mapChilden.insert(pair<string, Node*>(string(pMemberVariableName),pNode));
  116. return true;
  117. }
  118. // RED_MEMBERVARIABLEASSIGNER_GLUE_WEAK(this, "name", Node*, aaa::node_bind);
  119. return false;
  120. }
  121. SEL_MenuHandler QCoreLayer::onResolveREDCCMenuItemSelector(Ref * pTarget, const char * pSelectorName)
  122. {
  123. return nullptr;
  124. }
  125. Control::Handler QCoreLayer::onResolveREDCCControlSelector(Ref * pTarget, const char * pSelectorName)
  126. {
  127. return nullptr;
  128. }
  129. cocos2d::SEL_CallFuncN QCoreLayer::onResolveREDCCCallFuncSelector(cocos2d::Ref * pTarget, const char* pSelectorName) {
  130. // RED_SELECTORRESOLVER_CALLFUNC_GLUE(this, "onCallback1", TimelineCallbackTestLayer::onCallback1); //void(Node*)
  131. string selectorName(pSelectorName) ;
  132. string event = string("__CCCallFuncSelector__")+selectorName ;
  133. if(_timelineCallbackListeners.find(event) == _timelineCallbackListeners.end())
  134. {
  135. EventListenerCustom* ecl = EventListenerCustom::create(event, [this,pTarget,selectorName](EventCustom*){
  136. auto iter = _timelineCallbacks.find(selectorName) ;
  137. if(iter != _timelineCallbacks.end() && iter->second && pTarget == dynamic_cast<Ref*>(this))
  138. {
  139. iter->second();
  140. }
  141. });
  142. Node* node = dynamic_cast<Node*>(pTarget);
  143. if(node)
  144. {
  145. _director->getEventDispatcher()->addEventListenerWithSceneGraphPriority(ecl, node);
  146. _timelineCallbackListeners[event] = ecl;
  147. }
  148. }
  149. return CC_CALLFUNCN_SELECTOR(QCoreLayer::onTimeLineCallback);
  150. return nullptr;
  151. };
  152. bool QCoreLayer::onAssignREDCustomProperty(cocos2d::Ref* target, const char* memberVariableName, const cocos2d::Value& value) {
  153. _customProperties.insert(std::pair<std::string, Value>(std::string(memberVariableName), value));
  154. return true;
  155. }
  156. void QCoreLayer::onNodeLoaded(cocos2d::Node * node, redream::NodeLoader * nodeLoader)
  157. {
  158. }
  159. void QCoreLayer::registerCompletedAniCallBack(std::function<void(string name)> callback)
  160. {
  161. _aniDelegate->registerCompletedAniCallBack(callback);
  162. }
  163. void QCoreLayer::setAnimManager(redream::REDReader::REDAnimationManagerMapPtr map)
  164. {
  165. auto it = map->find(this);
  166. CC_SAFE_RELEASE_NULL(_mAnimCtrl);
  167. _mAnimCtrl = it->second;
  168. _mAnimCtrl->setDelegate(_aniDelegate);
  169. CC_SAFE_RETAIN(_mAnimCtrl);
  170. M_SNODE::iterator it1 = _mapChilden.begin();
  171. for (; it1 !=_mapChilden.end(); it1++) {
  172. QCoreLayer* cl = dynamic_cast<QCoreLayer*>(it1->second);
  173. if (cl != nullptr &&!(it1->first.empty()))
  174. {
  175. cl->setAnimManager(map);
  176. }
  177. }
  178. }
  179. float QCoreLayer::getAnimTime(std::string animName)
  180. {
  181. return _mAnimCtrl->getSequenceDuration(animName.c_str());
  182. }
  183. void QCoreLayer::playAnim(std::string animName, const std::function<void(float)> &cbFinishAnim, std::string cbScheduleKey)
  184. {
  185. CCASSERT(!animName.empty(), "时间线名字不能为空");
  186. _mAnimCtrl->runAnimationsForSequenceNamed(animName.c_str());
  187. if (cbFinishAnim) {
  188. float animTime = getAnimTime(animName);
  189. if (cbScheduleKey.empty()) {
  190. cbScheduleKey = "playAnim_" + Value(randomInt(1, 1000000)).asString();
  191. }
  192. scheduleOnce(cbFinishAnim, animTime, cbScheduleKey);
  193. }
  194. }
  195. void QCoreLayer::playAnimAndRemoveSelf(std::string animName)
  196. {
  197. _mAnimCtrl->runAnimationsForSequenceNamed(animName.c_str());
  198. registerCompletedAniCallBack([=](string timeLineName){
  199. if (timeLineName == animName) {
  200. this->removeFromParent();
  201. }
  202. });
  203. }
  204. bool QCoreLayer::isValidAnim(std::string animName)
  205. {
  206. bool ret = true;
  207. if (_mAnimCtrl->getSequenceId(animName.c_str()) == -1) {
  208. ret = false;
  209. }
  210. return ret;
  211. }
  212. void QCoreLayer::setAnimationSpeed(float tRate)
  213. {
  214. if(_mAnimCtrl){
  215. _mAnimCtrl->setAnimationSpeed(tRate);
  216. }else{
  217. CCAssert(false, "QCoreLayer setAnimationSpeed failed");
  218. }
  219. }
  220. Spawn* QCoreLayer::getNodeAniByName(std::string timeLineName, std::string nodeName,const Vec2& orginPos)
  221. {
  222. auto tNode = getByName(nodeName);
  223. return _mAnimCtrl->getNodeAniByName(timeLineName.c_str(),tNode,orginPos);
  224. }
  225. void QCoreLayer::changeToOtherParent(Node* newParent)
  226. {
  227. this->retain();
  228. std::function<void(const string&, QCoreLayer*)> cbBack = _cbOnExit;
  229. _cbOnExit = nullptr;
  230. this->removeFromParentAndCleanup(false);
  231. _cbOnExit = cbBack;
  232. newParent->addChild(this);
  233. this->release();
  234. }
  235. bool QCoreLayer::hasChileByName(std::string name)
  236. {
  237. auto iter = _mapChilden.find(name);
  238. if (iter != _mapChilden.end()) {
  239. return true;
  240. }else{
  241. return false;
  242. }
  243. }
  244. Node* QCoreLayer::getByName(std::string name)
  245. {
  246. // return _mapChilden[name];
  247. auto iter = _mapChilden.find(name);
  248. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  249. return iter->second;
  250. }
  251. Sprite* QCoreLayer::getSprite(std::string name)
  252. {
  253. auto iter = _mapChilden.find(name);
  254. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  255. return dynamic_cast<Sprite*>(iter->second);
  256. }
  257. Label* QCoreLayer::getLabel(std::string name)
  258. {
  259. // return (Label*)_mapChilden[name];
  260. auto iter = _mapChilden.find(name);
  261. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  262. return dynamic_cast<Label*>(iter->second);
  263. }
  264. ParticleSystemQuad* QCoreLayer::getParticle(std::string name)
  265. {
  266. // return (ParticleSystemQuad*)_mapChilden[name];
  267. auto iter = _mapChilden.find(name);
  268. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  269. return dynamic_cast<ParticleSystemQuad*>(iter->second);
  270. }
  271. ZMLCCParticleSystemQuad* QCoreLayer::getZMLCCParticle(std::string name)
  272. {
  273. // return (ParticleSystemQuad*)_mapChilden[name];
  274. auto iter = _mapChilden.find(name);
  275. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  276. return dynamic_cast<ZMLCCParticleSystemQuad*>(iter->second);
  277. }
  278. RRP::RParticleSystem* QCoreLayer::getRParticle(std::string name)
  279. {
  280. auto iter = _mapChilden.find(name);
  281. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  282. return dynamic_cast<RRP::RParticleSystem*>(iter->second);
  283. }
  284. QCoreLayer* QCoreLayer::getCoreLayer(std::string name)
  285. {
  286. // return (QCoreLayer*)_mapChilden[name];
  287. auto iter = _mapChilden.find(name);
  288. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  289. return dynamic_cast<QCoreLayer*>(iter->second);
  290. }
  291. QCoreBtn* QCoreLayer::getCoreBtn(std::string name)
  292. {
  293. // return (QCoreLayer*)_mapChilden[name];
  294. auto iter = _mapChilden.find(name);
  295. CCASSERT(iter != _mapChilden.end(), "ccb无这个变量???");
  296. return dynamic_cast<QCoreBtn*>(iter->second);
  297. }
  298. Value QCoreLayer::getCustomeProperty(const char* name) {
  299. std::map<std::string, Value>::iterator iter = _customProperties.find(std::string(name));
  300. if (iter != _customProperties.end()) {
  301. return iter->second;
  302. }
  303. return Value();
  304. }
  305. void QCoreLayer::updateAnimSpeed(float speed)
  306. {
  307. if (speed > 0) {
  308. _mAnimCtrl->updateSpeed(speed);
  309. }
  310. }
  311. redream::NodeLoaderLibrary* QCoreLayer::sharedLibrary()
  312. {
  313. auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
  314. lib->registerNodeLoader("QCoreLayer", QCoreLayerLoader::loader());
  315. lib->registerNodeLoader("QCoreBtn", QCoreBtnLoader::loader());
  316. return lib;
  317. }
  318. static redream::NodeLoaderLibrary * s_globalLoaderLibary = nullptr;
  319. void QCoreLayer::registerNodeLoaderLibrary(tuple<const char *, redream::NodeLoader *> nodeLoaderArr)
  320. {
  321. if (s_globalLoaderLibary == nullptr)
  322. {
  323. redream::NodeLoaderLibrary * ccNodeLoaderLibrary = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
  324. s_globalLoaderLibary = ccNodeLoaderLibrary;
  325. s_globalLoaderLibary->retain();
  326. }
  327. s_globalLoaderLibary->registerNodeLoader(get<0>(nodeLoaderArr), get<1>(nodeLoaderArr));
  328. }
  329. QCoreLayer * QCoreLayer::loadFromRED(string pREDFileName,Ref* owner)
  330. {
  331. redream::REDReader * ccbReader = new redream::REDReader(s_globalLoaderLibary);
  332. // ccbReader->autorelease();
  333. QCoreLayer * node = (QCoreLayer*)ccbReader->readNodeGraphFromFile(pREDFileName.c_str(), owner);
  334. if (node != nullptr) {
  335. node->setAnimManager(ccbReader->getAnimationManagers());
  336. node->_ccbName = pREDFileName;
  337. }
  338. ccbReader->release();
  339. return node;
  340. }
  341. void QCoreLayer::SmartScaleHeightNode(Node* layer, Size designSize)
  342. {
  343. Size frameSize = Director::getInstance()->getVisibleSize();
  344. Size contentSize = layer->getContentSize();
  345. if ((frameSize.height / frameSize.width) < (1136.0 / designSize.width)) {
  346. contentSize.width = frameSize.width;
  347. float targetScale = contentSize.width / designSize.width;
  348. layer->setScale(targetScale, 1);
  349. layer->setContentSize(contentSize);
  350. } else if ((frameSize.height / frameSize.width) > (1136.0 / designSize.width)) {
  351. contentSize.height = frameSize.height;
  352. float targetScale = contentSize.height / designSize.height;
  353. layer->setScale(1, targetScale);
  354. layer->setContentSize(contentSize);
  355. }
  356. }
  357. NS_RU_END