void SearchContext::append(int id, SearchEntry &entry) { lock(); int textOffset = 0; std::string str = generateDisplay(entry, textOffset); offset_ += str.length() - 1; entry.offset_ = offset_; list_.push_back(entry); unlock(); poke(id, str, entry.highlights_, textOffset, false); }
/** * Return the TextureDisplay. * @example * <listing> * var texturedisplay:Object = factory.getTextureDisplay('dragon'); * </listing> * @param The name of this Texture. * @param The name of the TextureAtlas. * @param The registration pivotX position. * @param The registration pivotY position. * @return An Object. */ Object* BaseFactory::getTextureDisplay(const String &textureName, const String &textureAtlasName, Number pivotX, Number pivotY) { ITextureAtlas* textureAtlas = 0; if(!textureAtlasName.empty()) { std::map<String , ITextureAtlas*>::iterator iter = _textureAtlasDic.find(textureAtlasName); if(iter != _textureAtlasDic.end()) { textureAtlas = iter->second; } } //if(!textureAtlas && !textureAtlasName) //{ // for (textureAtlasName in _textureAtlasDic) // { // textureAtlas = _textureAtlasDic[textureAtlasName]; // if(textureAtlas.getRegion(textureName)) // { // break; // } // textureAtlas = null; // } //} if(textureAtlas) { if(isNaN(pivotX) || isNaN(pivotY)) { SkeletonData* data = _dataDic[textureAtlasName]; if(data) { Point *pivot = data->getSubTexturePivot(textureName); if(pivot) { pivotX = pivot->x; pivotY = pivot->y; } } } return generateDisplay(textureAtlas, textureName, pivotX, pivotY); } return nullptr; }
/** * Build and returns a new Armature instance. * @example * <listing> * var armature:Armature = factory.buildArmature('dragon'); * </listing> * @param armatureName The name of this Armature instance. * @param The name of this animation * @param The name of this SkeletonData. * @param The name of this textureAtlas. * @param The name of this skin. * @return A Armature instance. */ Armature* BaseFactory::buildArmature(const String &armatureName, const String &animationName, const String &skeletonName, const String &textureAtlasName, const String &skinName) { ArmatureData* armatureData = 0; SkeletonData *data = 0; if(!skeletonName.empty()) { std::map<String , SkeletonData*>::iterator iter = _dataDic.find(skeletonName); if(iter != _dataDic.end()) { data = iter->second; armatureData = data->getArmatureData(armatureName); } } //else //{ // for(skeletonName in _dataDic) // { // data = _dataDic[skeletonName]; // armatureData = data->getArmatureData(armatureName); // if(armatureData) // { // break; // } // } //} if(!armatureData) { return nullptr; } _currentDataName = skeletonName; _currentTextureAtlasName = textureAtlasName.empty() ? skeletonName : textureAtlasName; Armature* armature = generateArmature(); armature->name = armatureName; Bone* bone; for(size_t i = 0 ; i < armatureData->boneDataList.size() ; i ++) { BoneData* boneData = armatureData->boneDataList[i]; bone = new Bone(); bone->name = boneData->name; bone->fixedRotation = boneData->fixedRotation; bone->scaleMode = boneData->scaleMode; bone->origin = boneData->transform; if(armatureData->getBoneData(boneData->parent)) { armature->addBone(bone, boneData->parent); } else { armature->addBone(bone); } } ArmatureData* animationArmatureData = 0; SkinData *skinDataCopy = 0; if(!animationName.empty() && animationName != armatureName) { //ArmatureData* animationArmatureData = data->getArmatureData(animationName); // Get the default animation //if(!animationArmatureData) //{ // for (skeletonName in _dataDic) // { // data = _dataDic[skeletonName]; // animationArmatureData = data->getArmatureData(animationName); // if(animationArmatureData) // { // break; // } // } //} ArmatureData* armatureDataCopy = data->getArmatureData(animationName); if(armatureDataCopy) { skinDataCopy = armatureDataCopy->getSkinData(""); } } if(animationArmatureData) { armature->getAnimation()->setAnimationDataList(animationArmatureData->animationDataList); } else { armature->getAnimation()->setAnimationDataList(armatureData->animationDataList); } SkinData* skinData = armatureData->getSkinData(skinName); if(!skinData) { return nullptr; //throw new ArgumentError(); } Slot* slot; DisplayData* displayData; Armature* childArmature; size_t i; //var helpArray:Array = []; for(size_t j = 0 ; j < skinData->slotDataList.size() ; j ++) { SlotData* slotData = skinData->slotDataList[j]; bone = armature->getBone(slotData->parent); if(!bone) { continue; } slot = generateSlot(); slot->name = slotData->name; slot->setBlendMode(slotData->blendMode); slot->_originZOrder = slotData->zOrder; slot->_dislayDataList = slotData->displayDataList; std::vector<Object*> helpArray; i = slotData->displayDataList.size(); helpArray.resize(i); while(i --) { displayData = slotData->displayDataList[i]; if(displayData->type == DisplayData::ARMATURE) { DisplayData* displayDataCopy = 0; if(skinDataCopy) { SlotData* slotDataCopy = skinDataCopy->getSlotData(slotData->name); if(slotDataCopy) { displayDataCopy = slotDataCopy->displayDataList[i]; } } else { displayDataCopy = 0; } childArmature = buildArmature(displayData->name, displayDataCopy?displayDataCopy->name:"", _currentDataName, _currentTextureAtlasName); if(childArmature) { helpArray[i] = childArmature; } //fix by Wayne Dimart: // break; we don't use break here, or will crach the program due to incomplete helpArray. continue; } else { helpArray[i] = generateDisplay(getTextureAtlas(_currentTextureAtlasName), displayData->name, displayData->pivot.x, displayData->pivot.y); } } slot->setDisplayList(helpArray); slot->changeDisplay(0); bone->addChild(slot); } // i = armature->_boneList.size(); while(i --) { armature->_boneList[i]->update(); } i = armature->_slotList.size(); while(i --) { slot = armature->_slotList[i]; slot->update(); } armature->updateSlotsZOrder(); return armature; }
void* BaseFactory::getTextureDisplay(const std::string &textureName, const std::string &textureAtlasName, const DisplayData *displayData) const { ITextureAtlas *textureAtlas = nullptr; TextureData *textureData = nullptr; if (!textureAtlasName.empty()) { auto iterator = _textureAtlasMap.find(textureAtlasName); if (iterator != _textureAtlasMap.end()) { textureAtlas = iterator->second; textureData = textureAtlas->textureAtlasData->getTextureData(textureName); } } if (!textureData) { AutoSearchType searchType = (textureAtlasName.empty() ? AutoSearchType::AST_ALL : (autoSearchTexture ? AutoSearchType::AST_AUTO : AutoSearchType::AST_NONE)); if (searchType != AutoSearchType::AST_NONE) { for (auto iterator = _textureAtlasMap.begin(); iterator != _textureAtlasMap.end(); ++iterator) { textureAtlas = iterator->second; if (searchType == AutoSearchType::AST_ALL || textureAtlas->textureAtlasData->autoSearch) { textureData = textureAtlas->textureAtlasData->getTextureData(textureName); if (textureData) { break; } } } } } if (!textureData) { return nullptr; } if (!displayData) { auto iterator = _dragonBonesDataMap.find(textureAtlas->textureAtlasData->name); if (iterator != _dragonBonesDataMap.end()) { DragonBonesData *dragonBonesData = iterator->second; for (size_t i = 0, l = dragonBonesData->armatureDataList.size(); i < l; ++i) { for (size_t j = 0, l = dragonBonesData->armatureDataList[i]->skinDataList.size(); j < l; ++j) { for (size_t k = 0, l = dragonBonesData->armatureDataList[i]->skinDataList[j]->slotDataList.size(); k < l; ++k) { for (size_t m = 0, l = dragonBonesData->armatureDataList[i]->skinDataList[j]->slotDataList[k]->displayDataList.size(); m < l; ++m) { displayData = dragonBonesData->armatureDataList[i]->skinDataList[j]->slotDataList[k]->displayDataList[m]; if (displayData->name != textureName) { displayData = nullptr; } else { break; } } if (displayData) { break; } } if (displayData) { break; } } if (displayData) { break; } } } } return generateDisplay(textureAtlas, textureData, displayData); }