void dTextureNodeInfo::SetPathName (const char* const path)
{
//const char* const ptr = dGetNameFromPath (path);
//strncpy (m_path, ptr, sizeof (m_path));
m_path = dGetNameFromPath (path);
m_id = dCRC64 (m_path.GetStr());
}
dCRCTYPE dMaterialNodeInfo::CalculateSignature() const
{
dCRCTYPE signature = 0;
signature = dCRC64 (&m_ambientColor, sizeof (m_ambientColor), signature);
signature = dCRC64 (&m_diffuseColor, sizeof (m_diffuseColor), signature);
signature = dCRC64 (&m_specularColor, sizeof (m_specularColor), signature);
signature = dCRC64 (&m_emissiveColor, sizeof (m_emissiveColor), signature);
signature = dCRC64 (&m_shininess, sizeof (m_shininess), signature);
signature = dCRC64 (&m_opacity, sizeof (m_opacity), signature);
signature = dCRC64 (&m_ambientTexId, sizeof (m_ambientTexId), signature);
signature = dCRC64 (&m_diffuseTexId, sizeof (m_diffuseTexId), signature);
signature = dCRC64 (&m_specularTexId, sizeof (m_specularTexId), signature);
signature = dCRC64 (&m_emissiveTexId, sizeof (m_emissiveTexId), signature);
return signature;
}
void AddItem (const dItem& item)
{
dState::dListNode* const node = Append(item);
static dCRCTYPE errorCRC = dCRC64 (DERROR_SYMBOL);
dItemKey key (item);
dTree<dList<dState::dListNode*>, dItemKey>::dTreeNode* mapNode = m_itemMap.Find (key);
if (!mapNode) {
mapNode = m_itemMap.Insert (key);
}
if (item.m_indexMarker == 0) {
dAssert (item.m_ruleNode);
const dRuleInfo& ruleInfo = item.m_ruleNode->GetInfo();
if (ruleInfo.GetCount()) {
const dSymbol& symbol = ruleInfo.GetFirst()->GetInfo();
if (symbol.m_nameCRC == errorCRC) {
m_hasErroItem = true;
}
}
}
dList<dState::dListNode*>& bucket = mapNode->GetInfo();
// check if bucket is not too big
dAssert (bucket.GetCount() < 16);
bucket.Append(node);
}
void InsertText (const char* const texName, GLuint id)
{
TextureEntry entry;
entry.m_textureID = id;
entry.m_textureName = texName;
entry.m_textureName.ToLower();
dCRCTYPE crc = dCRC64 (entry.m_textureName.GetStr());
Insert(entry, crc);
}
void InsertText (const char* const texName, GLuint id)
{
TextureEntry entry;
entry.m_textureID = id;
strcpy (entry.m_textureName, texName);
strlwr (entry.m_textureName);
dCRCTYPE crc = dCRC64 (entry.m_textureName);
Insert(entry, crc);
}
dParserCompiler::dParserCompiler(const dString& inputRules, const char* const outputFileName, const char* const scannerClassName)
:m_shiftReduceExpectedWarnings(0)
{
// scan the grammar into a list of rules.
int lastTerminalToken;
dProductionRule ruleList;
dOperatorsPrecedence operatorPrecedence;
dTree<dTokenInfo, dCRCTYPE> symbolList;
dString userCodeBlock;
dString userVariableClass ("");
dString endUserCode ("\n");
// scan grammar to a set of LR(1) rules
symbolList.Insert(dTokenInfo (DACCEPTING_TOKEN, TERMINAL, DACCEPT_SYMBOL), dCRC64 (DACCEPT_SYMBOL));
symbolList.Insert(dTokenInfo (DERROR_TOKEN, TERMINAL, DERROR_SYMBOL), dCRC64 (DERROR_SYMBOL));
ScanGrammarFile(inputRules, ruleList, symbolList, operatorPrecedence, userCodeBlock, userVariableClass, endUserCode, lastTerminalToken);
// convert the rules into a NFA.
dString debugFileName (outputFileName);
debugFileName += ".txt";
FILE* const debugFile = fopen (debugFileName.GetStr(), "w");
dTree<dState*, dCRCTYPE> stateList;
CanonicalItemSets (stateList, ruleList, symbolList, operatorPrecedence, debugFile);
fclose (debugFile);
// create a LR(1) parsing table from the NFA graphs
const dString& startSymbol = ruleList.GetFirst()->GetInfo().m_name;
BuildParsingTable (stateList, dCRC64 (startSymbol.GetStr()), operatorPrecedence);
//Write Parser class and header file
dString className (GetClassName(outputFileName));
GenerateHeaderFile (className, scannerClassName, outputFileName, symbolList, userVariableClass);
GenerateParserCode (className, scannerClassName, outputFileName, symbolList, stateList, userCodeBlock, endUserCode, lastTerminalToken);
dTree<dState*, dCRCTYPE>::Iterator iter(stateList);
for (iter.Begin(); iter; iter ++) {
dState* const state = iter.GetNode()->GetInfo();
delete state;
}
}
dPluginRecord* dPluginInterface::GetPlugin(const char* const signature) const
{
dTree<dPluginRecord*, dCRCTYPE>::dTreeNode* const node = m_pluginDictionary.Find(dCRC64 (signature));
_ASSERTE (node);
dPluginRecord* plugin = NULL;
if (node) {
plugin = node->GetInfo();
}
return plugin;
}
void dNodeInfo::ReplaceSingletonClass (const char* const className, const dNodeInfo* const singleton)
{
dCRCTYPE crc = dCRC64 (className);
dTree<const dNodeInfo*, dCRCTYPE>& dictionary = dNodeInfo::GetSingletonDictionary();
dTree<const dNodeInfo*, dCRCTYPE>::dTreeNode* const node = dictionary.Find(crc);
if (node) {
node->GetInfo() = singleton;
} else {
dRegisterSingleton (className, singleton);
}
}
void CalculateKey ()
{
dCRCTYPE key = 0;
for (dState::dListNode* itemNode = GetFirst(); itemNode; itemNode = itemNode->GetNext()) {
dItem& item = itemNode->GetInfo();
int index = 0;
key = dCRC64 (item.m_lookAheadSymbolName.GetStr(), key);
for (dRuleInfo::dListNode* node = item.m_ruleNode->GetInfo().GetFirst(); node; node = node->GetNext()) {
if (index == item.m_indexMarker) {
key = dCRC64 (".", key);
}
const dSymbol& info = node->GetInfo();
key = dCRC64 (info.m_name.GetStr(), key);
index ++;
}
if (item.m_indexMarker == item.m_ruleNode->GetInfo().GetCount()) {
key = dCRC64 (".", key);
}
}
m_key = key;
}
dNodeInfo* dNodeInfo::CreateFromClassName (const char* const className, dScene* const world)
{
dCRCTYPE crc = dCRC64 (className);
dTree<const dNodeInfo*, dCRCTYPE>& dictionary = dNodeInfo::GetSingletonDictionary();
dTree<const dNodeInfo*, dCRCTYPE>::dTreeNode* const node = dictionary.Find(crc);
if (node) {
const dNodeInfo* const singleton = node->GetInfo();
return singleton->MetaFunction(world);
} else {
m_uniqueIDCounter ++;
}
return NULL;
}
dPluginInterface::dPluginDll::dListNode* dPluginInterface::LoadPlugins(const char* const path)
{
char plugInPath[2048];
char rootPathInPath [2048];
GetAplicationDirectory(plugInPath);
strcat (plugInPath, path);
sprintf (rootPathInPath, "%s/*.dll", plugInPath);
dPluginDll::dListNode* const firstNode = m_allPlugins.GetLast();
// scan for all plugins in this folder
_finddata_t data;
intptr_t handle = _findfirst (rootPathInPath, &data);
if (handle != -1) {
do {
sprintf (rootPathInPath, "%s/%s", plugInPath, data.name);
HMODULE module = LoadLibrary(rootPathInPath);
if (module) {
// get the interface function pointer to the Plug in classes
GetPluginArray GetPluginsTable = (GetPluginArray) GetProcAddress (module, "GetPluginArray");
if (GetPluginsTable) {
m_allPlugins.Append(module);
} else {
FreeLibrary(module);
}
}
} while (_findnext (handle, &data) == 0);
_findclose (handle);
}
for (dPluginDll::dListNode* dllNode = firstNode ? firstNode->GetNext() : m_allPlugins.GetFirst(); dllNode; dllNode = dllNode->GetNext()) {
HMODULE module = dllNode->GetInfo();
GetPluginArray GetPluginsTable = (GetPluginArray) GetProcAddress (module, "GetPluginArray");
dPluginRecord** const table = GetPluginsTable();
for (int i = 0; table[i]; i ++) {
dPluginRecord* const plugin = table[i];
const char* const pluginName = plugin->GetSignature();
dCRCTYPE key = dCRC64 (pluginName);
_ASSERTE (!m_pluginDictionary.Find(key));
m_pluginDictionary.Insert(plugin, key);
}
}
return firstNode ? firstNode->GetNext() : m_allPlugins.GetFirst();
}
int dChatertSetMap::AddSet (const char* const set, int count)
{
ChatertSet newSet (set, count, m_id);
dCRCTYPE crc = dCRC64 (newSet.m_characters, 0);
dTree<dList <ChatertSet>::dListNode*, dCRCTYPE>::dTreeNode* node = m_crcID.Find(crc);
if (!node) {
dList <ChatertSet>::dListNode* const setNode = m_sets.Append(newSet);
m_table.Insert(setNode, newSet.m_id);
m_id ++;
node = m_crcID.Insert(setNode, crc);
}
dList <ChatertSet>::dListNode* const setNode = node->GetInfo();
return setNode->GetInfo().m_id;
}
GLuint GetTexture(const char* const texName)
{
GLuint texID = 0;
_ASSERTE (texName);
TextureEntry entry;
strcpy (entry.m_textureName, texName);
strlwr (entry.m_textureName);
dCRCTYPE crc = dCRC64 (entry.m_textureName);
dTreeNode* node = Find(crc);
if (node) {
texID = node->GetInfo().m_textureID;
}
return texID;
}
GLuint GetTexture(const char* const texName)
{
GLuint texID = 0;
dAssert (texName);
TextureEntry entry;
entry.m_textureName = texName;
entry.m_textureName.ToLower();
dCRCTYPE crc = dCRC64 (entry.m_textureName.GetStr());
dTreeNode* node = Find(crc);
if (node) {
node->GetInfo().AddRef();
texID = node->GetInfo().m_textureID;
}
return texID;
}
void SaveLastOperationSymbol (const dState* const state) const
{
for (dState::dListNode* node = state->GetFirst(); node; node = node->GetNext()) {
dItem& item = node->GetInfo();
const dRuleInfo& ruleInfo = item.m_ruleNode->GetInfo();
for (dRuleInfo::dListNode* infoSymbolNode = ruleInfo.GetFirst(); infoSymbolNode; infoSymbolNode = infoSymbolNode->GetNext()) {
const dSymbol& infoSymbol = infoSymbolNode->GetInfo();
if (infoSymbol.m_operatorPrecendeceOverright.Size()) {
dCRCTYPE crc = dCRC64(infoSymbol.m_operatorPrecendeceOverright.GetStr());
if (FindAssociation(crc)) {
item.m_lastOperatorSymbolCRC = crc;
item.m_lastOperatorSymbolName = infoSymbol.m_operatorPrecendeceOverright;
}
} else {
if (FindAssociation(infoSymbol.m_nameCRC)) {
item.m_lastOperatorSymbolCRC = infoSymbol.m_nameCRC;
item.m_lastOperatorSymbolName = infoSymbol.m_name;
}
}
}
}
}
// generates the canonical Items set for a LR(1) grammar
void dParserCompiler::CanonicalItemSets (
dTree<dState*, dCRCTYPE>& stateMap,
const dProductionRule& ruleList,
const dTree<dTokenInfo, dCRCTYPE>& symbolList,
const dOperatorsPrecedence& operatorPrecedence,
FILE* const debugFile)
{
dList<dItem> itemSet;
dList<dState*> stateList;
// start by building an item set with only the first rule
dItem& item = itemSet.Append()->GetInfo();
item.m_indexMarker = 0;
item.m_lookAheadSymbolCRC = dCRC64 (DACCEPT_SYMBOL);
item.m_lookAheadSymbolName = DACCEPT_SYMBOL;
item.m_ruleNode = ruleList.GetFirst();
// build a rule info map
dTree<dList<void*>, dCRCTYPE> ruleMap;
for (dProductionRule::dListNode* ruleNode = ruleList.GetFirst(); ruleNode; ruleNode = ruleNode->GetNext()) {
dRuleInfo& info = ruleNode->GetInfo();
dTree<dList<void*>, dCRCTYPE>::dTreeNode* node = ruleMap.Find(info.m_nameCRC);
if (!node) {
node = ruleMap.Insert(info.m_nameCRC);
}
dList<void*>& entry = node->GetInfo();
entry.Append(ruleNode);
}
// find the closure for the first this item set with only the first rule
dState* const state = Closure (itemSet, symbolList, ruleMap);
operatorPrecedence.SaveLastOperationSymbol (state);
stateMap.Insert(state, state->GetKey());
stateList.Append(state);
state->Trace(debugFile);
// now for each state found
int stateNumber = 1;
for (dList<dState*>::dListNode* node = stateList.GetFirst(); node; node = node->GetNext()) {
dState* const state = node->GetInfo();
dTree<dTokenInfo, dCRCTYPE>::Iterator iter (symbolList);
for (iter.Begin(); iter; iter ++) {
dCRCTYPE symbol = iter.GetKey();
dState* const newState = Goto (state, symbol, symbolList, ruleMap);
if (newState->GetCount()) {
const dTokenInfo& tokenInfo = iter.GetNode()->GetInfo();
dTransition& transition = state->m_transitions.Append()->GetInfo();
transition.m_symbol = symbol;
transition.m_name = tokenInfo.m_name;
transition.m_type = tokenInfo.m_type;
dAssert (transition.m_symbol == dCRC64(transition.m_name.GetStr()));
transition.m_targetState = newState;
dTree<dState*, dCRCTYPE>::dTreeNode* const targetStateNode = stateMap.Find(newState->GetKey());
if (!targetStateNode) {
newState->m_number = stateNumber;
stateNumber ++;
stateMap.Insert(newState, newState->GetKey());
newState->Trace(debugFile);
stateList.Append(newState);
operatorPrecedence.SaveLastOperationSymbol (newState);
} else {
transition.m_targetState = targetStateNode->GetInfo();
delete newState;
}
} else {
delete newState;
}
}
dTrace (("state#:%d items: %d transitions: %d\n", state->m_number, state->GetCount(), state->m_transitions.GetCount()));
}
}
dParserCompiler::dToken dParserCompiler::ScanGrammarRule(
dParserLexical& lexical,
dProductionRule& rules,
dTree<dTokenInfo, dCRCTYPE>& symbolList,
int& ruleNumber,
int& tokenEnumeration,
const dOperatorsPrecedence& operatorPrecedence)
{
dRuleInfo* currentRule = &rules.GetLast()->GetInfo();
dToken token = dToken(lexical.NextToken());
do {
dList<dTokenStringPair> ruleTokens;
for (token = dToken(lexical.NextToken()); !((token == SIMICOLOM) || (token == OR)); token = dToken(lexical.NextToken())) {
dAssert (token != -1);
dTokenStringPair& pair = ruleTokens.Append()->GetInfo();
pair.m_token = token;
pair.m_info = lexical.GetTokenString();
}
dList<dTokenStringPair>::dListNode* lastNode = ruleTokens.GetLast();
if (lastNode) {
if (lastNode->GetInfo().m_token != SEMANTIC_ACTION) {
lastNode = NULL;
} else {
currentRule->m_semanticActionCode = lastNode->GetInfo().m_info;
}
}
for (dList<dTokenStringPair>::dListNode* node = ruleTokens.GetFirst(); node != lastNode; node = node->GetNext()) {
dTokenStringPair& pair = node->GetInfo();
if (pair.m_token == LITERAL) {
dSymbol& symbol = currentRule->Append()->GetInfo();
symbol.m_token = pair.m_token;
symbol.m_name = pair.m_info;
symbol.m_nameCRC = dCRC64 (symbol.m_name.GetStr());
dTree<dTokenInfo, dCRCTYPE>::dTreeNode* symbolNode = symbolList.Find(symbol.m_nameCRC);
if (!symbolNode) {
symbolNode = symbolList.Insert(dTokenInfo (tokenEnumeration, NONTERMINAL, symbol.m_name), symbol.m_nameCRC);
tokenEnumeration ++;
}
symbol.m_type = symbolNode->GetInfo().m_type;
} else if (pair.m_token < 256) {
dAssert (pair.m_info.Size() == 1);
dSymbol& symbol = currentRule->Append()->GetInfo();
symbol.m_name = pair.m_info;
symbol.m_nameCRC = dCRC64 (symbol.m_name.GetStr());
symbol.m_type = TERMINAL;
symbol.m_token = LITERAL;
symbolList.Insert(dTokenInfo (pair.m_token, TERMINAL, symbol.m_name), symbol.m_nameCRC);
} else if (pair.m_token == PREC) {
node = node->GetNext();
for (dRuleInfo::dListNode* ruleNode = currentRule->GetLast(); ruleNode; ruleNode = ruleNode->GetPrev()) {
dSymbol& symbol = ruleNode->GetInfo();
if (operatorPrecedence.FindAssociation (symbol.m_nameCRC)) {
dTokenStringPair& pair = node->GetInfo();
symbol.m_operatorPrecendeceOverright = pair.m_info;
break;
}
}
// } else if (pair.m_token != SEMANTIC_ACTION) {
// // no user action allowed in the middle of a sentence
// _ASSERTE (pair.m_token == SEMANTIC_ACTION);
// } else {
// _ASSERTE (0);
}
}
if (token == OR) {
// this is a rule with multiples sentences alternates, add new rule with the same name Non terminal
dRuleInfo& rule = rules.Append()->GetInfo();
rule.m_ruleNumber = ruleNumber;
ruleNumber ++;
rule.m_ruleId = currentRule->m_ruleId;
rule.m_token = currentRule->m_token;
rule.m_type = NONTERMINAL;
//rule.m_name += currentRule->m_name;
rule.m_name = currentRule->m_name;
rule.m_nameCRC = currentRule->m_nameCRC;
currentRule = &rule;
}
} while (token != SIMICOLOM);
return token;
}
void dParserCompiler::ScanGrammarFile(
const dString& inputRules,
dProductionRule& ruleList,
dTree<dTokenInfo, dCRCTYPE>& symbolList,
dOperatorsPrecedence& operatorPrecedence,
dString& userCodeBlock,
dString& userVariableClass,
dString& endUserCode,
int& lastTokenEnum)
{
dString startSymbol ("");
int tokenEnumeration = 256;
int operatorPrecedencePriority = 0;
dParserLexical lexical (inputRules.GetStr());
LoadTemplateFile("dParserUserVariableTemplate_cpp.txt", userVariableClass);
// scan the definition segment
for (dToken token = dToken(lexical.NextToken()); token != GRAMMAR_SEGMENT; ) {
switch (int (token))
{
case START:
{
token = dToken(lexical.NextToken());
startSymbol = lexical.GetTokenString();
token = dToken(lexical.NextToken());
break;
}
case TOKEN:
{
for (token = dToken(lexical.NextToken()); token == LITERAL; token = dToken(lexical.NextToken())) {
const char* const name = lexical.GetTokenString();
symbolList.Insert(dTokenInfo (tokenEnumeration, TERMINAL, name), dCRC64 (name));
tokenEnumeration ++;
}
break;
}
case LEFT:
case RIGHT:
{
dOperatorsAssociation& association = operatorPrecedence.Append()->GetInfo();
association.m_prioprity = operatorPrecedencePriority;
operatorPrecedencePriority ++;
switch (int (token))
{
case LEFT:
association.m_associativity = dOperatorsAssociation::m_left;
break;
case RIGHT:
association.m_associativity = dOperatorsAssociation::m_right;
break;
}
for (token = dToken(lexical.NextToken()); (token == LITERAL) || ((token < 256) && !isalnum (token)); token = dToken(lexical.NextToken())) {
association.Append(dCRC64 (lexical.GetTokenString()));
}
break;
}
case UNION:
{
token = dToken(lexical.NextToken());
dAssert (token == SEMANTIC_ACTION);
userVariableClass = lexical.GetTokenString() + 1;
userVariableClass.Replace(userVariableClass.Size() - 1, 1, "");
token = dToken(lexical.NextToken());
break;
}
case CODE_BLOCK:
{
userCodeBlock += lexical.GetTokenString();
token = dToken(lexical.NextToken());
break;
}
case EXPECT:
{
token = dToken(lexical.NextToken());
dAssert (token == INTEGER);
m_shiftReduceExpectedWarnings = atoi (lexical.GetTokenString());
token = dToken(lexical.NextToken());
break;
}
default:;
{
dAssert (0);
token = dToken(lexical.NextToken());
}
}
}
int ruleNumber = 1;
lastTokenEnum = tokenEnumeration;
// scan the production rules segment
dToken token1 = dToken(lexical.NextToken());
for (; (token1 != GRAMMAR_SEGMENT) && (token1 != -1); token1 = dToken(lexical.NextToken())) {
//dTrace (("%s\n", lexical.GetTokenString()));
switch (int (token1))
{
case LITERAL:
{
// add the first Rule;
dRuleInfo& rule = ruleList.Append()->GetInfo();
rule.m_token = token1;
rule.m_type = NONTERMINAL;
rule.m_name = lexical.GetTokenString();
rule.m_nameCRC = dCRC64 (lexical.GetTokenString());
dTree<dTokenInfo, dCRCTYPE>::dTreeNode* nonTerminalIdNode = symbolList.Find(rule.m_nameCRC);
if (!nonTerminalIdNode) {
nonTerminalIdNode = symbolList.Insert(dTokenInfo (tokenEnumeration, NONTERMINAL, rule.m_name), rule.m_nameCRC);
tokenEnumeration ++;
}
rule.m_ruleId = nonTerminalIdNode->GetInfo().m_tokenId;
rule.m_ruleNumber = ruleNumber;
ruleNumber ++;
token1 = ScanGrammarRule(lexical, ruleList, symbolList, ruleNumber, tokenEnumeration, operatorPrecedence);
break;
}
default:
dAssert (0);
}
}
dProductionRule::dListNode* firtRuleNode = ruleList.GetFirst();
if (startSymbol != "") {
firtRuleNode = ruleList.Find (dCRC64 (startSymbol.GetStr()));
}
//Expand the Grammar Rule by adding an empty start Rule;
const dRuleInfo& firstRule = firtRuleNode->GetInfo();
dRuleInfo& rule = ruleList.Addtop()->GetInfo();
rule.m_ruleNumber = 0;
rule.m_ruleId = tokenEnumeration;
rule.m_token = firstRule.m_token;
rule.m_type = NONTERMINAL;
rule.m_name = firstRule.m_name + dString("__");
rule.m_nameCRC = dCRC64 (rule.m_name.GetStr());
symbolList.Insert(dTokenInfo (tokenEnumeration, rule.m_type, rule.m_name), rule.m_nameCRC);
tokenEnumeration ++;
dSymbol& symbol = rule.Append()->GetInfo();
symbol.m_token = firstRule.m_token;
symbol.m_type = firstRule.m_type;
symbol.m_name = firstRule.m_name;
symbol.m_nameCRC = firstRule.m_nameCRC;
// scan literal use code
if (token1 == GRAMMAR_SEGMENT) {
endUserCode = lexical.GetNextBuffer();
//endUserCode += "\n";
}
}
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely
*/
// NewtonCustomJoint.cpp: implementation of the NewtonCustomJoint class.
//
//////////////////////////////////////////////////////////////////////
#include "dCustomJointLibraryStdAfx.h"
#include "dCustomJoint.h"
dCRCTYPE dCustomJoint::m_key = dCRC64 ("dCustomJoint");
dCustomJoint::dSerializeMetaData m_metaData_CustomJoint("dCustomJoint");
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
dCustomJoint::dCustomJoint ()
:dCustomAlloc()
,m_localMatrix0(dGetIdentityMatrix())
,m_localMatrix1(dGetIdentityMatrix())
,m_userData(NULL)
,m_body0(NULL)
,m_body1(NULL)
,m_joint(NULL)
,m_world(NULL)
dCRCTYPE CustomJoint::GetSerializeKey() const
{
return dCRC64(CustomJoint::GetTypeName());
}
dCRCTYPE dLineNodeInfo::CalculateSignature() const
{
dCRCTYPE signature = 0;
dAssert (0);
#if 0
int vertexCount = NewtonMeshGetVertexCount (m_mesh);
int vertexStride = NewtonMeshGetVertexStrideInByte(m_mesh);
signature = dCRC64 (NewtonMeshGetVertexArray (m_mesh), vertexStride * vertexCount, signature);
// for now just compare the vertex array, do no forget to add more text using the face winding and material indexed
// save the polygon array
int faceCount = NewtonMeshGetTotalFaceCount (mesh);
int indexCount = NewtonMeshGetTotalIndexCount (mesh);
int* const faceArray = new int [faceCount];
void** const indexArray = new void* [indexCount];
int* const materialIndexArray = new int [faceCount];
int* const remapedIndexArray = new int [indexCount];
NewtonMeshGetFaces (mesh, faceArray, materialIndexArray, indexArray);
// save the faces vertex Count
dIntArrayToString (faceArray, faceCount, buffer, bufferSizeInBytes);
TiXmlElement* const polygons = new TiXmlElement ("polygons");
rootNode->LinkEndChild(polygons);
polygons->SetAttribute("count", faceCount);
polygons->SetAttribute("faceIndexCount", buffer);
dIntArrayToString (materialIndexArray, faceCount, buffer, bufferSizeInBytes);
TiXmlElement* const faceMaterial = new TiXmlElement ("faceMaterial");
polygons->LinkEndChild(faceMaterial);
faceMaterial->SetAttribute("index", buffer);
for (int i = 0; i < indexCount; i ++) {
int index = NewtonMeshGetVertexIndex (mesh, indexArray[i]);
remapedIndexArray[i] = vertexIndexList[index];
}
dIntArrayToString (remapedIndexArray, indexCount, buffer, bufferSizeInBytes);
TiXmlElement* const positionIndex = new TiXmlElement ("position");
polygons->LinkEndChild(positionIndex);
positionIndex->SetAttribute("index", buffer);
for (int i = 0; i < indexCount; i ++) {
int index = NewtonMeshGetPointIndex(mesh, indexArray[i]);
remapedIndexArray[i] = normalIndexList[index];
}
dIntArrayToString (remapedIndexArray, indexCount, buffer, bufferSizeInBytes);
TiXmlElement* const normalIndex = new TiXmlElement ("normal");
polygons->LinkEndChild(normalIndex);
normalIndex->SetAttribute("index", buffer);
for (int i = 0; i < indexCount; i ++) {
int index = NewtonMeshGetPointIndex(mesh, indexArray[i]);
remapedIndexArray[i] = uv0IndexList[index];
}
dIntArrayToString (remapedIndexArray, indexCount, buffer, bufferSizeInBytes);
TiXmlElement* const uv0Index = new TiXmlElement ("uv0");
polygons->LinkEndChild(uv0Index);
uv0Index->SetAttribute("index", buffer);
for (int i = 0; i < indexCount; i ++) {
int index = NewtonMeshGetPointIndex(mesh, indexArray[i]);
remapedIndexArray[i] = uv1IndexList[index];
}
dIntArrayToString (remapedIndexArray, indexCount, buffer, bufferSizeInBytes);
TiXmlElement* const uv1Index = new TiXmlElement ("uv1");
polygons->LinkEndChild(uv1Index);
uv1Index->SetAttribute("index", buffer);
#endif
return signature;
}
void dParserCompiler::BuildParsingTable (
const dTree<dState*, dCRCTYPE>& stateList,
dCRCTYPE startSymbol,
const dOperatorsPrecedence& operatorPrecedence) const
{
dTree<dState*, dCRCTYPE>::Iterator stateIter (stateList);
unsigned emptySymbol = 0;
const dCRCTYPE acceptingSymbol = dCRC64 (DACCEPT_SYMBOL);
// create Shift Reduce action table
for (stateIter.Begin(); stateIter; stateIter ++) {
dState* const state = stateIter.GetNode()->GetInfo();
// add all shift actions first
for (dList<dTransition>::dListNode* node = state->m_transitions.GetFirst(); node; node = node->GetNext()) {
dTransition& transition = node->GetInfo();
if (transition.m_type == TERMINAL) {
// find item generating this shift action and mark it as used.
const dState* const targetState = transition.m_targetState;
dAssert (!state->m_actions.Find (transition.m_symbol));
dTree<dAction, dCRCTYPE>::dTreeNode* const actionNode = state->m_actions.Insert (transition.m_symbol);
dAction& action = actionNode->GetInfo();
action.m_type = dSHIFT;
action.m_myItem = NULL;
action.m_nextState = targetState->m_number;
action.m_reduceRuleNode = NULL;
}
}
// add all reduce actions
dList<dAction*> potencialConflictinActions;
for (dState::dListNode* itemNode = state->GetFirst(); itemNode; itemNode = itemNode->GetNext()) {
dItem& item = itemNode->GetInfo();
const dRuleInfo& ruleInfo = item.m_ruleNode->GetInfo();
if ((ruleInfo.m_ruleNumber == 0) && (item.m_indexMarker == 1)) {
dTree<dAction, dCRCTYPE>::dTreeNode* const actionNode = state->m_actions.Insert (acceptingSymbol);
dAssert (actionNode);
dAction& action = actionNode->GetInfo();
action.m_type = dACCEPT;
action.m_myItem = &item;
action.m_reduceRuleNode = NULL;
} else if ((item.m_indexMarker == ruleInfo.GetCount()) && (ruleInfo.m_nameCRC != startSymbol)) {
dTree<dAction, dCRCTYPE>::dTreeNode* actionNode = state->m_actions.Find (item.m_lookAheadSymbolCRC);
if (!actionNode) {
actionNode = state->m_actions.Insert (item.m_lookAheadSymbolCRC);
dAction& action = actionNode->GetInfo();
action.m_type = dREDUCE;
action.m_myItem = &item;
action.m_nextState = 0;
action.m_reduceRuleNode = item.m_ruleNode;
} else {
dAction& action = actionNode->GetInfo();
action.m_myItem = &item;
action.m_reduceRuleNode = item.m_ruleNode;
potencialConflictinActions.Append (&actionNode->GetInfo());
}
}
}
// now resolve all conflicting actions
if (potencialConflictinActions.GetCount()) {
// resolve conflicting actions
dList<dAction*>::dListNode* nextActionNode = NULL;
for (dList<dAction*>::dListNode* actionNode = potencialConflictinActions.GetFirst(); actionNode; actionNode = nextActionNode) {
dAction* const action = actionNode->GetInfo();
if (action->m_type == dREDUCE) {
// this is a reduce reduce conflict
dAssert (0);
dTrace (("This is a reduce Reduce conflict, resolve in favor of of first production rule\n"));
}
nextActionNode = actionNode->GetNext();
const dItem& item = *action->m_myItem;
if (item.m_lastOperatorSymbolCRC != emptySymbol) {
const dOperatorsAssociation* const operatorAssosiation = operatorPrecedence.FindAssociation (item.m_lastOperatorSymbolCRC);
dAssert (operatorAssosiation);
if (operatorAssosiation->m_associativity == dOperatorsAssociation::m_left) {
const dOperatorsAssociation* const lookAheadOperatorAssosiation = operatorPrecedence.FindAssociation (item.m_lookAheadSymbolCRC);
if (!(lookAheadOperatorAssosiation && (lookAheadOperatorAssosiation->m_prioprity > operatorAssosiation->m_prioprity))) {
action->m_type = dREDUCE;
}
}
potencialConflictinActions.Remove(actionNode);
}
}
// for any conflicting actions left, display warning
for (dList<dAction*>::dListNode* actionNode = potencialConflictinActions.GetFirst(); actionNode; actionNode = actionNode->GetNext()) {
dAction* const action = actionNode->GetInfo();
dRuleInfo& rule = action->m_reduceRuleNode->GetInfo();
dString sentence;
sentence += rule.m_name;
sentence += " : ";
for (dRuleInfo::dListNode* node = rule.GetFirst(); node; node = node->GetNext()) {
sentence += node->GetInfo().m_name;
sentence += " ";
}
if (action->m_type == dSHIFT) {
if (!rule.m_shiftReduceErrorMark) {
rule.m_shiftReduceErrorMark = true;
if (m_shiftReduceExpectedWarnings <= 0) {
DisplayError ("\nstate %d: shift reduce warning resolved in favor of shift. on rule\n", state->m_number);
DisplayError (" %s\n", sentence.GetStr());
}
m_shiftReduceExpectedWarnings --;
}
} else {
dAssert (0);
DisplayError ("\nstate %d: reduce reduce error resolved in favor of first sentence. on rule\n", state->m_number);
DisplayError (" %s\n", sentence.GetStr());
}
}
}
}
// create Goto Table
for (stateIter.Begin(); stateIter; stateIter ++) {
dState* const state = stateIter.GetNode()->GetInfo();
for (dList<dTransition>::dListNode* node = state->m_transitions.GetFirst(); node; node = node->GetNext()) {
dTransition& transition = node->GetInfo();
if (transition.m_type == NONTERMINAL) {
state->m_goto.Insert (transition.m_targetState, transition.m_symbol);
}
}
}
}
CustomJoint::SerializeMetaData::SerializeMetaData(const char* const name)
{
CustomJoint::GetDictionary().Insert(this, dCRC64(name));
}
dNodeInfo::dRegisterSingleton::dRegisterSingleton (const char* const className, const dNodeInfo* const singleton)
{
dCRCTYPE crc = dCRC64 (className);
dTree<const dNodeInfo*, dCRCTYPE>& dictionary = dNodeInfo::GetSingletonDictionary();
dictionary.Insert (singleton, crc);
}