source file REDRenderShader.h

Go to the documentation of this file.

#ifndef RED_RENDER_SHADER_H
#define RED_RENDER_SHADER_H

//************************************************************************************************************
// Copyright (c) 2005 Redway3D. All rights reserved. Redway3D is a registered trademark. Any reproduction and /
// or utilization of any material from this document without Redway3D?s express authorization are prohibited.
//************************************************************************************************************

#include "REDShader.h"
#include "REDRenderShaderParameter.h"
#include "REDRenderCode.h"
#include "REDIReferenceSolving.h"
#include "REDShaderProgramID.h"
#include "REDIMaterial.h"


//******************************************************************************
//*** Light source form geometry ***********************************************
//******************************************************************************

#define RED_LIGHT_DIRECTIONAL     (0x00000001)
#define RED_LIGHT_BEAM            (0x00000002)
#define RED_LIGHT_SUN_LIGHT       (0x00000004)
#define RED_LIGHT_MOON_LIGHT      (0x00000008)
#define RED_LIGHT_POINT           (0x00000010)
#define RED_LIGHT_AREA            (0x00000020)
#define RED_LIGHT_POINT_SPOT      (0x00000040)
#define RED_LIGHT_AREA_SPOT       (0x00000080)
#define RED_LIGHT_NO_LIGHT        (0x00000100)     // Must not be set to zero !
#define RED_LIGHT_AMBIENT_LIGHT   (0x00000200)
#define RED_LIGHT_SKY_LIGHT       (0x00000400)
#define RED_LIGHT_PHYSICAL_LIGHT  (0x00000800)


//******************************************************************************
//*** Shader targets ***********************************************************
//******************************************************************************

#define RED_SHAD_TARGET_LIGHT_DIRECTIONAL          ( RED_LIGHT_DIRECTIONAL )
#define RED_SHAD_TARGET_LIGHT_BEAM                 ( RED_LIGHT_BEAM )
#define RED_SHAD_TARGET_LIGHT_POINT                ( RED_LIGHT_POINT )
#define RED_SHAD_TARGET_LIGHT_AREA                 ( RED_LIGHT_AREA )
#define RED_SHAD_TARGET_LIGHT_POINT_SPOT           ( RED_LIGHT_POINT_SPOT )
#define RED_SHAD_TARGET_LIGHT_AREA_SPOT            ( RED_LIGHT_AREA_SPOT )
#define RED_SHAD_TARGET_LIGHT_NO_LIGHT             ( RED_LIGHT_NO_LIGHT )
#define RED_SHAD_TARGET_LIGHT_SKY_LIGHT            ( RED_LIGHT_SKY_LIGHT )


#define RED_SHAD_TARGET_REFLECTION_VECTOR          ( 0x00001000 )
#define RED_SHAD_TARGET_INDIRECT_REFLECTION_VECTOR ( 0x00002000 )
#define RED_SHAD_TARGET_REFRACTION_VECTOR          ( 0x00004000 )
#define RED_SHAD_TARGET_INDIRECT_REFRACTION_VECTOR ( 0x00008000 )


#define RED_SHAD_TARGET_REFLECTION_CUTOFF          ( 0x00010000 )
#define RED_SHAD_TARGET_INDIRECT_REFLECTION_CUTOFF ( 0x00020000 )
#define RED_SHAD_TARGET_REFRACTION_CUTOFF          ( 0x00040000 )
#define RED_SHAD_TARGET_INDIRECT_REFRACTION_CUTOFF ( 0x00080000 )


#define RED_SHAD_TARGET_GI_DIFFUSE_COLOR           ( 0x00100000 )
#define RED_SHAD_TARGET_GI_REFLECTION_COLOR        ( 0x00200000 )
#define RED_SHAD_TARGET_GI_TRANSMISSION_COLOR      ( 0x00400000 )
#define RED_SHAD_TARGET_GI_NORMAL                  ( 0x00800000 )
#define RED_SHAD_TARGET_GI_NORMAL_INDIRECT         ( 0x02000000 )


