RmEffect.h

Go to the documentation of this file.

//=============================================================================
//=============================================================================
//=============================================================================

#ifndef _RM_CORE_EFFECT_H_
#define _RM_CORE_EFFECT_H_

#include <Core/RmTypes.h>
#include <Core/RmDefines.h>
#include <Core/RmMath.h>
#include <Core/RmMatrix.h>
#include <Core/RmStringToPtr.h>
#include <Core/RmLinkedList.h>
#include <Core/RmArray.h>
#include <Core/RmSurface.h>
#include <Core/RmVolume.h>

//=============================================================================
//=============================================================================

class RmMeshModelContainer;

//=============================================================================
// This structure is used to define a parent / child relationship between nodes.
// It is necessary to use to ensure proper data organization within an effect   
// workspace. Only the main application can modify / set these relationships.   
//=============================================================================
struct RmNodeTypeChildRuleStruct  
{
   RmNodeTypeChildRuleStruct() :
      pStrNodeTypeChain( NULL ),
      nMinNumChildren( 0 ),
      nMaxNumChildren( 0 )
   {
   };

   ~RmNodeTypeChildRuleStruct()
   {
      if ( pStrNodeTypeChain != NULL )
      {
         RmStrFreeT( pStrNodeTypeChain );
      }

      pStrNodeTypeChain = NULL;
   }

   RM_TCHAR  *pStrNodeTypeChain;
   int        nMinNumChildren;
   int        nMaxNumChildren;

}; // End of RmNodeTypeChildRuleStruct declaration and definition

typedef RmLinkedList< RmNodeTypeChildRuleStruct* >       RmNodeTypeChildRuleList;
typedef RmNodeTypeChildRuleList::iterator                RmNodeTypeChildRuleListIterator;
typedef RmNodeTypeChildRuleList::const_iterator          RmNodeTypeChildRuleListConstIterator;

typedef RmLinkedList< RmNodeTypeChildRuleList* >         RmListOfNodeTypeChildRuleLists;
typedef RmListOfNodeTypeChildRuleLists::iterator         RmListOfNodeTypeChildRuleListsIterator;
typedef RmListOfNodeTypeChildRuleLists::const_iterator   RmListOfNodeTypeChildRuleListsConstIterator;

class RmNode;
class RmEffectWorkspace;

