Maya-SDK/cpp_ref/dx11_shader_2dx11_shader_8h-example.html

#ifndef _dx11ShaderNode_h_

#define _dx11ShaderNode_h_

//-

// Copyright 2015 Autodesk, Inc.  All rights reserved.

//

// Use of this software is subject to the terms of the Autodesk license agreement

// provided at the time of installation or download, or which otherwise

// accompanies this software in either electronic or hard copy form.

//+


#include <maya/MPxHardwareShader.h>

#include <maya/MStringArray.h>

#include <maya/MVaryingParameterList.h>

#include <maya/MUniformParameterList.h>

#include <maya/MHWGeometry.h>

#include <maya/MPlugArray.h>


#include <maya/MMessage.h>


// Includes for DX11

#define WIN32_LEAN_AND_MEAN

#include <d3d11.h>


// for VS 2012, Win8 SDK includes DX sdk with some header removed

#if _MSC_VER >= 1700

#include <dxgi.h>

#else

#include <d3dx11.h>

#endif


#if USE_D3DX11EFFECTS

    // d3dx11effect.h comes from the D3DX11Effects library installer

    // or the DirectX SDK installer (legacy)

    // DirectX is now part of the Windows SDK installer

    #include <d3dx11effect.h>


    // have legacy DirectX SDK (June 2010)

    #if USE_DIRECTXSDK_D3DX11EFFECTS

        #ifndef USE_BOOL

        #define USE_BOOL // use BOOL instead of bool

        #endif

    #endif


    #define dx11ShaderDX11Device ID3D11Device

    #define dx11ShaderDX11DeviceContext ID3D11DeviceContext

    #define dx11ShaderDX11Effect ID3DX11Effect

    #define dx11ShaderDX11EffectTechnique ID3DX11EffectTechnique

    #define dx11ShaderDX11Pass ID3DX11EffectPass

    #define dx11ShaderDX11InputLayout ID3D11InputLayout

    #define dx11ShaderDX11InputElementDesc D3D11_INPUT_ELEMENT_DESC

    #define dx11ShaderDX11EffectVariable ID3DX11EffectVariable

    #define dx11ShaderDX11EffectShaderResourceVariable ID3DX11EffectShaderResourceVariable

    #define dx11ShaderDX11RasterizerState ID3D11RasterizerState

    #define dx11ShaderDX11DepthStencilState ID3D11DepthStencilState

    #define dx11ShaderDX11BlendState ID3D11BlendState

#else

    #define dx11ShaderDX11Device void

    #define dx11ShaderDX11DeviceContext void

    #define dx11ShaderDX11Effect void

    #define dx11ShaderDX11EffectTechnique void

    #define dx11ShaderDX11Pass void

    #define dx11ShaderDX11InputLayout void

    #define dx11ShaderDX11InputElementDesc void

    #define dx11ShaderDX11EffectVariable void

    #define dx11ShaderDX11EffectShaderResourceVariable void

    #define dx11ShaderDX11RasterizerState void

    #define dx11ShaderDX11DepthStencilState void

    #define dx11ShaderDX11BlendState void

#endif

#include <map>

#include <set>

#include <vector>


class CUniformParameterBuilder;


#define USE_GL_TEXTURE_CACHING


//

// Maya hardware shader node

//

class dx11ShaderNode : public MPxHardwareShader

{

private:

    // Identify the purpose of the current rendering process

    enum ERenderType

    {

        RENDER_SCENE,               // Render the textured material to the viewport 2.0

        RENDER_SCENE_NON_MATERIAL,  // Render non material items to the viewport 2.0

        RENDER_SWATCH,              // Render the swatch that represents the current selected technique

        RENDER_SWATCH_PROXY,        // Render a dummy swatch when no effect or no valid technique selected

        RENDER_UVTEXTURE            // Render a texture for the UV editor

    };


    inline bool isRenderScene(ERenderType renderType) const { return (renderType == RENDER_SCENE || renderType == RENDER_SCENE_NON_MATERIAL); }

