633 lines
17 KiB
C++
633 lines
17 KiB
C++
#include <StdAfx.h>
|
|
#include "vtPhysXAll.h"
|
|
|
|
#include "tinyxml.h"
|
|
|
|
int pFactory::loadFrom(pTireFunction& dst,const char* nodeName,const TiXmlDocument * doc )
|
|
{
|
|
int result = 0 ;
|
|
if (!strlen(nodeName)) { return -1; }
|
|
if (!doc) { return -1; }
|
|
const TiXmlElement *root = pFactory::Instance()->getFirstDocElement(doc->RootElement());
|
|
for (const TiXmlNode *child = root->FirstChild(); child; child = child->NextSibling() )
|
|
{
|
|
if ( (child->Type() == TiXmlNode::ELEMENT))
|
|
{
|
|
XString name = child->Value();
|
|
if (!strcmp(child->Value(), "tireFunction" ) )
|
|
{
|
|
const TiXmlElement *element = (const TiXmlElement*)child;
|
|
if (element->Type() == TiXmlNode::ELEMENT )
|
|
{
|
|
if(!strcmp( element->Attribute("name"),nodeName ) )
|
|
{
|
|
for (const TiXmlNode *node = element->FirstChild(); node; node = node->NextSibling() )
|
|
{
|
|
if ((node->Type() == TiXmlNode::ELEMENT) && (!stricmp(node->Value(),"settings")))
|
|
{
|
|
const TiXmlElement *sube = (const TiXmlElement*)node;
|
|
double v;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
int res = sube->QueryDoubleAttribute("ExtremumSlip",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.extremumSlip = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("ExtremumValue",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.extremumValue = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("AsymptoteSlip",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.asymptoteSlip = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("AsymptoteValue",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.asymptoteValue = static_cast<float>(v);
|
|
}
|
|
}
|
|
res = sube->QueryDoubleAttribute("StiffnessFactor",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.stiffnessFactor = static_cast<float>(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int pFactory::loadWheelDescrFromXML(pWheelDescr& dst,const char* nodeName,const TiXmlDocument * doc )
|
|
{
|
|
int result = 0 ;
|
|
if (!strlen(nodeName)) { return -1; }
|
|
if (!doc) { return -1; }
|
|
const TiXmlElement *root = pFactory::Instance()->getFirstDocElement(doc->RootElement());
|
|
for (const TiXmlNode *child = root->FirstChild(); child; child = child->NextSibling() )
|
|
{
|
|
if ( (child->Type() == TiXmlNode::ELEMENT))
|
|
{
|
|
XString name = child->Value();
|
|
if (!strcmp(child->Value(), "wheel" ) )
|
|
{
|
|
const TiXmlElement *element = (const TiXmlElement*)child;
|
|
if (element->Type() == TiXmlNode::ELEMENT )
|
|
{
|
|
if(!strcmp( element->Attribute("name"),nodeName ) )
|
|
{
|
|
for (const TiXmlNode *node = element->FirstChild(); node; node = node->NextSibling() )
|
|
{
|
|
if ((node->Type() == TiXmlNode::ELEMENT) && (!stricmp(node->Value(),"settings")))
|
|
{
|
|
const TiXmlElement *sube = (const TiXmlElement*)node;
|
|
double v;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
int res = sube->QueryDoubleAttribute("Suspension",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.wheelSuspension = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("Restitution",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.springRestitution = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("Damping",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.springDamping = static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("Bias",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.springBias= static_cast<float>(v);
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("MaxBreakForce",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.maxBrakeForce = static_cast<float>(v);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
|
|
res = sube->QueryDoubleAttribute("FrictionToSide",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.frictionToSide = static_cast<float>(v);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("FrictionToFront",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.frictionToFront = static_cast<float>(v);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
res = sube->QueryDoubleAttribute("InverseWheelMass",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.inverseWheelMass = static_cast<float>(v);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const char* flags = NULL;
|
|
flags = sube->Attribute("Flags");
|
|
if (flags && strlen(flags))
|
|
{
|
|
dst.wheelFlags = (WheelFlags)_str2WheelFlag(flags);
|
|
}
|
|
|
|
const char* sflags = NULL;
|
|
sflags = sube->Attribute("ShapeFlags");
|
|
if (sflags && strlen(sflags))
|
|
{
|
|
dst.wheelShapeFlags = (WheelShapeFlags)_str2WheelShapeFlag(sflags);
|
|
}
|
|
|
|
|
|
const char* latFunc = NULL;
|
|
latFunc = sube->Attribute("LateralFunction");
|
|
if (latFunc && strlen(latFunc))
|
|
{
|
|
int index = getEnumIndex(getManager()->GetContext()->GetParameterManager(),VTE_XML_TIRE_SETTINGS,latFunc);
|
|
if (index!=0)
|
|
{
|
|
loadFrom(dst.latFunc,latFunc,doc);
|
|
dst.latFunc.xmlLink = index;
|
|
if (!dst.latFunc.isValid())
|
|
{
|
|
xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"Lateral Tire Function from XML was incorrect, setting to default");
|
|
dst.latFunc.setToDefault();
|
|
}
|
|
}
|
|
}
|
|
|
|
const char* longFunc = NULL;
|
|
longFunc = sube->Attribute("LongitudeFunction");
|
|
if (longFunc && strlen(longFunc))
|
|
{
|
|
int index = getEnumIndex(getManager()->GetContext()->GetParameterManager(),VTE_XML_TIRE_SETTINGS,longFunc);
|
|
if (index!=0)
|
|
{
|
|
loadFrom(dst.longFunc,longFunc,doc);
|
|
dst.longFunc.xmlLink = index;
|
|
if (!dst.longFunc.isValid())
|
|
{
|
|
xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"Longitude Tire Function from XML was incorrect, setting to default");
|
|
dst.longFunc.setToDefault();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
int pFactory::loadVehicleDescrFromXML(pVehicleDesc& dst,const char* nodeName,const TiXmlDocument * doc )
|
|
{
|
|
|
|
|
|
int result = 0 ;
|
|
if (!strlen(nodeName)) { return -1; }
|
|
if (!doc) { return -1; }
|
|
const TiXmlElement *root = pFactory::Instance()->getFirstDocElement(doc->RootElement());
|
|
for (const TiXmlNode *child = root->FirstChild(); child; child = child->NextSibling() )
|
|
{
|
|
if ( (child->Type() == TiXmlNode::ELEMENT))
|
|
{
|
|
XString name = child->Value();
|
|
if (!strcmp(child->Value(), "vehicle" ) )
|
|
{
|
|
const TiXmlElement *element = (const TiXmlElement*)child;
|
|
if (element->Type() == TiXmlNode::ELEMENT )
|
|
{
|
|
if(!strcmp( element->Attribute("name"),nodeName ) )
|
|
{
|
|
for (const TiXmlNode *node = element->FirstChild(); node; node = node->NextSibling() )
|
|
{
|
|
if ((node->Type() == TiXmlNode::ELEMENT) && (!stricmp(node->Value(),"settings")))
|
|
{
|
|
const TiXmlElement *sube = (const TiXmlElement*)node;
|
|
double v;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
int res = sube->QueryDoubleAttribute("Mass",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
dst.mass = static_cast<float>(v);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int pFactory::_str2PhysicFlags(XString _in)
|
|
{
|
|
|
|
|
|
short nb = 0 ;
|
|
int result = 0;
|
|
XStringTokenizer tokizer(_in.CStr(), "|");
|
|
const char*tok = NULL;
|
|
while ((tok=tokizer.NextToken(tok)) )
|
|
{
|
|
XString tokx(tok);
|
|
|
|
if ( _stricmp(tokx.CStr(),"DisableHardware") == 0 )
|
|
{
|
|
result |= PMF_DONT_USE_HARDWARE;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"DoNotDeleteScenes") == 0 )
|
|
{
|
|
result |= PMF_DONT_DELETE_SCENES;
|
|
}
|
|
nb++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int pFactory::_str2SceneFlags(XString _in)
|
|
{
|
|
|
|
|
|
short nb = 0 ;
|
|
int result = 0;
|
|
XStringTokenizer tokizer(_in.CStr(), "|");
|
|
const char*tok = NULL;
|
|
while ((tok=tokizer.NextToken(tok)) )
|
|
{
|
|
XString tokx(tok);
|
|
|
|
if ( _stricmp(tokx.CStr(),"DisableSSE") == 0 )
|
|
{
|
|
result |= NX_SF_DISABLE_SSE;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"DisableCollision") == 0 )
|
|
{
|
|
result |= NX_SF_DISABLE_COLLISIONS;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"SimulateSeperateThread") == 0 )
|
|
{
|
|
result |= NX_SF_SIMULATE_SEPARATE_THREAD;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"EnableMultiThread") == 0 )
|
|
{
|
|
result |= NX_SF_ENABLE_MULTITHREAD;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"EnableActiveTransforms") == 0 )
|
|
{
|
|
result |= NX_SF_ENABLE_ACTIVETRANSFORMS;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"RestrictedScene") == 0 )
|
|
{
|
|
result |= NX_SF_RESTRICTED_SCENE;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"DisableSceneMutex") == 0 )
|
|
{
|
|
result |= NX_SF_DISABLE_SCENE_MUTEX;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"ForceConeFriction") == 0 )
|
|
{
|
|
result |= NX_SF_FORCE_CONE_FRICTION;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"DisableSceneMutex") == 0 )
|
|
{
|
|
result |= NX_SF_SEQUENTIAL_PRIMARY;
|
|
}
|
|
|
|
/*
|
|
if ( _stricmp(tokx.CStr(),"DisableHardware") == 0 )
|
|
{
|
|
result |= NX_SF_SEQUENTIAL_PRIMARY;
|
|
}*/
|
|
|
|
nb++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int pFactory::_str2WheelFlag(XString _in)
|
|
{
|
|
|
|
|
|
short nb = 0 ;
|
|
int result = 0;
|
|
XStringTokenizer tokizer(_in.CStr(), "|");
|
|
const char*tok = NULL;
|
|
while ((tok=tokizer.NextToken(tok)) )
|
|
{
|
|
XString tokx(tok);
|
|
|
|
if ( _stricmp(tokx.CStr(),"Steerable") == 0 )
|
|
{
|
|
result |= WF_SteerableInput;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"VehicleControlled") == 0 )
|
|
{
|
|
result |= WF_VehicleControlled;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"SteerableAuto") == 0 )
|
|
{
|
|
result |= WF_SteerableAuto;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"Handbrake") == 0 )
|
|
{
|
|
result |= WF_AffectedByHandbrake;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"Accelerated") == 0 )
|
|
{
|
|
result |= WF_Accelerated;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"Differential") == 0 )
|
|
{
|
|
result |= WF_AffectedByDifferential;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"IgnoreTireFunction") == 0 )
|
|
{
|
|
result |= WF_IgnoreTireFunction;
|
|
}
|
|
|
|
|
|
|
|
/*if ( _stricmp(tokx.CStr(),"Wheelshape") == 0 )
|
|
{
|
|
result |= WF_UseWheelShape;
|
|
}*/
|
|
|
|
nb++;
|
|
}
|
|
return result;
|
|
}
|
|
int pFactory::_str2WheelShapeFlag(XString _in)
|
|
{
|
|
|
|
|
|
short nb = 0 ;
|
|
int result = 0;
|
|
XStringTokenizer tokizer(_in.CStr(), "|");
|
|
const char*tok = NULL;
|
|
while ((tok=tokizer.NextToken(tok)) )
|
|
{
|
|
XString tokx(tok);
|
|
|
|
if ( _stricmp(tokx.CStr(),"AxisContactNormal") == 0 )
|
|
{
|
|
result |= WSF_AxleSpeedOverride;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"InputLateralSlip") == 0 )
|
|
{
|
|
result |= WSF_InputLatSlipVelocity;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"InputLongitudinal") == 0 )
|
|
{
|
|
result |= WSF_InputLongSlipVelocity;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"UnscaledSpringBehavior") == 0 )
|
|
{
|
|
result |= WSF_UnscaledSpringBehavior;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"WheelAxisContactNormal") == 0 )
|
|
{
|
|
result |= WSF_WheelAxisContactNormal;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"AxleSpeedOverride") == 0 )
|
|
{
|
|
result |= WSF_AxleSpeedOverride;
|
|
}
|
|
|
|
if ( _stricmp(tokx.CStr(),"EmulateLegacyWheel") == 0 )
|
|
{
|
|
result |= WSF_EmulateLegacyWheel;
|
|
}
|
|
if ( _stricmp(tokx.CStr(),"ClampedFriction") == 0 )
|
|
{
|
|
result |= WSF_ClampedFriction;
|
|
}
|
|
nb++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
|
|
int pVehicle::loadFromXML(const char* nodeName,const TiXmlDocument * doc )
|
|
{
|
|
NxMaterialDesc *result = new NxMaterialDesc();
|
|
result->setToDefault();
|
|
|
|
int res = 0;
|
|
|
|
if (!strlen(nodeName)) { return -1; }
|
|
if (!doc) { return -1; }
|
|
|
|
|
|
if ( strlen(nodeName) && doc)
|
|
{
|
|
const TiXmlElement *root = pFactory::Instance()->getFirstDocElement(doc->RootElement());
|
|
for (const TiXmlNode *child = root->FirstChild(); child; child = child->NextSibling() )
|
|
{
|
|
if ( (child->Type() == TiXmlNode::ELEMENT))
|
|
{
|
|
XString name = child->Value();
|
|
if (!strcmp(child->Value(), "vehicle" ) )
|
|
{
|
|
const TiXmlElement *element = (const TiXmlElement*)child;
|
|
if (element->Type() == TiXmlNode::ELEMENT )
|
|
{
|
|
if(!strcmp( element->Attribute("name"),nodeName ) )
|
|
{
|
|
for (const TiXmlNode *node = element->FirstChild(); node; node = node->NextSibling() )
|
|
{
|
|
if ((node->Type() == TiXmlNode::ELEMENT) && (!stricmp(node->Value(),"settings")))
|
|
{
|
|
const TiXmlElement *sube = (const TiXmlElement*)node;
|
|
double v;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
int res = sube->QueryDoubleAttribute("Mass",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f)
|
|
{
|
|
//setMass() =
|
|
continue;
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
res = sube->QueryDoubleAttribute("StaticFriction",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f){
|
|
result->staticFriction= (float)v;
|
|
continue;
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
res = sube->QueryDoubleAttribute("Restitution",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f){
|
|
result->restitution= (float)v;
|
|
continue;
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
res = sube->QueryDoubleAttribute("DynamicFrictionV",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f){
|
|
result->dynamicFrictionV= (float)v;
|
|
continue;
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
res = sube->QueryDoubleAttribute("StaticFrictionV",&v);
|
|
if (res == TIXML_SUCCESS)
|
|
{
|
|
if(v >=0.0f){
|
|
result->staticFrictionV= (float)v;
|
|
continue;
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
const char* dirOfAnisotropy = NULL;
|
|
dirOfAnisotropy = sube->Attribute("DirOfAnisotropy");
|
|
if (dirOfAnisotropy && strlen(dirOfAnisotropy))
|
|
{
|
|
VxVector vec = pFactory::Instance()->_str2Vec(dirOfAnisotropy);
|
|
if (vec.Magnitude() >0.1f)
|
|
{
|
|
result->flags = NX_MF_ANISOTROPIC;
|
|
result->dirOfAnisotropy = pMath::getFrom(vec);
|
|
continue;
|
|
}else
|
|
{
|
|
result->dirOfAnisotropy = pMath::getFrom(VxVector(0,0,0));
|
|
}
|
|
|
|
//result->setGravity(vec);
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
const char* FrictionCombineMode = NULL;
|
|
FrictionCombineMode = sube->Attribute("FrictionCombineMode");
|
|
if (FrictionCombineMode && strlen(FrictionCombineMode))
|
|
{
|
|
// int fMode = _str2CombineMode(FrictionCombineMode);
|
|
// result->frictionCombineMode = (NxCombineMode)fMode;
|
|
continue;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
const char* RestitutionCombineMode = NULL;
|
|
RestitutionCombineMode = sube->Attribute("RestitutionCombineMode");
|
|
if (RestitutionCombineMode && strlen(RestitutionCombineMode))
|
|
{
|
|
// int fMode = _str2CombineMode(RestitutionCombineMode);
|
|
// result->restitutionCombineMode= (NxCombineMode)fMode;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
// return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
|
|
|