RmDefines.h

//=================================================================================================//
// filename: RmDefines.h                                                                          //
//                                                                                                 //
//           ATI Research, Inc.                                                                    //
//           3D Application Research Group                                                         //
//                                                                                                 //
// Description: declaration file for RenderMonkey real-time Framework.                             //
//                                                                                                 //
//=================================================================================================//
//   (C) 2004 ATI Research, Inc.  All rights reserved.                                             //
//=================================================================================================//

#ifndef _RM_CORE_DEFINES_H_
#define _RM_CORE_DEFINES_H_

//==================================================================================================//
// RenderMonkey plug-in/application messages. These are the messages propagated by the application  //
// at run-time to communicate with the opened plug-ins. A plug-in can send out a custom message,    //
// however, the message will be broadcast either to all opened plug-ins or to all plug-ins of the   //
// specified type. See IRmApplication interface BroadcastMessage() methods for more details.        //
//==================================================================================================//

//--------------------------------------------------------------------------------------------------//
// Run-time database related messages
//--------------------------------------------------------------------------------------------------//

// A given node was updated, int nMessageData to the message handler contains RmNode* that was updated
#define  RM_MSG_NODE_UPDATED              1  

// This message gets sent out before a given node will be deleted from its place in the database
// All of the other nodes that may have been referencing the node to be deleted are still pointing
// to the node at this point. After this message the node will be removed from the database.
// int nMessageData to the message handler contains RmNode* that was deleted
#define  RM_MSG_NODE_ABOUT_TO_BE_DELETED  2  

// This message gets sent out after a node was deleted (removed from the database). 
// int nMessageData to the message handler contains RmNode* that was deleted
#define  RM_MSG_NODE_DELETED              3  

// A given node was added to the workspace. int nMessageData to the message handler contains RmNode* 
// that was added to the workspace:
#define  RM_MSG_NODE_ADDED                4

// A given node name was changed, int nMessageData to the message handler contains RmNode* that was updated
// int nMessageParameter contains a pointer to RmStringT (RmStringT*) which contains the old name (before
// rename happened) of the specified node:
#define  RM_MSG_NODE_NAME_CHANGED         5  

// A given node value was changed, int nMessageData to the message handler contains RmNode* that was updated
#define  RM_MSG_NODE_VALUE_CHANGED        6  

// This message is used to notify plug-ins that a particular docking pane was created
// The 'nMessageData' parameter is the integer ID for this docking pane. Any plug-in that
// owns that docking pane window should create the window for it upon receiving this message:
#define  RM_MSG_DOCKPANE_CREATED          7

// This message is sent out when variable node's semantic is changed. The 'nMessageData' field
// of this message contains a pointer to the variable node which semantic was changed
#define  RM_MSG_VARIABLE_SEMANTIC_CHANGED 8

// This message is sent out when a model's orientation is changed. The 'nMessageData' field
// of this message contains a pointer to the model node whose orientation was changed
#define  RM_MSG_MODEL_ORIENTATION_CHANGED 9

// This message is sent out when a texture's origin is changed. The 'nMessageData' field
// of this message contains a pointer to the texture node whose origin was changed
#define  RM_MSG_TEXTURE_ORIGIN_CHANGED 10

// This message is sent out when a the application is beginning a message block.
// This message will not get sent out for nested message blocks, only for the outermost.
#define  RM_MSG_BEGIN_MESSAGE_BLOCK    11

// This message is sent out when a the application is ending a message block.
// This message will not get sent out for nested message blocks, only for the outermost.
#define  RM_MSG_END_MESSAGE_BLOCK      12

// This message is sent out when a node is to be selected in an interface.
// The 'nMessageData' field of this message contains a pointer to the node
#define  RM_MSG_NODE_SELECTED          13

// Reserved number of run-time database-specific messages:
#define  RM_NUM_DATABASE_MSGS             30