    inline bool isRenderSwatch(ERenderType renderType) const { return (renderType == RENDER_SWATCH); }

    inline bool isRenderNonMaterialItem(ERenderType renderType) const { return (renderType == RENDER_SCENE_NON_MATERIAL); }


    inline bool needUpdateImplicitLightConnections(ERenderType renderType) const { return (renderType == RENDER_SCENE || renderType == RENDER_SWATCH); }

    inline bool needUpdateExplicitLightConnections(ERenderType renderType) const { return (renderType == RENDER_SCENE); }

    inline bool overrideRasterizerState(ERenderType renderType) const { return !isRenderScene(renderType); }

    inline bool needUpdateMayaSwatchRenderVar(ERenderType renderType) const { return (renderType == RENDER_SWATCH || renderType == RENDER_SWATCH_PROXY); }


    struct RenderItemDesc

    {

        bool isFatLine;

        bool isFatPoint;

    };


public:

    enum ELightType

    {

        eInvalidLight,

        eUndefinedLight,

        eSpotLight,

        ePointLight,

        eDirectionalLight,

        eAmbientLight,

        eVolumeLight,

        eAreaLight,

        eDefaultLight,


        eLightCount

    };


    // Identify the transparency state of the selected technique

    enum ETransparencyState

    {

        eOpaque,                // Technique is always opaque

        eTransparent,           // Technique is always transparent

        eTestOpacitySemantics,  // Technique transparency depends on the value of the float parameter with kOpacity semantic ( transparent if less than 1.0)

        eScriptedTest           // Technique transparency depends on the result of the transparencyTest MEL procedure

    };


    struct ContextStates

    {

        ContextStates() : rasterizerState(NULL), depthStencilState(NULL), blendState(NULL) {}


        dx11ShaderDX11RasterizerState*      rasterizerState;

        dx11ShaderDX11DepthStencilState*    depthStencilState;

        UINT                                stencilRef;

        dx11ShaderDX11BlendState*           blendState;

        float                               blendFactor[4];

        UINT                                sampleMask;

    };


    class LightParameterInfo

    {

        typedef dx11ShaderNode::ELightType ELightType;


    public:

        LightParameterInfo(ELightType lightType = dx11ShaderNode::eInvalidLight, bool hasLightTypeSemantics = false);


        ELightType  lightType() const;


    public:

        ELightType  fLightType;

        bool        fHasLightTypeSemantics;

        bool        fIsDirty;


        // This is a map<MUniformParameterList->index, ELightParameterType>

        typedef std::map<int, int> TConnectableParameters;

        TConnectableParameters fConnectableParameters;


        MObject     fAttrUseImplicit;

        MObject     fAttrConnectedLight;

        MObject     fCachedImplicitLight;

    };


public:

    // Constructor/Destructor housekeeping: create, copy setup

                        dx11ShaderNode();

    virtual             ~dx11ShaderNode();


    static  MTypeId     typeId();

    static  void*       creator();

    static  MStatus     initialize();

    static  void        initializeNodeAttrs();


    // Query the renderers supported by this shader

    //

    virtual const MRenderProfile& profile();


public:

    // Internal attribute housekeeping

    virtual void        copyInternalData( MPxNode* pSrc );

    static  void        postDuplicateCB( void *data );

    virtual bool        getInternalValue( const MPlug&, MDataHandle&);

    virtual bool        setInternalValue( const MPlug&, const MDataHandle&);


    virtual MStatus     connectionMade( const MPlug& plug, const MPlug& otherPlug, bool asSrc );


    virtual MStatus     dependsOn(const MPlug& plug, const MPlug& otherPlug, bool& depends) const;


    // Dynamic light connection housekeeping:

    virtual MStatus     setDependentsDirty(const MPlug & plugBeingDirtied, MPlugArray & affectedPlugs);


    // Topology Management

public:

    bool rebuildAlways(size_t baseVersionId) const;

    bool isDirty(size_t baseVersionId) const;

