284 lines
10 KiB
C++
Executable File
284 lines
10 KiB
C++
Executable File
//
|
|
// KRAnimationAttribute.cpp
|
|
// Kraken Engine
|
|
//
|
|
// Copyright 2022 Kearwood Gilbert. All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
// of conditions and the following disclaimer in the documentation and/or other materials
|
|
// provided with the distribution.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR
|
|
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// The views and conclusions contained in the software and documentation are those of the
|
|
// authors and should not be interpreted as representing official policies, either expressed
|
|
// or implied, of Kearwood Gilbert.
|
|
//
|
|
|
|
#include "KRAnimationAttribute.h"
|
|
#include "KRContext.h"
|
|
#include "KRAnimationManager.h"
|
|
#include "KRAnimationCurveManager.h"
|
|
|
|
|
|
KRAnimationAttribute::KRAnimationAttribute(KRContext& context) : KRContextObject(context)
|
|
{
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
|
|
m_target = NULL;
|
|
m_curve = NULL;
|
|
}
|
|
|
|
KRAnimationAttribute::~KRAnimationAttribute()
|
|
{
|
|
|
|
}
|
|
|
|
tinyxml2::XMLElement* KRAnimationAttribute::saveXML(tinyxml2::XMLNode* parent)
|
|
{
|
|
tinyxml2::XMLDocument* doc = parent->GetDocument();
|
|
tinyxml2::XMLElement* e = doc->NewElement("attribute");
|
|
parent->InsertEndChild(e);
|
|
e->SetAttribute("curve", m_curve_name.c_str());
|
|
e->SetAttribute("target", m_target_name.c_str());
|
|
const char* szAttribute = "none";
|
|
switch (m_node_attribute) {
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_NONE:
|
|
szAttribute = "none";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X:
|
|
szAttribute = "translate_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y:
|
|
szAttribute = "translate_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Z:
|
|
szAttribute = "translate_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_X:
|
|
szAttribute = "scale_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Y:
|
|
szAttribute = "scale_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Z:
|
|
szAttribute = "scale_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_X:
|
|
szAttribute = "rotate_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Y:
|
|
szAttribute = "rotate_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Z:
|
|
szAttribute = "rotate_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_X:
|
|
szAttribute = "pre_rotate_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Y:
|
|
szAttribute = "pre_rotate_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Z:
|
|
szAttribute = "pre_rotate_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_X:
|
|
szAttribute = "post_rotate_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Y:
|
|
szAttribute = "post_rotate_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Z:
|
|
szAttribute = "post_rotate_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_X:
|
|
szAttribute = "rotate_pivot_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Y:
|
|
szAttribute = "rotate_pivot_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Z:
|
|
szAttribute = "rotate_pivot_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_X:
|
|
szAttribute = "scale_pivot_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Y:
|
|
szAttribute = "scale_pivot_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Z:
|
|
szAttribute = "scale_pivot_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_X:
|
|
szAttribute = "rotate_offset_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Y:
|
|
szAttribute = "rotate_offset_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Z:
|
|
szAttribute = "rotate_offset_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_SCALE_OFFSET_X:
|
|
szAttribute = "scale_offset_x";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_SCALE_OFFSET_Y:
|
|
szAttribute = "scale_offset_y";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_SCALE_OFFSET_Z:
|
|
szAttribute = "scale_offset_z";
|
|
break;
|
|
case KRNode::KRENGINE_NODE_ATTRIBUTE_COUNT:
|
|
// Suppress warning
|
|
break;
|
|
}
|
|
|
|
e->SetAttribute("attribute", szAttribute);
|
|
return e;
|
|
}
|
|
|
|
void KRAnimationAttribute::loadXML(tinyxml2::XMLElement* e)
|
|
{
|
|
m_target = NULL;
|
|
m_curve = NULL;
|
|
m_curve_name = e->Attribute("curve");
|
|
m_target_name = e->Attribute("target");
|
|
|
|
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
|
|
|
|
const char* szAttribute = e->Attribute("attribute");
|
|
if (strcmp(szAttribute, "none") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
|
|
} else if (strcmp(szAttribute, "translate_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X;
|
|
} else if (strcmp(szAttribute, "translate_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y;
|
|
} else if (strcmp(szAttribute, "translate_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Z;
|
|
} else if (strcmp(szAttribute, "rotate_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_X;
|
|
} else if (strcmp(szAttribute, "rotate_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Y;
|
|
} else if (strcmp(szAttribute, "rotate_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Z;
|
|
} else if (strcmp(szAttribute, "scale_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_X;
|
|
} else if (strcmp(szAttribute, "scale_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Y;
|
|
} else if (strcmp(szAttribute, "scale_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Z;
|
|
} else if (strcmp(szAttribute, "pre_rotate_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_X;
|
|
} else if (strcmp(szAttribute, "pre_rotate_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Y;
|
|
} else if (strcmp(szAttribute, "pre_rotate_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Z;
|
|
} else if (strcmp(szAttribute, "post_rotate_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_X;
|
|
} else if (strcmp(szAttribute, "post_rotate_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Y;
|
|
} else if (strcmp(szAttribute, "post_rotate_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Z;
|
|
} else if (strcmp(szAttribute, "rotate_pivot_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_X;
|
|
} else if (strcmp(szAttribute, "rotate_pivot_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Y;
|
|
} else if (strcmp(szAttribute, "rotate_pivot_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Z;
|
|
} else if (strcmp(szAttribute, "scale_pivot_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_X;
|
|
} else if (strcmp(szAttribute, "scale_pivot_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Y;
|
|
} else if (strcmp(szAttribute, "scale_pivot_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Z;
|
|
} else if (strcmp(szAttribute, "rotate_offset_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_X;
|
|
} else if (strcmp(szAttribute, "rotate_offset_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Y;
|
|
} else if (strcmp(szAttribute, "rotate_offset_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Z;
|
|
} else if (strcmp(szAttribute, "scale_offset_x") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_X;
|
|
} else if (strcmp(szAttribute, "scale_offset_y") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Y;
|
|
} else if (strcmp(szAttribute, "scale_offset_z") == 0) {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Z;
|
|
} else {
|
|
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
|
|
}
|
|
}
|
|
|
|
KRNode::node_attribute_type KRAnimationAttribute::getTargetAttribute() const
|
|
{
|
|
return m_node_attribute;
|
|
}
|
|
|
|
void KRAnimationAttribute::setTargetAttribute(KRNode::node_attribute_type target_attribute)
|
|
{
|
|
m_node_attribute = target_attribute;
|
|
}
|
|
|
|
std::string KRAnimationAttribute::getTargetName() const
|
|
{
|
|
return m_target_name;
|
|
}
|
|
|
|
void KRAnimationAttribute::setTargetName(const std::string& target_name)
|
|
{
|
|
m_target_name = target_name;
|
|
m_target = NULL;
|
|
}
|
|
|
|
std::string KRAnimationAttribute::getCurveName() const
|
|
{
|
|
return m_curve_name;
|
|
}
|
|
|
|
void KRAnimationAttribute::setCurveName(const std::string& curve_name)
|
|
{
|
|
m_curve_name = curve_name;
|
|
m_curve = NULL;
|
|
}
|
|
|
|
KRNode* KRAnimationAttribute::getTarget()
|
|
{
|
|
if (m_target == NULL) {
|
|
m_target = getContext().getSceneManager()->getFirstScene()->getRootNode()->find<KRNode>(m_target_name); // FINDME, HACK! - This won't work with multiple scenes in a context; we should move the animations out of KRAnimationManager and attach them to the parent nodes of the animated KRNode's
|
|
}
|
|
if (m_target == NULL) {
|
|
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Kraken - Animation attribute could not find object: %s", m_target_name.c_str());
|
|
}
|
|
return m_target;
|
|
}
|
|
|
|
KRAnimationCurve* KRAnimationAttribute::getCurve()
|
|
{
|
|
if (m_curve == NULL) {
|
|
m_curve = getContext().getAnimationCurveManager()->getAnimationCurve(m_curve_name.c_str());
|
|
}
|
|
return m_curve;
|
|
}
|
|
|
|
void KRAnimationAttribute::deleteCurve()
|
|
{
|
|
KRAnimationCurve* curve = getCurve();
|
|
if (curve) {
|
|
getContext().getAnimationCurveManager()->deleteAnimationCurve(curve);
|
|
m_curve = NULL;
|
|
}
|
|
}
|
|
|