typedef RmLinkedList<RmNode *>       RmNodeList;
typedef RmNodeList::iterator         RmNodeListIterator;
typedef RmNodeList::const_iterator   RmNodeListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmNode
{     
public:

   //==========================================================================
   //==========================================================================
   RmNode();

   //==========================================================================
   //==========================================================================
   RmNode( const RM_TCHAR* strName, bool bHidden = false );

   //==========================================================================
   //==========================================================================
   RmNode( RmNode* pParentNode, const RM_TCHAR* strName, bool bHidden = false );

   //==========================================================================
   //==========================================================================
   virtual ~RmNode();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType  nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, 
                        RmNode           *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual void CopyNode(  RmNode   *pDestinationNode,
                           bool     bUnregisterDestinationNode,
                           bool     bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void CopyBranch(   RmNode   *pDestinationNode,
                              bool     bUnregisterDestinationNode,
                              bool     bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   void  AddNodeTypeChildRule( const RM_TCHAR *pStrNodeType,
                               const int       nMinNumChildren,
                               const int       nMaxNumChildren );

   //==========================================================================
   //==========================================================================
   void  RemoveNodeTypeChildRule( const RM_TCHAR *pStrNodeType );

   //==========================================================================
   //==========================================================================
   bool  IsValidOwner(  const RM_TCHAR *pStrNodeTypeChain,
                        const RM_TCHAR *pStrAPI,
                        int            *pMaxNumChildrenOfType = NULL );

   //==========================================================================
   //==========================================================================
   bool LoadXMLNode( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLNode( int hDoc, const RM_TCHAR *strXPath )
   {
      return( SaveXMLNode( hDoc, strXPath, true ) );
   }

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual void SetDescription( const RM_TCHAR* pStrDescription ) { m_strUserDescription = pStrDescription; };

   //==========================================================================
   //==========================================================================
   const RmStringT& GetType();

   //==========================================================================
   //==========================================================================
   const RmStringT& GetTypeChain() const                { return m_strTypeChain; }

   //==========================================================================
   //==========================================================================
   bool IsKindOf( const RM_TCHAR* pStrType );

   //==========================================================================
   //==========================================================================
   const RmStringT& GetName()     const                 {  return m_strName;                     }
   
   //==========================================================================
   //==========================================================================
   const RmStringT& GetNameChain();

   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );

   //==========================================================================
   //==========================================================================
   const RmStringT& GetAPI()  const                {      return m_strAPI;                  }
  
   //==========================================================================
   //==========================================================================
   bool  IsHidden();
  
   //==========================================================================
   //==========================================================================
   RmNode* GetParent()                             {     return m_pParent;                  }

   //==========================================================================
   //==========================================================================
   void SetParent( RmNode* pParentNode )           {      m_pParent = pParentNode;          }

   //==========================================================================
   //==========================================================================
   int GetNumChildren()                               {     return m_childrenList.size();       }

   //==========================================================================
   //==========================================================================
   bool  IsChild( RmNode* pChild );

   //==========================================================================
   //==========================================================================
   bool virtual AddChild( RmNode *pChildNode, RmNode *pNextSibling = NULL );

   //==========================================================================
   //==========================================================================
   void DeleteChild( RmNode *pChildNode );

   //==========================================================================
   //==========================================================================
   void DeleteAllChildren();

   //==========================================================================
   //==========================================================================
   void RemoveChild( RmNode *pChildNode );

   //==========================================================================
   //==========================================================================
   RmNodeList GetDescendantListByType( const RM_TCHAR* strNodeType );

   //==========================================================================
   //==========================================================================
   RmNodeList GetChildListByType( const RM_TCHAR* strNodeType );

   //==========================================================================
   //==========================================================================
   RmNode*    GetFirstChildOfType( const RM_TCHAR* strNodeType );

   //==========================================================================
   //==========================================================================
   RmNode*    GetFirstChildOfTypeNamed( const RM_TCHAR* strNodeType, const RM_TCHAR* strNodeName );

   //==========================================================================
   //==========================================================================
   RmNode*    GetFirstChildNamed( const RM_TCHAR* strNodeName );

   //==========================================================================
   //==========================================================================
   RmNode* GetChild( const RM_TCHAR* strChildName );

   //==========================================================================
   //==========================================================================
   RmNode* GetChild( int nIndex );

   //==========================================================================
   //==========================================================================
   int GetChildNodeIndex( RmNode *pChildNode );

   //==========================================================================
   //==========================================================================
   int GetChildNodeIndexByType( RmNode *pChildNode );

   //==========================================================================
   //==========================================================================
   int   GetNumDescendants();

   //==========================================================================
   //==========================================================================
   bool IsParentOf( RmNode* pDescendant );

   //==========================================================================
   //==========================================================================
   bool IsChildOfAncestor( RmNode* pChild );

   //==========================================================================
   //==========================================================================
   RmNode* GetNodeParent( const RM_TCHAR* strParentType );

   //==========================================================================
   //==========================================================================
   RmNode* GetDescendant( const RM_TCHAR* strNodeName, bool bUseNameChain = false );

   //==========================================================================
   //==========================================================================
   RmNode* GetDescendant( const RM_TCHAR* strNodeName, const RM_TCHAR* strType, bool bUseNameChain = false );

   //==========================================================================
   //==========================================================================
   virtual bool IsArtistEditable()                 { return false; };

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeNameValid( RmNode* pParent,
                                 const RM_TCHAR* pStrNodeName = NULL,
                                 const RM_TCHAR* pStrNodeType = NULL );
   
   //==========================================================================
   //==========================================================================
   void UpdateAll        ( RmNodeUpdateType  nodeUpdateType    /* default = RM_NODE_GENERAL_UPDATE */, 
                           RmNode           *pRmUpdateRootNode /* default = NULL */ );                      

   //==========================================================================
   //==========================================================================
   void UpdateAllChildren( RmNodeUpdateType  nodeUpdateType, RmNode *pRmUpdateRootNode );
   
   //==========================================================================
   //==========================================================================
   bool CheckAllNodeNames( RmLinkedList<RmStringT> *pStringList );

   //==========================================================================
   //==========================================================================
   void AutoInitializeNode();
   
   //==========================================================================
   //==========================================================================
   void TransferNode( RmNode* pDestinationNode );

   //==========================================================================
   //==========================================================================
   RmNode* SearchBackForNodeTypeNamed( const RM_TCHAR* strType, const RM_TCHAR* strName );

   //=========================================================================
   //==========================================================================
   RmNode* SearchBackForNodeType( const RM_TCHAR* strType );

   //==========================================================================
   //==========================================================================
   RmNode* SearchBackForNodeNamed( const RM_TCHAR* strName );

   //==========================================================================
   //==========================================================================
   RmNodeID GetNodeID() const    {     return m_nodeID;        };

   //==========================================================================
   //==========================================================================
   void  SetNodeID( RmNodeID id )           {     m_nodeID = id;          };

   //==========================================================================
   //==========================================================================
   void  InvalidateNodeID( bool bRecursive );

   //==========================================================================
   //==========================================================================
   RmNodeListIterator      BeginChildren()       {    return m_childrenList.begin();   };

   //==========================================================================
   //==========================================================================
   RmNodeListConstIterator BeginChildren() const {    return m_childrenList.begin();   };

   //==========================================================================
   //==========================================================================
   RmNodeListIterator      EndChildren()         {    return m_childrenList.end();     };

   //==========================================================================
   //==========================================================================
   RmNodeListConstIterator EndChildren()   const {    return m_childrenList.end();     };

   //==========================================================================
   //==========================================================================
   RmNodeTypeChildRuleListConstIterator BeginNodeTypeChildRule();

   //==========================================================================
   //==========================================================================
   RmNodeTypeChildRuleListConstIterator EndNodeTypeChildRule();
   
   //==========================================================================
   //==========================================================================
   static RmStringToPtrMap*   GetNodeTypeOrderMap();
   
   //==========================================================================
   //==========================================================================
   static void RmInitNodeTypeChildRuleLists();
   static void RmUninitializeNodeTypeChildRuleLists();

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType );

   //==========================================================================
   //==========================================================================
   void SetAPI( const RM_TCHAR* pStrAPI, bool bOverride = false );

   //==========================================================================
   //==========================================================================
   void  SetIsHidden( bool bHidden );
   
   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList()           {  return( m_pRmNodeChildRuleList );    }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmNodeChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmNodeChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           
   
   //==========================================================================
   //==========================================================================
   const RmNodeTypeChildRuleStruct* GetNodeTypeChildRule( const RM_TCHAR *pStrNodeTypeChain );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLNode( int hDoc, const RM_TCHAR *strXPath, bool bSortChildren );

   //==========================================================================
   //==========================================================================
   void SortChildren();


private:
   RmStringT m_strName;            
   RmStringT m_strNameChain;       
   RmStringT m_strType;            
   RmStringT m_strTypeChain;       

private :

   static RmNodeTypeChildRuleList         *m_pRmNodeChildRuleList;            
   static RmListOfNodeTypeChildRuleLists  *m_pRmListOfNodeTypeChildRuleLists; 

protected:
   RmStringT m_strDescription;     
   RmStringT m_strUserDescription; 

   RmStringT m_strAPI;             




   bool       m_bHidden;           
   RmNodeList m_childrenList;      
   RmNode*    m_pParent;           

   RmNodeID   m_nodeID;            

}; // End of RmNode class definition



//=============================================================================
//=============================================================================
class RM_API RmVariable: public RmNode
{
public:
   //==========================================================================
   //==========================================================================
   RmVariable()
   { 
      RmNode::SetType( RM_VARIABLE_TYPE );
      m_bArtistVar          = false;  
      m_strVariableSemantic = _T( "" );
      
   } // end RmVariable()

   //==========================================================================
   //==========================================================================
   virtual ~RmVariable()   {};

   //==========================================================================
   //==========================================================================
   virtual bool IsArtistEditable()           {  return m_bArtistVar;       }
   
   //==========================================================================
   //==========================================================================
   void  SetIsArtistEditable( bool bValue )   {  m_bArtistVar = bValue;     }

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual const RM_TCHAR* GetVariableSemantic()                              { return( m_strVariableSemantic ); }

   //==========================================================================
   //==========================================================================
   virtual void SetVariableSemantic( const RM_TCHAR* pStrVariableSemantic )   { m_strVariableSemantic = pStrVariableSemantic; }

   //==========================================================================
   //==========================================================================
   virtual bool IsPredefinedVariable();

   //==========================================================================
   //==========================================================================
   virtual bool IsPrelinkedVariable();
   
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmNode::SetType( RmStringT( RmStringT( _T("RmVariable.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           
   
protected:

   bool        m_bArtistVar;           
   RmStringT   m_strVariableSemantic;  


private :
   static RmNodeTypeChildRuleList  *m_pRmVariableChildRuleList; 

}; // End of RmVariable class definition

//=============================================================================
//=============================================================================
class RM_API RmDynamicVariable: public RmVariable
{
public:
   //==========================================================================
   //==========================================================================
   enum DynamicVariableType
   {
      TypeFloat,   
      TypeInteger, 
      TypeBoolean  
      
   }; // End enum DynamicVariableType
         
public:

   //==========================================================================
   //==========================================================================
   RmDynamicVariable();

   //==========================================================================
   //==========================================================================
   virtual ~RmDynamicVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType     /* = RM_NODE_GENERAL_UPDATE */, 
                        RmNode          *pRmUpdateRootNode  /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );
      
   //==========================================================================
   //==========================================================================
   void SetDynamicVariableType( DynamicVariableType dynamicVariableType );

   //==========================================================================
   //==========================================================================
   DynamicVariableType  GetDynamicVariableType() { return( m_dynamicVariableType ); }

   //==========================================================================
   //==========================================================================
   int GetDynamicVariableTypeElementSize() { return( GetDynamicVariableTypeElementSize( m_dynamicVariableType ) ); }

   //==========================================================================
   //==========================================================================
   int GetDynamicVariableTypeElementSize(  DynamicVariableType dynamicVariableType );
   
   //==========================================================================
   //==========================================================================
   void SetIsNormalized(  bool bIsNormalized );

   //==========================================================================
   //==========================================================================
   bool  IsNormalized()    { return( m_bIsNormalized ); }
   
   //==========================================================================
   //==========================================================================
   int   GetNumRows()      { return( m_nRows ); };

   //==========================================================================
   //==========================================================================
   int   GetNumColumns()   { return( m_nColumns ); };
   
   //==========================================================================
   //==========================================================================
   void  SetNumRows(    int nRows );

   //==========================================================================
   //==========================================================================
   void  SetNumColumns( int nColumns );
   
   //==========================================================================
   //==========================================================================
   void  SetIsClamped(  bool bIsClamped );

   //==========================================================================
   //==========================================================================
   bool  IsClamped()    { return( m_bIsClamped ); }
      
   //==========================================================================
   //==========================================================================
   void  SetIsFixedSize( bool bIsFixedSize ) { m_bIsFixedSize = bIsFixedSize; }

   //==========================================================================
   //==========================================================================
   bool  IsFixedSize()     { return( m_bIsFixedSize ); }
   
   //==========================================================================
   //==========================================================================
   void  SetFloatMinMax( float fMin, float fMax );

   //==========================================================================
   //==========================================================================
   void  SetIntegerMinMax( int nMin, int nMax );

   //==========================================================================
   //==========================================================================
   void  SetBooleanMinMax( BOOL bMin, BOOL bMax );
   
   //==========================================================================
   //==========================================================================
   void  GetFloatMinMax( float &fMin, float &fMax );

   //==========================================================================
   //==========================================================================
   void  GetIntegerMinMax( int &nMin, int &nMax );

   //==========================================================================
   //==========================================================================
   void  GetBooleanMinMax( BOOL &bMin, BOOL &bMax );
   
   //==========================================================================
   //==========================================================================
   void  SetFloatData( int nRow, int nCol, float fData );

   //==========================================================================
   //==========================================================================
   void  SetIntegerData( int nRow, int nCol, int nData );

   //==========================================================================
   //==========================================================================
   void  SetBooleanData( int nRow, int nCol, BOOL bData );
   
   //==========================================================================
   //==========================================================================
   float GetFloatData( int nRow, int nCol );

   //==========================================================================
   //==========================================================================
   int   GetIntegerData( int nRow, int nCol );

   //==========================================================================
   //==========================================================================
   BOOL  GetBooleanData( int nRow, int nCol );
   
   //==========================================================================
   //==========================================================================
   float* GetFloatDataBlock();

   //==========================================================================
   //==========================================================================
   int* GetIntegerDataBlock();

   //==========================================================================
   //==========================================================================
   BOOL* GetBooleanDataBlock();
         
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmDynamicVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmDynamicVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmDynamicVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           
   
   //==========================================================================
   //==========================================================================
   void ConvertDynamicData( void*                pDestData,
                            DynamicVariableType  destDataType,
                            void*                pSourceData,
                            DynamicVariableType  sourceDataType );
                              
   //==========================================================================
   //==========================================================================
   int  FloatToInt( float fValue )
   {
      return( ( fValue >= 0.0f ) ? ( int )( fValue + 0.5f ) : ( int )( fValue - 0.5f ) );
      
   } // End FloatToInt( float fValue )
      
   //==========================================================================
   //==========================================================================
   void* GetDataPointer( void*               pData,
                         DynamicVariableType dataType,
                         int                 nRowIndex,
                         int                 nColumnIndex );

   //==========================================================================
   //==========================================================================
   void* GetDataPointer( void*               pData,
                         DynamicVariableType dataType,
                         int                 nRowIndex,
                         int                 nColumnIndex,
                         int                 nNumRows,
                         int                 nNumColumns );
   
   //==========================================================================
   //==========================================================================
   bool LoadXMLDataValues( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );


   //==========================================================================
   //==========================================================================
   bool SaveXMLDataValues( int hDoc, const RM_TCHAR *strXPath );
   
protected:
   DynamicVariableType  m_dynamicVariableType; 
   int                  m_nRows;               
   int                  m_nColumns;            
   void*                m_pDynamicVariableData; 
   bool                 m_bIsFixedSize;         
   bool                 m_bIsClamped;           
   bool                 m_bIsNormalized;        
   void*                m_pDynamicVariableMin;  
   void*                m_pDynamicVariableMax;  
   
private :
   static RmNodeTypeChildRuleList  *m_pRmDynamicVariableChildRuleList; 

};    // End of RmDynamicVariable class definition

//=============================================================================
//=============================================================================
class RM_API RmLightVariable: public RmVariable
{
public: 

   //==========================================================================
   //==========================================================================
   enum LightVariableType
   {
      TypePositional,  
      TypeDirectional, 
      TypeSpotlight,   
      
   }; // End enum LightVariableType

public:  

   //==========================================================================
   //==========================================================================
   RmLightVariable();

   //==========================================================================
   //==========================================================================
   virtual ~RmLightVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );

   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );
      
   //==========================================================================
   //==========================================================================
   LightVariableType GetLightVariableType()                          { return( m_lightVariableType ); }

   //==========================================================================
   //==========================================================================
   void SetLightVariableType( LightVariableType lightVariableType )  { m_lightVariableType = lightVariableType; }
   
   //==========================================================================
   //==========================================================================
   bool IsEnabled()                                   { return( m_bEnabled ); }

   //==========================================================================
   //==========================================================================
   void SetIsEnabled( bool bEnabled )                 { m_bEnabled = bEnabled; }
   
   //==========================================================================
   //==========================================================================
   const float* GetAmbientColor()                     {     return m_fAmbientColorArray;     }

   //==========================================================================
   //==========================================================================
   const float* GetDiffuseColor()                     {     return m_fDiffuseColorArray;     }

   //==========================================================================
   //==========================================================================
   const float* GetSpecularColor()                    {     return m_fSpecularColorArray;    }
       
   //==========================================================================
   //==========================================================================
   void SetAmbientColor( float *pfColorArray );

   //==========================================================================
   //==========================================================================
   void SetDiffuseColor( float *pfColorArray );

   //==========================================================================
   //==========================================================================
   void SetSpecularColor( float *pfColorArray );
   
   //==========================================================================
   //==========================================================================
   const float* GetPosition()                         {  return m_fPositionArray;      }

   //==========================================================================
   //==========================================================================
   const float* GetDirection()                        {  return m_fDirectionArray;     }
  
   //==========================================================================
   //==========================================================================
   void SetPosition( float *pfPositionArray );

   //==========================================================================
   //==========================================================================
   void SetDirection( float *pfDirectionArray );
   
   //==========================================================================
   //==========================================================================
   const float* GetAttenuation()                            {  return m_fAttenuationArray;      }

   //==========================================================================
   //==========================================================================
   void         SetAttenuation( float *pfAttenuationArray );
   
   //==========================================================================
   //==========================================================================
   float GetSpotlightTheta()                          { return( m_fSpotlightTheta );   }        

   //==========================================================================
   //==========================================================================
   float GetSpotlightPhi()                            { return( m_fSpotlightPhi );     }        
   
   //==========================================================================
   //==========================================================================
   void SetSpotlightTheta( float fSpotlightTheta )    { m_fSpotlightTheta = fSpotlightTheta; }        

   //==========================================================================
   //==========================================================================
   void SetSpotlightPhi( float fSpotlightPhi )        { m_fSpotlightPhi = fSpotlightPhi;     }        
   
   //==========================================================================
   //==========================================================================
   float GetRange()                                   { return( m_fRange );      }        

   //==========================================================================
   //==========================================================================
   float GetFalloff()                                 { return( m_fFalloff );    }        
                 
   //==========================================================================
   //==========================================================================
   void SetRange( float fRange )                      { m_fRange = fRange;       }        

   //==========================================================================
   //==========================================================================
   void SetFalloff( float fFalloff )                  { m_fFalloff = fFalloff;   }        
   
protected:  

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmLightVariableChildRuleList ); }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmLightVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmLightVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   LightVariableType m_lightVariableType; 
   
   bool  m_bEnabled;                      

   float m_fAmbientColorArray[4];         
   float m_fDiffuseColorArray[4];         
   float m_fSpecularColorArray[4];        
   
   float m_fPositionArray[3];             
   float m_fDirectionArray[3];            
   
   float m_fAttenuationArray[3];          
   
   float m_fSpotlightTheta;               
   float m_fSpotlightPhi;                 
   
   float m_fRange;                        
   float m_fFalloff;                      
   
private :

   static RmNodeTypeChildRuleList  *m_pRmLightVariableChildRuleList; 

};    // End of RmLightVariable class definition