    size_t geometryVersionId() const;


private:

    bool hasUpdatedVaryingInput() const;

    void setTopoDirty();


    // Effect Management

public:

    static bool reloadAll(const MString& effectName);

    bool reload();


    const MString& effectName() const;

    dx11ShaderDX11Effect* effect() const;


    double boundingBoxExtraScale() const;


private:

    bool loadEffect( const MString& effectName );


    bool loadFromFile( const MString& fileName, dx11ShaderDX11Device* dxDevice);

    bool loadFromBuffer( const MString& identifier, const void* pData, unsigned int dataSize, dx11ShaderDX11Device* dxDevice);


    bool initializeEffect();

    void resetData(bool clearEffect = true);


    // Technique Management

public:

    const MStringArray& techniques() const;

    inline int techniqueCount() const;


    bool techniqueIsTransparent() const;

    bool techniqueSupportsAdvancedTransparency() const;

    bool techniqueOverridesDrawState() const;

    bool techniqueOverridesNonMaterialItems() const;

    bool techniqueHandlesConsolidatedGeometry() const;

    bool techniqueIsSelectable() const;


    // Does the technique know how to render shadows or other special context?

    bool techniqueHandlesContext(MHWRender::MDrawContext& context) const;

    bool passHandlesContext(const MStringArray& passSemantics, unsigned int passIndex, ERenderType renderType, const RenderItemDesc* renderItemDesc = NULL) const;


    // Return the active technique number. Will be -1 if none

    int activeTechnique() const;


    // Return pointer to active technique

    dx11ShaderDX11EffectTechnique* technique() const;


    // Return name of active technique

    const MString& activeTechniqueName() const;


    // Return name of index buffer type of active technique

    const MString& techniqueIndexBufferType() const;


private:

    bool initializeTechniques();

    bool setTechnique( const MString& techniqueName );

    bool setTechnique( int techniqueNumber );


    void initTechniqueParameters();


    void storeDefaultTextureNames();

    void restoreDefaultTextureNames();


    // Pass Management

public:

    // Return the number of pass in active technique

    int techniquePassCount() const;


private:

    dx11ShaderDX11Pass* activatePass( dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11EffectTechnique* dxTechnique, unsigned int passId, ERenderType renderType ) const;

    dx11ShaderDX11Pass* activatePass( dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11EffectTechnique* dxTechnique, unsigned int passId, const MStringArray& passSem, ERenderType renderType, const RenderItemDesc* renderItemDesc = NULL ) const;


    bool passHasHullShader(dx11ShaderDX11Pass* dxPass) const;

    dx11ShaderDX11InputLayout* getInputLayout(dx11ShaderDX11Device* dxDevice, dx11ShaderDX11Pass* dxPass, unsigned int numLayouts, const dx11ShaderDX11InputElementDesc* layoutDesc) const;


    // Rendering

public:

    // Render to GL viewport

    virtual MStatus render( MGeometryList& iterator);


    // Override this method to draw a image for swatch rendering.

    virtual MStatus renderSwatchImage( MImage & image );


    // Override these methods to support texture display in the UV texture editor.

    //

    virtual MStatus getAvailableImages( const MPxHardwareShader::ShaderContext &context, const MString& uvSetName, MStringArray &imageNames );

    virtual MStatus renderImage( const MPxHardwareShader::ShaderContext &context, const MString& imageName, floatRegion region, const MPxHardwareShader::RenderParameters& parameters, int &imageWidth, int &imageHeight );

    virtual MStatus renderImage( const MPxHardwareShader::ShaderContext &context, MHWRender::MUIDrawManager& uiDrawManager, const MString& imageName, floatRegion region, const MPxHardwareShader::RenderParameters& parameters, int &imageWidth, int &imageHeight );


    // Render to DX vp2

    bool render(const MHWRender::MDrawContext& context, const MHWRender::MRenderItemList& renderItemList);


private:

    typedef std::vector<const MHWRender::MRenderItem*> RenderItemList;