//--------------------------------------------------------------------------------------------------//
// RenderMonkey application execution related messages 
//--------------------------------------------------------------------------------------------------//

// Sent out to all open modules to notify them that the application is about to close. 
#define  RM_MSG_APP_CLOSING               (RM_NUM_DATABASE_MSGS + 1)

// Sent out to all open modules to notify them that a new workspace is created
#define  RM_MSG_APP_FILE_NEW              (RM_NUM_DATABASE_MSGS + 2)

// Sent out to all open modules to notify them that a file was opened
#define  RM_MSG_APP_FILE_OPEN             (RM_NUM_DATABASE_MSGS + 3)

// Sent out to all open modules to notify them that a file open operation has started
// (nMessageData is NULL)
#define  RM_MSG_APP_FILE_OPEN_BEGIN       (RM_NUM_DATABASE_MSGS + 4)

// Sent out to all open modules to notify them that a file was opened and the opening operation was finished:
// (nMessageData is NULL)
#define  RM_MSG_APP_FILE_OPEN_COMPLETE    (RM_NUM_DATABASE_MSGS + 5)

// Sent out to all open modules to notify them that a file is about to be closed:
#define  RM_MSG_APP_FILE_CLOSE            (RM_NUM_DATABASE_MSGS + 6)

// Sent out to all open modules to notify them that a file is about to be closed and the operation has started:
// (nMessageData is NULL)
#define  RM_MSG_APP_FILE_CLOSE_BEGIN      (RM_NUM_DATABASE_MSGS + 7)

// Sent out to all open modules to notify them that a file has been closed and the operation was finished:
// (nMessageData is NULL)
#define  RM_MSG_APP_FILE_CLOSE_COMPLETE   (RM_NUM_DATABASE_MSGS + 8)

// Sent out to all open modules before RenderMonkey saves the workspace to make sure that the modules
// propagate any data that they may have into the run-time database before it's saved out to XML. The
// modules may query the user whether the data should be saved.
#define  RM_MSG_APP_QUERY_TO_SAVE_DATA    (RM_NUM_DATABASE_MSGS + 9)

// Sent out to all open modules before RenderMonkey saves the workspace to make sure that the modules
// propagate any data that they may have into the run-time database before it's saved out to XML. The 
// modules should not query the user whether the data should be saved, but just propagate it directly:
#define  RM_MSG_APP_SAVE_DATA             (RM_NUM_DATABASE_MSGS + 10)

// The saving data operation has started (nMessageData is NULL)
#define  RM_MSG_APP_SAVE_DATA_BEGIN       (RM_NUM_DATABASE_MSGS + 11)

// The saving data operation has finished (nMessageData is NULL)
#define  RM_MSG_APP_SAVE_DATA_COMPLETE    (RM_NUM_DATABASE_MSGS + 11)

// Reserved number of application-specific messages:
#define  RM_NUM_APP_MSGS                  (RM_NUM_DATABASE_MSGS + 15)

//--------------------------------------------------------------------------------------------------//
// RenderMonkey viewer-specific messages
//--------------------------------------------------------------------------------------------------//

// A request for the viewer to recreate all resources. Global graphics update for the active effect:
#define RM_VIEW_UPDATE_ALL                      (RM_NUM_APP_MSGS + 1)

// Forces the viewer to reload all textures in the active effect:
#define RM_VIEW_UPDATE_TEXTURES                 (RM_NUM_APP_MSGS + 2)

// Forces the viewer to reload all models in the active effect
#define RM_VIEW_UPDATE_MODELS                   (RM_NUM_APP_MSGS + 3)

// This message forces compilation of all modified ("dirty") shaders in the active effect. Note that
// nMessageData parameter of the shader may contain the following data:
//       RmShader* node - if nMessageData node is a single shader node, then that's the only shader
//                        that needs to be recompiled
//       RmEffect* node - if nMessageData node is an effect node, then the viewer should recompile
//                        all shaders in the specified effect.
//       RmWorkspace* node or NULL - in that case the viewer should recompile all shaders in the workspace
//
#define RM_VIEW_COMPILE_SHADERS                 (RM_NUM_APP_MSGS + 4)

