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);
}
