// creates a node tree that matches the current scene and animation
AnimationNode* Animator::CreateNodeTree(aiNode* node, AnimationNode* parent)
{
//create a node
AnimationNode* internalNode = new AnimationNode(node->mName.data);
internalNode->parent = parent;
mapNodesByName[node] = internalNode;
//copy its transformation
internalNode->localTransform = node->mTransformation;
CalculateGlobalTransform(internalNode);
//find the index of the animation track affecting this node, if any
if (currentAnimationIndex < mainScene->mNumAnimations)
{
internalNode->channelIndex = -1;
for (unsigned int i = 0; i < currentAnimation->mNumChannels; i++)
{
if (currentAnimation->mChannels[i]->mNodeName.data == internalNode->name)
{
internalNode->channelIndex = i;
break;
}
}
}
//continue for all child nodes and assign the created internal nodes as our children
for (unsigned int i = 0; i < node->mNumChildren; i++)
{
AnimationNode* childNode = CreateNodeTree(node->mChildren[i], internalNode);
internalNode->children.push_back(childNode);
}
return internalNode;
}
// ------------------------------------------------------------------------------------------------
// Recursively creates an internal node structure matching the current scene and animation.
SceneAnimNode* SceneAnimator::CreateNodeTree(aiNode* pNode, SceneAnimNode* pParent)
{
// create a node
SceneAnimNode* internalNode = new SceneAnimNode(pNode->mName.data);
internalNode->mParent = pParent;
mNodesByName[pNode] = internalNode;
// copy its transformation
internalNode->mLocalTransform = pNode->mTransformation;
CalculateGlobalTransform(internalNode);
// find the index of the animation track affecting this node, if any
if (mCurrentAnimIndex < mScene->mNumAnimations)
{
internalNode->mChannelIndex = -1;
const aiAnimation* currentAnim = mScene->mAnimations[mCurrentAnimIndex];
for (unsigned int a = 0; a < currentAnim->mNumChannels; a++)
{
if (currentAnim->mChannels[a]->mNodeName.data == internalNode->mName)
{
internalNode->mChannelIndex = a;
break;
}
}
}
// continue for all child nodes and assign the created internal nodes as our children
for (unsigned int a = 0; a < pNode->mNumChildren; a++)
{
SceneAnimNode* childNode = CreateNodeTree(pNode->mChildren[a], internalNode);
internalNode->mChildren.push_back(childNode);
}
return internalNode;
}
// ------------------------------------------------------------------------------------------------
// Sets the animation to use for playback.
void SceneAnim::SetAnimIndex( size_t pAnimIndex)
{
// no change
if( pAnimIndex == mCurrentAnimIndex)
return;
// kill data of the previous anim
delete mRootNode; mRootNode = NULL;
delete mAnimEvaluator; mAnimEvaluator = NULL;
mNodesByName.clear();
mCurrentAnimIndex = pAnimIndex;
// create the internal node tree. Do this even in case of invalid animation index
// so that the transformation matrices are properly set up to mimic the current scene
mRootNode = CreateNodeTree( mScene->mRootNode, NULL);
// invalid anim index
if( mCurrentAnimIndex >= mScene->mNumAnimations)
return;
// create an evaluator for this animation
//mAnimEvaluator = new AnimEval(mScene->mAnimations[mCurrentAnimIndex]);
mAnimEvaluator = new AnimEval;
mAnimEvaluator->init(mScene->mAnimations[mCurrentAnimIndex]);
}
NodeTree* CreateBinaryTree()
{
NodeTree* p;
char* data=(char*)malloc(sizeof(char)*100);
scanf("%s",data);
if (strcmp(data,"*")==0)
{
return NULL;
}
else {
p=CreateNodeTree(atoi(data));
p->left=CreateBinaryTree();
p->right=CreateBinaryTree();
}
return p;
}
// sets the animation to use for playback
void Animator::SetAnimationIndex(int animIndex)
{
if (animIndex == currentAnimationIndex)
{
return;
}
// kill data of the previous animation
if (rootNode != NULL)
{
delete rootNode;
rootNode = NULL;
}
if (lastFramePosition != NULL)
{
delete[] lastFramePosition;
lastFramePosition = NULL;
}
mapNodesByName.clear();
currentAnimation = NULL;
currentAnimationIndex = animIndex;
currentAnimation = mainScene->mAnimations[currentAnimationIndex];
// create the internal node tree. Do this even in case of invalid animation index
// so that the transformation matrices are properly set up to mimic the current scene
rootNode = CreateNodeTree(mainScene->mRootNode, NULL);
// invalid animation index
if (animIndex >= mainScene->mNumAnimations)
{
currentAnimationIndex = 0;
currentAnimation = mainScene->mAnimations[currentAnimationIndex];
}
lastFramePosition = new glm::uvec3[currentAnimation->mNumChannels];
}
// NodeTree
Offset<NodeTree> FlatBuffersSerialize::createNodeTree(const tinyxml2::XMLElement *objectData,
std::string classType)
{
std::string classname = classType.substr(0, classType.find("ObjectData"));
CCLOG("classname = %s", classname.c_str());
std::string name = "";
Offset<Options> options;
std::vector<Offset<NodeTree>> children;
if (classname == "ProjectNode")
{
auto reader = ProjectNodeReader::getInstance();
options = CreateOptions(*_builder, reader->createOptionsWithFlatBuffers(objectData, _builder));
}
else if (classname == "SimpleAudio")
{
auto reader = ComAudioReader::getInstance();
options = CreateOptions(*_builder, reader->createOptionsWithFlatBuffers(objectData, _builder));
}
else
{
std::string readername = getGUIClassName(classname);
readername.append("Reader");
NodeReaderProtocol* reader = dynamic_cast<NodeReaderProtocol*>(ObjectFactory::getInstance()->createObject(readername));
options = CreateOptions(*_builder, reader->createOptionsWithFlatBuffers(objectData, _builder));
}
// children
bool containChildrenElement = false;
const tinyxml2::XMLElement* child = objectData->FirstChildElement();
while (child)
{
CCLOG("child name = %s", child->Name());
if (strcmp("Children", child->Name()) == 0)
{
containChildrenElement = true;
break;
}
child = child->NextSiblingElement();
}
if (containChildrenElement)
{
child = child->FirstChildElement();
CCLOG("element name = %s", child->Name());
while (child)
{
const tinyxml2::XMLAttribute* attribute = child->FirstAttribute();
bool bHasType = false;
while (attribute)
{
std::string attriname = attribute->Name();
std::string value = attribute->Value();
if (attriname == "ctype")
{
children.push_back(createNodeTree(child, value));
bHasType = true;
break;
}
attribute = attribute->Next();
}
if(!bHasType)
{
children.push_back(createNodeTree(child, "NodeObjectData"));
}
child = child->NextSiblingElement();
}
}
//
std::string customClassName = "";
const tinyxml2::XMLAttribute* attribute = objectData->FirstAttribute();
while (attribute)
{
std::string attriname = attribute->Name();
std::string value = attribute->Value();
if (attriname == "CustomClassName")
{
customClassName = value;
break;
}
attribute = attribute->Next();
}
return CreateNodeTree(*_builder,
_builder->CreateString(classname),
_builder->CreateVector(children),
options,
_builder->CreateString(customClassName));
}
// Static
DARKSDK void GFCreateNodeTree ( float fX, float fY, float fZ )
{
CreateNodeTree ( fX, fY, fZ );
}
