157 lines
4.2 KiB
C++
157 lines
4.2 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "core/item.h"
|
|
#include "log/log.h"
|
|
|
|
using namespace GS::Core;
|
|
using namespace GS::NML;
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool Item::FromMetaTag(Tag &tag)
|
|
{
|
|
if (tag.name != "Item")
|
|
__ERR__(__LOG_E__ << "Could not parse item, incorrect root tag (" << tag.name << ").\n", false)
|
|
|
|
item_flags = 0;
|
|
|
|
position.Set(0, 0, 0);
|
|
rotation.Set(0, 0, 0);
|
|
scale.Set(1, 1, 1);
|
|
|
|
opacity = 1;
|
|
pivot_matrix = Matrix4::IdentityMatrix();
|
|
rorder = Math::rOrder_Default;
|
|
|
|
registry.Clear();
|
|
|
|
// Parse root tags.
|
|
NMLTagForeach(pt, tag)
|
|
{
|
|
// Legacy support.
|
|
if (pt->name == "OffsetPosition")
|
|
{
|
|
Vector4 position;
|
|
position.FromMetaTag(*pt);
|
|
pivot_matrix.SetRow(3, position);
|
|
}
|
|
else if (pt->name == "OffsetMatrix")
|
|
pivot_matrix.FromMetaTag(*pt);
|
|
|
|
else if (pt->name == "Position")
|
|
position.FromMetaTag(*pt);
|
|
else if (pt->name == "Rotation")
|
|
rotation.FromMetaTag(*pt);
|
|
else if (pt->name == "Scale")
|
|
scale.FromMetaTag(*pt);
|
|
|
|
else if (pt->name == "Target")
|
|
target.FromMetaTag(*pt);
|
|
else if (pt->name == "TargetOffsetRotation")
|
|
;
|
|
|
|
else if (pt->name == "ItemFlag")
|
|
{
|
|
NMLTagForeach(ft, *pt)
|
|
{
|
|
if (ft->name == "HasTarget")
|
|
item_flags.Set(ItemFlagHasTarget);
|
|
if (ft->name == "Invisible")
|
|
item_flags.Set(ItemFlagInvisible);
|
|
if (ft->name == "LinkOnlyPosition")
|
|
item_flags.Set(ItemFlagInheritPositionOnly);
|
|
}
|
|
}
|
|
|
|
else if (pt->name == "RotationOrder")
|
|
{
|
|
String ro(pt->GetString());
|
|
|
|
if (ro == "ZYX") rorder = Math::rOrder_ZYX;
|
|
else if (ro == "YZX") rorder = Math::rOrder_YZX;
|
|
else if (ro == "ZXY") rorder = Math::rOrder_ZXY;
|
|
else if (ro == "XZY") rorder = Math::rOrder_XZY;
|
|
else if (ro == "YXZ") rorder = Math::rOrder_YXZ;
|
|
else if (ro == "XYZ") rorder = Math::rOrder_XYZ;
|
|
else if (ro == "XY") rorder = Math::rOrder_XY;
|
|
|
|
else __LOG_W__ << "Unknown rotation order '" << ro << "'.\n";
|
|
}
|
|
else if (
|
|
(pt->name == "OrientationQuaternion") ||
|
|
(pt->name == "OrientationMatrix")
|
|
)
|
|
;
|
|
else if (pt->name == "Registry")
|
|
{
|
|
NMLTagForeach(child, *pt)
|
|
registry.AddRoot(child->Clone());
|
|
}
|
|
else __LOG_W__ << "Unknown tag '" << pt->name << "' in <Item>.\n";
|
|
}
|
|
|
|
MarkTransformationDirty();
|
|
item_flags.Set(ItemFlagRotationMatrixDirty);
|
|
|
|
ComputeMatrix();
|
|
ComputeInverseMatrix();
|
|
return true;
|
|
}
|
|
Tag *Item::AsMetaTag() const
|
|
{
|
|
Tag *root = new Tag("Item");
|
|
if (!root)
|
|
__ERR__(__LOG_E__ << "Could not serialize item. Failed to create root tag.\n", NULL)
|
|
|
|
Vector4 NULL_vec(0, 0, 0), NULL_scale(1, 1, 1);
|
|
|
|
// Save transformation.
|
|
if (pivot_matrix != Matrix4::IdentityMatrix())
|
|
root->AddChild(pivot_matrix.AsMetaTag("OffsetMatrix"));
|
|
if (position != NULL_vec)
|
|
root->AddChild(position.AsMetaTag("Position"));
|
|
if (rotation != NULL_vec)
|
|
root->AddChild(rotation.AsMetaTag("Rotation"));
|
|
if (scale != NULL_scale)
|
|
root->AddChild(scale.AsMetaTag("Scale"));
|
|
|
|
if (item_flags.Get() != 0)
|
|
if (Tag *ft = root->AddChild("ItemFlag"))
|
|
{
|
|
if (item_flags.IsSet(ItemFlagHasTarget))
|
|
ft->AddChild("HasTarget");
|
|
if (item_flags.IsSet(ItemFlagInvisible))
|
|
ft->AddChild("Invisible");
|
|
if (item_flags.IsSet(ItemFlagInheritPositionOnly))
|
|
ft->AddChild("LinkOnlyPosition");
|
|
}
|
|
|
|
root->AddChild(target.AsMetaTag("Target"));
|
|
|
|
switch (rorder)
|
|
{
|
|
case Math::rOrder_ZYX: root->AddChild("RotationOrder", "ZYX"); break;
|
|
case Math::rOrder_YZX: root->AddChild("RotationOrder", "YZX"); break;
|
|
case Math::rOrder_ZXY: root->AddChild("RotationOrder", "ZXY"); break;
|
|
case Math::rOrder_XZY: root->AddChild("RotationOrder", "XZY"); break;
|
|
case Math::rOrder_YXZ: root->AddChild("RotationOrder", "YXZ"); break;
|
|
case Math::rOrder_XYZ: root->AddChild("RotationOrder", "XYZ"); break;
|
|
case Math::rOrder_XY: root->AddChild("RotationOrder", "XY"); break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Registry.
|
|
Tag *tag_registry = root->AddChild("Registry");
|
|
NMLFileForeach(child, registry)
|
|
tag_registry->AddChild(child->Clone());
|
|
|
|
return root;
|
|
}
|
|
//------------------------------------------------------------------------------
|