khanat-opennel-code/code/nel/src/ligo/primitive.cpp

2768 lines
68 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdligo.h"
#include "nel/misc/types_nl.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/ligo/primitive.h"
#include "nel/ligo/ligo_config.h"
#include "nel/ligo/primitive_class.h"
#include "nel/misc/i_xml.h"
#include "nel/misc/path.h"
using namespace NLMISC;
using namespace std;
const uint32 NLLIGO_PRIMITIVE_VERSION = 1;
namespace NLLIGO
{
CPrimitiveContext *CPrimitiveContext::_Instance = NULL;
// ***************************************************************************
// XML helpers
// ***************************************************************************
void Error (const char *filename, const char *format, ...)
{
va_list args;
va_start( args, format );
char buffer[1024];
vsnprintf( buffer, 1024, format, args );
va_end( args );
nlwarning ("In File (%s) %s", filename, buffer);
}
// ***************************************************************************
void XMLError (xmlNodePtr xmlNode, const char *filename, const char *format, ... )
{
va_list args;
va_start( args, format );
char buffer[1024];
vsnprintf( buffer, 1024, format, args );
va_end( args );
Error (filename, "node (%s), line (%p) : %s", xmlNode->name, xmlNode->content, buffer);
}
// ***************************************************************************
xmlNodePtr GetFirstChildNode (xmlNodePtr xmlNode, const char *filename, const char *childName)
{
// Call the CIXml version
xmlNodePtr result = CIXml::getFirstChildNode (xmlNode, childName);
if (result) return result;
// Output a formated error
XMLError (xmlNode, filename, "Can't find XML node named (%s)", childName);
return NULL;
}
// ***************************************************************************
bool GetPropertyString (string &result, const char *filename, xmlNodePtr xmlNode, const char *propName)
{
// Call the CIXml version
if (!CIXml::getPropertyString (result, xmlNode, propName))
{
// Output a formated error
XMLError (xmlNode, filename, "Can't find XML node property (%s)", propName);
return false;
}
return true;
}
// ***************************************************************************
bool ReadInt (const char *propName, int &result, const char *filename, xmlNodePtr xmlNode)
{
string value;
if (GetPropertyString (value, filename, xmlNode, propName))
{
result = atoi (value.c_str ());
return true;
}
return false;
}
// ***************************************************************************
void WriteInt (const char *propName, int value, xmlNodePtr xmlNode)
{
// Set properties
xmlSetProp (xmlNode, (const xmlChar*)propName, (const xmlChar*)(toString (value).c_str ()));
}
// ***************************************************************************
bool ReadUInt (const char *propName, uint &result, const char *filename, xmlNodePtr xmlNode)
{
string value;
if (GetPropertyString (value, filename, xmlNode, propName))
{
result = strtoul (value.c_str (), NULL, 10);
return true;
}
return false;
}
// ***************************************************************************
void WriteUInt (const char *propName, uint value, xmlNodePtr xmlNode)
{
// Set properties
xmlSetProp (xmlNode, (const xmlChar*)propName, (const xmlChar*)(toString (value).c_str ()));
}
// ***************************************************************************
bool ReadFloat (const char *propName, float &result, const char *filename, xmlNodePtr xmlNode)
{
string value;
if (GetPropertyString (value, filename, xmlNode, propName))
{
NLMISC::fromString(value, result);
return true;
}
return false;
}
// ***************************************************************************
void WriteFloat (const char *propName, float value, xmlNodePtr xmlNode)
{
// Set properties
xmlSetProp (xmlNode, (const xmlChar*)propName, (const xmlChar*)(toString (value).c_str ()));
}
// ***************************************************************************
bool ReadVector (CPrimVector &point, const char *filename, xmlNodePtr xmlNode)
{
CPrimVector pos;
if (ReadFloat ("X", pos.x, filename, xmlNode))
{
if (ReadFloat ("Y", pos.y, filename, xmlNode))
{
if (ReadFloat ("Z", pos.z, filename, xmlNode))
{
pos.Selected = false;
string result;
if (CIXml::getPropertyString (result, xmlNode, "SELECTED"))
{
if (result == "true")
pos.Selected = true;
}
point = pos;
return true;
}
}
}
return false;
}
// ***************************************************************************
void WriteVector (const CPrimVector &point, xmlNodePtr xmlNode)
{
// Set properties
xmlSetProp (xmlNode, (const xmlChar*)"X", (const xmlChar*)(toString (point.x).c_str ()));
xmlSetProp (xmlNode, (const xmlChar*)"Y", (const xmlChar*)(toString (point.y).c_str ()));
xmlSetProp (xmlNode, (const xmlChar*)"Z", (const xmlChar*)(toString (point.z).c_str ()));
if (point.Selected)
xmlSetProp (xmlNode, (const xmlChar*)"SELECTED", (const xmlChar*)"true");
}
// ***************************************************************************
bool GetNodeString (string &result, const char *filename, xmlNodePtr xmlNode, const char *nodeName)
{
// Look for the node
xmlNodePtr node = CIXml::getFirstChildNode (xmlNode, nodeName);
if (!node)
{
XMLError (xmlNode, filename, "Can't find XML node named (%s)", nodeName);
return false;
}
// Get the node string
if (!CIXml::getContentString (result, node))
{
XMLError (xmlNode, filename, "Can't find any text in the node named (%s)", nodeName);
return false;
}
return true;
}
// ***************************************************************************
bool GetContentString (string &result, const char *filename, xmlNodePtr xmlNode)
{
// Get the node string
if (!CIXml::getContentString (result, xmlNode))
{
XMLError (xmlNode, filename, "Can't find any text in the node");
return false;
}
return true;
}
// ***************************************************************************
// CPropertyString
// ***************************************************************************
CPropertyString::CPropertyString (const char *str)
{
String = str;
}
CPropertyString::CPropertyString (const std::string &str)
{
String = str;
}
// ***************************************************************************
CPropertyString::CPropertyString (const char *str, bool _default)
{
String = str;
Default = _default;
}
// ***************************************************************************
// CPropertyStringArray
// ***************************************************************************
CPropertyStringArray::CPropertyStringArray (const std::vector<std::string> &stringArray)
{
StringArray = stringArray;
}
// ***************************************************************************
CPropertyStringArray::CPropertyStringArray (const std::vector<std::string> &stringArray, bool _default)
{
StringArray = stringArray;
Default = _default;
}
// ***************************************************************************
void CPrimPoint::serial (NLMISC::IStream &f)
{
// serial base info
IPrimitive::serial(f);
f.serial(Point);
f.serial(Angle);
}
// ***************************************************************************
void CPrimPath::serial (NLMISC::IStream &f)
{
IPrimitive::serial(f);
f.serialCont(VPoints);
}
// ***************************************************************************
bool CPrimZone::contains (const NLMISC::CVector &v, const std::vector<CPrimVector> &points)
{
uint32 i;
CVector vMin, vMax;
// Point or line can't contains !
if (points.size() < 3)
return false;
// Get the bounding rectangle of the zone
vMax = vMin = points[0];
for (i = 0; i < points.size(); ++i)
{
if (vMin.x > points[i].x)
vMin.x = points[i].x;
if (vMin.y > points[i].y)
vMin.y = points[i].y;
if (vMax.x < points[i].x)
vMax.x = points[i].x;
if (vMax.y < points[i].y)
vMax.y = points[i].y;
}
if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
return false;
uint32 nNbIntersection = 0;
for (i = 0; i < points.size(); ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[(i+1)%points.size()];
if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
continue;
if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
continue;
float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
if (xinter > v.x)
++nNbIntersection;
}
if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
return true;
else
return false;
}
// ***************************************************************************
bool CPrimZone::contains (const NLMISC::CVector &v, const std::vector<NLMISC::CVector> &points)
{
uint32 i;
CVector vMin, vMax;
// Point or line can't contains !
if (points.size() < 3)
return false;
// Get the bounding rectangle of the zone
vMax = vMin = points[0];
for (i = 0; i < points.size(); ++i)
{
if (vMin.x > points[i].x)
vMin.x = points[i].x;
if (vMin.y > points[i].y)
vMin.y = points[i].y;
if (vMax.x < points[i].x)
vMax.x = points[i].x;
if (vMax.y < points[i].y)
vMax.y = points[i].y;
}
if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
return false;
uint32 nNbIntersection = 0;
for (i = 0; i < points.size(); ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[(i+1)%points.size()];
if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
continue;
if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
continue;
float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
if (xinter > v.x)
++nNbIntersection;
}
if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
return true;
else
return false;
}
// ***************************************************************************
// CPrimNode
// ***************************************************************************
bool CPrimNode::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
return IPrimitive::read (xmlNode, filename, version, config);
}
// ***************************************************************************
uint CPrimNode::getNumVector () const
{
return 0;
}
// ***************************************************************************
const CPrimVector *CPrimNode::getPrimVector () const
{
return NULL;
}
// ***************************************************************************
CPrimVector *CPrimNode::getPrimVector ()
{
return NULL;
}
// ***************************************************************************
NLLIGO::IPrimitive *CPrimNode::copy () const
{
return new CPrimNode (*this);
}
// ***************************************************************************
// CPrimNode
// ***************************************************************************
/*void CPrimNode::operator= (const CPrimNode &node)
{
// Copy the IPrimitive
IPrimitive::operator= (node);
}
// ***************************************************************************
void CPrimPoint::operator= (const CPrimPoint &node)
{
// Copy the IPrimitive
IPrimitive::operator= (node);
}
// ***************************************************************************
void CPrimPath::operator= (const CPrimPath &node)
{
// Copy the IPrimitive
}
// ***************************************************************************
void CPrimZone::operator= (const CPrimZone &node)
{
// Copy the IPrimitive
IPrimitive::operator= (node);
}
*/
// ***************************************************************************
uint CPrimPoint::getNumVector () const
{
return 1;
}
// ***************************************************************************
const CPrimVector *CPrimPoint::getPrimVector () const
{
return &Point;
}
// ***************************************************************************
CPrimVector *CPrimPoint::getPrimVector ()
{
return &Point;
}
// ***************************************************************************
NLLIGO::IPrimitive *CPrimPoint::copy () const
{
return new CPrimPoint (*this);
}
// ***************************************************************************
bool CPrimPoint::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
// Read points
xmlNodePtr ptNode = GetFirstChildNode (xmlNode, filename, "PT");
if (ptNode)
{
// Read a vector
if (!ReadVector (Point, filename, ptNode))
return false;
ptNode = CIXml::getFirstChildNode (xmlNode, "ANGLE");
if (ptNode)
{
// Read a float
if (!ReadFloat ("VALUE", Angle, filename, ptNode))
return false;
}
else
Angle = 0;
}
else
{
return false;
}
return IPrimitive::read (xmlNode, filename, version, config);
}
// ***************************************************************************
void CPrimPoint::write (xmlNodePtr xmlNode, const char *filename) const
{
// Save the point
xmlNodePtr ptNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"PT", NULL);
WriteVector (Point, ptNode);
// Save the angle
if (Angle != 0)
{
xmlNodePtr ptNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"ANGLE", NULL);
WriteFloat ("VALUE", Angle, ptNode);
}
IPrimitive::write (xmlNode, filename);
}
// ***************************************************************************
// CPrimPath
// ***************************************************************************
uint CPrimPath::getNumVector () const
{
return (uint)VPoints.size ();
}
// ***************************************************************************
const CPrimVector *CPrimPath::getPrimVector () const
{
if (VPoints.empty())
return NULL;
return &(VPoints[0]);
}
// ***************************************************************************
NLLIGO::IPrimitive *CPrimPath::copy () const
{
return new CPrimPath (*this);
}
// ***************************************************************************
CPrimVector *CPrimPath::getPrimVector ()
{
if (VPoints.empty())
return NULL;
return &(VPoints[0]);
}
// ***************************************************************************
bool CPrimPath::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
// Read points
VPoints.clear ();
VPoints.reserve (CIXml::countChildren (xmlNode, "PT"));
xmlNodePtr ptNode = CIXml::getFirstChildNode (xmlNode, "PT");
if (ptNode)
{
do
{
// Read a vector
VPoints.push_back (CPrimVector ());
if (!ReadVector (VPoints.back (), filename, ptNode))
return false;
ptNode = CIXml::getNextChildNode (ptNode, "PT");
}
while (ptNode);
}
return IPrimitive::read (xmlNode, filename, version, config);
}
// ***************************************************************************
void CPrimPath::write (xmlNodePtr xmlNode, const char *filename) const
{
// Save the points
for (uint i=0; i<VPoints.size (); i++)
{
xmlNodePtr ptNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"PT", NULL);
WriteVector (VPoints[i], ptNode);
}
IPrimitive::write (xmlNode, filename);
}
// ***************************************************************************
// CPrimZone
// ***************************************************************************
uint CPrimZone::getNumVector () const
{
return (uint)VPoints.size ();
}
// ***************************************************************************
const CPrimVector *CPrimZone::getPrimVector () const
{
if (VPoints.empty())
return NULL;
return &(VPoints[0]);
}
// ***************************************************************************
NLLIGO::IPrimitive *CPrimZone::copy () const
{
return new CPrimZone (*this);
}
// ***************************************************************************
CPrimVector *CPrimZone::getPrimVector ()
{
if(VPoints.empty()) return 0;
return &(VPoints[0]);
}
// ***************************************************************************
bool CPrimZone::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
// Read points
VPoints.clear ();
VPoints.reserve (CIXml::countChildren (xmlNode, "PT"));
xmlNodePtr ptNode = CIXml::getFirstChildNode (xmlNode, "PT");
if (ptNode)
{
do
{
// Read a vector
VPoints.push_back (CPrimVector ());
if (!ReadVector (VPoints.back (), filename, ptNode))
return false;
ptNode = CIXml::getNextChildNode (ptNode, "PT");
}
while (ptNode);
}
return IPrimitive::read (xmlNode, filename, version, config);
}
// ***************************************************************************
void CPrimZone::write (xmlNodePtr xmlNode, const char *filename) const
{
// Save the points
for (uint i=0; i<VPoints.size (); i++)
{
xmlNodePtr ptNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"PT", NULL);
WriteVector (VPoints[i], ptNode);
}
IPrimitive::write (xmlNode, filename);
}
// ***************************************************************************
bool CPrimZone::contains (const NLMISC::CVector &v, const std::vector<CPrimVector> &points, float &distance, NLMISC::CVector &nearPos, bool isPath)
{
H_AUTO(NLLIGO_Contains1)
uint32 i;
CVector vMin, vMax;
float nearest = FLT_MAX;
CVector pos;
// Point or line can't contains !
if (points.size() < 3 || isPath)
{
// only compute the distance.
if (points.size() == 1)
{
distance = (points[0] - v).norm();
nearPos = points[0];
}
else if (points.size() == 2)
{
distance = getSegmentDist(v, points[0], points[1], nearPos);
}
else
{
// compute nearest segment
for (i = 0; i < points.size()-1; ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[i+1];
float dist = getSegmentDist(v, p1, p2, pos);
if( dist < nearest)
{
nearest = dist;
nearPos = pos;
}
}
distance = nearest;
}
return false;
}
// Get the bounding rectangle of the zone
vMax = vMin = points[0];
for (i = 0; i < points.size(); ++i)
{
vMin.x = min(vMin.x, points[i].x);
vMin.y = min(vMin.y, points[i].y);
vMax.x = max(vMax.x, points[i].x);
vMax.y = max(vMax.y, points[i].y);
}
if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
{
// find the nearest distance of all segment
for (uint i=0; i<points.size(); ++i)
{
float dist = getSegmentDist(v, points[i], points[(i+1) % points.size()], pos);
if (dist < nearest)
{
nearest = dist;
nearPos = pos;
}
}
distance = nearest;
return false;
}
uint32 nNbIntersection = 0;
for (i = 0; i < points.size(); ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[(i+1)%points.size()];
float dist = getSegmentDist(v, p1, p2, pos);
if( dist < nearest)
{
nearest = dist;
nearPos = pos;
}
if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
continue;
if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
continue;
float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
if (xinter > v.x)
++nNbIntersection;
}
distance = nearest;
if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
return true;
else
return false;
}
// ***************************************************************************
bool CPrimZone::contains (const NLMISC::CVector &v, const std::vector<CVector> &points, float &distance, NLMISC::CVector &nearPos, bool isPath)
{
H_AUTO(NLLIGO_Contains2)
uint32 i;
CVector vMin, vMax;
float nearest = FLT_MAX;
CVector pos;
// Point or line can't contains !
if (points.size() < 3 || isPath)
{
// only compute the distance.
if (points.size() == 1)
{
distance = (points[0] - v).norm();
nearPos = points[0];
}
else if (points.size() == 2)
{
distance = getSegmentDist(v, points[0], points[1], nearPos);
}
else
{
// compute nearest segment
for (i = 0; i < points.size()-1; ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[i+1];
float dist = getSegmentDist(v, p1, p2, pos);
if( dist < nearest)
{
nearest = dist;
nearPos = pos;
}
}
distance = nearest;
}
return false;
}
// Get the bounding rectangle of the zone
vMax = vMin = points[0];
for (i = 0; i < points.size(); ++i)
{
vMin.x = min(vMin.x, points[i].x);
vMin.y = min(vMin.y, points[i].y);
vMax.x = max(vMax.x, points[i].x);
vMax.y = max(vMax.y, points[i].y);
}
if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
{
// find the nearest distance of all segment
for (uint i=0; i<points.size(); ++i)
{
float dist = getSegmentDist(v, points[i], points[(i+1) % points.size()], pos);
if (dist < nearest)
{
nearest = dist;
nearPos = pos;
}
}
distance = nearest;
return false;
}
uint32 nNbIntersection = 0;
for (i = 0; i < points.size(); ++i)
{
const CVector &p1 = points[i];
const CVector &p2 = points[(i+1)%points.size()];
float dist = getSegmentDist(v, p1, p2, pos);
if( dist < nearest)
{
nearest = dist;
nearPos = pos;
}
if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
continue;
if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
continue;
float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
if (xinter > v.x)
++nNbIntersection;
}
distance = nearest;
if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
return true;
else
return false;
}
// ***************************************************************************
float CPrimZone::getSegmentDist(const NLMISC::CVector v, const NLMISC::CVector &p1, const NLMISC::CVector &p2, NLMISC::CVector &nearPos)
{
// two points, compute distance to the segment.
CVector V = (p2-p1).normed();
double length= (p2-p1).norm();
float distance;
// case where p1==p2
if(length==0.0)
{
nearPos= p1;
distance = (p1-v).norm();
}
// standard case
else
{
float t = (float)((double)((v-p1)*V)/length);
if (t < 0.0f)
{
nearPos = p1;
distance = (p1-v).norm();
}
else if (t > 1.0f)
{
nearPos = p2;
distance = (p2-v).norm();
}
else
{
nearPos = p1 + t*(p2-p1);
distance = (v-nearPos).norm();
}
}
return distance;
}
// ***************************************************************************
NLMISC::CVector CPrimZone::getBarycentre() const
{
CVector sum( CVector::Null );
uint n = (uint)VPoints.size();
if ( n != 0 )
{
for ( uint i=0; i!=n; ++i )
sum += VPoints[i];
return sum / (float)n;
}
else
return sum;
}
// ***************************************************************************
void CPrimZone::getAABox( NLMISC::CVector& cornerMin, NLMISC::CVector& cornerMax ) const
{
cornerMin.x = FLT_MAX;
cornerMin.y = FLT_MAX;
cornerMin.z = 0;
cornerMax.x = -FLT_MAX;
cornerMax.y = -FLT_MAX;
cornerMax.z = 0;
for ( uint i=0; i!=VPoints.size(); ++i )
{
const CVector& p = VPoints[i];
if ( p.x < cornerMin.x )
cornerMin.x = p.x;
if ( p.x > cornerMax.x )
cornerMax.x = p.x;
if ( p.y < cornerMin.y )
cornerMin.y = p.y;
if ( p.y > cornerMax.y )
cornerMax.y = p.y;
}
}
// ***************************************************************************
float CPrimZone::getAreaOfAABox() const
{
CVector cornerMin, cornerMax;
getAABox( cornerMin, cornerMax );
return (cornerMax.x-cornerMin.x) * (cornerMax.y-cornerMin.y);
}
// ***************************************************************************
void CPrimZone::serial (NLMISC::IStream &f)
{
IPrimitive::serial(f);
f.serialCont(VPoints);
}
// ***************************************************************************
void CPrimRegion::serial (NLMISC::IStream &f)
{
f.xmlPushBegin ("REGION");
f.xmlSetAttrib ("NAME");
f.serial (Name);
f.xmlPushEnd();
sint version = 2;
version = f.serialVersion (version);
string check = "REGION";
f.serialCheck (check);
f.xmlPush ("POINTS");
f.serialCont (VPoints);
f.xmlPop ();
f.xmlPush ("PATHES");
f.serialCont (VPaths);
f.xmlPop ();
f.xmlPush ("ZONES");
f.serialCont (VZones);
f.xmlPop ();
if (version > 1)
{
f.xmlPush ("HIDEPOINTS");
f.serialCont (VHidePoints);
f.xmlPop ();
f.xmlPush ("HIDEZONES");
f.serialCont (VHideZones);
f.xmlPop ();
f.xmlPush ("HIDEPATHS");
f.serialCont (VHidePaths);
f.xmlPop ();
}
else
{
VHidePoints.resize (VPoints.size(), false);
VHideZones.resize (VZones.size(), false);
VHidePaths.resize (VPaths.size(), false);
}
}
// ***************************************************************************
// IPrimitive
// ***************************************************************************
IPrimitive::IPrimitive ()
{
_Parent = NULL;
}
IPrimitive::IPrimitive (const IPrimitive &node) : IStreamable()
{
_Parent = NULL;
IPrimitive::operator= (node);
}
// ***************************************************************************
void IPrimitive::serial (NLMISC::IStream &f)
{
// NB : unparsed parameters are not binary serialized !
// serialize the property container
if (f.isReading())
{
uint32 size;
f.serial(size);
for (uint i=0; i<size; ++i)
{
std::string s;
f.serial(s);
IProperty *&pp = _Properties[s];
f.serialPolyPtr(pp);
}
}
else
{
uint32 size = (uint32)_Properties.size();
f.serial(size);
std::map<std::string, IProperty*>::iterator first(_Properties.begin()), last(_Properties.end());
for (; first != last; ++first)
{
std::string &s = const_cast<std::string&>(first->first);
f.serial(s);
f.serialPolyPtr(first->second);
}
}
f.serial(_ChildId);
// f.serial(Layer);
// f.serial(Name);
// f.serial(Expanded);
// serial the childrens
if (f.isReading())
{
std::vector<IPrimitive*> children;
f.serialContPolyPtr(children);
uint index = 0;
for(std::vector<IPrimitive*>::iterator it = children.begin(); it != children.end(); ++it, ++index)
{
insertChild(*it, index);
}
}
else
{
f.serialContPolyPtr(_Children);
}
if (f.isReading())
{
// reloc child link
vector<IPrimitive*>::iterator first(_Children.begin()), last(_Children.end());
for (; first != last; ++first)
{
if (*first)
(*first)->_Parent = this;
}
}
}
// ***************************************************************************
void IPrimitive::updateChildId (uint index)
{
uint i;
uint count = (uint)_Children.size ();
for (i=index; i<count; i++)
_Children[i]->_ChildId = i;
}
// ***************************************************************************
void IPrimitive::branchLink()
{
onBranchLink();
std::vector<IPrimitive*>::iterator first(_Children.begin()), last(_Children.end());
for (; first != last; ++first)
{
(*first)->branchLink();
}
}
// ***************************************************************************
void IPrimitive::branchUnlink()
{
onBranchUnlink();
std::vector<IPrimitive*>::iterator first(_Children.begin()), last(_Children.end());
for (; first != last; ++first)
{
(*first)->branchUnlink();
}
}
// ***************************************************************************
void IPrimitive::operator= (const IPrimitive &node)
{
// Clean dest
removeChildren ();
removeProperties ();
// copy deprecated param
// Layer = node.Layer;
// Name = node.Name;
// copy unparsed properties
_UnparsedProperties = node._UnparsedProperties;
// Copy the flags
// Expanded = node.Expanded;
_ChildId = node._ChildId;
// Copy children
_Children.resize (node._Children.size ());
for (uint child = 0; child < node._Children.size (); child++)
{
// Copy the child
_Children[child] = node._Children[child]->copy ();
// Set the parent
_Children[child]->_Parent = this;
}
// Copy properties
std::map<std::string, IProperty*>::const_iterator ite = node._Properties.begin ();
while (ite != node._Properties.end ())
{
// Get the property
CPropertyString *propString = dynamic_cast<CPropertyString *>(ite->second);
if (propString)
{
// New property
CPropertyString *newProp = new CPropertyString ();
*newProp = *propString;
_Properties.insert (std::map<std::string, IProperty*>::value_type (ite->first, newProp));
}
else
{
CPropertyStringArray *propStringArray = dynamic_cast<CPropertyStringArray *>(ite->second);
if (propStringArray)
{
// New property
CPropertyStringArray *newProp = new CPropertyStringArray ();
*newProp = *propStringArray;
_Properties.insert (std::map<std::string, IProperty*>::value_type (ite->first, newProp));
}
else
{
CPropertyColor *propColor = dynamic_cast<CPropertyColor *>(ite->second);
nlverify (propColor);
// New property
CPropertyColor *newProp = new CPropertyColor ();
*newProp = *propColor;
_Properties.insert (std::map<std::string, IProperty*>::value_type (ite->first, newProp));
}
}
ite++;
}
#ifdef NLLIGO_DEBUG
_DebugClassName = node._DebugClassName;
_DebugPrimitiveName = node._DebugPrimitiveName;
#endif
}
const IPrimitive *IPrimitive::getPrimitive (const std::string &absoluteOrRelativePath) const
{
const IPrimitive *cursor=this;
string path=absoluteOrRelativePath;
if (path.find("//")==0) // an absolute path.
{
while (cursor->getParent())
cursor=cursor->getParent();
path.erase(0,2);
}
while (!path.empty())
{
if (path.find("/")==0)
{
path.erase(0,1);
continue;
}
if (path.find("..")==0)
{
cursor=cursor->getParent();
if (!cursor)
return NULL;
path.erase(0,2);
continue;
}
string::size_type indexStr=path.find("/");
string childName;
if (indexStr==string::npos)
{
childName=path;
path="";
}
else
{
childName=path.substr(0,indexStr);
path.erase(0, indexStr);
}
childName=toUpper(childName);
const IPrimitive*child=NULL;
uint childIndex;
for (childIndex=0;childIndex<cursor->getNumChildren();childIndex++)
{
cursor->getChild(child,childIndex);
string name;
if ( child->getPropertyByName("class", name)
&& toUpper(name)==childName )
break;
}
if (childIndex>=cursor->getNumChildren())
return NULL;
cursor=child;
}
return cursor;
}
// ***************************************************************************
bool IPrimitive::getProperty (uint index, std::string &property_name, const IProperty *&result) const
{
// Look for the property
std::map<std::string, IProperty*>::const_iterator ite = _Properties.begin ();
while (ite != _Properties.end ())
{
if (index == 0)
{
property_name = ite->first;
result = ite->second;
return true;
}
index--;
ite ++;
}
nlwarning ("NLLIGO::IPrimitive::getProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
return false;
}
// ***************************************************************************
bool IPrimitive::getProperty (uint index, std::string &property_name, IProperty *&result)
{
// Look for the property
std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
while (ite != _Properties.end ())
{
if (index == 0)
{
property_name = ite->first;
result = ite->second;
return true;
}
index--;
ite ++;
}
nlwarning ("NLLIGO::IPrimitive::getProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, const IProperty *&result) const
{
// Look for the property
std::map<std::string, IProperty*>::const_iterator ite = _Properties.find (property_name);
if (ite != _Properties.end ())
{
result = ite->second;
return true;
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, IProperty *&result) const
{
// Look for the property
std::map<std::string, IProperty*>::const_iterator ite = _Properties.find (property_name);
if (ite != _Properties.end ())
{
result = ite->second;
return true;
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, std::string *&result) const
{
// Get the property
IProperty *prop;
if (getPropertyByName (property_name, prop))
{
CPropertyString *strProp = dynamic_cast<CPropertyString *> (prop);
if (strProp)
{
result = &(strProp->String);
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
}
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, std::string &result) const
{
// Get the property
const IProperty *prop;
if (getPropertyByName (property_name, prop))
{
const CPropertyString *strProp = dynamic_cast<const CPropertyString *> (prop);
if (strProp)
{
result = strProp->String;
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
}
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, std::vector<std::string> *&result) const
{
// Get the property
IProperty *prop;
if (getPropertyByName (property_name, prop))
{
CPropertyStringArray *strProp = dynamic_cast<CPropertyStringArray *> (prop);
if (strProp)
{
result = &(strProp->StringArray);
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
}
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, const std::vector<std::string> *&result) const
{
// Get the property
IProperty *prop;
if (getPropertyByName (property_name, prop))
{
const CPropertyStringArray *strProp = dynamic_cast<const CPropertyStringArray *> (prop);
if (strProp)
{
result = &(strProp->StringArray);
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
}
}
return false;
}
// ***************************************************************************
bool IPrimitive::getPropertyByName (const char *property_name, NLMISC::CRGBA &result) const
{
// Get the property
IProperty *prop;
if (getPropertyByName (property_name, prop))
{
const CPropertyColor *colorProp = dynamic_cast<const CPropertyColor *> (prop);
if (colorProp)
{
result = colorProp->Color;
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a color.", property_name);
}
}
return false;
}
// ***************************************************************************
bool IPrimitive::removeProperty (uint index)
{
// Look for the property
std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
while (ite != _Properties.end ())
{
if (index == 0)
{
_Properties.erase (ite);
return true;
}
index--;
ite ++;
}
nlwarning ("NLLIGO::IPrimitive::removeProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
return false;
}
// ***************************************************************************
bool IPrimitive::removePropertyByName (const char *property_name)
{
// Look for the property
std::map<std::string, IProperty*>::iterator ite = _Properties.find (property_name);
if (ite != _Properties.end ())
{
_Properties.erase (ite);
return true;
}
return false;
}
// ***************************************************************************
void IPrimitive::removeProperties ()
{
std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
while (ite != _Properties.end ())
{
delete ite->second;
ite++;
}
_Properties.clear ();
}
// ***************************************************************************
bool IPrimitive::getChild (const IPrimitive *&result, uint childId) const
{
if (childId < _Children.size ())
{
result = _Children[childId];
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getChild : invalid index (index : %d, size %d).", childId, _Children.size ());
}
return false;
}
// ***************************************************************************
bool IPrimitive::getChild (IPrimitive *&result, uint childId)
{
if (childId < _Children.size ())
{
result = _Children[childId];
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::getChild : invalid index (index : %d, size %d).", childId, _Children.size ());
}
return false;
}
// ***************************************************************************
bool IPrimitive::removeChild (IPrimitive *child)
{
uint childId;
if (getChildId(childId, child))
{
return removeChild(childId);
}
else
{
nlwarning("NLLIGO::IPrimitive::removeChild : invalid child, can't remove (child : %p)", child);
}
return false;
}
// ***************************************************************************
bool IPrimitive::removeChild (uint childId)
{
if (childId < _Children.size ())
{
delete _Children[childId];
_Children.erase (_Children.begin()+childId);
updateChildId (childId);
return true;
}
else
{
nlwarning ("NLLIGO::IPrimitive::removeChild : invalid index (index : %d, size %d).", childId, _Children.size ());
}
return false;
}
// ***************************************************************************
void IPrimitive::removeChildren ()
{
// Erase children
for (uint i=0; i<_Children.size (); i++)
{
delete _Children[i];
}
_Children.clear ();
}
// ***************************************************************************
bool IPrimitive::unlinkChild(IPrimitive *child)
{
uint childId;
if (getChildId(childId, child))
{
child->onUnlinkFromParent();
child->branchUnlink();
_Children.erase (_Children.begin()+childId);
updateChildId (childId);
child->_Parent = NULL;
child->_ChildId = 0;
return true;
}
else
{
nlwarning("NLLIGO::IPrimitive::unlinkChild : invalid child, can't unlink (child : %p)", child);
}
return false;
}
// ***************************************************************************
bool IPrimitive::insertChild (IPrimitive *primitive, uint index)
{
// At the end ?
if (index == AtTheEnd)
index = (uint)_Children.size ();
// Index valid ?
if (index>_Children.size ())
return false;
// Insert
_Children.insert (_Children.begin () + index, primitive);
// Update child id
updateChildId (index);
// Link to the parent
primitive->_Parent = this;
// signaling
primitive->onLinkToParent();
primitive->branchLink();
return true;
}
// ***************************************************************************
IPrimitive::~IPrimitive ()
{
// Remove children
removeChildren ();
// Erase properties
removeProperties ();
}
// ***************************************************************************
bool IPrimitive::checkProperty(const std::string &property_name) const
{
if (_Properties.find(property_name) == _Properties.end())
return false;
return true;
}
// ***************************************************************************
bool IPrimitive::addPropertyByName (const char *property_name, IProperty *result)
{
bool inserted = _Properties.insert (std::map<std::string, IProperty*>::value_type (property_name, result)).second;
if (inserted)
{
return true;
}
return false;
}
// ***************************************************************************
bool IPrimitive::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
// Erase old properties
_Properties.clear ();
// Read the unparsed properties (for editor view)
xmlNodePtr commentNode = CIXml::getFirstChildNode(xmlNode, XML_COMMENT_NODE);
if (commentNode)
{
if (!CIXml::getContentString(_UnparsedProperties, commentNode))
_UnparsedProperties = "";
}
// Read the expanded flag
// string expanded;
// Expanded = true;
// if (CIXml::getPropertyString (expanded, xmlNode, "EXPANDED"))
// Expanded = (expanded != "false");
// Read the properties
xmlNodePtr propNode;
propNode = CIXml::getFirstChildNode (xmlNode, "PROPERTY");
if (propNode)
{
do
{
// Read the name
string name;
if (GetNodeString (name, filename, propNode, "NAME"))
{
// Get the property type
string type;
if (GetPropertyString (type, filename, propNode, "TYPE"))
{
// The property
IProperty *property = NULL;
// Check the type
if (type == "string")
{
// Create a new property
CPropertyString *propertyString = new CPropertyString;
property = propertyString;
// Read it
if (!GetNodeString (propertyString->String, filename, propNode, "STRING"))
{
return false;
}
}
else if (type == "string_array")
{
// Create a new property
CPropertyStringArray *propertyStringArray = new CPropertyStringArray;
property = propertyStringArray;
// Read strings
xmlNodePtr stringNode;
propertyStringArray->StringArray.reserve (CIXml::countChildren (propNode, "STRING"));
stringNode = CIXml::getFirstChildNode (propNode, "STRING");
if (stringNode)
{
do
{
// Add the string
string content;
GetContentString (content, filename, stringNode);
propertyStringArray->StringArray.push_back (content);
stringNode = CIXml::getNextChildNode (stringNode, "STRING");
}
while (stringNode);
}
}
else if (type == "color")
{
// Create a new property
CPropertyColor *propertyColor= new CPropertyColor;
property = propertyColor;
// Read strings
xmlNodePtr colorNode;
colorNode = CIXml::getFirstChildNode (xmlNode, "COLOR");
string R, G, B, A;
if (GetPropertyString (R, filename, colorNode, "R") &&
GetPropertyString (G, filename, colorNode, "G") &&
GetPropertyString (B, filename, colorNode, "B") &&
GetPropertyString (A, filename, colorNode, "A"))
{
sint32 sR=0, sG=0, sB=0, sA=255;
sR = atoi (R.c_str ());
clamp (sR, 0, 255);
sG = atoi (G.c_str ());
clamp (sG, 0, 255);
sB = atoi (B.c_str ());
clamp (sB, 0, 255);
sA = atoi (A.c_str ());
clamp (sR, 0, 255);
propertyColor->Color.R = (uint8)sR;
propertyColor->Color.G = (uint8)sG;
propertyColor->Color.B = (uint8)sB;
propertyColor->Color.A = (uint8)sA;
}
else
return false;
}
// Property found ?
if (property == NULL)
{
XMLError (propNode, filename, "IPrimitive::read : Unknown property type (%s)", type.c_str ());
return false;
}
// Add it
_Properties.insert (std::map<std::string, IProperty*>::value_type (name, property));
}
else
{
return false;
}
}
else
{
return false;
}
propNode = CIXml::getNextChildNode (propNode, "PROPERTY");
}
while (propNode);
}
// Initialise default value
initDefaultValues (config);
// Read children
xmlNodePtr childNode;
childNode = CIXml::getFirstChildNode (xmlNode, "CHILD");
if (childNode)
{
do
{
// Get the property class
string type;
if (GetPropertyString (type, filename, childNode, "TYPE"))
{
// Primitive
if (type=="node")
type="CPrimNode";
if (type=="point")
type="CPrimPoint";
if (type=="path")
type="CPrimPath";
if (type=="zone")
type="CPrimZone";
if (type=="alias")
type="CPrimAlias";
IPrimitive *primitive = static_cast<IPrimitive *> (CClassRegistry::create (type));
// Primitive type not found ?
if (primitive == NULL)
{
XMLError (childNode, filename, "IPrimitive::read : Unknown primitive type (%s)", type.c_str ());
return false;
}
// Read it
primitive->read (childNode, filename, version, config);
// Add it
insertChild (primitive);
}
else
{
return false;
}
childNode = CIXml::getNextChildNode (childNode, "CHILD");
}
while (childNode);
}
#ifdef NLLIGO_DEBUG
// store debug data
getPropertyByName("class", _DebugClassName);
getPropertyByName("name", _DebugPrimitiveName);
#endif
// Done
return true;
}
// ***************************************************************************
void IPrimitive::initDefaultValues (CLigoConfig &config)
{
// Get the primitive class
const CPrimitiveClass *primitiveClass = config.getPrimitiveClass (*this);
if (primitiveClass)
{
// For each properties
uint count = (uint)primitiveClass->Parameters.size ();
uint i;
for (i=0; i<count; i++)
{
const CPrimitiveClass::CParameter &parameter = primitiveClass->Parameters[i];
// Get the property
IProperty *result;
if (!getPropertyByName (parameter.Name.c_str(), result))
{
// Create the property
if ((parameter.Type == CPrimitiveClass::CParameter::StringArray) || (parameter.Type == CPrimitiveClass::CParameter::ConstStringArray))
result = new CPropertyStringArray();
else
result = new CPropertyString();
nlverify (addPropertyByName (parameter.Name.c_str(), result));
}
}
// Set the default values
for (i=0; i<count; i++)
{
const CPrimitiveClass::CParameter &parameter = primitiveClass->Parameters[i];
CPropertyString *pString = NULL;
CPropertyStringArray *pStringArray = NULL;
IProperty *result;
nlverify (getPropertyByName (parameter.Name.c_str(), result));
pString = dynamic_cast<CPropertyString*>(result);
if (!pString)
pStringArray = dynamic_cast<CPropertyStringArray*>(result);
// Property have default values ?
if (pString)
{
// Empty string ?
if (pString->String.empty())
{
// Set as default
pString->Default = true;
parameter.getDefaultValue (pString->String, *this, *primitiveClass);
}
}
else if (pStringArray)
{
// Empty string array ?
if (pStringArray->StringArray.empty())
{
// Set as default
pStringArray->Default = true;
parameter.getDefaultValue (pStringArray->StringArray, *this, *primitiveClass);
}
}
}
}
}
// ***************************************************************************
void IPrimitive::write (xmlNodePtr xmlNode, const char *filename) const
{
// Save the expanded flag
// if (!Expanded)
// xmlSetProp (xmlNode, (const xmlChar*)"EXPANDED", (const xmlChar*)"false");
// Set the type
xmlSetProp (xmlNode, (const xmlChar*)"TYPE", (const xmlChar*)(const_cast<IPrimitive*> (this)->getClassName ().c_str ()));
// Save the unparsed property
if (!_UnparsedProperties.empty())
{
xmlNodePtr commentNode = xmlNewComment((const xmlChar*)(_UnparsedProperties.c_str()));
nlverify(commentNode);
xmlAddChild(xmlNode, commentNode);
}
// Save the properties
std::map<std::string, IProperty*>::const_iterator ite = _Properties.begin ();
while (ite != _Properties.end ())
{
// Not a default property ?
if (!ite->second->Default)
{
// Create new nodes
xmlNodePtr propNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"PROPERTY", NULL);
xmlNodePtr nameNode = xmlNewChild ( propNode, NULL, (const xmlChar*)"NAME", NULL);
xmlNodePtr textNode = xmlNewText ((const xmlChar *)(ite->first.c_str ()));
xmlAddChild (nameNode, textNode);
// Type
const CPropertyString *str = dynamic_cast<const CPropertyString *> (ite->second);
if (str)
{
// Set the type
xmlSetProp (propNode, (const xmlChar*)"TYPE", (const xmlChar*)"string");
// Create new nodes
xmlNodePtr stringNode = xmlNewChild ( propNode, NULL, (const xmlChar*)"STRING", NULL);
xmlNodePtr textNode = xmlNewText ((const xmlChar *)(str->String.c_str ()));
xmlAddChild (stringNode, textNode);
}
else
{
// Should be an array
const CPropertyStringArray *array = dynamic_cast<const CPropertyStringArray *> (ite->second);
if (array)
{
// Set the type
xmlSetProp (propNode, (const xmlChar*)"TYPE", (const xmlChar*)"string_array");
// For each strings in the array
for (uint i=0; i<array->StringArray.size (); i++)
{
// Create new nodes
xmlNodePtr stringNode = xmlNewChild ( propNode, NULL, (const xmlChar*)"STRING", NULL);
xmlNodePtr textNode = xmlNewText ((const xmlChar *)(array->StringArray[i].c_str ()));
xmlAddChild (stringNode, textNode);
}
}
else
{
// Should be a color
const CPropertyColor *color = safe_cast<const CPropertyColor *> (ite->second);
// Set the type
xmlSetProp (propNode, (const xmlChar*)"TYPE", (const xmlChar*)"color");
// Create new nodes
xmlNodePtr colorNode = xmlNewChild ( propNode, NULL, (const xmlChar*)"COLOR", NULL);
xmlSetProp (colorNode, (const xmlChar*)"R", (const xmlChar*)toString (color->Color.R).c_str ());
xmlSetProp (colorNode, (const xmlChar*)"G", (const xmlChar*)toString (color->Color.G).c_str ());
xmlSetProp (colorNode, (const xmlChar*)"B", (const xmlChar*)toString (color->Color.B).c_str ());
xmlSetProp (colorNode, (const xmlChar*)"A", (const xmlChar*)toString (color->Color.A).c_str ());
}
}
}
ite++;
}
// Save the children
for (uint i=0; i<_Children.size (); i++)
{
// New node
xmlNodePtr childNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"CHILD", NULL);
// Write it
_Children[i]->write (childNode, filename);
}
}
// ***************************************************************************
bool IPrimitive::getChildId (uint &childId, const IPrimitive *child) const
{
childId = child->_ChildId;
return true;
}
// ***************************************************************************
uint IPrimitive::getNumProperty () const
{
return (uint)_Properties.size ();
}
// ***************************************************************************
std::string IPrimitive::getName() const
{
std::string ret;
getPropertyByName("name", ret);
return ret;
}
// ***************************************************************************
const std::string &IPrimitive::getUnparsedProperties() const
{
return _UnparsedProperties;
}
// ***************************************************************************
void IPrimitive::setUnparsedProperties(const std::string &unparsedProperties) const
{
_UnparsedProperties = unparsedProperties;
}
// ***************************************************************************
// CPrimAlias
// ***************************************************************************
CPrimAlias::CPrimAlias() :
_Alias(0),
_Container(NULL)
{
}
CPrimAlias::CPrimAlias(const CPrimAlias &other)
: IPrimitive(other)
{
// clear the container reference and alias
_Container = NULL;
_Alias = other._Alias;
}
CPrimAlias::~CPrimAlias()
{
if (_Container)
onBranchUnlink();
}
void CPrimAlias::onBranchLink()
{
CPrimitiveContext &ctx = CPrimitiveContext::instance();
// context must be set when handling alias
nlassert(ctx.CurrentPrimitive);
nlassert(_Container == NULL || _Container == ctx.CurrentPrimitive);
_Container = ctx.CurrentPrimitive;
// generate a new alias, eventually keeping the current one if any and if still available
_Alias = _Container->genAlias(this, _Alias);
}
void CPrimAlias::onBranchUnlink()
{
nlassert(_Container != NULL);
_Container->releaseAlias(this, _Alias);
_Container = NULL;
// NB : we keep the alias value for next linkage
}
uint32 CPrimAlias::getAlias() const
{
return _Alias;
}
uint32 CPrimAlias::getFullAlias() const
{
nlassert(_Container != NULL);
return _Container->buildFullAlias(_Alias);
}
void CPrimAlias::regenAlias()
{
// container must exist
nlassert(_Container);
// generate a new alias, eventually keeping the current one if any and if still available
_Alias = _Container->genAlias(this, _Alias);
}
// Read the primitive
bool CPrimAlias::read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
{
// Read alias
xmlNodePtr ptNode = CIXml::getFirstChildNode (xmlNode, "ALIAS");
if (ptNode)
{
sint val = 0;
if (ReadInt ("VALUE", val, filename, ptNode))
{
_Alias = uint32(val);
// nlassert( CPrimitiveContext::instance().CurrentPrimitive);
//// nlassert(_Container);
// CPrimitiveContext::instance().CurrentPrimitive->reserveAlias(_Alias);
// // set to null, it will be rewrited by onBranchLink callback
//// _Container = NULL;
}
else
{
// error in format !
nlwarning("CPrimAlias::read: Can't find xml property 'VALUE' in element <ALIAS>");
return false;
}
}
else
{
// error in format !
nlwarning("CPrimAlias::read: Can't find xml element <ALIAS>");
return false;
}
return IPrimitive::read (xmlNode, filename, version, config);
}
// Write the primitive
void CPrimAlias::write (xmlNodePtr xmlNode, const char *filename) const
{
// Write alias
xmlNodePtr ptNode = xmlNewChild(xmlNode, NULL, (const xmlChar*)"ALIAS", NULL);
WriteInt("VALUE", int(_Alias), ptNode);
IPrimitive::write (xmlNode, filename);
}
// Create a copy of this primitive
IPrimitive *CPrimAlias::copy () const
{
// NB : this will not call the reserveAlias on the container
CPrimAlias *pa = new CPrimAlias(*this);
// clear the alias and container reference
// pa->_Alias = 0;
// pa->_Container = 0;
return pa;
}
// serial for binary save
void CPrimAlias::serial (NLMISC::IStream &f)
{
IPrimitive::serial(f);
f.serial(_Alias);
// if (f.isReading())
// {
// nlassert(_Container);
// _Container->reserveAlias(_Alias);
// }
}
// ***************************************************************************
// CPrimitives
// ***************************************************************************
CPrimitives::CPrimitives () :
_LigoConfig(NULL)
{
// init the alias generator
_LastGeneratedAlias = 0;
_AliasStaticPart = 0;
RootNode = static_cast<CPrimNode *> (CClassRegistry::create ("CPrimNode"));
// get the current ligo context (if any)
_LigoConfig = CPrimitiveContext::instance().CurrentLigoConfig;
}
// ***************************************************************************
CPrimitives::CPrimitives (const CPrimitives &other)
{
operator =(other);
// _LastGeneratedAlias = other._LastGeneratedAlias;
// // get the current ligo context (if any)
// _LigoConfig = CPrimitiveContext::instance().CurrentLigoConfig;
//
// CPrimitives *temp = CPrimitiveContext::instance().CurrentPrimitive;
// CPrimitiveContext::instance().CurrentPrimitive = this;
// // copy the nodes
// RootNode = static_cast<CPrimNode *> (((IPrimitive*)other.RootNode)->copy ());
// RootNode->branchLink();
//
// CPrimitiveContext::instance().CurrentPrimitive = temp;
}
// ***************************************************************************
CPrimitives::~CPrimitives ()
{
delete RootNode;
}
// ***************************************************************************
uint32 CPrimitives::getAliasStaticPart()
{
return _AliasStaticPart;
}
// ***************************************************************************
void CPrimitives::setAliasStaticPart(uint32 staticPart)
{
_AliasStaticPart = staticPart;
}
// ***************************************************************************
uint32 CPrimitives::buildFullAlias(uint32 dynamicPart)
{
if (_LigoConfig)
{
return _LigoConfig->buildAlias(_AliasStaticPart, dynamicPart, true);
}
else
return dynamicPart;
}
// ***************************************************************************
uint32 CPrimitives::genAlias(IPrimitive *prim, uint32 preferedAlias)
{
nlassert(_LigoConfig);
uint32 ret;
if (preferedAlias != 0)
{
// only dynamic part allowed here
nlassert(preferedAlias == (preferedAlias & _LigoConfig->getDynamicAliasMask()));
// check is the prefered alias is not already in use
map<uint32, IPrimitive*>::iterator it(_AliasInUse.find(preferedAlias));
if (it == _AliasInUse.end())
{
// this alias is available, just use it
// nldebug("Alias: added alias %u, %u alias used", preferedAlias, _AliasInUse.size()+1);
_AliasInUse.insert(make_pair(preferedAlias, prim));
return preferedAlias;
}
else
{
// check who own the alias now
if (it->second == prim)
{
// ok, the alias is already own by this primitive
// nldebug("Alias: using alias %u, %u alias used", preferedAlias, _AliasInUse.size()+1);
return preferedAlias;
}
}
}
// make sure there are some free aliases
uint32 mask = _LigoConfig->getDynamicAliasMask();
nlassert(_AliasInUse.size() < mask);
// increment alias counter
++_LastGeneratedAlias;
// mask with the dynamic alias mask
_LastGeneratedAlias &= _LigoConfig->getDynamicAliasMask();
ret = _LastGeneratedAlias;
while (_AliasInUse.find(ret) != _AliasInUse.end())
{
// this alias is already in use ! generate a new one
// increment, mask, affect...
++_LastGeneratedAlias;
_LastGeneratedAlias &= _LigoConfig->getDynamicAliasMask();
ret = _LastGeneratedAlias;
}
// insert the alias
// nldebug("Alias: added alias %u, %u alias in use", ret, _AliasInUse.size()+1);
_AliasInUse.insert(make_pair(ret, prim));
// callback
prim->onModifyPrimitive (*this);
return ret;
}
//void CPrimitives::reserveAlias(uint32 dynamicAlias)
//{
// // need ligo config
// nlassert(_LigoConfig);
// // only dynamic part allowed here
// nlassert(dynamicAlias == (dynamicAlias & _LigoConfig->getDynamicAliasMask()));
// std::set<uint32>::iterator it(_AliasInUse.find(dynamicAlias));
// // warn if already found
// if (it != _AliasInUse.end())
// {
// const string &fileName = _LigoConfig->getFileNameForStaticAlias(_AliasStaticPart);
// if (fileName.empty())
// nlwarning("Dynamic Alias %u is already in use");
// else
// nlwarning("Dynamic Alias %u is already in use in file '%s'",
// dynamicAlias,
// fileName.c_str());
// return;
// }
//
// // insert the alias
// nldebug("Alias: added alias %u, %u alias in use", dynamicAlias, _AliasInUse.size()+1);
// _AliasInUse.insert(dynamicAlias);
//}
//
void CPrimitives::releaseAlias(IPrimitive *prim, uint32 alias)
{
// need ligo config
nlassert(_LigoConfig);
// only dynamic part allowed here
nlassert(alias == (alias & _LigoConfig->getDynamicAliasMask()));
std::map<uint32, IPrimitive*>::iterator it(_AliasInUse.find(alias));
// need to be found
nlassert(it != _AliasInUse.end());
if (it->second != prim)
{
nlwarning("CPrimitives::releaseAlias: The alias %u is own by another primitive !", alias);
return;
}
// remove this alias
// nldebug("Alias: remove alias %u, %u alias left", it->first, _AliasInUse.size()-1);
_AliasInUse.erase(it);
}
// ***************************************************************************
void CPrimitives::forceAlias(CPrimAlias *prim, uint32 alias)
{
// need ligo config
nlassert(_LigoConfig);
// only dynamic part allowed here
nlassert(alias == (alias & _LigoConfig->getDynamicAliasMask()));
// store the alias in the primitive
prim->_Alias = alias;
std::map<uint32, IPrimitive*>::iterator it(_AliasInUse.find(alias));
if (it != _AliasInUse.end() && it->second != prim)
{
// we need to alloc and set a new alias for the current alias holder
CPrimAlias *pa = static_cast<CPrimAlias*>(const_cast<IPrimitive*>(it->second));
// reserve the alias for the new primitive
it->second = prim;
// and regen an alias for the old
pa->regenAlias();
}
else
{
// just store the association
_AliasInUse.insert(make_pair(alias, prim));
}
}
// ***************************************************************************
uint32 CPrimitives::getLastGeneratedAlias()
{
return _LastGeneratedAlias;
}
// ***************************************************************************
IPrimitive *CPrimitives::getPrimitiveByAlias(uint32 primAlias)
{
// check the static part of the alias
uint32 staticAlias = _LigoConfig->getStaticAliasMask() & primAlias;
staticAlias = staticAlias >> _LigoConfig->getDynamicAliasSize();
if (staticAlias != _AliasStaticPart)
return NULL;
// clear the static part before searching
primAlias &= _LigoConfig->getDynamicAliasMask();
std::map<uint32, IPrimitive*>::const_iterator it(_AliasInUse.find(primAlias));
if (it != _AliasInUse.end())
return it->second->getParent();
else
return NULL;
}
// ***************************************************************************
void CPrimitives::buildPrimitiveWithAliasList(std::map<uint32, IPrimitive*> &result)
{
nlassert(_LigoConfig != NULL);
std::map<uint32, IPrimitive*>::iterator first(_AliasInUse.begin()), last(_AliasInUse.end());
for (; first != last; ++first)
{
result.insert(make_pair(_LigoConfig->buildAlias(_AliasStaticPart, first->first), first->second->getParent()));
}
}
// ***************************************************************************
CPrimitives& CPrimitives::operator= (const CPrimitives &other)
{
// RootNode = static_cast<CPrimNode *> (((IPrimitive*)other.RootNode)->copy ());
// return *this;
_AliasStaticPart = other._AliasStaticPart;
_LastGeneratedAlias = other._LastGeneratedAlias;
// get the current ligo context (if any)
_LigoConfig = CPrimitiveContext::instance().CurrentLigoConfig;
CPrimitives *temp = CPrimitiveContext::instance().CurrentPrimitive;
CPrimitiveContext::instance().CurrentPrimitive = this;
// copy the nodes
RootNode = static_cast<CPrimNode *> (((IPrimitive*)other.RootNode)->copy ());
RootNode->branchLink();
CPrimitiveContext::instance().CurrentPrimitive = temp;
return *this;
}
// ***************************************************************************
bool CPrimitives::read (xmlNodePtr xmlNode, const char *filename, CLigoConfig &config)
{
nlassert (xmlNode);
_Filename = CFile::getFilename(filename);
if (_LigoConfig)
{
// try to get the static alias mapping
_AliasStaticPart = _LigoConfig->getFileStaticAliasMapping(CFile::getFilename(filename));
}
// Clear the primitives
RootNode->removeChildren ();
RootNode->removeProperties ();
// Get the name
if (strcmp ((const char*)xmlNode->name, "PRIMITIVES") == 0)
{
// Get the version
string versionName = "0";
if (GetPropertyString (versionName, filename, xmlNode, "VERSION"))
{
// Get the version
uint32 version = atoi (versionName.c_str ());
// Check the version
if (version <= NLLIGO_PRIMITIVE_VERSION)
{
// Read the primitives
xmlNode = GetFirstChildNode (xmlNode, filename, "ROOT_PRIMITIVE");
if (xmlNode)
{
if (version > 0)
{
xmlNodePtr subNode = GetFirstChildNode(xmlNode, filename, "ALIAS");
if (subNode)
{
uint temp;
ReadUInt("LAST_GENERATED", temp, filename, subNode);
_LastGeneratedAlias = temp;
}
else
_LastGeneratedAlias = 0;
}
else
_LastGeneratedAlias = 0;
// Read the primitive tree
((IPrimitive*)RootNode)->read (xmlNode, filename, version, config);
}
}
else
{
Error (filename, "CPrimitives::read : Unknown file version (%d)", version);
return false;
}
}
else
{
return false;
}
}
else
{
XMLError (xmlNode, filename, "This XML document is not a NeL primitive file");
return false;
}
return true;
}
// ***************************************************************************
void CPrimitives::write (xmlDocPtr doc, const char *filename) const
{
nlassert (doc);
// Primitive node
xmlNodePtr primNode = xmlNewDocNode (doc, NULL, (const xmlChar*)"PRIMITIVES", NULL);
xmlDocSetRootElement (doc, primNode);
write (primNode, filename);
}
// ***************************************************************************
void CPrimitives::write (xmlNodePtr root, const char *filename) const
{
nlassert (root);
// Version node
xmlSetProp (root, (const xmlChar*)"VERSION", (const xmlChar*)toString (NLLIGO_PRIMITIVE_VERSION).c_str ());
// The primitive root node
xmlNodePtr nameNode = xmlNewChild ( root, NULL, (const xmlChar*)"ROOT_PRIMITIVE", NULL);
xmlNodePtr subNode = xmlNewChild ( nameNode, NULL, (const xmlChar*)"ALIAS", NULL);
WriteUInt("LAST_GENERATED", _LastGeneratedAlias, subNode);
// Write the primitive tree
((IPrimitive*)RootNode)->write (nameNode, filename);
}
// ***************************************************************************
void CPrimitives::serial(NLMISC::IStream &f)
{
uint currentVersion = NLLIGO_PRIMITIVE_VERSION;
f.serialVersion(currentVersion);
if (currentVersion == 0)
{
f.serial(_LastGeneratedAlias);
}
if (f.isReading())
{
RootNode->removeChildren ();
RootNode->removeProperties ();
}
f.serialPolyPtr(RootNode);
f.serial(_Filename);
if (f.isReading() && _LigoConfig)
{
_AliasStaticPart = _LigoConfig->getFileStaticAliasMapping(_Filename);
}
}
// ***************************************************************************
void CPrimitives::convertAddPrimitive (IPrimitive *child, const IPrimitive *prim, bool hidden)
{
// The primitve
IPrimitive *primitive = NULL;
// What kind of primitive ?
const CPrimPoint *oldPoint = dynamic_cast<const CPrimPoint *>(prim);
if (oldPoint)
{
// Create a primitive
CPrimPoint *point = static_cast<CPrimPoint *> (CClassRegistry::create ("CPrimPoint"));
primitive = point;
// Copy it
*point = *oldPoint;
}
else
{
// Path ?
const CPrimPath *oldPath = dynamic_cast<const CPrimPath *>(prim);
if (oldPath)
{
// Create a primitive
CPrimPath *path = static_cast<CPrimPath *> (CClassRegistry::create ("CPrimPath"));
primitive = path;
// Copy it
*path = *oldPath;
}
else
{
const CPrimZone *oldZone = safe_cast<const CPrimZone *>(prim);
if (oldZone)
{
// Create a primitive
CPrimZone *zone = static_cast<CPrimZone *> (CClassRegistry::create ("CPrimZone"));
primitive = zone;
// Copy it
*zone = *oldZone;
}
}
}
// Primitive has been created ?
if (primitive)
{
// Create a property for the name
CPropertyString *nameProp = new CPropertyString;
// nameProp->String = prim->Name;
// Add the property
primitive->addPropertyByName ("name", nameProp);
// The primitive is hidden ?
if (hidden)
{
// Create a property for hidden
nameProp = new CPropertyString;
// Add the property
primitive->addPropertyByName ("hidden", nameProp);
}
// Add the child
child->insertChild (primitive);
}
}
// ***************************************************************************
void CPrimitives::convertPrimitive (const IPrimitive *prim, bool hidden)
{
// Look for the group
uint numChildren = RootNode->getNumChildren ();
uint j;
for (j=0; j<numChildren; j++)
{
IPrimitive *child;
nlverify (RootNode->getChild (child, j));
const IProperty *prop;
if (child->getPropertyByName ("name", prop))
{
// Prop string
const CPropertyString *name = dynamic_cast<const CPropertyString *>(prop);
if (name)
{
// This one ?
/* if (name->String == prim->Layer)
{
convertAddPrimitive (child, prim, hidden);
break;
}
*/ }
}
}
// Not found ?
if (j==numChildren)
{
// Create a node
CPrimNode *primNode = static_cast<CPrimNode *> (CClassRegistry::create ("CPrimNode"));
// Create a property for the layer
CPropertyString *nameProp = new CPropertyString;
// nameProp->String = prim->Layer;
// Add the property
primNode->addPropertyByName ("name", nameProp);
// Add the child
RootNode->insertChild (primNode);
// Add the primitive
convertAddPrimitive (primNode, prim, hidden);
}
}
// ***************************************************************************
void CPrimitives::convert (const CPrimRegion &region)
{
// Delete
RootNode->removeChildren ();
RootNode->removeProperties ();
// For each primitives
uint i;
for (i=0; i<region.VPoints.size (); i++)
{
convertPrimitive (&(region.VPoints[i]), region.VHidePoints[i]);
}
for (i=0; i<region.VPaths.size (); i++)
{
convertPrimitive (&(region.VPaths[i]), region.VHidePaths[i]);
}
for (i=0; i<region.VZones.size (); i++)
{
convertPrimitive (&(region.VZones[i]), region.VHideZones[i]);
}
}
// ***************************************************************************
CPrimitiveContext::CPrimitiveContext():
CurrentLigoConfig(NULL),
CurrentPrimitive(NULL)
{
}
static bool LIGORegistered = false;
void Register ()
{
if( LIGORegistered )
{
nlinfo( "LIGO classes have already been registered." );
return;
}
NLMISC_REGISTER_CLASS(CPropertyString);
NLMISC_REGISTER_CLASS(CPropertyStringArray);
NLMISC_REGISTER_CLASS(CPropertyColor);
NLMISC_REGISTER_CLASS(CPrimNode);
NLMISC_REGISTER_CLASS(CPrimPoint);
NLMISC_REGISTER_CLASS(CPrimPath);
NLMISC_REGISTER_CLASS(CPrimZone);
NLMISC_REGISTER_CLASS(CPrimAlias);
LIGORegistered = true;
}
// ***************************************************************************
} // namespace NLLIGO