store the model and animation data in less space: the (sometimes extremely) reduced footprint in memory and on disk of the animation is caused by the fact that the animation data (tipically) consists of only one mesh (a series of vertices and faces) in a well-known "pose" and the skeletal data, that is made up of "weights" and transformation info. Instead of storing for each "keyframe" a "snapshot" of the positions of all the model vertices in order to obtain at runtime the final xyz coordinates through linear interpolation between keys, in the skeletal case the position of each vertex in 3D space is calculated taking into account the influences of one or more "bone" from the character "skeleton" on each vertex of that single "pose" mesh. For a complete description of this animation method I advise to search the web for related articles and examples (before looking at my code).
	have more accurate and smooth animations than in the case of simple linear interpolation between keyframed meshes.

	checking out the C++ strong object oriented implementation of the CNode class that is used for:      calculating for each "GEOMOBJ" the final transformation matrix given a time value, before the rendering phase (EvalWorldState method).      rendering the node graph to the current OpenGL rendering context (Render method).      dumping the node graph details to a tree control identified by an HWND handle (DumpInTreeCtrl method)
	viewing how to write a MFC application that renders 3D content in a view/window using OpenGL.
	checking out the implementation of interesting MFC custom CWnd classes such as CTimeSlider, that implements a sliding button used for setting the current frame position for the active animation in the style of those seen in 3DStudio.
	checking out the implementation and employment of typical math classes and objects used in real-world games for representing and manipulating matrices, vectors, planes and quaternions.

CSceneRoot*       pSR = new CSceneRoot( (anim_stream_desc_t* ) pbAnim );
if ( pSR-> m_bCorrupt != FALSE )
{
      delete pSR; // the pbAnim data is corrupt.
}
else
{
      // pSR can be consumed...
}

At this point, the rendering methods can be invoked on pSR in order to render the animation in an OpenGL rendering context. The first step for doing this is to call the EvalWorldState method specifying the time value at which the scene has to be "evaluated". This means that the required transformation matrices and animation data will be calculated for allowing the actual rendering phase to take place. Then the Render method itself has to be called: this method will use the precalculated EvalWorldState data for drawing in the OpenGL rendering context. The only parameter that is required when calling the Render method is the rendering mode that has to be used. The following values can be specified:

enum ERenderMode {
      eWireframe,
      eSolid,
      eTexture,
      eSolidPlusWireframe,
      eWireframeSpecialGreen,
      eWireframeSpecialRed
};

For a real example of the steps described above, check out the OnPaint implementation of the CAnimOpenGLRenderer class. This method contains also the various calls to the OpenGL library required for setting up the projection and transformation matrices and the z-buffer and lighting configuration.

USING THE EXAMPLE APPLICATION

For using the plugin, install 3DStudio MAX 3.1 and optionally Character Studio 2.2. Then copy in the plugin directory of 3DStudio MAX (named "Plugins") the MSC.dlu file. After that, you can export 3DStudio MAX animations directly from the program interface activating the "MapGen Server Control" plugin from the "Utilities" pane of the program and then pressing the "export" button. Make sure to launch on the local machine or on a DCOM reachable machine on the network the MFC Example Application (name "Renderer.exe") before doing anything. The Example Application will setup a DCOM server with CLSID equal to "CLSID_MapGenModeler" listening for incoming connections from the plugin module.

The workspace files in the archive included with this article were created with Visual Studio 6.0. I guess that converting them for a newer version of Visual Studio will not be a problem. For compiling or recompiling the example application, make sure to do the following:

	Specify in Visual Studio, in the "Include Files" window, the path to the "Renderer\Include\BCG464" folder.
	Specify in Visual Studio, in the "Library Files" window, the path to the "Renderer\Lib" folder.

DOWNLOAD

Download the SCR Application (binaries only) from here (871KB).
Download the SCR Application (plus source code) from here (1611KB).