    // Render functions for a list of render items

    bool renderTechnique(dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11EffectTechnique* dxTechnique,

                    unsigned int numPasses, const MStringArray& passSem,

                    const RenderItemList& renderItemList,

                    const MVaryingParameterList& varyingParameters, ERenderType renderType, const MString& indexBufferType) const;

    bool renderPass(dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11Pass* dxPass,

                    const RenderItemList& renderItemList,

                    const MVaryingParameterList& varyingParameters, ERenderType renderType, const MString& indexBufferType) const;


    // Render functions for a single geometry

    bool renderTechnique(dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11EffectTechnique* dxTechnique, unsigned int numPasses,

                    const MHWRender::MGeometry* geometry, MHWRender::MGeometry::Primitive primitiveType, unsigned int primitiveStride,

                    const MVaryingParameterList& varyingParameters, ERenderType renderType, const MString& indexBufferType ) const;


    bool renderPass(dx11ShaderDX11Device *dxDevice, dx11ShaderDX11DeviceContext *dxContext, dx11ShaderDX11Pass* dxPass,

                    const MHWRender::MGeometry* geometry, MHWRender::MGeometry::Primitive primitiveType, unsigned int primitiveStride,

                    const MVaryingParameterList& varyingParameters, ERenderType renderType, const MString& indexBufferType) const;


    // Render function for a single geometry into a texture target

    bool renderTechnique(dx11ShaderDX11Device *dxDevice, dx11ShaderDX11EffectTechnique* dxTechnique, unsigned int numPasses,

                    MHWRender::MRenderTarget* textureTarget, unsigned int width, unsigned int height, float clearColor[4],

                    const MHWRender::MGeometry* geometry, MHWRender::MGeometry::Primitive primitiveType, unsigned int primitiveStride,

                    const MVaryingParameterList& varyingParameters, ERenderType renderType, const MString& indexBufferType) const;


public:

    void backupStates(dx11ShaderDX11DeviceContext *dxContext, ContextStates &states) const;

    void restoreStates(dx11ShaderDX11DeviceContext *dxContext, ContextStates &states) const;


private:

    typedef std::map< dx11ShaderDX11EffectShaderResourceVariable*, MHWRender::MTexture* > ResourceTextureMap;

    bool updateParameters( const MHWRender::MDrawContext& context, MUniformParameterList& uniformParameters, ResourceTextureMap &resourceTexture, ERenderType renderType ) const;

    void updateOverrideNonMaterialItemParameters( const MHWRender::MRenderItem* item, RenderItemDesc& renderItemDesc ) const;

    void updateViewportGlobalParameters( const MHWRender::MDrawContext& context ) const;


public:

    void updateShaderBasedGeoChanges();

    void updateLightsInformation();


private:

    typedef std::map<int, bool> TshadowFlagBackupState;

    void initShadowFlagBackupState(TshadowFlagBackupState& stateBackup ) const;

    void setPerGeometryShadowOnFlag(bool receivesShadows, TshadowFlagBackupState& stateBackup ) const;


    // Uniform and varying parameters

public:

    void clearParameters();


private:

    // Uniform and varying parameters

    void preBuildUniformParameterList();

    bool buildUniformParameterList();

    bool buildVaryingParameterList();


    bool buildVertexDescriptorFromVaryingParameters();


    // Internal

    void initMayaParameters();


    // Attribute Editor

public:

    const MStringArray& getUIGroups() const;

    MStringArray getUIGroupParameters(int uiGroupIndex) const;

    int getIndexForUIGroupName(const MString& uiGroupName, bool appendGroup = false);


    const MStringArray& lightInfoDescription() const;


    MString getLightConnectionInfo(int lightIndex);

    MStringArray getLightableParameters(int lightIndex, bool showSemantics);

    int getIndexForLightName(const MString& lightName, bool appendLight = false);


    bool getVariableNameAsAttributeName(){ return fVariableNameAsAttributeName; }


private:

    bool appendParameterNameIfVisible(int paramIndex, MStringArray& paramArray) const;