// This message notifies the plug-ins that shader compilation has started:
#define RM_VIEW_COMPILE_SHADERS_BEGIN           (RM_NUM_APP_MSGS + 5)

// This message notifies the plug-ins that shader compilation has finished
// This message data may contain either a RmShader node or an RmPass node for
// which the shaders were compiled.
#define RM_VIEW_COMPILE_SHADERS_COMPLETE        (RM_NUM_APP_MSGS + 6)

// This message notifies the viewer module that the active effect is changes. int parameter contains the new
// RmNode* for the active effect:
#define RM_VIEW_CHANGE_ACTIVE_EFFECT            (RM_NUM_APP_MSGS + 7)

// Changes View's UI Mode ( Rotate, Pan etc )
#define RM_VIEW_SET_UI_MODE                     (RM_NUM_APP_MSGS + 8)

// Reset View to original
#define RM_VIEW_RESET                           (RM_NUM_APP_MSGS + 9)

// This message requests that the active viewer updates the contents of a given
// renderable texture. The pointer to the renderable texture node (RmRenderableTexture)
// is passed as the message parameter for this message
#define RM_VIEW_UPDATE_RENDER_TEXTURE_CONTENTS  (RM_NUM_APP_MSGS + 10)

// This message notifies the viewer to render a frame and to swap buffers if necessary
#define RM_VIEW_RENDER_FRAME_CONTENTS           (RM_NUM_APP_MSGS + 11)

// Reserved number of viewer-specific messages:
#define RM_NUM_VIEW_MSGS                        (RM_NUM_APP_MSGS + 15)
        

// Return codes for RenderMonkey plug-ins' MessageHandler() methods:
#define RM_OK     1  
#define RM_FAIL   0


//--------------------------------------------------------------------------------------------------//
// Miscellaneous RenderMonkey messages
//--------------------------------------------------------------------------------------------------//

// Notifies shader editor to highlight a given line of code: Int nMessageData of the PlugIn message
// handler contains a pointer to a RmHighlightLine structure, containing message details
#define RM_MSG_EDITOR_HIGHLIGHT_LINE         (RM_NUM_VIEW_MSGS + 1)

// Notifies the modules that the shader is about to be compiled
#define RM_MSG_COMMIT_SHADER_CHANGES         (RM_NUM_VIEW_MSGS + 2)  

// Notifies all MDI frame windows that the MDI client windows are going to be tiled vertically:
#define RM_MSG_MDI_CLIENT_TILE_VERTICALLY    (RM_NUM_VIEW_MSGS + 3)  

// Notifies all MDI frame windows that the MDI client windows are going to be tiled horizontally:
#define RM_MSG_MDI_CLIENT_TILE_HORIZONTALLY  (RM_NUM_VIEW_MSGS + 4)  

#define     RM_MSG_USER     100 // Plug-in can use customized message above this number

//--------------------------------------------------------------------------------------------------//
// Windows messages 
//--------------------------------------------------------------------------------------------------//

// Ask MDI window to return the shader node that is actively being edited in the shader editor
#define     RM_WM_MSG_GET_EDITING_SHADER (WM_USER+500)  

// Change page command
#define     RM_COMMAND_ID_CHANGE_PAGE 40021

// Next Error command
#define     RM_COMMAND_ID_NEXT_COMPILE_ERROR 50221

//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
// Resource ID ranges
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//

// Control IDs reserved for the main RenderMonkey application, do not use IDs in this range:
#define     RM_RESOURCE_ID_APP       100
#define     RM_RESOURCE_ID_APP_MAX   500

#define     RM_CONTROL_ID_APP       2000 
#define     RM_CONTROL_ID_APP_MAX   3000 