#define RED_SHAD_TARGET_SOFT_KILL                  ( 0x10000000 )


#define RED_SHAD_TARGET_BSDF                       ( 0x20000000 )


#define RED_SHAD_TARGET_ANY_LIGHT                ( RED_SHAD_TARGET_LIGHT_DIRECTIONAL |\
                                                   RED_SHAD_TARGET_LIGHT_BEAM        |\
                                                   RED_SHAD_TARGET_LIGHT_POINT       |\
                                                   RED_SHAD_TARGET_LIGHT_AREA        |\
                                                   RED_SHAD_TARGET_LIGHT_POINT_SPOT  |\
                                                   RED_SHAD_TARGET_LIGHT_AREA_SPOT   |\
                                                   RED_SHAD_TARGET_LIGHT_SKY_LIGHT )

#define RED_SHAD_TARGET_ALL                      ( 0xffffffff )


#define RED_L0    (RED_SHAD_TARGET_LIGHT_NO_LIGHT)
#define RED_LALL  (RED_SHAD_TARGET_ANY_LIGHT)
#define RED_LP    (RED_SHAD_TARGET_LIGHT_POINT)
#define RED_LS    (RED_SHAD_TARGET_LIGHT_POINT_SPOT)
#define RED_LD    (RED_SHAD_TARGET_LIGHT_DIRECTIONAL)
#define RED_LB    (RED_SHAD_TARGET_LIGHT_BEAM)
#define RED_LA    (RED_SHAD_TARGET_LIGHT_AREA)
#define RED_LE    (RED_SHAD_TARGET_LIGHT_AREA_SPOT)
#define RED_LK    (RED_SHAD_TARGET_LIGHT_SKY_LIGHT)


#define RED_GID       (RED_SHAD_TARGET_GI_DIFFUSE_COLOR)
#define RED_GIR       (RED_SHAD_TARGET_GI_REFLECTION_COLOR)
#define RED_GIT       (RED_SHAD_TARGET_GI_TRANSMISSION_COLOR)
#define RED_GIN       (RED_SHAD_TARGET_GI_NORMAL)
#define RED_GIN_IND   (RED_SHAD_TARGET_GI_NORMAL_INDIRECT)


#define RED_VMxTy(matx,uv) (8*(uv) + (matx))


//******************************************************************************
//*** Light source parameters **************************************************
//******************************************************************************

#define RED_SHADER_LIGHT_ATTENUATION              "light_att"
#define RED_SHADER_LIGHT_SHADOW_IMAGE             "light_shadow"
#define RED_SHADER_LIGHT_RANGE                    "light_range"
#define RED_SHADER_LIGHT_SPOT_FALLOFF             "spot_falloff"
#define RED_SHADER_LIGHT_BEAM_FALLOFF             "beam_falloff"
#define RED_SHADER_LIGHT_POS                      "light_pos"
#define RED_SHADER_LIGHT_SIGHT                    "light_sight"
#define RED_SHADER_LIGHT_TOP                      "light_top"
#define RED_SHADER_LIGHT_RIGHT                    "light_right"
#define RED_SHADER_LIGHT_PROJUV                   "light_projuv"
#define RED_SHADER_LIGHT_AMBCOL                   "light_amb_color"
#define RED_SHADER_LIGHT_DIFCOL                   "light_dif_color"
#define RED_SHADER_LIGHT_SPECOL                   "light_spec_color"
#define RED_SHADER_INDIRECT_FACE_CULLING          "ray_facing"
#define RED_SHADER_LIGHT_FRAGMENT_POS_JITTER      "light_fragment_pos_jitter"
#define RED_SHADER_LIGHT_AREA_SAMPLE_POS          "light_area_pos"
#define RED_SHADER_LIGHT_SKY_SAMPLE_POS_JITTER    "light_sky_pos_jitter"
#define RED_SHADER_LIGHT_SKY_SMOOTH_CUBE          "light_sky_smooth_cube"


