void run()
{
for( AbstractClassRep* classRep = AbstractClassRep::getClassList();
classRep != NULL;
classRep = classRep->getNextClass() )
{
// Create object.
ConsoleObject* object = classRep->create();
test( object, avar( "AbstractClassRep::create failed for class '%s'", classRep->getClassName() ) );
if( !object )
continue;
// Make sure it's a SimObject.
SimObject* simObject = dynamic_cast< SimObject* >( object );
if( !simObject )
{
SAFE_DELETE( object );
continue;
}
// Register the object.
bool result = simObject->registerObject();
test( result, avar( "registerObject failed for object of class '%s'", classRep->getClassName() ) );
if( result )
simObject->deleteObject();
else
SAFE_DELETE( simObject );
}
}
void SimDataBlockEvent::unpack(NetConnection *cptr, BitStream *bstream)
{
if(bstream->readFlag())
{
mProcess = true;
id = bstream->readInt(DataBlockObjectIdBitSize) + DataBlockObjectIdFirst;
S32 classId = bstream->readClassId(NetClassTypeDataBlock, cptr->getNetClassGroup());
mIndex = bstream->readInt(DataBlockObjectIdBitSize);
mTotal = bstream->readInt(DataBlockObjectIdBitSize + 1);
SimObject* ptr;
if( Sim::findObject( id, ptr ) )
{
// An object with the given ID already exists. Make sure it has the right class.
AbstractClassRep* classRep = AbstractClassRep::findClassRep( cptr->getNetClassGroup(), NetClassTypeDataBlock, classId );
if( classRep && dStrcmp( classRep->getClassName(), ptr->getClassName() ) != 0 )
{
Con::warnf( "A '%s' datablock with id: %d already existed. "
"Clobbering it with new '%s' datablock from server.",
ptr->getClassName(), id, classRep->getClassName() );
ptr->deleteObject();
ptr = NULL;
}
}
if( !ptr )
ptr = ( SimObject* ) ConsoleObject::create( cptr->getNetClassGroup(), NetClassTypeDataBlock, classId );
mObj = dynamic_cast< SimDataBlock* >( ptr );
if( mObj != NULL )
{
#ifdef DEBUG_SPEW
Con::printf(" - SimDataBlockEvent: unpacking event of type: %s", mObj->getClassName());
#endif
mObj->unpackData( bstream );
}
else
{
#ifdef DEBUG_SPEW
Con::printf(" - SimDataBlockEvent: INVALID PACKET! Could not create class with classID: %d", classId);
#endif
delete ptr;
cptr->setLastError("Invalid packet in SimDataBlockEvent::unpack()");
}
#ifdef TORQUE_DEBUG_NET
U32 checksum = bstream->readInt(32);
AssertISV( (checksum ^ DebugChecksum) == (U32)classId,
avar("unpack did not match pack for event of class %s.",
mObj->getClassName()) );
#endif
}
}
S32 script_simobject_find(const char* classname, const char* name)
{
SimObject *object;
if( Sim::findObject( name, object ) )
{
// if we specified a classname do type checking
if (classname && dStrlen(classname))
{
AbstractClassRep* ocr = object->getClassRep();
while (ocr)
{
if (!dStricmp(ocr->getClassName(), classname))
return object->getId();
ocr = ocr->getParentClass();
}
}
// invalid type
return 0;
}
// didn't find object
return 0;
}
void EditorIconRegistry::loadFromPath( const String &path, bool overwrite )
{
AbstractClassRep *classRep = AbstractClassRep::getClassList();
while ( classRep )
{
String iconFile = String::ToString( "%s%s", path.c_str(), classRep->getClassName() );
add( classRep->getClassName(), iconFile.c_str(), overwrite );
classRep = classRep->getNextClass();
}
String defaultIconFile = path + "default";
mDefaultIcon.set( defaultIconFile,
&GFXDefaultPersistentProfile,
avar("%s() - mIcons[] (line %d)",
__FUNCTION__, __LINE__) );
}
bool EditorIconRegistry::hasIconNoRecurse( const SimObject *object )
{
AbstractClassRep *classRep = object->getClassRep();
StringNoCase key( classRep->getClassName() );
IconMap::Iterator icon = mIcons.find( key );
return icon != mIcons.end();
}
AbstractClassRep* AbstractClassRep::findClassRep(const char* in_pClassName)
{
AssertFatal(initialized,
"AbstractClassRep::findClassRep() - Tried to find an AbstractClassRep before AbstractClassRep::initialize().");
for (AbstractClassRep *walk = classLinkList; walk; walk = walk->nextClass)
if (!dStricmp(walk->getClassName(), in_pClassName))
return walk;
return NULL;
}
void TypeValidator::consoleError(SimObject *object, const char *format, ...)
{
char buffer[1024];
va_list argptr;
va_start(argptr, format);
dVsprintf(buffer, sizeof(buffer), format, argptr);
va_end(argptr);
AbstractClassRep *rep = object->getClassRep();
AbstractClassRep::Field &fld = rep->mFieldList[fieldIndex];
const char *objectName = object->getName();
if(!objectName)
objectName = "unnamed";
Con::warnf("%s - %s(%d) - invalid value for %s: %s",
rep->getClassName(), objectName, object->getId(), fld.pFieldname, buffer);
}
void GuiInspectorDatablockField::setClassName( StringTableEntry className )
{
// Walk the ACR list and find a matching class if any.
AbstractClassRep *walk = AbstractClassRep::getClassList();
while(walk)
{
if(!dStricmp(walk->getClassName(), className))
{
// Match!
mDesiredClass = walk;
return;
}
walk = walk->getNextClass();
}
// No dice.
Con::warnf("GuiInspectorDatablockField::setClassName - no class '%s' found!", className);
return;
}
GFXTexHandle EditorIconRegistry::findIcon( const char *className )
{
// On the chance we have this className already in the map,
// check there first because its a lot faster...
StringNoCase key( className );
IconMap::Iterator icon = mIcons.find( key );
if ( icon != mIcons.end() && icon->value.isValid() )
return icon->value;
// Well, we could still have an icon for a parent class,
// so find the AbstractClassRep for the className.
//
// Unfortunately the only way to do this is looping through
// the AbstractClassRep linked list.
bool found = false;
AbstractClassRep* pClassRep = AbstractClassRep::getClassList();
while ( pClassRep )
{
if ( key.equal( pClassRep->getClassName(), String::NoCase ) )
{
found = true;
break;
}
pClassRep = pClassRep->getNextClass();
}
if ( !found )
{
Con::errorf( "EditorIconRegistry::findIcon, passed className %s was not an AbstractClassRep!", key.c_str() );
return mDefaultIcon;
}
// Now do a find by AbstractClassRep recursively up the class tree...
return findIcon( pClassRep );
}
void AbstractClassRep::initialize()
{
AssertFatal(!initialized, "Duplicate call to AbstractClassRep::initialize()!");
Vector<AbstractClassRep *> dynamicTable(__FILE__, __LINE__);
AbstractClassRep *walk;
// Initialize namespace references...
for (walk = classLinkList; walk; walk = walk->nextClass)
{
walk->mNamespace = Con::lookupNamespace(StringTable->insert(walk->getClassName()));
walk->mNamespace->mUsage = walk->getDocString();
walk->mNamespace->mClassRep = walk;
}
// Initialize field lists... (and perform other console registration).
for (walk = classLinkList; walk; walk = walk->nextClass)
{
// sg_tempFieldList is used as a staging area for field lists
// (see addField, addGroup, etc.)
sg_tempFieldList.setSize(0);
walk->init();
// So if we have things in it, copy it over...
if (sg_tempFieldList.size() != 0)
walk->mFieldList = sg_tempFieldList;
// And of course delete it every round.
sg_tempFieldList.clear();
}
// Calculate counts and bit sizes for the various NetClasses.
for (U32 group = 0; group < NetClassGroupsCount; group++)
{
U32 groupMask = 1 << group;
// Specifically, for each NetClass of each NetGroup...
for(U32 type = 0; type < NetClassTypesCount; type++)
{
// Go through all the classes and find matches...
for (walk = classLinkList; walk; walk = walk->nextClass)
{
if(walk->mClassType == type && walk->mClassGroupMask & groupMask)
dynamicTable.push_back(walk);
}
// Set the count for this NetGroup and NetClass
NetClassCount[group][type] = dynamicTable.size();
if(!NetClassCount[group][type])
continue; // If no classes matched, skip to next.
// Sort by type and then by name.
dQsort((void *) &dynamicTable[0], dynamicTable.size(), sizeof(AbstractClassRep *), ACRCompare);
// Allocate storage in the classTable
classTable[group][type] = new AbstractClassRep*[NetClassCount[group][type]];
// Fill this in and assign class ids for this group.
for(U32 i = 0; i < NetClassCount[group][type];i++)
{
classTable[group][type][i] = dynamicTable[i];
dynamicTable[i]->mClassId[group] = i;
}
// And calculate the size of bitfields for this group and type.
NetClassBitSize[group][type] =
getBinLog2(getNextPow2(NetClassCount[group][type] + 1));
AssertFatal(NetClassCount[group][type] < (1 << NetClassBitSize[group][type]), "NetClassBitSize too small!");
dynamicTable.clear();
}
}
// Ok, we're golden!
initialized = true;
}
void TamlBinaryReader::parseChildren( Stream& stream, TamlCallbacks* pCallbacks, SimObject* pSimObject, const U32 versionId )
{
// Debug Profiling.
PROFILE_SCOPE(TamlBinaryReader_ParseChildren);
// Sanity!
AssertFatal( pSimObject != NULL, "Taml: Cannot parse children on a NULL object." );
// Fetch children count.
U32 childrenCount;
stream.read( &childrenCount );
// Finish if no children.
if ( childrenCount == 0 )
return;
// Fetch the Taml children.
TamlChildren* pChildren = dynamic_cast<TamlChildren*>( pSimObject );
// Is this a sim set?
if ( pChildren == NULL )
{
// No, so warn.
Con::warnf("Taml: Child element found under parent but object cannot have children." );
return;
}
// Fetch any container child class specifier.
AbstractClassRep* pContainerChildClass = pSimObject->getClassRep()->getContainerChildClass( true );
// Iterate children.
for ( U32 index = 0; index < childrenCount; ++ index )
{
// Parse child element.
SimObject* pChildSimObject = parseElement( stream, versionId );
// Finish if child failed.
if ( pChildSimObject == NULL )
return;
// Do we have a container child class?
if ( pContainerChildClass != NULL )
{
// Yes, so is the child object the correctly derived type?
if ( !pChildSimObject->getClassRep()->isClass( pContainerChildClass ) )
{
// No, so warn.
Con::warnf("Taml: Child element '%s' found under parent '%s' but object is restricted to children of type '%s'.",
pChildSimObject->getClassName(),
pSimObject->getClassName(),
pContainerChildClass->getClassName() );
// NOTE: We can't delete the object as it may be referenced elsewhere!
pChildSimObject = NULL;
// Skip.
continue;
}
}
// Add child.
pChildren->addTamlChild( pChildSimObject );
// Find Taml callbacks for child.
TamlCallbacks* pChildCallbacks = dynamic_cast<TamlCallbacks*>( pChildSimObject );
// Do we have callbacks on the child?
if ( pChildCallbacks != NULL )
{
// Yes, so perform callback.
mpTaml->tamlAddParent( pChildCallbacks, pSimObject );
}
}
}
GuiInspectorField* GuiInspectorGroup::constructField( S32 fieldType )
{
// See if we can construct a field of this type
ConsoleBaseType *cbt = ConsoleBaseType::getType(fieldType);
if( !cbt )
return NULL;
// Alright, is it a datablock?
if(cbt->isDatablock())
{
// Default to GameBaseData
StringTableEntry typeClassName = cbt->getTypeClassName();
if( mParent->getNumInspectObjects() == 1 && !dStricmp(typeClassName, "GameBaseData") )
{
// Try and setup the classname based on the object type
char className[256];
dSprintf(className,256,"%sData", mParent->getInspectObject( 0 )->getClassName());
// Walk the ACR list and find a matching class if any.
AbstractClassRep *walk = AbstractClassRep::getClassList();
while(walk)
{
if(!dStricmp(walk->getClassName(), className))
break;
walk = walk->getNextClass();
}
// We found a valid class
if (walk)
typeClassName = walk->getClassName();
}
GuiInspectorDatablockField *dbFieldClass = new GuiInspectorDatablockField( typeClassName );
if( dbFieldClass != NULL )
{
// return our new datablock field with correct datablock type enumeration info
return dbFieldClass;
}
}
// Nope, not a datablock. So maybe it has a valid inspector field override we can use?
if(!cbt->getInspectorFieldType())
// Nothing, so bail.
return NULL;
// Otherwise try to make it!
ConsoleObject *co = create(cbt->getInspectorFieldType());
GuiInspectorField *gif = dynamic_cast<GuiInspectorField*>(co);
if(!gif)
{
// Wasn't appropriate type, bail.
delete co;
return NULL;
}
return gif;
}