//=============================================================================
//=============================================================================
class RM_API RmMaterialVariable: public RmVariable
{
public:  

   //==========================================================================
   //==========================================================================
   RmMaterialVariable();

   //==========================================================================
   //==========================================================================
   virtual ~RmMaterialVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );
      
   //==========================================================================
   //==========================================================================
   const float* GetAmbientColor()                  {  return m_fAmbientColorArray;     }

   //==========================================================================
   //==========================================================================
   const float* GetDiffuseColor()                  {  return m_fDiffuseColorArray;     }

   //==========================================================================
   //==========================================================================
   const float* GetSpecularColor()                 {  return m_fSpecularColorArray;    }

   //==========================================================================
   //==========================================================================
   const float* GetEmissiveColor()                 {  return m_fEmissiveColorArray;    }
  
   //==========================================================================
   //==========================================================================
   float GetSpecularPower()                        { return( m_fSpecularPower ); }
         
   //==========================================================================
   //==========================================================================
   void SetAmbientColor(  float *pfColorArray );

   //==========================================================================
   //==========================================================================
   void SetDiffuseColor(  float *pfColorArray );
   
   //==========================================================================
   //==========================================================================
   void SetSpecularColor( float *pfColorArray );

   //==========================================================================
   //==========================================================================
   void SetEmissiveColor( float *pfColorArray );
   
   //==========================================================================
   //==========================================================================
   void SetSpecularPower( float fSpecularPower )   { m_fSpecularPower = fSpecularPower; }
   
protected:  

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmMaterialVariableChildRuleList ); }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmMaterialVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmMaterialVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   float m_fAmbientColorArray[4];  
   float m_fDiffuseColorArray[4];  
   float m_fSpecularColorArray[4]; 
   float m_fEmissiveColorArray[4]; 
   float m_fSpecularPower;         
   
private :
   static RmNodeTypeChildRuleList  *m_pRmMaterialVariableChildRuleList; 

};    // End of RmMaterialVariable class definition

//=============================================================================
//=============================================================================
class RM_API RmVectorVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmVectorVariable();

   //==========================================================================
   //==========================================================================
   RmVectorVariable( float fX, float fY, float fZ, float fW, bool bClamp, bool bNormalize,
                     float fMin = -10.0f, float fMax = 10.0f );

   //==========================================================================
   //==========================================================================
   RmVectorVariable( float fX, float fY, float fZ, float fW );

   //==========================================================================
   //==========================================================================
   RmVectorVariable( float fVector[4] );

   //==========================================================================
   //==========================================================================
   virtual ~RmVectorVariable()     {};

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );

   //==========================================================================
   // \brief GetData
   //==========================================================================
   float* GetData()                       {  return m_fValues;         }

   //==========================================================================
   // \brief GetValue
   //==========================================================================
   float  GetValue( int nIndex )          {  return m_fValues[nIndex]; }

   //==========================================================================
   //==========================================================================
   void SetValue( int nIndex, float fValue );

   //==========================================================================
   //==========================================================================
   void SetValues( float fX, float fY, float fZ, float fW );

   //==========================================================================
   //==========================================================================
   void SetValues( float fValues[4] );

   //==========================================================================
   //==========================================================================
   bool IsClamped()                    {  return m_bClamp;  }

   //==========================================================================
   //==========================================================================
   void SetIsClamped( bool bClamp );

   //==========================================================================
   //==========================================================================
   float GetMin()                         {  return m_fMin;      }

   //==========================================================================
   //==========================================================================
   float GetMax()                         {  return m_fMax;      }

   //==========================================================================
   //==========================================================================
   void SetMin( float fMin );

   //==========================================================================
   //
   //==========================================================================
   void SetMax( float fMax );

   //==========================================================================
   //==========================================================================
   void SetMinMax( float fMin, float fMax );

   //==========================================================================
   //==========================================================================
   bool IsNormalized()                 {   return m_bNormalize;     }

   //==========================================================================
   //==========================================================================
   void SetIsNormalized( bool bValue );

   //==========================================================================
   //==========================================================================
   void Normalize();

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmVectorVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmVectorVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmVectorVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:
   
   float m_fValues[4];        

   float m_fMin;              
   float m_fMax;              

   bool  m_bClamp;            
   
   bool  m_bNormalize;        



private :
   static RmNodeTypeChildRuleList  *m_pRmVectorVariableChildRuleList; 

};    // End of RmVectorVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmMatrixVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmMatrixVariable();

   //==========================================================================
   //==========================================================================
   RmMatrixVariable( float fMatrix[16] );

   //==========================================================================
   //==========================================================================
   virtual ~RmMatrixVariable() {};

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
    
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
          
   //==========================================================================
   //==========================================================================
   float* GetData()        {     return m_fValues;    }

   //==========================================================================
   //==========================================================================
   float GetValue( int nIndex );

   //==========================================================================
   //==========================================================================
   float GetValue( int nRowIndex, int nColumnIndex );

   //==========================================================================
   //==========================================================================
   void SetValue( int nIndex, float fValue );

   //==========================================================================
   //==========================================================================
   void SetValue( int nRowIndex, int nColumnIndex, float fValue );

   //==========================================================================
   //==========================================================================
   void SetValues( float fMatrix[16] );

   //==========================================================================
   //==========================================================================
   int GetNumElements()       {     return 16;     }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmMatrixVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmMatrixVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmMatrixVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   float m_fValues[16]; 

private :
   static RmNodeTypeChildRuleList  *m_pRmMatrixVariableChildRuleList; 

};    // End of RmMatrixVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmFloatVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmFloatVariable();

   //==========================================================================
   //==========================================================================
   RmFloatVariable( float fValue );

   //==========================================================================
   //==========================================================================
   RmFloatVariable( float fValue, bool bClamp, float fMin = -1.0f, float fMax = 1.0f );

   //==========================================================================
   //==========================================================================
   virtual ~RmFloatVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      
   
   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
   
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   virtual void SetName( const RM_TCHAR* strNewName );

   //==========================================================================
   //==========================================================================
   float GetValue()                       {  return m_fValue;        }

   //==========================================================================
   //==========================================================================
   void SetValue( float fValue );

   //==========================================================================
   //==========================================================================
   bool IsClamped()                    {  return m_bClamp;        }

   //==========================================================================
   //==========================================================================
   void SetIsClamped( bool bClamp )
   {  
      m_bClamp = bClamp;      
      Update( RM_NODE_VALUE_CHANGED_UPDATE, this );
   }

   //==========================================================================
   //==========================================================================
   float GetMin()                         {  return m_fMin;          }

   //==========================================================================
   //==========================================================================
   float GetMax()                         {  return m_fMax;          }

   //==========================================================================
   //==========================================================================
   void SetMin( float fMin );

   //==========================================================================
   //==========================================================================
   void SetMax( float fMax );

   //==========================================================================
   //==========================================================================
   void SetMinMax( float fMin, float fMax );

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmFloatVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmFloatVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmFloatVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   float m_fValue;         

   float m_fMin;           
   float m_fMax;           

   bool  m_bClamp;         


private :
   static RmNodeTypeChildRuleList  *m_pRmFloatVariableChildRuleList; 

}; // End of RmFloatVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmIntegerVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmIntegerVariable();

   //==========================================================================
   //==========================================================================
   RmIntegerVariable( int nValue );       

   //==========================================================================
   //==========================================================================
   RmIntegerVariable( int nValue, bool bClamp, int nMin, int nMax );

   //==========================================================================
   //==========================================================================
   virtual ~RmIntegerVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
   
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   int GetValue()                      {  return m_nValue;  }

   //==========================================================================
   //==========================================================================
   void SetValue( int nValue );

   //==========================================================================
   //==========================================================================
   bool IsClamped()                 {  return m_bClamp;   }

   //==========================================================================
   //==========================================================================
   void SetIsClamped( bool bClamp )
   {  
      m_bClamp = bClamp;      
      Update( RM_NODE_VALUE_CHANGED_UPDATE, this );
   }

   //==========================================================================
   //==========================================================================
   int GetMin()                         {  return m_nMin;  }

   //==========================================================================
   //==========================================================================
   int GetMax()                         {  return m_nMax;  }

   //==========================================================================
   //==========================================================================
   void SetMin( int nMin );

   //==========================================================================
   //==========================================================================
   void SetMax( int nMax );

   //==========================================================================
   //==========================================================================
   void SetMinMax( int nMin, int nMax );

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmIntegerVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmIntegerVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmIntegerVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   int m_nValue;     

   int m_nMin;       
   int m_nMax;       

   bool m_bClamp;    

private :
   static RmNodeTypeChildRuleList  *m_pRmIntegerVariableChildRuleList; 

}; // End of RmIntegerVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmStringVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmStringVariable();

   //==========================================================================
   //==========================================================================
   RmStringVariable( const RM_TCHAR* strValue );

   //==========================================================================
   //==========================================================================
   virtual ~RmStringVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   const RmStringT& GetValue()                       { return m_string;  }

   //==========================================================================
   //==========================================================================
   void SetValue( const RM_TCHAR* strValue );

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmStringVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmStringVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmStringVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmStringT m_string;       

private :
   static RmNodeTypeChildRuleList  *m_pRmStringVariableChildRuleList; 

}; // End of RmStringVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmBooleanVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmBooleanVariable();

   //==========================================================================
   //==========================================================================
   RmBooleanVariable( bool bValue );

   //==========================================================================
   //==========================================================================
   virtual ~RmBooleanVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
   
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   bool GetValue()                        {  return m_bValue;     };

   //==========================================================================
   //==========================================================================
   void SetValue( bool bValue )        {  m_bValue = bValue;   };

   //==========================================================================
   //==========================================================================
   void SetValue( int  nValue )        {  m_bValue = ( nValue > 0 ) ? true : false; };

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmBooleanVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmBooleanVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmBooleanVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:
   
   bool m_bValue;       