// Command IDs reserved for the main RenderMonkey application, do not use IDs in this range:
#define     RM_COMMAND_ID_APP       10000 
#define     RM_COMMAND_ID_APP_MAX   20000 
                                        
// Application reserved window messages IDs. All plug-in messages should be in the range 
// outside of this reserved range.  
#define     RM_WIN_MSG_ID_APP      (WM_USER+100)  
#define     RM_WIN_MSG_ID_MAX      (WM_USER+1000)  

// Each plug-in can use resources IDs above RM_RESOURCE_ID_USER value to declare its own resources
#define     RM_RESOURCE_ID_USER    (RM_RESOURCE_ID_APP_MAX+1)

// Each plug-in can use IDs above RM_CONTROL_ID_USER to declare its own control IDs
#define     RM_CONTROL_ID_USER     (RM_CONTROL_ID_APP_MAX+1)

// Each plug-in can use IDs above RM_COMMAND_ID_USER to declare its own command IDs
#define     RM_COMMAND_ID_USER     (RM_COMMAND_ID_APP_MAX+1)
                                        
// Each plug-in can use IDs above RM_WIN_MSG_ID_USER to declare its own windows message IDs
#define     RM_WIN_MSG_ID_USER     (RM_WIN_MSG_ID_MAX+1)  

//--------------------------------------------------------------------------------------------------//
// RenderMonkey native string related defines
//--------------------------------------------------------------------------------------------------//
#define RM_NAME_SIZE          128
#define RM_PATH_SIZE          2048
      
//--------------------------------------------------------------------------------------------------//
// RenderMonkey mesh related defines
//--------------------------------------------------------------------------------------------------//

// Maximum number of stream allowed for a given stream map
#define RM_MAX_NUM_STREAMS             16

// Maximum value of the usage index for each individual stream channel
#define RM_MAX_NUM_VERTEXUSAGE_INDEX   16

//--------------------------------------------------------------------------------------------------//
// RenderMonkey docking window identifiers
//--------------------------------------------------------------------------------------------------//

// Starting docking pane ID
#define RM_DOCKPANE_ID               1000

// Docking pane identifier for workspace tree view window
#define RM_WORKSPACE_DOCKPANE_ID     1000

// Docking pane identifier for artist editor window
#define RM_ARTISTEDITOR_DOCKPANE_ID  1001

// Docking pane identifier for output window
#define RM_OUTPUT_DOCKPANE_ID        1002

// Docking pane identifier for any user-defined plug-in window. 
#define RM_USER_DOCKPANE_ID          1100

// Maximum allowed docking pane identifer for any user-defined plug-in window.
#define RM_USER_DOCKPANE_MAX_ID      2000

// Maximum allowed docking pane identifer for the system
#define RM_DOCKPANE_MAX_ID           2000

//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//
// Predefined variables semantics definitions
//
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//