    // Light Management

public:

    void refreshLightConnectionAttributes(bool inSceneUpdateNotification=false);


    void connectLight(int lightIndex, MDagPath light);

    void disconnectLight(int lightIndex);


private:

    void refreshView() const;

    void setLightRequiresShadows(const MObject& lightObject, bool requiresShadow) const;

    void updateImplicitLightConnections(const MHWRender::MDrawContext& context, ERenderType renderType) const;

    void updateExplicitLightConnections(const MHWRender::MDrawContext& context, ERenderType renderType) const;


private:

    void updateImplicitLightParameterCache(std::vector<CUniformParameterBuilder*>& builders);

    void clearLightConnectionData();


private:

    void getLightParametersToUpdate(std::set<int>& parametersToUpdate, ERenderType renderType) const;


    void connectLight(const LightParameterInfo& lightInfo, MHWRender::MLightParameterInformation* lightParam, ERenderType renderType=RENDER_SCENE) const;

    bool connectExplicitAmbientLight(const LightParameterInfo& lightInfo, const MObject& sourceLight) const;

    void turnOffLight(const LightParameterInfo& lightInfo) const;

    void setLightParameterLocking(const LightParameterInfo& lightInfo, bool locked) const;


    // Texture Management

private:

    MHWRender::MTexture* loadTexture(const MString& textureName, const MString& layerName, int alphaChannelIdx, int mipmapLevels, MObject node = MObject()) const;

    void releaseTexture(MHWRender::MTexture* texture) const;

    void assignTexture(dx11ShaderDX11EffectShaderResourceVariable* resourceVariable, const MString& textureName, const MString& layerName, int alphaChannelIdx, ResourceTextureMap& resourceTexture, MObject node = MObject()) const;

    void releaseAllTextures(ResourceTextureMap& resourceTexture) const;

    void releaseAllTextures();


  MHWRender::MTexture* getUVTexture(MHWRender::MDrawContext *context, const MString& imageName, int& imageWidth, int& imageHeight);

  MHWRender::MTexture* getUVTexture(MHWRender::MDrawContext *context, const MString& imageName, int& imageWidth, int& imageHeight,

      MString &textureName, MString& layerName, int &alphaChannelIdx, int &mipmapLevels);


public:

    bool getTextureFile(const MString& uniformName, MString& textureFile) const;


    // Convenient functions

private:

    void setParameterAsVector(int paramIndex, float* data) const;

    void setParameterAsScalar(int paramIndex, float data) const;

    void setParameterAsScalar(int paramIndex, bool data) const;

    void setParameterAsScalar(int paramIndex, int data) const;

    void setParameterAsMatrix(int paramIndex, MMatrix& data) const;

    void setParameterAsResource(int paramIndex, ID3D11ShaderResourceView* inResource) const;

    void setParameterFromUniformAsVector(int paramIndex,const MHWRender::MDrawContext& context, const float *data = NULL) const;

    void setParameterFromUniformAsScalar(int paramIndex,const MHWRender::MDrawContext& context) const;


public:

    const MHWRender::MVertexBufferDescriptorList* vertexBufferDescLists();


    // Diagnostics/description strings

private:

    void displayErrorAndWarnings() const;

    void reportInternalError( const char* function, size_t errcode ) const;


    // External content management

private:

    virtual void getExternalContent(MExternalContentInfoTable& table) const;

    virtual void setExternalContent(const MExternalContentLocationTable& table);


private:

    struct PassSpec

    {

        MString drawContext;

        bool forFatLine;

        bool forFatPoint;

    };

    unsigned int findMatchingPass(const PassSpec& passSpecTest) const;


private:

    // Version id, used by VP2.0 override to determine when a rebuild is necessary

    size_t                          fGeometryVersionId;


    // Keeps track if the anything in the shader may change the geo

    bool                            fShaderChangesGeo;

    double                          fLastTime;


    bool                            fIgnoreLightLimits;