//******************************************************************************
//*** Indirect rendering parameters ********************************************
//******************************************************************************

#define RED_SHADER_INDIRECT_RAY_POS               "ray_pos"
#define RED_SHADER_INDIRECT_RAY_DIR               "ray_dir"
#define RED_SHADER_INDIRECT_RAY_TRIANGLE          "ray_triangle"
#define RED_SHADER_POLYGON_FACING                 "polygon_facing"


//******************************************************************************
//*** RenderShaderData class ***************************************************
//******************************************************************************

namespace RED
{
  class String;
  
  
  // RED::RenderShaderData class:
  // ----------------------------
  
  class REDFullExp RenderShaderData : public RED::Object
  {
    public:
      
      // Typing information:
      // -------------------
      
      SET_CID( CID_class_REDRenderShaderData ) IMPLEMENT_AS();
      
      
      // Construction and destruction methods:
      // -------------------------------------
      
      RenderShaderData();
      
      
      RenderShaderData( RED::HARDWARE_PLATFORM iPlatformID,
                        int iShaderTarget );
      
      
      RenderShaderData (const RenderShaderData &iSource);
      
     
      virtual ~RenderShaderData ();
      
      
      RED_RC operator = (const RenderShaderData& iSource);
      
      
      // Data members:
      // -------------
      
      RED::HARDWARE_PLATFORM _platform_id;
      
      int _ltarget;
      
      RED::ShaderProgramID _vshid;
      
      RED::ShaderProgramID _gshid;
      
      RED::ShaderProgramID _pshid;
      
      int _is_rendercode;
      
      RED::RenderCode _rendercode;
      
      RED::Vector< RED::RenderShaderParameter > _parameters;
  };
};


//******************************************************************************
//*** RED::RenderShader class **************************************************
//******************************************************************************

namespace RED
{
  // RED::SOFT_GEOMETRY_PRIMITIVE enumeration:
  // -----------------------------------------
  
  enum SOFT_GEOMETRY_PRIMITIVE { GEO_UNMODIFIED              = 0,
                                 GEO_POINTS                  = 1,
                                 GEO_LINE_SEGMENTS           = 2,
                                 GEO_LINE_SEGMENTS_ADJACENCY = 3,
                                 GEO_LINE_STRIP              = 4,
                                 GEO_TRIANGLES               = 5,
                                 GEO_TRIANGLES_ADJACENCY     = 6 };
  
  
  // RED::SOFT_GEOMETRY_SHADER function prototype:
  // ---------------------------------------------
  
  typedef RED_RC (*SOFT_GEOMETRY_SHADER)( RED::Vector< double >(&       oVertexAttrib)[RED_VSH_NB_INPUTS],
                                          RED_VSH_INPUT(&               oChannels)[RED_VSH_NB_INPUTS],
                                          int&                          oChannelsCount,
                                          RED::Vector< int >&           oPrimitives,
                                          RED::SOFT_GEOMETRY_PRIMITIVE& oType,
                                          
                                          void*(                        iVertexAttrib[RED_VSH_NB_INPUTS]),
                                          RED::MESH_FORMAT              iFormat[RED_VSH_NB_INPUTS],
                                          int                           iSize[RED_VSH_NB_INPUTS],
                                          int                           iVerticesCount,
                                          int*                          iIndex,
                                          int                           iCount,
                                          RED::SOFT_GEOMETRY_PRIMITIVE& iType,
                                          
                                          const double*                 iProgramLocal,
                                          const double*                 iModelViewMatrix,
                                          const double*                 iModelViewProjMatrix,
                                          const double*                 iModelMatrix );
  
  
  // RED::RenderShader class:
  // ------------------------
  
  class REDFullExp RenderShader : public RED::Shader
  {
    public:
      
      // Typing information:
      // -------------------
      
      SET_CID( CID_class_REDRenderShader ) IMPLEMENT_AS();