#define RM_PREDEFINED_TIME_CYCLE_PERIOD                              _T( "TimeCyclePeriod" )
#define RM_PREDEFINED_TIME_0_X                                       _T( "Time0_X" )            
#define RM_PREDEFINED_COS_TIME_0_X                                   _T( "CosTime0_X" )             
#define RM_PREDEFINED_SIN_TIME_0_X                                   _T( "SinTime0_X" )             
#define RM_PREDEFINED_TAN_TIME_0_X                                   _T( "TanTime0_X" )      
#define RM_PREDEFINED_TIME_0_1                                       _T( "Time0_1" )    
#define RM_PREDEFINED_COS_TIME_0_1                                   _T( "CosTime0_1" )
#define RM_PREDEFINED_SIN_TIME_0_1                                   _T( "SinTime0_1" )
#define RM_PREDEFINED_TAN_TIME_0_1                                   _T( "TanTime0_1" )
#define RM_PREDEFINED_TIME_0_2PI                                     _T( "Time0_2PI" )
#define RM_PREDEFINED_COS_TIME_0_2PI                                 _T( "CosTime0_2PI" )
#define RM_PREDEFINED_SIN_TIME_0_2PI                                 _T( "SinTime0_2PI" )
#define RM_PREDEFINED_TAN_TIME_0_2PI                                 _T( "TanTime0_2PI" )
#define RM_PREDEFINED_TIME_0_X_PACKED                                _T( "Time0_X_Packed" )
#define RM_PREDEFINED_TIME_0_1_PACKED                                _T( "Time0_1_Packed" )
#define RM_PREDEFINED_TIME_0_2PI_PACKED                              _T( "Time0_2PI_Packed")
#define RM_PREDEFINED_VIEWPORT_WIDTH                                 _T( "ViewportWidth" )
#define RM_PREDEFINED_VIEWPORT_HEIGHT                                _T( "ViewportHeight" )
#define RM_PREDEFINED_VIEWPORT_DIMENSIONS                            _T( "ViewportDimensions" )
#define RM_PREDEFINED_VIEWPORT_WIDTH_INVERSE                         _T( "ViewportWidthInverse" )
#define RM_PREDEFINED_VIEWPORT_HEIGHT_INVERSE                        _T( "ViewportHeightInverse" )
#define RM_PREDEFINED_VIEWPORT_DIMENSIONS_INVERSE                    _T( "ViewportDimensionsInverse" )
#define RM_PREDEFINED_RANDOM_FRAC_1_PER_PASS                         _T( "RandomFraction1PerPass" )
#define RM_PREDEFINED_RANDOM_FRAC_2_PER_PASS                         _T( "RandomFraction2PerPass" )
#define RM_PREDEFINED_RANDOM_FRAC_3_PER_PASS                         _T( "RandomFraction3PerPass" )
#define RM_PREDEFINED_RANDOM_FRAC_4_PER_PASS                         _T( "RandomFraction4PerPass" )
#define RM_PREDEFINED_RANDOM_FRAC_1_PER_EFFECT                       _T( "RandomFraction1PerEffect" )
#define RM_PREDEFINED_RANDOM_FRAC_2_PER_EFFECT                       _T( "RandomFraction2PerEffect" )
#define RM_PREDEFINED_RANDOM_FRAC_3_PER_EFFECT                       _T( "RandomFraction3PerEffect" )
#define RM_PREDEFINED_RANDOM_FRAC_4_PER_EFFECT                       _T( "RandomFraction4PerEffect" )
#define RM_PREDEFINED_PASS_INDEX                                     _T( "PassIndex" )
#define RM_PREDEFINED_FPS                                            _T( "FPS" )
#define RM_PREDEFINED_TIME_ELAPSED                                   _T( "TimeElapsed" )
#define RM_PREDEFINED_MOUSE_RIGHT_BUTTON                             _T( "RightMouseButton" )
#define RM_PREDEFINED_MOUSE_MIDDLE_BUTTON                            _T( "MiddleMouseButton" )
#define RM_PREDEFINED_MOUSE_LEFT_BUTTON                              _T( "LeftMouseButton" )
#define RM_PREDEFINED_MOUSE_COORDINATE_X                             _T( "MouseCoordinateX" )
#define RM_PREDEFINED_MOUSE_COORDINATE_Y                             _T( "MouseCoordinateY" )
#define RM_PREDEFINED_MOUSE_COORDINATE_X_NDC                         _T( "MouseCoordinateXNDC" )
#define RM_PREDEFINED_MOUSE_COORDINATE_Y_NDC                         _T( "MouseCoordinateYNDC" )
#define RM_PREDEFINED_MOUSE_COORDINATES_XY                           _T( "MouseCoordinateXY" )
#define RM_PREDEFINED_MOUSE_COORDINATES_XY_NDC                       _T( "MouseCoordinateXYNDC" )
#define RM_PREDEFINED_MOUSE_BUTTONS_PACKED                           _T( "MouseButtonsPacked" )
#define RM_PREDEFINED_MOUSE_COORDS_PACKED                            _T( "MouseCoordsPacked" )
#define RM_PREDEFINED_VIEW_DIRECTION                                 _T( "ViewDirection" )
#define RM_PREDEFINED_VIEW_POSITION                                  _T( "ViewPosition" )
#define RM_PREDEFINED_VIEW_SIDE                                      _T( "ViewSideVector" )
#define RM_PREDEFINED_VIEW_UP                                        _T( "ViewUpVector" )
#define RM_PREDEFINED_FOV                                            _T( "FOV" )
#define RM_PREDEFINED_FAR_CLIP_PLANE                                 _T( "FarClipPlane" )
#define RM_PREDEFINED_NEAR_CLIP_PLANE                                _T( "NearClipPlane" )
#define RM_PREDEFINED_MODEL_BBOX_TOP_LEFT_CORNER                     _T( "ModelBoundingBoxTopLeftCorner" )
#define RM_PREDEFINED_MODEL_BBOX_BOTTOM_RIGHT_CORNER                 _T( "ModelBoundingBoxBottomRightCorner" )
#define RM_PREDEFINED_MODEL_BBOX_CENTER                              _T( "ModelBoundingBoxCenter" )
#define RM_PREDEFINED_MODEL_CENTROID                                 _T( "ModelCentroid" )
#define RM_PREDEFINED_MODEL_BSPHERE_CENTER                           _T( "ModelBoundingSphereCenter" )
#define RM_PREDEFINED_MODEL_BSPHERE_RADIUS                           _T( "ModelBoundingSphereRadius" )