    // Force the shader variable name to become the Maya attribute name, regardless of UIName annotation

    bool                            fVariableNameAsAttributeName;


    // Identifier to track scene-render-frame in order to optimize the updateParameter routine.

    mutable MUint64                 fLastFrameStamp;


    // For duplicate

    dx11ShaderNode*                 fDuplicateNodeSource;

    MCallbackId                     fPostDuplicateCallBackId;

    MPlugArray                      fDuplicatedConnections;


    // Effect name

    MString                         fEffectName;

    // Pointer to effect

    dx11ShaderDX11Effect*           fEffect;


    // List of techniques by name

    MStringArray                    fTechniqueNames;


    // Active technique index

    int                             fTechniqueIdx;

    // Active technique name

    MString                         fTechniqueName;

    // Pointer to active technique

    dx11ShaderDX11EffectTechnique*  fTechnique;

    // Active technique mipmapLevels value when loading textures

    int                             fTechniqueTextureMipMapLevels;

    // Active technique custom primitive generator that will be used to generate the index buffer.

    MString                         fTechniqueIndexBufferType;


    bool                            fTechniqueIsSelectable;

    ETransparencyState              fTechniqueIsTransparent;

    MString                         fOpacityPlugName;

    MString                         fTransparencyTestProcName;

    bool                            fTechniqueSupportsAdvancedTransparency;

    bool                            fTechniqueOverridesNonMaterialItems;

    bool                            fTechniqueHandlesConsolidatedGeometry;

    bool                            fTechniqueOverridesDrawState;


    // The enum version of .technique attribute (node local dynamic attr)

    MObject                         fTechniqueEnumAttr;


    // Active technique pass count

    unsigned int                    fTechniquePassCount;

    typedef std::map<unsigned int, PassSpec> PassSpecMap;

    PassSpecMap                     fTechniquePassSpecs;


    // List of uniform parameters.

    MUniformParameterList           fUniformParameters;


    // List of vertex buffer descriptions.

    MVaryingParameterList                   fVaryingParameters;

    MHWRender::MVertexBufferDescriptorList  fVaryingParametersVertexDescriptorList;

    size_t                                  fVaryingParametersGeometryVersionId;

    size_t                                  fVaryingParametersUpdateId;


    // default UV editor textures

    MStringArray                            fDefaultTextureNames;


    typedef std::vector<LightParameterInfo> LightParameterInfoVec;

    LightParameterInfoVec           fLightParameters;

    MStringArray                    fLightNames;

    MStringArray                    fLightDescriptions;

    mutable int                     fImplicitAmbientLight;


    MStringArray                    fUIGroupNames;

    std::vector<std::vector<int> >  fUIGroupParameters;


    ResourceTextureMap              fResourceTextureMap;

    mutable bool                    fForceUpdateTexture;

    int                             fFixedTextureMipMapLevels;

    MHWRender::MTexture*            fUVEditorTexture;


#ifdef USE_GL_TEXTURE_CACHING

    // Caching for UV Texture image

    MString                         fUVEditorLastTexture;

    MString                         fUVEditorLastLayer;

    int                             fUVEditorLastAlphaChannel;

    float                           fUVEditorBaseColor[4];

    bool                            fUVEditorShowAlphaMask;

    unsigned int                    fUVEditorGLTextureId;

    float                           fUVEditorGLTextureScaleU;

    float                           fUVEditorGLTextureScaleV;

#endif //USE_GL_TEXTURE_CACHING


    // Bounding Box Extra Scale

    MString                         fBBoxExtraScalePlugName;

    double                          fBBoxExtraScaleValue;


    // Maya Swatch Render

    dx11ShaderDX11EffectVariable*   fMayaSwatchRenderVar;


    // Maya full screen gamma correction

    dx11ShaderDX11EffectVariable*   fMayaGammaCorrectVar;

    dx11ShaderDX11EffectVariable*   fMayaHwFogEnabled;

    dx11ShaderDX11EffectVariable*   fMayaHwFogMode;