private :
   static RmNodeTypeChildRuleList  *m_pRmBooleanVariableChildRuleList; 

}; // End of RmBooleanVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmTextureVariable: public RmVariable
{
public:
   //==========================================================================
   //==========================================================================
   RmTextureVariable();

   //==========================================================================
   //==========================================================================
   virtual ~RmTextureVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
   
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid();

   //==========================================================================
   //==========================================================================
   const RmStringT& GetFileName()     {     return m_strFileName;  }

   //==========================================================================
   //==========================================================================
   void GetFullFileName( RM_TCHAR* strFullPath, int nSize );
   
   //==========================================================================
   //==========================================================================
   void SetFileName( const RM_TCHAR* strFileName, bool bUpdateDatabase = true );

   //==========================================================================
   //==========================================================================
   virtual bool LoadTexture() { return true; };

   //==========================================================================
   //==========================================================================
   virtual RmTexture*       GetTexture() { return NULL; };

   //==========================================================================
   //==========================================================================
   virtual const RmTexture* GetTexture() const { return NULL; };

   //==========================================================================
   //==========================================================================
   void SetRequestedPixelFormat( RmPixelFormatType format ) { m_requestedPixelFormat = format; };

   //==========================================================================
   //==========================================================================
   RmPixelFormatType  GetRequestedPixelFormat() const { return m_requestedPixelFormat; };

   //=========================================================================
   //=========================================================================
   void SetOrigin( RmTextureOrigin textureOrigin ) { m_textureOrigin = textureOrigin; }
   
   //=========================================================================
   //=========================================================================
   RmTextureOrigin GetOrigin() { return( m_textureOrigin ); }
   
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmVariable::SetType( RmStringT( RmStringT( _T("RmTextureVariable.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmTextureVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmTextureVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmTextureVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:
   
   RmStringT            m_strFileName;          
   RmPixelFormatType    m_requestedPixelFormat; 


   RmTextureOrigin      m_textureOrigin;        

   bool                 m_bTextureLoaded;       

private :
   static RmNodeTypeChildRuleList  *m_pRmTextureVariableChildRuleList; 

}; // End of RmTextureVariable class definition


//=============================================================================
//=============================================================================
class RM_API Rm2DTextureVariable: public RmTextureVariable
{
public:

   //==========================================================================
   //==========================================================================
   Rm2DTextureVariable();

   //==========================================================================
   //==========================================================================
   Rm2DTextureVariable( const RM_TCHAR* strNodeName, const RM_TCHAR* strFileName = NULL );

   //==========================================================================
   //==========================================================================
   virtual ~Rm2DTextureVariable();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();
   
   //==========================================================================
   //==========================================================================
   virtual bool LoadTexture();

   //==========================================================================
   //==========================================================================
   virtual RmTexture*       GetTexture() { return m_pTexture; };

   //==========================================================================
   //==========================================================================
   virtual const RmTexture* GetTexture() const { return m_pTexture; };

   //==========================================================================
   //==========================================================================
   Rm2DTexture*       Get2DTexture() { return m_pTexture; };
   
   //==========================================================================
   //==========================================================================
   const Rm2DTexture* Get2DTexture() const { return m_pTexture; };

protected:
   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmTextureVariable::SetType( RmStringT( RmStringT( _T("Rm2DTextureVariable.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

private :
   Rm2DTexture* m_pTexture; 
}; // End of Rm2DTextureVariable class definition


//=============================================================================
//=============================================================================
class RM_API RmCubemapVariable : public RmTextureVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmCubemapVariable();

   //==========================================================================
   //==========================================================================
   RmCubemapVariable( const RM_TCHAR* strNodeName, const RM_TCHAR* strFileName = NULL );

   //==========================================================================
   //==========================================================================
   virtual ~RmCubemapVariable();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();
   
   //==========================================================================
   //==========================================================================
   virtual bool LoadTexture();

   //==========================================================================
   //==========================================================================
   virtual RmTexture*       GetTexture() { return m_pCubemap; };

   //==========================================================================
   //==========================================================================
   virtual const RmTexture* GetTexture() const { return m_pCubemap; };

   //==========================================================================
   //==========================================================================
   RmCubemap*       GetCubemap() { return m_pCubemap; };

   //==========================================================================
   //==========================================================================
   const RmCubemap* GetCubemap() const { return m_pCubemap; };

private :
   RmCubemap* m_pCubemap; 
}; // End of RmCubemapVariable class definition


//=============================================================================
//=============================================================================
class RM_API Rm3DTextureVariable: public RmTextureVariable
{
public:

   //==========================================================================
   //==========================================================================
   Rm3DTextureVariable();

   //==========================================================================
   //==========================================================================
   Rm3DTextureVariable( const RM_TCHAR* strNodeName, const RM_TCHAR* strFileName = NULL );

   //==========================================================================
   //==========================================================================
   virtual ~Rm3DTextureVariable();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();
   
   //==========================================================================
   //==========================================================================
   virtual bool LoadTexture();

   //==========================================================================
   //==========================================================================
   virtual RmTexture*       GetTexture() { return m_pVolumeTexture; };

   //==========================================================================
   //==========================================================================
   virtual const RmTexture* GetTexture() const { return m_pVolumeTexture; };

   //==========================================================================
   //==========================================================================
   Rm3DTexture*       Get3DTexture() { return m_pVolumeTexture; };

   //==========================================================================
   //==========================================================================
   const Rm3DTexture* Get3DTexture() const { return m_pVolumeTexture; };

private :
   Rm3DTexture* m_pVolumeTexture; 
}; // End of Rm3DTextureVariable class definition



//=============================================================================
//=============================================================================
class RM_API RmColorVariable: public RmVariable
{
public:

   //==========================================================================
   //==========================================================================
   RmColorVariable();

   //==========================================================================
   //==========================================================================
   RmColorVariable( float fRed, float fGreen, float fBlue, float fAlpha );

   //==========================================================================
   //==========================================================================
   RmColorVariable( float fColor[4] );

   //==========================================================================
   //==========================================================================
   RmColorVariable( const RM_TCHAR* strName, float fRed, float fGreen, float fBlue, float fAlpha );

   //==========================================================================
   //==========================================================================
   RmColorVariable( const RM_TCHAR* strName, float fColor[4] );

   //==========================================================================
   //==========================================================================
   virtual ~RmColorVariable();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );
   
   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
       
   //==========================================================================
   //==========================================================================
   float* GetValue()                      {     return m_fColor;     }

   //==========================================================================
   //==========================================================================
   float GetChannel( int nIndex );

   //==========================================================================
   //==========================================================================
   float GetR()                           {     return m_fColor[0];  } 

   //==========================================================================
   //==========================================================================
   float GetG()                           {     return m_fColor[1];  }

   //==========================================================================
   //==========================================================================
   float GetB()                           {     return m_fColor[2];  }

   //==========================================================================
   //==========================================================================
   float GetA()                           {     return m_fColor[3];  }

   //==========================================================================
   //==========================================================================
   void SetValue( int nIndex, float fValue );

   //==========================================================================
   //==========================================================================
   void SetValues( float fValues[4] );

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmColorVariableChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmColorVariableChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmColorVariableChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:
   
   float m_fColor[4];      

private :
   static RmNodeTypeChildRuleList  *m_pRmColorVariableChildRuleList; 

}; // End of RmColorVariable class definition


//.................................................................................
//.................................................................................
//    Stream mapping related classes
//.................................................................................
//.................................................................................


class RmStream;
class RmStreamMap;

//=============================================================================
//=============================================================================
class RM_API RmStreamChannel: public RmNode
{
public:

   //==========================================================================
   //==========================================================================
   RmStreamChannel();

   //==========================================================================
   //==========================================================================
   RmStreamChannel( DWORD dwUsage, DWORD dwUsageIndex, DWORD dwRegisterIndex, DWORD dwDataType );
      // RmStreamChannel *RmAddStreamChannel(RmStream *node, DWORD usage, DWORD usageIndex, DWORD reg, DWORD chanType)

   //==========================================================================
   //==========================================================================
   virtual ~RmStreamChannel();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   unsigned long GetRegister()                        {        return m_ulRegister;       }

   //==========================================================================
   //==========================================================================
   void SetRegister( unsigned long ulRegister );

   //==========================================================================
   //==========================================================================
   unsigned long GetDataType()                        {        return m_ulDataType;       }

   //==========================================================================
   //==========================================================================
   void SetDataType( unsigned long ulType );

   //==========================================================================
   // \brief Get size
   //==========================================================================
   int GetSize()                                      {        return m_nDataSize;        }

   //==========================================================================
   //==========================================================================
   unsigned long GetUsage()                           {        return m_ulUsage;          }

   //==========================================================================
   //==========================================================================
   void SetUsage( unsigned long ulUsage );

   //==========================================================================
   //==========================================================================
   unsigned long GetUsageIndex()                      {        return m_ulUsageIndex;     }

   //==========================================================================
   //==========================================================================
   void SetUsageIndex( unsigned long ulUsageIndex );

   //==========================================================================
   //==========================================================================
   const RM_TCHAR* GetUsageString();

   //==========================================================================
   //==========================================================================
   RmStream* GetParentStream()
   {
      return (RmStream *) GetParent();
   }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmStreamChannelChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmStreamChannelChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmStreamChannelChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:
   RmStringT        m_strUsage;          

   unsigned long    m_ulRegister;        
   unsigned long    m_ulDataType;        
   unsigned long    m_ulUsage;           
   unsigned long    m_ulUsageIndex;      

   int              m_nDataSize;         

private :
   static RmNodeTypeChildRuleList  *m_pRmStreamChannelChildRuleList; 

}; // End of RmStreamChannel class definition

typedef RmLinkedList<RmStreamChannel*>        RmStreamChannelList;
typedef RmStreamChannelList::iterator         RmStreamChannelListIterator;
typedef RmStreamChannelList::const_iterator   RmStreamChannelListConstIterator;


//=============================================================================
//=============================================================================
class RM_API RmStream : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmStream();

   //==========================================================================
   //==========================================================================
   RmStream( const RM_TCHAR* strStreamName, bool bInitialize = true );

   //==========================================================================
   //==========================================================================
   virtual ~RmStream();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   RmStreamChannelListIterator         BeginChannels()            {     return m_channelList.begin(); }

   //==========================================================================
   //==========================================================================
   RmStreamChannelListConstIterator    BeginChannels()   const    {     return m_channelList.begin(); }

   //==========================================================================
   //==========================================================================
   RmStreamChannelListIterator         EndChannels()              {     return m_channelList.end();   }

   //==========================================================================
   //==========================================================================
   RmStreamChannelListConstIterator    EndChannels()     const    {     return m_channelList.end();   }

   //==========================================================================
   //==========================================================================
   int GetNumChannels()          {     return m_channelList.size();     }

   //==========================================================================
   //==========================================================================
   bool AddChannel( RmStreamChannel* pChannel );

   //==========================================================================
   //==========================================================================
   void DeleteChannel( RmStreamChannel* pChannel );

   //==========================================================================
   //==========================================================================
   void DeleteAllChannels();

   //==========================================================================
   //==========================================================================
   void DeleteChannel( unsigned long ulUsage, unsigned long ulUsageIndex, unsigned long ulDataType );

   //==========================================================================
   //==========================================================================
   RmStreamChannel* GetChannel( unsigned long ulUsage, unsigned long ulUsageIndex, unsigned long ulDataType );

   //==========================================================================
   //==========================================================================
   RmStreamChannel* GetChannel( const RM_TCHAR* strChannelName );

   //==========================================================================
   //==========================================================================
   RmStreamChannel* GetChannel( int nIndex );

   //==========================================================================
   //==========================================================================
   int GetStride()         {     return m_nStride;    }

   //==========================================================================
   //==========================================================================
   RmStreamMap* GetParentStreamMap()
   {
      return (RmStreamMap *)GetParent();
   }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmStreamChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmStreamChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmStreamChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmStreamChannelList m_channelList;        
         
   int  m_nStride;                           

private :
   static RmNodeTypeChildRuleList  *m_pRmStreamChildRuleList; 

}; // End of RmStream class definition


typedef RmLinkedList<RmStream *>        RmStreamList;
typedef RmStreamList::iterator          RmStreamListIterator;
typedef RmStreamList::const_iterator    RmStreamListConstIterator;


//=============================================================================
//=============================================================================
class RM_API RmStreamMap : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmStreamMap();

   //==========================================================================
   //==========================================================================
   RmStreamMap( const RM_TCHAR* strName, bool bInitialize = true );

   //==========================================================================
   //==========================================================================
   virtual ~RmStreamMap();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid()                      { return( !m_streamList.empty() ? RmNode::IsNodeValid() : false ); };
   
   //==========================================================================
   //==========================================================================
   bool AddStream( RmStream* pStream );

   //==========================================================================
   //==========================================================================
   RmStream* GetStream( const RM_TCHAR* strStreamName );

   //==========================================================================
   //==========================================================================
   RmStream* GetStream( int nIndex );

   //==========================================================================
   //==========================================================================
   void DeleteStream( RmStream* pStream );

   //==========================================================================
   //==========================================================================
   void DeleteStream( const RM_TCHAR* strStreamName );

   //==========================================================================
   //==========================================================================
   int GetNumStreams()              {        return m_streamList.size();      }

   //==========================================================================
   //==========================================================================
   RmStreamListIterator          BeginStreams()          {     return m_streamList.begin();  }

   //==========================================================================
   //==========================================================================
   RmStreamListConstIterator     BeginStreams() const    {     return m_streamList.begin();  }

   //==========================================================================
   //==========================================================================
   RmStreamListIterator          EndStreams()            {     return m_streamList.end();    }

   //==========================================================================
   //==========================================================================
   RmStreamListConstIterator     EndStreams()   const    {     return m_streamList.end();    }

   //==========================================================================
   //==========================================================================
   int GetHandle()                  {     return m_nHandle;       }

   //==========================================================================
   //==========================================================================
   void SetHandle( int nHandle )    {     m_nHandle = nHandle;    }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmStreamMapChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmStreamMapChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmStreamMapChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   int          m_nHandle;          
   RmStreamList m_streamList;       

private :
   static RmNodeTypeChildRuleList  *m_pRmStreamMapChildRuleList; 

}; // End of RmStreamMap class definition

//=============================================================================
//=============================================================================
class RM_API RmStreamMapReference : public RmNode  
{   
public:

   //==========================================================================
   //==========================================================================
   RmStreamMapReference();

   //==========================================================================
   //==========================================================================
   RmStreamMapReference( RmStreamMap* pStreamMap );

   //==========================================================================
   //==========================================================================
   virtual ~RmStreamMapReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid()                      { return( ( NULL != m_pStreamMap ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   void SetReference( RmStreamMap* pStreamMap );

   //==========================================================================
   //==========================================================================
   RmStreamMap* GetReference()            {        return m_pStreamMap;          }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmStreamMapReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmStreamMapReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmStreamMapReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmStreamMap* m_pStreamMap;       

private :
   static RmNodeTypeChildRuleList  *m_pRmStreamMapReferenceChildRuleList; 

}; // End of RmStreamMapReference class definition


//=============================================================================
//=============================================================================
class RM_API RmShaderConstant: public RmNode
{
public:

   //==========================================================================
   //==========================================================================
   RmShaderConstant();

   //==========================================================================
   //==========================================================================
   RmShaderConstant( const RM_TCHAR *strConstantName, const RM_TCHAR* strConstantType, 
                     int nRegister );

   //==========================================================================
   //==========================================================================
   RmShaderConstant( RmNode *pNode, int nRegister );

   //==========================================================================
   //==========================================================================
   virtual ~RmShaderConstant();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid()          {     return( ( NULL != m_pNode ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   // \brief Get register
   //==========================================================================
   int GetRegister()                      {     return m_nRegister;        }

   //==========================================================================
   //==========================================================================
   void SetRegister( int nIndex )      {     m_nRegister = nIndex;      }

   //==========================================================================
   //==========================================================================
   int GetElementCount();

   //==========================================================================
   //==========================================================================
   const RmStringT& GetDataType()              {     return m_strConstantType;  }

   //==========================================================================
   //==========================================================================
   RmNode* GetParameterNode()       {        return m_pNode;         }  

   //==========================================================================
   //==========================================================================
   void LinkToParameterNode( RmNode *pNode );

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmShaderConstantChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmShaderConstantChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmShaderConstantChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected: 

   int        m_nRegister;         
   RmNode*    m_pNode;             
   RmStringT  m_strConstantType;   

private :
   static RmNodeTypeChildRuleList  *m_pRmShaderConstantChildRuleList; 

}; // End of RmShaderConstant class definition

typedef RmLinkedList<RmShaderConstant*>       RmShaderConstantList;
typedef RmShaderConstantList::iterator       RmShaderConstantListIterator;
typedef RmShaderConstantList::const_iterator RmShaderConstantListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmSampler : public RmNode
{
public:

   //==========================================================================
   //==========================================================================
   RmSampler();

   //==========================================================================
   //==========================================================================
   RmSampler( const RM_TCHAR *strSamplerName, int nRegister );

   //==========================================================================
   //==========================================================================
   virtual ~RmSampler();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid()             {     return( ( NULL != m_pTextureObject ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   void SetRegister( int nIndex )         {     m_nRegister = nIndex;   }
   
   //==========================================================================
   //==========================================================================
   int GetRegister()                      {     return m_nRegister;     }

   //==========================================================================
   //==========================================================================
   RmNode*       GetTextureObject()       { return m_pTextureObject; };

   //==========================================================================
   //==========================================================================
   const RmNode* GetTextureObject() const { return m_pTextureObject; };

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

protected: 

   int       m_nRegister;        
   RmNode   *m_pTextureObject;   

}; // End of RmSampler class definition


typedef RmLinkedList<RmSampler*>        RmSamplerList;
typedef RmSamplerList::iterator        RmSamplerListIterator;
typedef RmSamplerList::const_iterator  RmSamplerListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmShader : public RmNode  
{
public:
   //==========================================================================
   //==========================================================================
   RmShader();

   //==========================================================================
   //==========================================================================
   virtual ~RmShader();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual bool IsHighLevel()
   {
      return false;
   }

   //==========================================================================
   //==========================================================================
   virtual void DeleteConstant( int nRegister );

   //==========================================================================
   //==========================================================================
   virtual void DeleteConstant( const RM_TCHAR *strConstantName );

   //==========================================================================
   //==========================================================================
   virtual void DeleteAllConstants();

   //==========================================================================
   //==========================================================================
   virtual bool AddConstant( RmShaderConstant *pConstant );

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstant* GetConstant( int nRegister );

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstant* GetConstant( const RM_TCHAR *strConstantName );

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstant* GetConstantByIndex( int nIndex );

   //==========================================================================
   //==========================================================================
   virtual int GetNumConstants() const                                     {      return m_constantList.size(); };

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstantListIterator        BeginConstants()         {     return m_constantList.begin();   }

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstantListConstIterator   BeginConstants()  const  {     return m_constantList.begin();   }

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstantListIterator        EndConstants()           {     return m_constantList.end();     }

   //==========================================================================
   //==========================================================================
   virtual RmShaderConstantListConstIterator   EndConstants()    const  {     return m_constantList.end();     }

   //==========================================================================
   //==========================================================================
   void  SetCode( const RM_TCHAR* strCode );

   //==========================================================================
   //==========================================================================
   const RmStringT&  GetShaderCode() const                       {        return m_strCode;       }

   //==========================================================================
   //==========================================================================
   void GetMaxInstructionInfo( int &nMaxALUInstructions, int &nMaxTexInstructions )
   {
      nMaxALUInstructions = m_nMaxALUInstructions;
      nMaxTexInstructions = m_nMaxTexInstructions;
         
   } // end void GetMaxInstructionInfo( int &nMaxALUInstructions, int &nMaxTexInstructions )
   
   //==========================================================================
   //==========================================================================
   void SetMaxInstructionInfo( int nMaxALUInstructions, int nMaxTexInstructions )
   {
      m_nMaxALUInstructions   = nMaxALUInstructions;
      m_nMaxTexInstructions   = nMaxTexInstructions;
         
   } // end void SetMaxInstructionInfo( int nMaxALUInstructions, int nMaxTexInstructions )

   //==========================================================================
   //==========================================================================
   RM_TCHAR* GetFullName();   

   //==========================================================================
   //==========================================================================
   RM_TCHAR* GetFullNameWithAPI();

   //==========================================================================
   //==========================================================================
   int GetHandle()                                    {     return m_nHandle;                }

   //==========================================================================
   //==========================================================================
   void SetHandle( int nHandle )                   {     m_nHandle = nHandle;             }

   //==========================================================================
   //==========================================================================
   bool IsModified()  const                        {     return m_bModified;     }

   //==========================================================================
   //==========================================================================
   void SetModified( bool bModified )              {     m_bModified = bModified;   }

   //==========================================================================
   //==========================================================================
   bool IsPixelShader()                            {     return( m_bPixelShader == true );   }

   //==========================================================================
   //==========================================================================
   bool IsVertexShader()                           {     return( m_bPixelShader == false );  }

   //==========================================================================
   //==========================================================================
   void SetIsPixelShader( bool bPixelShader )      {     m_bPixelShader = bPixelShader;      }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmNode::SetType( RmStringT( RmStringT( _T("RmShader.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmShaderChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmShaderChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmShaderChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmStringT            m_strCode;              
   bool                 m_bModified;            
   int                  m_nHandle;              
   RmShaderConstantList m_constantList;         
   bool                 m_bPixelShader;         
   int                  m_nMaxALUInstructions;  
   int                  m_nMaxTexInstructions;  
     
private :
   static RmNodeTypeChildRuleList  *m_pRmShaderChildRuleList; 

}; // End of RmShader class definition



//=============================================================================
//=============================================================================
class RM_API RmHLShader : public RmShader
{
public:
   //==========================================================================
   //==========================================================================
   RmHLShader();

   //==========================================================================
   //==========================================================================
   virtual ~RmHLShader();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual bool IsHighLevel()
   {
      return true;
   }

   //==========================================================================
   //==========================================================================
   virtual RmSampler* GetSampler( const RM_TCHAR *strSamplerName );

   //==========================================================================
   //==========================================================================
   virtual void DeleteSampler( const RM_TCHAR *strSamplerName );

   //==========================================================================
   //==========================================================================
   virtual bool AddSampler( RmSampler* pSampler );

   //==========================================================================
   //==========================================================================
   virtual void DeleteAllSamplers();

   //==========================================================================
   //==========================================================================
   virtual int  GetNumSamplers() const                               {     return m_samplerList.size(); };

   //==========================================================================
   //==========================================================================
   virtual RmSamplerListIterator        BeginSamplers()           {     return m_samplerList.begin();   }

   //==========================================================================
   //==========================================================================
   virtual RmSamplerListConstIterator   BeginSamplers()  const    {     return m_samplerList.begin();   }

   //==========================================================================
   //==========================================================================
   virtual RmSamplerListIterator        EndSamplers()             {     return m_samplerList.end();     }

   //==========================================================================
   //==========================================================================
   virtual RmSamplerListConstIterator   EndSamplers()    const    {     return m_samplerList.end();     }

   //==========================================================================
   //==========================================================================
   virtual void AddParameterDeclaration( RmNode *pParameterNode, int nRegisterIndex )   {};


protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmHLShaderChildRuleList ); }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmHLShaderChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmHLShaderChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmShader::SetType( RmStringT( RmStringT( _T("RmHLShader.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

protected:

   RmSamplerList m_samplerList;      
     
private :
   static RmNodeTypeChildRuleList  *m_pRmHLShaderChildRuleList; 
   
}; // End of RmHLShader class definition


//=============================================================================
//=============================================================================
class RM_API RmHLSLShader : public RmHLShader
{
public:
   //==========================================================================
   //==========================================================================
   RmHLSLShader();

   //==========================================================================
   //==========================================================================
   RmHLSLShader( const RM_TCHAR* strName, bool bPixelShader );

   //==========================================================================
   //==========================================================================
   virtual ~RmHLSLShader();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void AddParameterDeclaration( RmNode *pParameterNode, int nRegisterIndex );

   //==========================================================================
   //==========================================================================
   RmStringT& GetDisassemblyCode()                                {      return m_strDisassembly;            }

   //==========================================================================
   //==========================================================================
   void SetDisassemblyCode( RmStringT rstrDisassembly )        {      m_strDisassembly = rstrDisassembly; }

   //==========================================================================
   //==========================================================================
   void SetDisassemblyCode( const RM_TCHAR* strDisassembly )   {      m_strDisassembly = strDisassembly; }
   
   //==========================================================================
   //==========================================================================
   void SetTarget( const RM_TCHAR* strTarget );

   //==========================================================================
   //==========================================================================
   const RmStringT& GetTarget()                                   {     return m_strTarget;        }
   
   //==========================================================================
   //==========================================================================
   void SetEntryPoint( const RM_TCHAR* strEntryPt );

   //==========================================================================
   //==========================================================================
   const RmStringT& GetEntryPoint()                               {     return m_strEntryPt;       }
   
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmHLSLShaderChildRuleList ); }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmHLSLShaderChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmHLSLShaderChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmHLShader::SetType( RmStringT( RmStringT( _T("RmHLSLShader.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )

private:

   RmStringT m_strTarget;           
   RmStringT m_strEntryPt;          
   RmStringT m_strDisassembly;      
   
private :
   static RmNodeTypeChildRuleList  *m_pRmHLSLShaderChildRuleList; 
   
};    // End of RmHLSLShader class definition


//=============================================================================
//=============================================================================
class RM_API RmGLShader : public RmHLShader
{
public:
   //==========================================================================
   //==========================================================================
   RmGLShader();

   //==================================================================================================
   //==================================================================================================
   RmGLShader( const RM_TCHAR* strName, bool bPixelShader );   
   
   //==========================================================================
   //==========================================================================
   virtual ~RmGLShader();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual void AddParameterDeclaration( RmNode *pParameterNode, int nRegisterIndex );


   //======================================================================
   //======================================================================

private:
   virtual void                              DeleteConstant( int nRegister );
   virtual void                              DeleteConstant( const RM_TCHAR *strConstantName );
   virtual void                              DeleteAllConstants();
   virtual bool                              AddConstant( RmShaderConstant *pConstant );
   virtual RmShaderConstant*                 GetConstant( int nRegister );
   virtual RmShaderConstant*                 GetConstant( const RM_TCHAR *strConstantName );
   virtual RmShaderConstant*                 GetConstantByIndex( int nIndex );
   virtual int                               GetNumConstants() const;
   virtual RmShaderConstantListIterator      BeginConstants();
   virtual RmShaderConstantListConstIterator BeginConstants()  const;
   virtual RmShaderConstantListIterator      EndConstants();
   virtual RmShaderConstantListConstIterator EndConstants()    const;

   virtual RmSampler*                  GetSampler( const RM_TCHAR *strSamplerName );
   virtual void                        DeleteSampler( const RM_TCHAR *strSamplerName );
   virtual bool                        AddSampler( RmSampler* pSampler );
   virtual void                        DeleteAllSamplers();
   virtual int                         GetNumSamplers() const;
   virtual RmSamplerListIterator       BeginSamplers();
   virtual RmSamplerListConstIterator  BeginSamplers()  const;
   virtual RmSamplerListIterator       EndSamplers();
   virtual RmSamplerListConstIterator  EndSamplers()    const;


protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmGLShaderChildRuleList ); }
   
   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmGLShaderChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmGLShaderChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

   //==========================================================================
   //==========================================================================
   virtual void SetType( const RM_TCHAR* strNewType )
   {
      RmHLShader::SetType( RmStringT( RmStringT( _T("RmGLShader.") ) + RmStringT( strNewType ) ) );

   } // End of SetType( const RM_TCHAR* strNewType )
   
private :
   static RmNodeTypeChildRuleList  *m_pRmGLShaderChildRuleList; 
   
};    // End of RmGLShader class definition


//=============================================================================
//=============================================================================
class RM_API RmModelData : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmModelData();

   //=========================================================================
   //=========================================================================
   RmModelData( const RM_TCHAR* strName, const RM_TCHAR* strFileName );   

   //==========================================================================
   //==========================================================================
   virtual ~RmModelData();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();

   //=========================================================================
   //=========================================================================
   void SetFileName( const RM_TCHAR* strFileName, bool bUpdateDatabase = true );

   //=========================================================================
   //=========================================================================
   const RmStringT& GetFileName();

   //=========================================================================
   //=========================================================================
   void GetFullFileName( RM_TCHAR* strFullPath, int nSize );

   //=========================================================================
   //=========================================================================
   bool LoadModel();

   //=========================================================================
   //=========================================================================
   bool CreateMeshModelContainer();

   //=========================================================================
   //=========================================================================
   RmMeshModelContainer*       GetMeshContainer()        { return m_pModelContainer; };

   //=========================================================================
   //=========================================================================
   const RmMeshModelContainer* GetMeshContainer() const  { return m_pModelContainer; };

   //=========================================================================
   //=========================================================================
   void SetOrientation( RmModelOrientation modelOrientation ) { m_modelOrientation = modelOrientation; }
   
   //=========================================================================
   //=========================================================================
   RmModelOrientation GetOrientation() { return( m_modelOrientation ); }
   
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmModelDataChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmModelDataChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmModelDataChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmStringT             m_strFileName;       
   RmMeshModelContainer *m_pModelContainer;  
   bool                  m_bModelLoaded;      
   RmModelOrientation    m_modelOrientation;  

private :
   static RmNodeTypeChildRuleList  *m_pRmModelDataChildRuleList; 

}; // End of RmModelData class definition


//=============================================================================
//=============================================================================
class RM_API RmModelReference : public RmNode  
{   
public:

   //==========================================================================
   //==========================================================================
   RmModelReference();

   //==========================================================================
   //==========================================================================
   RmModelReference( const RM_TCHAR* strName );

   //==========================================================================
   //==========================================================================
   virtual ~RmModelReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();   

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();

   //=========================================================================
   //=========================================================================
   void SetReference( RmModelData* pModel );

   //=========================================================================
   //=========================================================================
   RmModelData* GetReference()         
   {
      return m_pModel;
   }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmModelReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmModelReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmModelReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmModelData*         m_pModel;            

private :
   static RmNodeTypeChildRuleList  *m_pRmModelReferenceChildRuleList; 

}; // End of RmModelReference class definition 

RM_API RmModelData* RmAddModel( RmNode *node, RM_TCHAR *name, RM_TCHAR *filename );


//=============================================================================
//=============================================================================
class RM_API RmRenderableTexture : public Rm2DTextureVariable 
{
public:

   //==========================================================================
   //==========================================================================
   RmRenderableTexture();

   //==========================================================================
   //==========================================================================
   RmRenderableTexture( const RM_TCHAR* strName, int nWidth, int nHeight, unsigned int unFormat,
                        bool bUseViewportDims, bool bGenerateMipMaps );

   //==========================================================================
   //==========================================================================
   virtual ~RmRenderableTexture();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid() { return( RmVariable::IsNodeValid() ); }
   
   //==========================================================================
   //==========================================================================
   virtual bool LoadTexture();
   
   //==========================================================================
   //==========================================================================
   int   GetWidth()                                   {        return m_nWidth;                 }
   
   //==========================================================================
   //==========================================================================
   void  SetWidth( int nWidth )                       {        m_nWidth = nWidth;               }

   //==========================================================================
   //==========================================================================
   int  GetHeight()                                   {        return m_nHeight;                }

   //==========================================================================
   //==========================================================================
   void SetHeight( int nHeight )                      {        m_nHeight = nHeight;             }

   //==========================================================================
   //==========================================================================
   float GetWidthRatio()                              {        return m_fWidthRatio;            }
   
   //==========================================================================
   //==========================================================================
   void SetWidthRatio( float fWidthRatio )            {        m_fWidthRatio = fWidthRatio;     }

   //==========================================================================
   //==========================================================================
   float GetHeightRatio()                             {        return m_fHeightRatio;           }

   //==========================================================================
   //==========================================================================
   void SetHeightRatio( float fHeightRatio )          {        m_fHeightRatio = fHeightRatio;   }
   
   //==========================================================================
   //==========================================================================
   unsigned int GetFormat()                           {        return m_unFormat;               }

   //==========================================================================
   //==========================================================================
   void SetFormat( unsigned int unFormat )            {        m_unFormat = unFormat;           }

   //==========================================================================
   //==========================================================================
   bool UseViewportDimensions()                       {        return m_bUseViewportDims;       }

   //==========================================================================
   //==========================================================================
   void SetUseViewportDimensions( bool bUse )         {        m_bUseViewportDims = bUse;       }

   //==========================================================================
   //==========================================================================
   bool GenerateMipMaps()                             {        return m_bGenerateMipMaps;       }

   //==========================================================================
   //==========================================================================
   void SetGenerateMipMaps( bool bValue )             {        m_bGenerateMipMaps = bValue;     }

   //==========================================================================
   //==========================================================================
   int GetHandle()                                       {        return m_nHandle;             }

   //==========================================================================
   //==========================================================================
   void SetHandle( int nHandle )                      {        m_nHandle = nHandle;             }


protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmRenderableTextureChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmRenderableTextureChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmRenderableTextureChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   int          m_nWidth;              
   int          m_nHeight;             
   unsigned int m_unFormat;            
   bool         m_bUseViewportDims;    
   float        m_fWidthRatio;         
   float        m_fHeightRatio;        
   bool         m_bGenerateMipMaps;    

   int          m_nHandle;             

private:
   static RmNodeTypeChildRuleList  *m_pRmRenderableTextureChildRuleList; 

}; // End of RmRenderableTexture class definition

typedef RmLinkedList< RmRenderableTexture* >    RmRenderableTextureList;
typedef RmRenderableTextureList::iterator       RmRenderableTextureListIterator;
typedef RmRenderableTextureList::const_iterator RmRenderableTextureListConstIterator;
 
//=============================================================================
//=============================================================================
class RM_API RmRenderTarget : public RmNode 
{
public:

   //==========================================================================
   //==========================================================================
   RmRenderTarget();

   RmRenderTarget( int nIndex );
   
   //===========================================================================================
   //===========================================================================================
   RmRenderTarget(   const RM_TCHAR* strName,
                     int nIndex,
                     DWORD dwClearColor,
                     bool bEnableColorClear,
                     bool bEnableDepthClear,
                     float fDepthClearValue,
                     RmRenderableTexture* pTexture = NULL );

   //==========================================================================
   //==========================================================================
   virtual ~RmRenderTarget();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   void SetRenderToScreen( bool bRenderToScreen = true ) { m_bRenderToScreen = bRenderToScreen; }
   
   //==========================================================================
   //==========================================================================
   bool IsRenderToScreen()                    {         return m_bRenderToScreen;       }

   //==========================================================================
   //==========================================================================
   void EnableColorClear( bool bClear )        {        m_bColorClear = bClear;       }

   //==========================================================================
   //==========================================================================
   bool IsColorClearEnabled()                   {        return m_bColorClear;         }

   //==========================================================================
   //==========================================================================
   bool IsDepthClearEnabled()                   {        return m_bDepthClear;         }

   //==========================================================================
   //==========================================================================
   void EnableDepthClear( bool bDepthClear )    {        m_bDepthClear = bDepthClear;  }
   
   //==========================================================================
   //==========================================================================
   float GetDepthClearValue()                      {        return m_fDepthClear;         }
   
   //==========================================================================
   //==========================================================================
   void  SetDepthClearValue( float fDepth )     {        m_fDepthClear = fDepth;       }

   //==========================================================================
   //==========================================================================
   RM_RGBA GetClearColor()                      {        return m_dwClearColor;        }

   //==========================================================================
   //==========================================================================
   void SetClearColor( RM_RGBA dwColor )        {        m_dwClearColor = dwColor;     }

   //==========================================================================
   //=========================================================================
   virtual bool IsNodeValid();

   //==========================================================================
   //==========================================================================
   void SetRenderableTexture( RmRenderableTexture* pTexture );

   //==========================================================================
   //==========================================================================
   RmRenderableTexture* GetRenderableTexture()     {        return m_pRTexture;           }

   //==========================================================================
   //==========================================================================
   int GetIndex()                                           { return m_nIndex;            }

   //==========================================================================
   //==========================================================================
   void SetIndex( int nIndex )                              { m_nIndex = nIndex;          }  
   
   //==========================================================================
   //==========================================================================
   void SetHandle( unsigned int unHandle )      {        m_unHandle = unHandle;        }

   //==========================================================================
   //==========================================================================
   unsigned int GetHandle()                        {        return m_unHandle;            }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmRenderTargetChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmRenderTargetChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmRenderTargetChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   RmRenderableTexture* m_pRTexture; 

   int            m_nIndex;          

   bool           m_bRenderToScreen; 

   bool           m_bColorClear;     
   bool           m_bDepthClear;     

   RM_RGBA        m_dwClearColor;    
   float          m_fDepthClear;     

   unsigned int   m_unHandle;        

private:
   static RmNodeTypeChildRuleList  *m_pRmRenderTargetChildRuleList; 

}; // End of RmRenderTarget class definition

typedef RmLinkedList< RmRenderTarget* >    RmRenderTargetList;
typedef RmRenderTargetList::iterator       RmRenderTargetListIterator;
typedef RmRenderTargetList::const_iterator RmRenderTargetListConstIterator;


//=============================================================================
//=============================================================================
class RM_API RmState: public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmState()
   {
      SetType( RM_STATE_TYPE );
      m_bHidden   = true;
      m_ulState   = 0;
      m_ulValue   = 0;
      m_strUsage  = _T("");
   };

   //==========================================================================
   //==========================================================================
   RmState(unsigned long ulStateType, unsigned long ulStateValue, RM_TCHAR* pStrUsage )
   {
      SetType( RM_STATE_TYPE );
      m_bHidden   = true;
      m_ulState   = ulStateType;
      m_ulValue   = ulStateValue;
      m_strUsage  = pStrUsage;
   }

   //==========================================================================
   //==========================================================================
   virtual ~RmState()    {};

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   unsigned long GetStateType()                       {     return m_ulState;           }

   //==========================================================================
   //==========================================================================
   void SetStateType( unsigned long ulType )          {     m_ulState = ulType;         }

   //==========================================================================
   //==========================================================================
   unsigned long GetValue()                           {     return m_ulValue;          }

   //==========================================================================
   //==========================================================================
   void SetValue( unsigned long nValue )              {     m_ulValue = nValue;        }

   //==========================================================================
   //==========================================================================
   const RmStringT& GetUsage()                         {     return m_strUsage;          }

   //==========================================================================
   //==========================================================================
   void SetUsage( const RM_TCHAR* pStrUsage )          {      m_strUsage = RmStringT( pStrUsage );   }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

protected:
   unsigned long  m_ulState;        
   unsigned long  m_ulValue;        
   RmStringT      m_strUsage;       

private:
   static RmNodeTypeChildRuleList  *m_pRmStateChildRuleList; 

}; // End of RmState class definition


typedef RmLinkedList<RmState *>      RmStateList;
typedef RmStateList::iterator       RmStateListIterator;
typedef RmStateList::const_iterator RmStateListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmTextureReference : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmTextureReference();

   //==========================================================================
   //==========================================================================
   RmTextureReference( const RM_TCHAR* strTextureName );

   //==========================================================================
   //==========================================================================
   virtual ~RmTextureReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //==========================================================================
   virtual bool IsNodeValid();

   //==========================================================================
   //==========================================================================
   RmNode* GetReference()                             {      return m_pTextureNode;             }

   //==========================================================================
   //==========================================================================
   void SetReference( RmNode* pTextureVariable );

   //==========================================================================
   //==========================================================================
   int   GetHandle()                                  {        return m_nHandle;                }

   //=========================================================================
   //==========================================================================
   void  SetHandle( int nHandle )                  {        m_nHandle = nHandle;             }
   
protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmTextureReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmTextureReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmTextureReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:     

   RmNode*              m_pTextureNode;         
   int                  m_nHandle;              

private:
   static RmNodeTypeChildRuleList  *m_pRmTextureReferenceChildRuleList; 

}; // End of RmTextureReference class definition


//=============================================================================
//=============================================================================
class RM_API RmTextureObject : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmTextureObject();

   //==========================================================================
   //==========================================================================
   RmTextureObject( bool bVertexTexture, int nStageIndex, const RM_TCHAR *pStrAPI );

   //==========================================================================
   //==========================================================================
   virtual ~RmTextureObject();

   //==========================================================================
   //==========================================================================
   void Initialize();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();

   //=========================================================================
   //=========================================================================
   bool AddTextureReference( RmTextureReference* pTextureRef );
   
   //=========================================================================
   //=========================================================================
   void DeleteTextureReference();

   //=========================================================================
   //=========================================================================
   RmTextureReference* GetTextureReference()                {     return m_pTextureRef;      }

   //=========================================================================
   //=========================================================================
   RmState* FindTextureStageState( unsigned long ulType );

   //=========================================================================
   //=========================================================================
   bool AddTextureStageState( RmState* pTextureState );

   //=========================================================================
   //=========================================================================
   void DeleteTextureStageState( unsigned long ulType );

   //=========================================================================
   //
   //=========================================================================
   RmState* FindSamplerState( unsigned long ulType );

   //=========================================================================
   //=========================================================================
   bool AddSamplerState( RmState* pSamplerState );

   //=========================================================================
   //=========================================================================
   void DeleteSamplerState( unsigned long ulType );

   //=========================================================================
   //=========================================================================
   int GetStageIndex()                                         {        return m_nStageIndex;            }

   //=========================================================================
   //=========================================================================
   void SetStageIndex( int nIndex )                         {        m_nStageIndex = nIndex;          }  

   //=========================================================================
   //=========================================================================
   RmStateListIterator        BeginTextureStageStates()           {     return m_textureStageStates.begin();   }

   //=========================================================================
   //=========================================================================
   RmStateListConstIterator   BeginTextureStageStates()  const    {     return m_textureStageStates.begin();   }
   
   //=========================================================================
   //=========================================================================
   RmStateListIterator        EndTextureStageStates()             {     return m_textureStageStates.end();     }

   //=========================================================================
   //=========================================================================
   RmStateListConstIterator   EndTextureStageStates()    const    {     return m_textureStageStates.end();     }

   //=========================================================================
   //=========================================================================
   RmStateListIterator        BeginSamplerStates()                {     return m_samplerStates.begin();        }
   
   //=========================================================================
   //=========================================================================
   RmStateListConstIterator   BeginSamplerStates()  const         {     return m_samplerStates.begin();        }
   
   //=========================================================================
   //=========================================================================
   RmStateListIterator        EndSamplerStates()                  {     return m_samplerStates.end();          }

   //=========================================================================
   //=========================================================================
   RmStateListConstIterator   EndSamplerStates()    const         {     return m_samplerStates.end();          }

   //=========================================================================
   //=========================================================================
   bool IsVertexTexture()                                         {     return m_bVertexTexture; }
   

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmTextureObjectChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmTextureObjectChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmTextureObjectChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   int                 m_nStageIndex;         
   RmStateList         m_textureStageStates;  
   RmStateList         m_samplerStates;       
   RmTextureReference *m_pTextureRef;         
   bool                m_bVertexTexture;      

private:
   static RmNodeTypeChildRuleList  *m_pRmTextureObjectChildRuleList; 

}; // End of RmTextureObject class definition

typedef RmLinkedList< RmTextureObject* >    RmTextureObjectList;
typedef RmTextureObjectList::iterator       RmTextureObjectListIterator;
typedef RmTextureObjectList::const_iterator RmTextureObjectListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmLightReference : public RmNode  
{
public: 

   //==========================================================================
   //==========================================================================
   RmLightReference();

   //==========================================================================
   //==========================================================================
   RmLightReference( const RM_TCHAR *strLightName );

   //==========================================================================
   //==========================================================================
   virtual ~RmLightReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   virtual bool IsNodeValid()                      { return( ( NULL != m_pLightNode ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   RmNode* GetReference()                             { return m_pLightNode; }

   //==========================================================================
   //==========================================================================
   void SetReference( RmLightVariable* pRmLightVariable );

protected: 

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmLightReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmLightReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmLightReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected: 

   RmLightVariable   *m_pLightNode; 

private:
   static RmNodeTypeChildRuleList  *m_pRmLightReferenceChildRuleList; 

}; // End of RmLightReference class definition

//=============================================================================
//=============================================================================
class RM_API RmLightObject : public RmNode  
{
public: 

   //==========================================================================
   //==========================================================================
   RmLightObject();

   //==========================================================================
   //==========================================================================
   RmLightObject( int nStageIndex, const RM_TCHAR *pStrAPI );

   //==========================================================================
   //==========================================================================
   virtual ~RmLightObject();

   //==========================================================================
   //==========================================================================
   void Initialize();

   //==========================================================================
   //==========================================================================
    virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid()                               { return( ( NULL != m_pLightReference ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   bool AddLightReference( RmLightReference *pLightReference );
   
   //==========================================================================
   //==========================================================================
   void DeleteLightReference();
   
   //==========================================================================
   //==========================================================================
   RmLightReference* LightReference()                       { return m_pLightReference;   }

   //==========================================================================
   //==========================================================================
   int GetIndex()                                              { return m_nIndex;            }

   //==========================================================================
   //==========================================================================
   void SetIndex( int nIndex )                              { m_nIndex = nIndex;          }  

protected: 

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmLightObjectChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmLightObjectChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmLightObjectChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected: 

   int               m_nIndex;            
   RmLightReference *m_pLightReference;   

private:
   static RmNodeTypeChildRuleList  *m_pRmLightObjectChildRuleList; 

}; // End of RmLightObject class definition

typedef RmLinkedList< RmLightObject*>     RmLightObjectList;
typedef RmLightObjectList::iterator       RmLightObjectListIterator;
typedef RmLightObjectList::const_iterator RmLightObjectListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmMaterialReference : public RmNode  
{
public: 

   //==========================================================================
   //==========================================================================
   RmMaterialReference();

   //==========================================================================
   //==========================================================================
   RmMaterialReference( const RM_TCHAR *strMaterialName );

   //==========================================================================
   //==========================================================================
   virtual ~RmMaterialReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid()                      { return( ( NULL != m_pMaterialNode ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   RmNode* GetReference()                             { return m_pMaterialNode; }

   //==========================================================================
   //==========================================================================
   void SetReference( RmMaterialVariable *pRmMaterialVariable );

protected: 

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmMaterialReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmMaterialReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmMaterialReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected: 

   RmMaterialVariable *m_pMaterialNode; 

private:
   static RmNodeTypeChildRuleList  *m_pRmMaterialReferenceChildRuleList; 

}; // End of RmMaterialReference class definition

//=============================================================================
//=============================================================================
class RM_API RmMaterialObject : public RmNode  
{
public: 

   //==========================================================================
   //==========================================================================
   RmMaterialObject();

   //==========================================================================
   //==========================================================================
   RmMaterialObject( int nStageIndex, const RM_TCHAR *pStrAPI );

   //==========================================================================
   //==========================================================================
   virtual ~RmMaterialObject();

   //==========================================================================
   //==========================================================================
   void Initialize();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid()    { return( ( NULL != m_pMaterialReference ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   bool AddMaterialReference( RmMaterialReference *pMaterialReference );
   
   //==========================================================================
   //==========================================================================
   void DeleteMaterialReference();
   
   //==========================================================================
   //==========================================================================
   RmMaterialReference* MaterialReference()                 { return m_pMaterialReference;   }

   //==========================================================================
   //==========================================================================
   int GetIndex()                                           { return m_nIndex;            }

   //==========================================================================
   //==========================================================================
   void SetIndex( int nIndex )                              { m_nIndex = nIndex;          }  

protected: 

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmMaterialObjectChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmMaterialObjectChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmMaterialObjectChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected: 

   int                  m_nIndex;               
   RmMaterialReference *m_pMaterialReference;   

private:

   static RmNodeTypeChildRuleList  *m_pRmMaterialObjectChildRuleList; 

}; // End of RmMaterialObject class definition

typedef RmLinkedList< RmMaterialObject* >    RmMaterialObjectList;
typedef RmMaterialObjectList::iterator       RmMaterialObjectListIterator;
typedef RmMaterialObjectList::const_iterator RmMaterialObjectListConstIterator;

//=============================================================================
//=============================================================================
class RM_API RmRenderStateBlock : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmRenderStateBlock();

   //==========================================================================
   //==========================================================================
   virtual ~RmRenderStateBlock();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   RmState* FindRenderState( unsigned long state );

   //==========================================================================
   //==========================================================================
   bool AddRenderState( RmState* pState );

   //==========================================================================
   //==========================================================================
   void DeleteRenderState( unsigned long state );

   //==========================================================================
   //==========================================================================
   RmStateListIterator        BeginRenderStates()        {     return m_stateList.begin();   }

   //==========================================================================
   //==========================================================================
   RmStateListConstIterator   BeginRenderStates()  const {     return m_stateList.begin();   }

   //==========================================================================
   //==========================================================================
   RmStateListIterator        EndRenderStates()          {     return m_stateList.end();     }

   //==========================================================================
   //==========================================================================
   RmStateListConstIterator   EndRenderStates()    const {     return m_stateList.end();     }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmRenderStateBlockChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmRenderStateBlockChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmRenderStateBlockChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:  

   RmStateList m_stateList;      

private:
   static RmNodeTypeChildRuleList  *m_pRmRenderStateBlockChildRuleList; 

}; // End of RmRenderStateBlock class definition


//=============================================================================
//=============================================================================
class RM_API RmCamera : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmCamera();

   //==========================================================================
   //==========================================================================
   virtual ~RmCamera() {};

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //==========================================================================
   //==========================================================================
   void SetPosition( RmVector3D& pNewPosition )
   {
      m_cameraPosition.x = pNewPosition.x;
      m_cameraPosition.y = pNewPosition.y;
      m_cameraPosition.z = pNewPosition.z;
   }

   //==========================================================================
   //==========================================================================
   void SetPosition( float x, float y, float z )
   {
      m_cameraPosition.x = x;
      m_cameraPosition.y = y;
      m_cameraPosition.z = z;
   }

   //==========================================================================
   //==========================================================================
   void SetLookAt( RmVector3D& pNewLookAt )
   {
      m_lookAtVector.x = pNewLookAt.x;
      m_lookAtVector.y = pNewLookAt.y;
      m_lookAtVector.z = pNewLookAt.z;
   }

   //==========================================================================
   //==========================================================================
   void SetLookAt( float x, float y, float z )
   {
      m_lookAtVector.x = x;
      m_lookAtVector.y = y;
      m_lookAtVector.z = z;
   }
   
   //==========================================================================
   //==========================================================================
   void SetUp( RmVector3D& pNewUp )
   {
      m_upVector.x = pNewUp.x;
      m_upVector.y = pNewUp.y;
      m_upVector.z = pNewUp.z;
   }

   //==========================================================================
   //==========================================================================
   void SetUp( float x, float y, float z )
   {
      m_upVector.x = x;
      m_upVector.y = y;
      m_upVector.z = z;
   }

   //==========================================================================
   //==========================================================================
   void SetFOV( float fFOV )                       { m_fFOV = fFOV; }

   //==========================================================================
   //==========================================================================
   void SetNearClipPlane( float fNearClipPlane )   { m_fNearClipPlane = fNearClipPlane; }

   //==========================================================================
   //==========================================================================
   void SetFarClipPlane( float fFarClipPlane )     { m_fFarClipPlane = fFarClipPlane; }

   //==========================================================================
   //==========================================================================
   RmVector3D  GetPosition()  { return( m_cameraPosition ); }

   //==========================================================================
   //==========================================================================
   RmVector3D  GetLookAtPosition()    { return( m_lookAtVector ); }

   //==========================================================================
   //==========================================================================
   RmVector3D  GetUp();
   
   //==========================================================================
   //==========================================================================
   RmVector3D  GetLookAt();

   //==========================================================================
   //==========================================================================
   RmVector3D  GetCross();

   //==========================================================================
   //==========================================================================
   float GetFOV()             { return m_fFOV; }

   //==========================================================================
   //==========================================================================
   float GetNearClipPlane()   { return m_fNearClipPlane; }

   //==========================================================================
   //==========================================================================
   float GetFarClipPlane()    { return m_fFarClipPlane; }

   //==========================================================================
   //==========================================================================
   void SetCameraParameters( const RmMatrix4x4 &mat, bool bSetLookAt );

   //==========================================================================
   //==========================================================================
   RmMatrix4x4 GetCameraMatrix();

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmCameraChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmCameraChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmCameraChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

   RmVector3D m_cameraPosition; 
   RmVector3D m_lookAtVector;   
   RmVector3D m_upVector;       

   float m_fFOV;                
   float m_fNearClipPlane;      
   float m_fFarClipPlane;       

   RmProjectionMode  m_projectionMode;

private:
   static RmNodeTypeChildRuleList  *m_pRmCameraChildRuleList; 

}; // End of RmCamera class definition

//=============================================================================
//=============================================================================
class RM_API RmCameraReference : public RmNode  
{
public:

   //==========================================================================
   //==========================================================================
   RmCameraReference();

   //==========================================================================
   //==========================================================================
   RmCameraReference( const RM_TCHAR* strName );

   //==========================================================================
   //==========================================================================
   virtual ~RmCameraReference();

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();

   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid() { return( ( NULL != m_pCamera ) ? RmNode::IsNodeValid() : false ); };

   //==========================================================================
   //==========================================================================
   void SetReference( RmCamera* pRmCamera );

   //==========================================================================
   //==========================================================================
   bool IsUseActiveCamera()                           { return( m_bUseActiveCamera ); }

   //==========================================================================
   //==========================================================================
   void SetUseActiveCamera( bool bUseActiveCamera );

   //==========================================================================
   //==========================================================================
   RmCamera* GetReference()                           {   return m_pCamera; }

protected:

   //==========================================================================
   //==========================================================================
   virtual void CopyNodeData( RmNode *pDestinationNode, bool bIncludeLoadedData );

   //==========================================================================
   //==========================================================================
   virtual RmNodeTypeChildRuleList* GetNodeTypeChildRuleList() { return( m_pRmCameraReferenceChildRuleList ); }

   //==========================================================================
   //==========================================================================
   virtual void SetNodeTypeChildRuleList( RmNodeTypeChildRuleList* pRmNodeChildRuleList )
   {
      assert( NULL == m_pRmCameraReferenceChildRuleList );
      assert( NULL != pRmNodeChildRuleList );
      
      m_pRmCameraReferenceChildRuleList = pRmNodeChildRuleList;
      
   } // End virtual void SetNodeTypeChildRuleList()           

protected:

   RmCamera *m_pCamera;             
   bool      m_bUseActiveCamera;    


private:
   static RmNodeTypeChildRuleList  *m_pRmCameraReferenceChildRuleList; 

}; // End of RmCameraReference class definition

//=============================================================================
//=============================================================================
class RM_API RmPass : public RmNode  
{
public:
   //==========================================================================
   //==========================================================================
   RmPass(); 

   //==========================================================================
   //==========================================================================
   RmPass( const RM_TCHAR *strPassName, const int nPassIndex );

   //==========================================================================
   //==========================================================================
   virtual ~RmPass();

   //==========================================================================
   //==========================================================================
   bool virtual AddChild( RmNode *pChildNode, RmNode *pNextSibling = NULL );

   //==========================================================================
   //==========================================================================
   virtual void Update( RmNodeUpdateType nodeUpdateType /* = RM_NODE_GENERAL_UPDATE */, RmNode *pRmUpdateRootNode /* = NULL */ );                      

   //==========================================================================
   //==========================================================================
   virtual bool LoadXMLData( int hDoc, const RM_TCHAR *strXPath, const RM_TCHAR *strRmXMLVersion );
   
   //==========================================================================
   //==========================================================================
   virtual bool SaveXMLData( int hDoc, const RM_TCHAR *strXPath );

   //==========================================================================
   //==========================================================================
   virtual RmNode* Clone( bool bIncludeLoadedData );

   //==========================================================================
   // \brief Description of the node
   //==========================================================================
   virtual const RM_TCHAR* GetDescription();
   
   //=========================================================================
   //=========================================================================
   virtual bool IsNodeValid();
   
   //==========================================================================
   //==========================================================================
   bool AddVertexShader( RmShader *pVertexShader );

   //==========================================================================
   //==========================================================================
   bool AddPixelShader( RmShader *pPixelShader );

   //==========================================================================
   //==========================================================================
   RmShader* GetVertexShader()         {    return m_pVertexShader;     }

   //==========================================================================
   //==========================================================================
   RmShader* GetPixelShader()          {     return m_pPixelShader;     }

   //==========================================================================
   //==========================================================================
   RmShader* GetActivePixelShader();

   //==========================================================================
   //==========================================================================
   RmShader* GetActiveVertexShader();

   //==========================================================================
   //==========================================================================
   RmShader* GetShader( const RM_TCHAR *strShaderName );

   //==========================================================================
   //==========================================================================
   bool AddStreamMappingReference( RmStreamMapReference *pStreamMapReference );

   //==========================================================================
   //==========================================================================
   RmStreamMap* GetStreamMap();

   //==========================================================================
   //==========================================================================
   RmStreamMapReference* GetStreamMapReference()      {  return m_pStreamMapReference; }   
   
   //==========================================================================
   //==========================================================================
   bool AddRenderStateBlock( RmRenderStateBlock *pBlock );

   //==========================================================================
   //==========================================================================
   RmRenderStateBlock* GetRenderStateBlock()    {     return m_pRenderStateBlock;   }

   //==========================================================================
   //==========================================================================
   int GetNumTextureObjects()                   {  return m_textureObjectList.size();  }

   //==========================================================================
   //==========================================================================
   int GetNumVertexTextureObjects()             {  return m_vertexTextureObjectList.size();  }
   
   //==========================================================================