#define RM_PREDEFINED_VIEW_PROJECTION_MATRIX                         _T( "ViewProjection" )
#define RM_PREDEFINED_VIEW_MATRIX                                    _T( "View" )
#define RM_PREDEFINED_VIEW_INVERSE_MATRIX                            _T( "ViewInverse" )
#define RM_PREDEFINED_VIEW_INVERSE_TRANSPOSE                         _T( "ViewInverseTranspose" )
#define RM_PREDEFINED_PROJECTION_MATRIX                              _T( "Projection" )
#define RM_PREDEFINED_WORLD_VIEW_PROJECTION_MATRIX                   _T( "WorldViewProjection" )
#define RM_PREDEFINED_WORLD_MATRIX                                   _T( "World" )
#define RM_PREDEFINED_WORLD_INVERSE_MATRIX                           _T( "WorldInverse" )
#define RM_PREDEFINED_WORLD_INVERSE_TRANSPOSE_MATRIX                 _T( "WorldInverseTranspose" )
#define RM_PREDEFINED_WORLD_VIEW_MATRIX                              _T( "WorldView" )
#define RM_PREDEFINED_WORLD_VIEW_INVERSE_MATRIX                      _T( "WorldViewInverse" )
#define RM_PREDEFINED_WORLD_VIEW_INVERSE_TRANSPOSE_MATRIX            _T( "WorldViewInverseTranspose" )
#define RM_PREDEFINED_WORLD_VIEW_PROJECTION_INVERSE_MATRIX           _T( "WorldViewProjectionInverse" )
#define RM_PREDEFINED_WORLD_VIEW_PROJECTION_INVERSE_TRANSPOSE_MATRIX _T( "WorldViewProjectionInverseTranspose" )
#define RM_PREDEFINED_VIEW_INVERSE_TRANSPOSE_MATRIX                  _T( "ViewInverseTranspose" )
#define RM_PREDEFINED_VIEW_PROJECTION_INVERSE_TRANSPOSE_MATRIX       _T( "ViewProjectionInverseTranspose" )
#define RM_PREDEFINED_PROJECTION_INVERSE_MATRIX                      _T( "ProjectionInverse" )
#define RM_PREDEFINED_PROJECTION_INVERSE_TRANSPOSE_MATRIX            _T( "ProjectionInverseTranspose" )
#define RM_PREDEFINED_VIEW_PROJECTION_INVERSE_MATRIX                 _T( "ViewProjectionInverse" )
#define RM_PREDEFINED_VIEW_PROJECTION_INVERSE_TRANPOSE_MATRIX        _T( "ViewProjectionInverseTranspose" )
#define RM_PREDEFINED_VIEW_PROJECTION_TRANSPOSE                      _T( "ViewProjectionTranspose" )
#define RM_PREDEFINED_VIEW_TRANSPOSE                                 _T( "ViewTranspose" )
#define RM_PREDEFINED_WORLD_VIEW_PROJECTION_TRANSPOSE                _T( "WorldViewProjectionTranspose" )
#define RM_PREDEFINED_WORLD_TRANSPOSE                                _T( "WorldTranspose" )
#define RM_PREDEFINED_WORLD_VIEW_TRANSPOSE                           _T( "WorldViewTranspose" )
#define RM_PREDEFINED_PROJECTION_TRANSPOSE                           _T( "ProjectionTranspose" )

