bool matchesPattern( const char* pattern )
{
U32 indexInName = 0;
U32 indexInPattern = 0;
while( mName[ indexInName ] != '\0' )
{
if( pattern[ indexInPattern ] == '\0' )
break;
else if( dToupper( mName[ indexInName ] ) == dToupper( pattern[ indexInPattern ] ) )
{
indexInName ++;
indexInPattern ++;
}
else if( pattern[ indexInPattern ] == '*' )
{
// Handle senseless concatenation of wildcards.
while( pattern[ indexInPattern ] == '*' )
indexInPattern ++;
// Skip to next slash in name.
while( mName[ indexInName ] && mName[ indexInName ] != '/' )
indexInName ++;
}
else
return false;
}
return ( pattern[ indexInPattern ] == '\0'
|| ( indexInPattern > 0 && pattern[ indexInPattern ] == '*' ) );
}
const char* dStrichr( const char* str, char ch )
{
AssertFatal( str != NULL, "dStrichr - NULL string" );
if( !ch )
return dStrchr( str, ch );
char c = dToupper( ch );
while( *str )
{
if( dToupper( *str ) == c )
return str;
++ str;
}
return NULL;
}
bool LightAnimData::AnimValue<COUNT>::animate(F32 time, F32 *output, bool multiply)
{
F32 scaledTime, lerpFactor, valueRange, keyFrameLerp;
U32 posFrom, posTo;
S32 keyFrameFrom, keyFrameTo;
F32 initialValue = *output;
if (!multiply)
initialValue = 1;
bool wasAnimated = false;
for ( U32 i=0; i < COUNT; i++ )
{
if ( mIsZero( timeScale[i] ) )
continue;
wasAnimated = true;
scaledTime = mFmod( time, period[i] ) * timeScale[i];
posFrom = mFloor( scaledTime );
posTo = mCeil( scaledTime );
keyFrameFrom = dToupper( keys[i][posFrom] ) - 65;
keyFrameTo = dToupper( keys[i][posTo] ) - 65;
valueRange = ( value2[i] - value1[i] ) / 25.0f;
if ( !smooth[i] )
output[i] = (value1[i] + (keyFrameFrom * valueRange)) * initialValue;
else
{
lerpFactor = scaledTime - posFrom;
keyFrameLerp = ( keyFrameTo - keyFrameFrom ) * lerpFactor;
output[i] = (value1[i] + ((keyFrameFrom + keyFrameLerp) * valueRange)) * initialValue;
}
}
return wasAnimated;
}
static inline nat_char
nat_toupper( nat_char a )
{
return dToupper( a );
}
static void _assignCommandKeys(const char* accel, MenuRef menu, MenuItemIndex item)
{
if(!(accel && *accel))
return;
// get the modifier keys
String _accel = String::ToLower( accel );
int mods = _getModifierMask(_accel);
// accel is space or dash delimted.
// the modifier key is either the last token in accel, or the first char in accel.
const char* key = dStrrchr(_accel, ' ');
if(!key)
key = dStrrchr(_accel, '-');
if(!key)
key = _accel;
else
key++;
if(dStrlen(key) <= 1)
{
char k = dToupper( key[0] );
SetMenuItemCommandKey( menu, item, false, k );
}
else
{
SInt16 glyph = kMenuNullGlyph;
//*** A lot of these mappings came from a listing at http://developer.apple.com/releasenotes/Carbon/HIToolboxOlderNotes.html
if(!dStricmp(key, "DELETE"))
glyph = kMenuDeleteRightGlyph;
else if(!dStricmp(key, "HOME"))
glyph = kMenuNorthwestArrowGlyph;
else if(!dStricmp(key, "END"))
glyph = kMenuSoutheastArrowGlyph;
else if(!dStricmp(key, "BACKSPACE"))
glyph = kMenuDeleteLeftGlyph;
else if(!dStricmp(key, "TAB"))
glyph = kMenuTabRightGlyph;
else if(!dStricmp(key, "RETURN"))
glyph = kMenuReturnGlyph;
else if(!dStricmp(key, "ENTER"))
glyph = kMenuEnterGlyph;
else if(!dStricmp(key, "PG UP"))
glyph = kMenuPageUpGlyph;
else if(!dStricmp(key, "PG DOWN"))
glyph = kMenuPageDownGlyph;
else if(!dStricmp(key, "ESC"))
glyph = kMenuEscapeGlyph;
else if(!dStricmp(key, "LEFT"))
glyph = kMenuLeftArrowGlyph;
else if(!dStricmp(key, "RIGHT"))
glyph = kMenuRightArrowGlyph;
else if(!dStricmp(key, "UP"))
glyph = kMenuUpArrowGlyph;
else if(!dStricmp(key, "DOWN"))
glyph = kMenuDownArrowGlyph;
else if(!dStricmp(key, "SPACE"))
glyph = kMenuSpaceGlyph;
else if(!dStricmp(key, "F1"))
glyph = kMenuF1Glyph;
else if(!dStricmp(key, "F2"))
glyph = kMenuF2Glyph;
else if(!dStricmp(key, "F3"))
glyph = kMenuF3Glyph;
else if(!dStricmp(key, "F4"))
glyph = kMenuF4Glyph;
else if(!dStricmp(key, "F5"))
glyph = kMenuF5Glyph;
else if(!dStricmp(key, "F6"))
glyph = kMenuF6Glyph;
else if(!dStricmp(key, "F7"))
glyph = kMenuF7Glyph;
else if(!dStricmp(key, "F8"))
glyph = kMenuF8Glyph;
else if(!dStricmp(key, "F9"))
glyph = kMenuF9Glyph;
else if(!dStricmp(key, "F10"))
glyph = kMenuF10Glyph;
else if(!dStricmp(key, "F11"))
glyph = kMenuF11Glyph;
else if(!dStricmp(key, "F12"))
glyph = kMenuF12Glyph;
else if(!dStricmp(key, "F13"))
glyph = kMenuF13Glyph;
else if(!dStricmp(key, "F14"))
glyph = kMenuF14Glyph;
else if(!dStricmp(key, "F15"))
glyph = kMenuF15Glyph;
SetMenuItemKeyGlyph(menu, item, glyph);
}
SetMenuItemModifiers(menu, item, mods);
}
void XMLExport::exportNamespaces()
{
// keep track of which enumTables are in use
Vector < const EnumTable*> enumTables;
mXML->pushNewElement("Namespaces");
for (Namespace *walk = Namespace::mNamespaceList; walk; walk = walk->mNext)
{
if ( walk->mName && !walk->isClass() )
continue;
const char *name = walk->mName ? walk->mName : "";
mXML->pushNewElement("Namespace");
mXML->setAttribute("name", name);
Namespace *p = walk->mParent;
mXML->pushNewElement("Parents");
while (p)
{
if (p->mName == walk->mName)
{
p = p->mParent;
continue;
}
const char* pname = p->mName ? p->mName : "";
mXML->pushNewElement("Parent");
mXML->setAttribute("name", pname);
mXML->popElement(); // Parent
p = p->mParent;
}
mXML->popElement(); // Parents
// Entries (Engine/Script Methods/Functions)
mXML->pushNewElement("Entries");
Namespace::Entry *entry;
VectorPtr<Namespace::Entry *> vec;
walk->getEntryList(&vec);
for( NamespaceEntryListIterator compItr = vec.begin(); compItr != vec.end(); compItr++ )
{
entry = *compItr;
if (entry->mNamespace != walk)
continue;
if (entry->mNamespace->mName != walk->mName)
continue;
mXML->pushNewElement("Entry");
//consistently name functions
char functionName[512];
dSprintf(functionName, 512, entry->mFunctionName);
functionName[0] = dTolower(functionName[0]);
S32 minArgs = entry->mMinArgs;
S32 maxArgs = entry->mMaxArgs;
if (maxArgs < minArgs)
maxArgs = minArgs;
mXML->setAttribute("name", functionName);
mXML->setAttribute("minArgs", avar("%i", minArgs));
mXML->setAttribute("maxArgs", avar("%i", maxArgs));
const char* usage = "";
if (entry->mUsage && entry->mUsage[0])
usage = entry->mUsage;
mXML->setAttribute("usage", usage);
mXML->setAttribute("package", entry->mPackage ? entry->mPackage : "");
mXML->setAttribute("entryType", avar("%i", entry->mType));
mXML->popElement(); // Entry
}
mXML->popElement(); // Entries
// Fields
mXML->pushNewElement("Fields");
AbstractClassRep *rep = walk->mClassRep;
Vector<U32> classFields;
if (rep)
{
AbstractClassRep *parentRep = rep->getParentClass();
const AbstractClassRep::FieldList& flist = rep->mFieldList;
for(U32 i = 0; i < flist.size(); i++)
{
if (parentRep)
{
if (parentRep->findField(flist[i].pFieldname))
continue;
}
classFields.push_back(i);
}
for(U32 i = 0; i < classFields.size(); i++)
{
U32 index = classFields[i];
char fieldName[256];
dSprintf(fieldName, 256, flist[index].pFieldname);
//consistently name fields
fieldName[0] = dToupper(fieldName[0]);
mXML->pushNewElement("Field");
mXML->setAttribute("name", fieldName);
mXML->setAttribute("type", avar("%i", flist[index].type));
// RD: temporarily deactivated; TypeEnum is no more; need to sync this up
// if (flist[index].type == TypeEnum && flist[index].table && dStrlen(flist[index].table->name))
// {
// if (!enumTables.contains(flist[index].table))
// enumTables.push_back(flist[index].table);
//
// mXML->setAttribute("enumTable", flist[index].table->name);
//
// }
const char* pFieldDocs = "";
if (flist[index].pFieldDocs && flist[index].pFieldDocs[0])
pFieldDocs = flist[index].pFieldDocs;
mXML->setAttribute("docs", pFieldDocs);
mXML->setAttribute("elementCount", avar("%i", flist[index].elementCount));
mXML->popElement(); // Field
}
}
mXML->popElement(); // Fields
mXML->popElement(); // Namespace
}
mXML->popElement(); // Namespaces
mXML->pushNewElement("EnumTables");
// write out the used EnumTables
for (S32 i = 0; i < enumTables.size(); i++)
{
mXML->pushNewElement("EnumTable");
const EnumTable* table = enumTables[i];
mXML->setAttribute("name", table->name);
mXML->setAttribute("firstFlag", avar("%i", table->firstFlag));
mXML->setAttribute("mask", avar("%i", table->mask));
mXML->pushNewElement("Enums");
for (S32 j = 0; j < table->size; j++)
{
mXML->pushNewElement("Enum");
mXML->setAttribute("name", table->table[j].label);
mXML->setAttribute("index", avar("%i", table->table[j].index));
mXML->popElement(); // Enum
}
mXML->popElement(); //Enums
mXML->popElement(); // EnumTable
}
mXML->popElement(); // EnumTables
}
inline bool IsCharMatch( char e, char s, bool caseSensitive )
{
return ( ( e == '?' ) || ( caseSensitive && e == s ) || ( dToupper(e) == dToupper(s) ) );
}