      SET_CHUNK_SIGNATURE( 0x00000306 ); IMPLEMENT_CHUNKINTERPRETER();
      
      
      // Construction and destruction method:
      // ------------------------------------
      
      RenderShader();
      
      
      virtual RED::Shader* Clone() const;
      
      
      virtual ~RenderShader();
      
      
      RED_RC operator = (const RenderShader &iSrc);
      
      
      void Reset();
      
      
      void ResetPlatform( RED::HARDWARE_PLATFORM iPlatformId );
      
      
      // Programs management:
      // --------------------
      
      virtual RED_RC SetVertexProgramId( const RED::ShaderProgramID& iVshProgramID,
                                         int                         iShaderTarget,
                                         RED::Object*                iResourceManager,
                                         RED::HARDWARE_PLATFORM      iPlatformId = RED::HW_GENERIC );
      
      
      RED_RC GetVertexProgramId( RED::ShaderProgramID&  oProgram,
                                 int                    iShaderTarget,
                                 RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetVertexProgramId( RED::Vector< RED::ShaderProgramID >&   oProgramList,
                                 RED::Vector< RED::HARDWARE_PLATFORM >& oPlatformList,
                                 RED::Vector< int >&                    oTargetList ) const;
      
      
      virtual RED_RC SetGeometryProgramId( const RED::ShaderProgramID& iGshProgramID,
                                           int                         iShaderTarget,
                                           RED::Object*                iResourceManager,
                                           RED::HARDWARE_PLATFORM      iPlatformId = RED::HW_GENERIC );
      
      
      RED_RC GetGeometryProgramId( RED::ShaderProgramID&  oProgram,
                                   int                    iShaderTarget,
                                   RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetGeometryProgramId( RED::Vector< RED::ShaderProgramID >&   oProgramList,
                                   RED::Vector< RED::HARDWARE_PLATFORM >& oPlatformList,
                                   RED::Vector< int >&                    oTargetList ) const;
      
      
      virtual RED_RC SetPixelProgramId( const RED::ShaderProgramID& iPshProgramId,
                                        int                         iShaderTarget,
                                        RED::Object*                iResourceManager,
                                        RED::HARDWARE_PLATFORM      iPlatformId = RED::HW_GENERIC );
      
      
      RED_RC GetPixelProgramId( RED::ShaderProgramID&  oProgram,
                                int                    iShaderTarget,
                                RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetPixelProgramId( RED::Vector< RED::ShaderProgramID >&   oProgramList,
                                RED::Vector< RED::HARDWARE_PLATFORM >& oPlatformList,
                                RED::Vector< int >&                    oTargetList ) const;
      
      
      // Rendercode management:
      // ----------------------
      
      virtual RED_RC SetRenderCode( const RED::RenderCode&  iRenderCode,
                                    int                     iShaderTarget,
                                    RED::HARDWARE_PLATFORM  iPlatformId = RED::HW_GENERIC );
      
      
      RED_RC GetRenderCode( RED::RenderCode**      oRenderCode,
                            int                    iShaderTarget,
                            RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetRenderCode( RED::Vector< RED::RenderCode* >&       oCodeList,
                            RED::Vector< RED::HARDWARE_PLATFORM >& oPlatformList,
                            RED::Vector< int >&                    oTargetList ) const;
      
      
      
      // Managing rendering parameters:
      // ------------------------------
      
      virtual RED_RC AddParameter( const RED::RenderShaderParameter& iParam,
                                   int                               iShaderTarget,
                                   RED::HARDWARE_PLATFORM            iPlatformId = RED::HW_GENERIC );
      
      
      virtual RED_RC RemoveParameterFromPlatform( const RED::String&     iName,
                                                  RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC );
      
      
      virtual RED_RC RemoveParameter( const RED::String& iName );
      
      
      // Parameter lookup:
      // -----------------
      
      virtual RED_RC GetParameter( RED::RenderShaderParameter*& oParam,
                                   const RED::String&           iName,
                                   int                          iShaderTarget,
                                   RED::HARDWARE_PLATFORM       iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetParameter( RED::Vector< RED::RenderShaderParameter* >& oParamList,
                           RED::Vector< RED::HARDWARE_PLATFORM >&      oPlatformList,
                           RED::Vector< int >&                         oTargetList,
                           const RED::String&                          iName ) const;
      
      
      RED_RC GetParameter( RED::Vector< RED::RenderShaderParameter* >& oParamList,
                           const RED::String&                          iName ) const;
      
      
      // Parameter list lookup:
      // ----------------------
      
      RED_RC GetParameters( RED::Vector< RED::RenderShaderParameter* >& ioParamList,
                            int                                         iShaderTargets = RED_SHAD_TARGET_ALL,
                            RED::HARDWARE_PLATFORM                      iPlatformId = RED::HW_GENERIC ) const;
      
      
      RED_RC GetParameters( RED::Vector< RED::RenderShaderParameter* >& ioParamList,
                            RED::RenderShaderParameter::TYPE            iType,
                            int                                         iShaderTargets = RED_SHAD_TARGET_ALL,
                            RED::HARDWARE_PLATFORM                      iPlatformId = RED::HW_GENERIC ) const;
      
      
      // Miscellaneous:
      // --------------
      
      RED_RC GetPlatformsCount( int& oCount ) const;
      
      
      RED_RC GetPlatformList( RED::Vector< RED::HARDWARE_PLATFORM >& oPlatformList ) const;
      
      
      RED_RC GetShaderTargets( RED::Vector<int>&      oTargets,
                               RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC ) const;
      
      
      static RED_RC FakeColorWithImage( RED::Object*&     oImage,
                                        const RED::Color& iColor,
                                        RED::Object*      iResourceManager );
      
      
      static int VertexProgramSelection( int                iNbInputs,
                                         RED::MESH_CHANNEL  iUV[7],
                                         const RED::Object* iTexture[7],
                                         const RED::Matrix* iTransform[7] );
      
      
      static int CompositeTextureSelection( int                iNbInputs,
                                            const RED::Object* iTexture[16] );
      
      
      static RED::MESH_CHANNEL SelectSingleUV( int                iNbInputs,
                                               RED::MESH_CHANNEL  iUV[16],
                                               const RED::Object* iTexture[16] );
      
      
      RED_RC BindLight( int                    iChannel,
                        bool                   iSpecular,
                        bool                   iBump,
                        bool                   iDirect,
                        RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC );
      
      
      RED_RC BindRayVsTriangle( int                    iTarget,
                                RED::HARDWARE_PLATFORM iPlatformId = RED::HW_GENERIC );
      
      
      // Internals:
      // ----------
      
                        virtual RED_RC UpdateFrom( const RED::Object& iShader, 
                                 const RED::State&  iState, 
                                 int                iSrcStateNumber );
      
      
      virtual RED_RC GetOperationStream( const RED::Object*                     iCaller,
                                                                                                                                                                 RED::Vector<int>&                      ioStream,
                                         RED::HARDWARE_PLATFORM iPlatformId ) const;
      
      
      RED_RC Solve( RED::IReferenceManager* iReferenceManager,
                    const RED::State&       iState );
      
      
      // I/O operations:
      // ---------------
      
      virtual RED_RC Save( RED::IStream*    iStream, 
                           StreamingPolicy& iPolicy,
                           int              iState = -1 ) const;
      
      
      // Built-in shaders input parameters:
      // ----------------------------------
      
      RED_RC SetInputParameter( RED::MATERIAL_PASS iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( const RED::Color&  iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( const RED::Vector4& iParameter,
                                const RED::String&  iName,
                                RED::Object*        iResMgr,
                                bool                iEvaluate = true );
      
      
      RED_RC SetInputParameter( const RED::Object* iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( const RED::Matrix& iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( RED::MESH_CHANNEL  iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( double             iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC SetInputParameter( bool               iParameter,
                                const RED::String& iName,
                                RED::Object*       iResMgr,
                                bool               iEvaluate = true );
      
      
      RED_RC GetInputParameter( RED::MATERIAL_PASS& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( RED::Color& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( RED::Vector4& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( RED::Object*& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( RED::Matrix& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( RED::MESH_CHANNEL& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( double& oParameter, const RED::String& iName ) const;
      
      
      RED_RC GetInputParameter( bool& oParameter, const RED::String& iName ) const;
      
      
      bool IsInputParameter( const RED::String& iName ) const;
      
      
      RED_RC EvaluateFromInputParameters( RED::Object* iResMgr );
      
      
      int GetInputParametersCount() const;
      
      
      // @cond INCLUDE_HIGH_LEVEL_SHADER_INPUT_PARAMETERS
      
      RED_RC GetInputParameter( RED::MATERIAL_PASS& oParameter, int iNumber ) const;
      RED_RC GetInputParameter( RED::Color&         oParameter, int iNumber ) const;
      RED_RC GetInputParameter( RED::Vector4&       oParameter, int iNumber ) const;
      RED_RC GetInputParameter( RED::Object*&       oParameter, int iNumber ) const;
      RED_RC GetInputParameter( RED::Matrix&        oParameter, int iNumber ) const;
      RED_RC GetInputParameter( RED::MESH_CHANNEL&  oParameter, int iNumber ) const;
      RED_RC GetInputParameter( double&             oParameter, int iNumber ) const;
      RED_RC GetInputParameter( bool&               oParameter, int iNumber ) const;



      RED_RC GetInputParameters( RED::Vector< RED::RenderShaderParameter >& oInputParameters ) const;  
      
      
      RED_RC GetInputParameter( RED::RenderShaderParameter*& oParameter,
                                int iNumber ) const;
      
      
      RED_RC GetInputParameter( RED::RenderShaderParameter*& oParameter,
                                const RED::String& iName ) const;
      
      // @endcond
      
      
    protected:
      
      // Object data:
      // ------------
      
      RED::Vector< RED::Vector< RED::RenderShaderData > > _pdata;
      
      
      // Internals:
      // ----------
      
      RED::Vector< RED::RenderShaderData >* PlatformLookup( RED::HARDWARE_PLATFORM iPlatformID,
                                                            bool                   iExactMatch ) const;
      
      
      RED_RC GetPlatformData( RED::RenderShaderData*& oData,
                              int                     iShaderTarget,
                              RED::HARDWARE_PLATFORM  iPlatformId );
      
      
      const RED::RenderShaderData* FindPlatformData( int                    iShaderTarget,
                                                     RED::HARDWARE_PLATFORM iPlatformId ) const;
      
      
      // Built-in shaders input parameters:
      // ----------------------------------
      
      // @cond INCLUDE_HIGH_LEVEL_SHADER_INPUT_PARAMETERS
      
      RED::CID _input_cid;
      
      RED::Vector< RED::RenderShaderParameter > _input_parameters;
      
      
      RED_RC AddInputParameter( RED::MATERIAL_PASS  iParameter, const RED::String& iName );
      RED_RC AddInputParameter( const RED::Color&   iParameter, const RED::String& iName );
      RED_RC AddInputParameter( const RED::Vector4& iParameter, const RED::String& iName );
      RED_RC AddInputParameter( const RED::Object*  iParameter, const RED::String& iName );
      RED_RC AddInputParameter( const RED::Matrix&  iParameter, const RED::String& iName );
      RED_RC AddInputParameter( RED::MESH_CHANNEL   iParameter, const RED::String& iName );
      RED_RC AddInputParameter( double              iParameter, const RED::String& iName );
      RED_RC AddInputParameter( bool                iParameter, const RED::String& iName );
      
      
      void ClearInputParameters();
      
      
      void SetInputParameterShaderCID( RED::CID iCID );
      
      // @endcond
  };
};


#endif