//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//                                                                                                  //
//             Supported DirectX 9.0 shader models                                                  //
//                                                                                                  //
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
#define RM_DX_VERSION      0x00090003
#define RM_DX_VERSION_STR  _T( "DirectX 9.0c" )

#define RM_DX_VS_1_1       _T("vs_1_1")
#define RM_DX_VS_2_0       _T("vs_2_0")
#define RM_DX_VS_2_SW      _T("vs_2_sw")
#define RM_DX_VS_3_0       _T("vs_3_0")
#define RM_DX_VS_3_SW      _T("vs_3_sw")

#define RM_NUM_DX_VS_TARGETS 5

#define RM_DX_PS_1_1       _T("ps_1_1")
#define RM_DX_PS_1_2       _T("ps_1_2")
#define RM_DX_PS_1_3       _T("ps_1_3")
#define RM_DX_PS_1_4       _T("ps_1_4")
#define RM_DX_PS_2_0       _T("ps_2_0")
#define RM_DX_PS_2_A       _T("ps_2_a")
#define RM_DX_PS_2_B       _T("ps_2_b")
#define RM_DX_PS_2_SW      _T("ps_2_sw")
#define RM_DX_PS_3_0       _T("ps_3_0")
#define RM_DX_PS_3_SW      _T("ps_3_sw")

#define RM_NUM_DX_PS_TARGETS 10


//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//                                                                                                  //
// Use these macros for clean deletion of pointers and resources within RenderMonkey plug-ins       //
//                                                                                                  //
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------//

// Deletes a pointer and resets it to NULL:
#ifndef RM_SAFE_DELETE
#define RM_SAFE_DELETE( p )         { if( p )   { delete (p);        (p) = NULL;    }}
#endif // End of RM_SAFE_DELETE

// Deletes an array and resets the array pointer to NULL:
#ifndef RM_SAFE_DELETE_ARRAY
#define RM_SAFE_DELETE_ARRAY( p )   { if( p )   { delete[] (p);      (p) = NULL;    }}
#endif // End of RM_SAFE_DELETE_ARRAY

// Deletes a pointer if it's not NULL and resets it to NULL after deletion.
// If the input pointer is already NULL, calls assertion.
#ifndef RM_SAFE_DELETE_ASSERT
#define RM_SAFE_DELETE_ASSERT(p)    if ( (p) != NULL )   { delete (p); (p) = NULL; } else { assert( (p) != NULL ); }
#endif // End of RM_SAFE_DELETE_ASSERT

// Deletes a pointer to an array if it's not NULL and resets it to NULL after deletion.
// If the input pointer is already NULL, calls assertion.
#ifndef RM_SAFE_DELETE_ARRAY_ASSERT
#define RM_SAFE_DELETE_ARRAY_ASSERT(p) if ( (p) != NULL )   { delete[] (p); (p) = NULL; } else { assert( (p) != NULL ); }
#endif // End of RM_SAFE_DELETE_ASSERT