    dx11ShaderDX11EffectVariable*   fMayaHwFogStart;

    dx11ShaderDX11EffectVariable*   fMayaHwFogEnd;

    dx11ShaderDX11EffectVariable*   fMayaHwFogDensity;

    dx11ShaderDX11EffectVariable*   fMayaHwFogColor;

    dx11ShaderDX11EffectVariable*   fDepthRange;


    typedef std::map< dx11ShaderDX11Pass*, bool > PassHasHullShaderMap;

    mutable PassHasHullShaderMap    fPassHasHullShaderMap;


    struct CachedInputElementDesc

    {

        MString SemanticName;

        unsigned int SemanticIndex;

        int Format;

        unsigned int InputSlot;

        unsigned int AlignedByteOffset;

        int InputSlotClass;

        unsigned int InstanceDataStepRate;

    };


    struct InputLayoutData

    {

        dx11ShaderDX11InputLayout* inputLayout;

        unsigned int numLayouts;

        CachedInputElementDesc* layoutDesc;

    };

    typedef std::map< dx11ShaderDX11Pass*, InputLayoutData > PassInputLayoutMap;

    mutable PassInputLayoutMap      fPassInputLayoutMap;


    mutable MString                 fErrorLog;

    mutable MString                 fWarningLog;

    mutable unsigned int            fErrorCount;

};


// INLINE


// Topology Management

inline bool dx11ShaderNode::rebuildAlways(size_t baseVersionId) const

{

    return hasUpdatedVaryingInput() || isDirty(baseVersionId);

}


inline bool dx11ShaderNode::isDirty(size_t baseVersionId) const

{

    return (fGeometryVersionId != baseVersionId);

}


inline size_t dx11ShaderNode::geometryVersionId() const

{

    return fGeometryVersionId;

}


// Effect Management

inline const MString& dx11ShaderNode::effectName() const

{

    return fEffectName;

}


inline dx11ShaderDX11Effect* dx11ShaderNode::effect() const

{

    return fEffect;

}


inline double dx11ShaderNode::boundingBoxExtraScale() const

{

    return (fBBoxExtraScaleValue > 1.0f ? fBBoxExtraScaleValue : 1.0f);

}


// Technique Management

inline const MStringArray& dx11ShaderNode::techniques() const

{

    return fTechniqueNames;

}


inline int dx11ShaderNode::techniqueCount() const

{

    return (int)fTechniqueNames.length();

}


inline int dx11ShaderNode::activeTechnique() const

{

    return fTechniqueIdx;

}


inline dx11ShaderDX11EffectTechnique* dx11ShaderNode::technique() const

{

    return fTechnique;

}


inline const MString& dx11ShaderNode::activeTechniqueName() const

{

    return fTechniqueName;

}


inline const MString& dx11ShaderNode::techniqueIndexBufferType() const

{

    return fTechniqueIndexBufferType;

}


inline bool dx11ShaderNode::techniqueOverridesDrawState() const

{

    return fTechniqueOverridesDrawState;

}


inline bool dx11ShaderNode::techniqueSupportsAdvancedTransparency() const

{

    return fTechniqueSupportsAdvancedTransparency;

}


inline bool dx11ShaderNode::techniqueOverridesNonMaterialItems() const

{

    return fTechniqueOverridesNonMaterialItems;

}


inline bool dx11ShaderNode::techniqueHandlesConsolidatedGeometry() const

{

    return fTechniqueHandlesConsolidatedGeometry;

}


inline bool dx11ShaderNode::techniqueIsSelectable() const

{

    return fTechniqueIsSelectable;

}


// Pass Management

inline int dx11ShaderNode::techniquePassCount() const

{

    return fTechniquePassCount;

}


// Attribute Editor

inline const MStringArray& dx11ShaderNode::getUIGroups() const

{

    return fUIGroupNames;

}


inline const MStringArray& dx11ShaderNode::lightInfoDescription() const

{

    return fLightDescriptions;

}


#endif /* _dx11ShaderNode_h_ */