Note: I have omitted the namespace prefixes and ‘using namespace xxx’ statements in the code below to improve readability. Also, since I didn’t run the code through a compiler, there may be a lot of typos.
Don’t be confused by Rtti vs. RTTI:
Rtti is the class name, MyClass::RTTI is the name of the Rtti-object of a class. Every RefCounted derived class has exactly one static instance of Core::Rtti, which is initialized before main() is entered.
Check whether an object is an instance of a specific, or of a derived class:
This is the standard feature of the Nebula3 RTTI system, checking whether an object can safely be cast to a specific class interface:
// check whether obj is instance of a specific class:
if (obj->IsInstanceOf(MyClass::RTTI)) …
// check whether obj is instance of class, or a derived class:
Compared to Nebula2, N3’s RTTI check is extremely fast (in N2, it was necessary to convert a class name string into a pointer first before doing the check). In N3, RTTI checks are simple pointer comparisons. The IsA() method is a bit slower if the class doesn’t match since it needs to walk the inheritance hierarchy towards the root. Because of this it is always better to use the IsInstanceOf() method if possible, since this is always only a single pointer comparison.
Both methods also exist as class-name and class-fourcc versions, but of course these are both slower then the methods which directly work with the RTTI objects:
if (obj->IsInstanceOf(“MyNamespace::MyClass”)) …
Using Ptr<> cast methods for safe-casting:
The Ptr<> class comes with 3 cast methods, 2 for safe up- and down-casts, and one unsafe-but-fast C-style cast. To do a down-cast (from a general parent class down to a specialized sub-class) you can do this:
// assume that res is a Ptr<Resource>, and safely down-cast
// it to a Ptr<D3D9Texture> (D3D9Texture is a subclass of Resource):
const Ptr<D3D9Texture>& d3d9Tex = res.downcast<D3D9Texture>();
This will generate a runtime-error if tex is not a D3D9Texture object.
Safely casting upwards in the inheritance hierarchy works as well:
const Ptr<Resource>& res = d3d9Tex.upcast<Resource>();
An unsafe C-style cast is done like this:
const Ptr<Resource>& res = d3d9Tex.cast<Resource>();
An unsafe cast is the fastest (in release mode, the compiler should optimize the method call into nothing), but of course it also makes it extremely easy to shoot yourself in the foot. The 2 safe-cast methods call the Rtti::IsDerivedFrom() method, no temporary Ptr<> object will be created since they return a const-ref.
Query RTTI objects directly:
You can directly query many class properties without having an actual object of the class around:
// get the name of a class:
const String& className = MyClass::RTTI.GetName();
// get the FourCC identifier of aclass:
FourCC classFourCC = MyClass::RTTI.GetFourCC();
// get a pointer to the Rtti object of the parent class
// (returns 0 when called on RefCounted::RTTI)
Rtti* parentRtti = MyClass::RTTI.GetParent();
// check if a class is derived from this class:
// by Rtti object:
if (MyClass::RTTI.IsDerivedFrom(OtherClass::RTTI)) …
// by class name:
if (MyClass::RTTI.IsDerivedFrom(“MyNamespace::OtherClass”)) …
// by class fourcc:
You can check two Rtti objects for equality or inequality:
const Rtti& otherRtti = …;
if (MyClass::RTTI == otherRtti)…
if (MyClass::RTTI != otherRtti)…
Since it is guaranteed that only one Rtti object exists per class this is equivalent with comparing the addresses of 2 Rtti objects (and that’s in fact what the equality and inequality operators do internally).
Create objects directly through the RTTI object:
Ptr<MyClass> myObj = (MyClass*) MyClass::RTTI.Create();
The old-school C-style cast looks a bit out of place but is currently necessary because the Rtti::Create() method returns a raw pointer, not a smart-pointer.
Creating an object through the RTTI object instead of the static MyClass::Create() method is useful if you want to hand the type of an object as an argument to a method call like this:
Ptr<RefCounted> CreateObjectOfAnyClass(const Rtti& rtti)
This is a lot faster then the 2 other alternatives, creating the object through its class name or class fourcc identifier.
Create objects by class name or FourCC identifier
You can use the Core::Factory singleton to create RefCounted-derived objects by class name or by a FourCC identifier:
Ptr<MyClass> obj = (MyClass*) Factory::Instance()->Create(“MyNamespace::MyClass”);
Ptr<MyClass> obj = (MyClass*) Factory::Instance()->Create(FourCC(‘MYCL’));
This is mainly useful for serialization code, or if the type of an object must be communicated over a network connection.
Lookup the RTTI object of a class through the Core::Factory singleton
You can get a pointer to the static RTTI object of a class by class name or class FourCC identifier:
const Rtti* rtti = Factory::Instance()->GetClassRtti(“MyNamespace::MyClass”);
const Rtti* rtti = Factory::Instance()->GetClassRtti(FourCC(‘MYCL’));
This will fail hard if the class doesn’t exist, you can check whether a class has been registered with the factory using the ClassExists() methods:
bool classExists = Factory::Instance()->ClassExists(“MyNamespace::MyClass”);
bool classExists = Factory::Instance()->ClassExists(FourCC(‘MYCL’));
There are 2 common problems with Nebula3’s RTTI system.
When writing a new class, it may happen that the FourCC code of the class is already taken. In this case, an error dialog will popup at application start which looks like this:
To fix this collision, change the FourCC code of one of the affected classes and recompile.
The other problem is that a class doesn’t register at application startup because the constructor of its static RTTI object has been “optimized away” by the linker. This happens when there’s no actual C++ code in the application which directly uses this class. This is the case if an object is created through N3’s create-by-class-name or create-by-class-fourcc mechanism and the class is only accessed indirectly through virtual method calls.
In this case the linker will drop the .obj module of this class completely since there are no calls from the outside into the object module. That’s a neat optimization to keep the executable size small, and it works great with the static object model of plain C++, but with Nebula3’s dynamic object model we need to trick the linker into linking “unused” classes into the executable. We don’t have to do this for every RefCounted-derived class fortunately, only for specific parts of the inheritance hierarchy (for instance subclasses of ModelNode and ModelNodeInstance in the Render layer, or subclasses of Property in the Application layer)
To prevent the linker from dropping a class the following procedure is recommended:
- add a __RegisterClass(MyClass) macro to a central .h ‘class registry’ header file
- include this header file into a .cc file which definitely won’t be dropped by the linker
The header file /nebula3/code/render/render_classregistry.h is an example for such a centralized class registry header.