// Releases the given interface and resets the pointer to the interface to NULL:
#ifndef RM_SAFE_RELEASE
#define RM_SAFE_RELEASE( p )        { if ( p )   { (p)->Release();    (p) = NULL;    }}
#endif // End of RM_SAFE_RELEASE

// If the pointer isn't NULL, it frees the given pointer and resets it to NULL:
#ifndef RM_SAFE_FREE
#define RM_SAFE_FREE( p )           {  if ( p )    {  free( (p) );   (p) = NULL;    }}
#endif

// If the pointer isn't NULL, it frees the given pointer and resets it to NULL, otherwise this method asserts:
#ifndef RM_SAFE_FREE_ASSERT
#define RM_SAFE_FREE_ASSERT( p )           {  if ( p )    {  free( (p) );   (p) = NULL;    } else { assert( (p) != NULL ); } }
#endif

//--------------------------------------------------------------------------------------------------//
// Math constants definitions
//--------------------------------------------------------------------------------------------------//
#define RM_PI                 3.141592653f
#define RM_TWO_PI             6.283185307f
#define RM_DEG_2_RAD(a)       ((a) / 57.295779513f)
#define RM_RAD_2_DEG(a)       ((a) * 57.295779513f)

// Determines the maximum string length for window titles - used to register windows with the main 
// application:
#define RM_MAXIMUM_WINDOW_TITLE_SIZE   128

//--------------------------------------------------------------------------------------------------//
// Color conversion from individual bytes into a DWORD and vice versa
//--------------------------------------------------------------------------------------------------//

// RM_RGBA is compatible with COLORREF, but fully exposes the alpha channel
#define RM_RGBA                     DWORD

// Extracts the red, green, blue, or alpha byte component from the RM_RGBA DWORD
#define RmGetRValue( rgba )         ( (BYTE )( ( rgba ) ) )
#define RmGetGValue( rgba )         ( (BYTE )( ( rgba ) >> 8 ) )
#define RmGetBValue( rgba )         ( (BYTE )( ( rgba ) >> 16 ) )
#define RmGetAValue( rgba )         ( (BYTE )( ( rgba ) >> 24 ) )

// Converts the four byte components into an RM_RGBA DWORD
#define RmMakeRGBAb( r, g, b, a )   ( ( RM_RGBA )(   ( ( DWORD )( ( BYTE )( r ) ) ) \
                                                   | ( ( DWORD )( ( BYTE )( g ) ) << 8 ) \
                                                   | ( ( DWORD )( ( BYTE )( b ) ) << 16 ) \
                                                   | ( ( DWORD )( ( BYTE )( a ) ) << 24 ) ) )
                                                   
// Converts the 4 float component vector into an RM_RGBA DWORD
#define RmMakeRGBAfv( rgba )        ( RmMakeRGBAb( ( BYTE )( rgba[ 0 ] * 255.0f ), \
                                                   ( BYTE )( rgba[ 1 ] * 255.0f ), \
                                                   ( BYTE )( rgba[ 2 ] * 255.0f ), \
                                                   ( BYTE )( rgba[ 3 ] * 255.0f ) ) )
                                       


//============================//
// General Preference defines //
//============================//
#define RM_DEFAULT_AUTO_REFRESH           FALSE
#define RM_DEFAULT_TIME_CYCLE             120            // sec
#define RM_DEFAULT_REFRESH_PERIOD         5              // sec
#define RM_DEFAULT_TEXTURE_DIRECTORY      _T(".\\Media\\Textures\\")
#define RM_DEFAULT_MODEL_DIRECTORY        _T(".\\Media\\Models\\")
#define RM_DEFAULT_MODEL_ORIENTATION      RM_ORIENTATION_LHS
#define RM_DEFAULT_TEXTURE_ORIGIN         RM_ORIGIN_TOP_LEFT

#endif // _RM_CORE_DEFINES_H_

---