shaders.h

Go to the documentation of this file.

//
// Copyright 2010 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.  
//
//

#pragma once

#include "iparamb2.h"
#include "stdmat.h"
#include "buildver.h"

#define     N_ID_CHANNELS   16      //!< Number of IDs in stdMat
class Shader;
#define OPACITY_PARAM   0
#define DEFAULT_SOFTEN  0.1f

class ShaderParamDlg : public ParamDlg {
    public:
        virtual Class_ID ClassID()=0;
        
        virtual void SetThing(ReferenceTarget *m)=0;

        virtual void SetThings( StdMat2* pMtl, Shader* pShader )=0;
        
        virtual ReferenceTarget* GetThing()=0;

        virtual Shader* GetShader()=0;
        
        virtual void SetTime(TimeValue t) { UNUSED_PARAM(t); }  
        
        virtual void DeleteThis()=0;        
        
        virtual INT_PTR PanelProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam )=0; 
        
        virtual void LoadDialog( int draw )=0;
        virtual void UpdateDialog( ParamID paramId )=0;

        virtual HWND GetHWnd()=0;

        virtual int  FindSubTexFromHWND(HWND hw)=0;
        
        virtual void UpdateOpacity()=0;
        
        virtual void UpdateMapButtons()=0;
};
 
// Can be or'd w/ mtl, not sure it's necessary
#define SELFILLUM_CLR_ON    (1<<16) 

#define HAS_BUMPS               0x01L       //!< Indicates that the bump mapping is present.
#define HAS_REFLECT             0x02L       //!< Indicates that there is any kind of reflection (raytraced, etc).
#define HAS_REFRACT             0x04L       //!< Indicates that there is any kind of refraction.
#define HAS_OPACITY             0x08L       //!< Indicates that opacity mapping is used.

#define HAS_REFLECT_MAP         0x10L
#define HAS_REFRACT_MAP         0x20L       //!< Indicates that there is a refraction map only.
#define HAS_MATTE_MTL           0x40L



#define UNSUPPORTED_CHANNEL     0x01L       //!< Indicates that the channel is not supported (is not used).
#define CLR_CHANNEL             0x02L       //!< A color channel. The Color.r, Color.g and Color.b parameters are used.
#define MONO_CHANNEL            0x04L       //!< A monochrome channel. Only the Color.r is used.
#define BUMP_CHANNEL            0x08L       //!< The bump mapping channel.
#define REFL_CHANNEL            0x10L       //!< The reflection channel.
#define REFR_CHANNEL            0x20L       //!< The refraction channel.
#define DISP_CHANNEL            0x40L       //!< The displacement channel.
#define SLEV_CHANNEL            0x80L       

#define ELIMINATE_CHANNEL       0x8000L

#define SKIP_CHANNELS   (UNSUPPORTED_CHANNEL+BUMP_CHANNEL+REFL_CHANNEL+REFR_CHANNEL) 



#define  DEFAULT_SHADER_CLASS_ID BLINNClassID //!< Class Id upper half for loading the Pre 3.0 shaders

#ifndef USE_LIMITED_STDMTL // orb 01-14-2002
#define  PHONGClassID (STDSHADERS_CLASS_ID+2)
#define  METALClassID (STDSHADERS_CLASS_ID+4)
#endif // USE_LIMITED_STDMTL


#define  BLINNClassID (STDSHADERS_CLASS_ID+3)               //!< For Blinn Shader
static Class_ID BlinnClassID(STDSHADERS_CLASS_ID + 3,0);    

#define ANISOSHADER_CLASS_ID 0x2857f460                         //!< For Anisotropic Shader
static Class_ID AnisoShaderClassID( ANISOSHADER_CLASS_ID, 0);   
static Class_ID AnisoShaderDlgClassID( ANISOSHADER_CLASS_ID, 0);

enum Shader_Anisotropic_Shader_BlockID
{
    aniso_params
};

enum Shader_Anisotropic_Shader_ParamIDs
{ 
    an_ambient, an_diffuse, an_specular, an_self_illum_color,
    an_diffuse_level, an_specular_level, an_self_illum_amnt, 
    an_glossiness, an_anisotropy, an_orientation, 
    an_map_channel, an_ad_texlock, an_ad_lock, an_ds_lock, an_use_self_illum_color, 
};


#define NEWSHADERS_CLASS_ID      0x2857f420                                 //!< For Oren/Nayar/Blinn Shader
static Class_ID OrenNayarBlinnShaderClassID( NEWSHADERS_CLASS_ID + 1, 0);   
static Class_ID OrenNayarShaderDlgClassID( NEWSHADERS_CLASS_ID + 2, 0);     

enum Shader_Oren_Nayar_Blinn_BlockID
{
    onb_params
};
enum Shader_Oren_Nayar_Blinn_ParamIDs
{ 
    onb_ambient, onb_diffuse, onb_specular,
    onb_self_illum_color, onb_self_illum_amnt,
    onb_glossiness, onb_specular_level, onb_soften,
    onb_diffuse_level, onb_roughness, 
    onb_ad_texlock, onb_ad_lock, onb_ds_lock, onb_use_self_illum_color, 
};



#define STRAUSS_SHADER_CLASS_ID     0x2857f450                      //!< For Strauss Shader
static Class_ID StraussShaderClassID( STRAUSS_SHADER_CLASS_ID, 0);  

enum Shader_Strauss_BlockID
{
    strauss_params
};

enum Shader_Strauss_ParamIDs
{ 
    st_diffuse, st_glossiness, st_metalness, 
};

class ParamBlockDescID;
class IParamBlock;

class BaseShader : public SpecialFX {
    public:
        #pragma warning(push)
        #pragma warning(disable:4100)
        RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 
             PartID& partID,  RefMessage message) {return REF_SUCCEED;}

        SClass_ID SuperClassID() {return SHADER_CLASS_ID;}

        BOOL BypassPropertyLevel() { return TRUE; }  

        virtual ULONG GetRequirements(int subMtlNum)=0;

        virtual ShaderParamDlg* CreateParamDialog(
            HWND hOldRollup, 
            HWND hwMtlEdit, 
            IMtlParams *imp, 
            StdMat2* theMtl, 
            int rollupOpen, 
            int n=0) = 0;

        virtual int NParamDlgs(){ return 1; }

        virtual ShaderParamDlg* GetParamDlg(int n=0 )=0;
        
        virtual void SetParamDlg( ShaderParamDlg* newDlg, int n=0 )=0;

        IOResult Save(ISave *isave) { return SpecialFX::Save(isave); }
        
        IOResult Load(ILoad *iload) { return SpecialFX::Load(iload); }

        virtual ULONG SupportStdParams()=0;

        virtual void ConvertParamBlk( ParamBlockDescID *descOld, int oldCount, IParamBlock *oldPB ){};

        virtual void GetIllumParams( ShadeContext &sc, IllumParams& ip )=0;

        virtual void Illum(ShadeContext &sc, IllumParams &ip)=0;

// begin - ke/mjm - 03.16.00 - merge reshading code
        // these support the pre-shade/reshade protocol
//      virtual void PreIllum(ShadeContext &sc, IReshadeFragment* pFrag){}
//      virtual void PostIllum(ShadeContext &sc, IllumParams &ip, IReshadeFragment* pFrag ){ Illum(sc,ip); }

        // >>>> new for V4, one call superceded, 2 new ones added
        virtual void ShadeReflection(ShadeContext &sc, IllumParams &ip, Color &mapClr){}
        
        virtual void ShadeTransmission(ShadeContext &sc, IllumParams &ip, Color &mapClr, float amount){}
            
        virtual void AffectReflection(ShadeContext &sc, IllumParams &ip, Color &rcol){}

        virtual void CombineComponents( ShadeContext &sc, IllumParams& ip ){};
        #pragma warning(pop)
        
        virtual long nTexChannelsSupported()=0;
        
        virtual MSTR GetTexChannelName( long nTextureChan )=0;
        
        virtual MSTR GetTexChannelInternalName( long nTextureChan ) { return GetTexChannelName(nTextureChan); }
        
        virtual long ChannelType( long nTextureChan )=0;
        
        virtual long StdIDToChannel( long stdID )=0;

        virtual long nUserIllumOut(){ return 0; } 

        virtual MCHAR** UserIllumNameArray(){ return NULL; } 

        virtual void Reset()=0; 

    };


#define SHADERBASE_CHUNK    0x39bf
#define SHADERNAME_CHUNK    0x0100


#define STD_PARAM_NONE          (0)             //!< Indicates that none of the flags in the Standard_Parameters is used
#define STD_PARAM_ALL           (0xffffffffL)   //!< Indicates that all of the flags in the Standard_Parameters are used
#define STD_PARAM_METAL         (1)             //!< Only used by the Metal shader
#define STD_PARAM_LOCKDS        (1<<1)          //!< Indicates support for the Diffuse/Specular lock.
#define STD_PARAM_LOCKAD        (1<<2)          //!< Indicates support for the Ambient/Diffuse lock.
#define STD_PARAM_LOCKADTEX     (1<<3)          //!< Indicates support for the Ambient/Diffuse texture lock.
#define STD_PARAM_SELFILLUM     (1<<4)          //!< Indicates support for the Self Illumination parameter.
#define STD_PARAM_SELFILLUM_CLR (1<<5)          //!< Indicates support for the Self Illumination color parameter.
#define STD_PARAM_AMBIENT_CLR   (1<<6)          //!< Indicates support for the Ambient color parameter.
#define STD_PARAM_DIFFUSE_CLR   (1<<7)          //!< Indicates support for the Diffuse color parameter.
#define STD_PARAM_SPECULAR_CLR  (1<<8)          //!< Indicates support for the Specular color parameter.
#define STD_PARAM_FILTER_CLR    (1<<9)          //!< Indicates support for the Filter color parameter.
#define STD_PARAM_GLOSSINESS    (1<<10)         //!< Indicates support for the Glossiness parameter.
#define STD_PARAM_SOFTEN_LEV    (1<<11)         //!< Indicates support for the Soften Level parameter.
#define STD_PARAM_SPECULAR_LEV  (1<<12)         //!< Indicates support for the Specular Level parameter.
#define STD_PARAM_DIFFUSE_LEV   (1<<13)         //!< Indicates support for the Diffuse Level parameter.
#define STD_PARAM_DIFFUSE_RHO   (1<<14)         //!< Indicates support for the Roughness parameter.
#define STD_PARAM_ANISO         (1<<15)         //!< Indicates support for the Specular Highlight Anisotropy parameter.
#define STD_PARAM_ORIENTATION   (1<<16)         //!< Indicates support for the Specular Highlight Orientation parameter.
#define STD_PARAM_REFL_LEV      (1<<17)         //!< This is reserved for future use.
#define STD_PARAM_SELFILLUM_CLR_ON      (1<<18) //!< Indicates support for the Self Illumination Color On/Off checkbox.

#define STD_BASIC2_DLG          (1<<20)          

#define STD_EXTRA_DLG           (1<<21)         

#define STD_EXTRA_REFLECTION    (1<<22)         

#define STD_EXTRA_REFRACTION    (1<<23)         

#define STD_EXTRA_OPACITY       (1<<24)         




#define STD_EXTRA   (STD_EXTRA_DLG \
                    +STD_EXTRA_REFLECTION+STD_EXTRA_REFRACTION \
                    +STD_EXTRA_OPACITY )

#define STD_BASIC   (0x00021ffeL | STD_BASIC2_DLG)

#ifndef USE_LIMITED_STDMTL // orb 01-14-2002
#define STD_BASIC_METAL (0x00021fffL | STD_BASIC2_DLG)
#define STD_ANISO   (0x0002cffe)
#define STD_MULTILAYER  (0x0002fffe)
#define STD_ONB     (0x00023ffe)
#define STD_WARD    (0x00000bce)
#endif // USE_LIMITED_STDMTL



class Shader : public BaseShader, public IReshading
{
    public:
    #pragma warning(push)
    #pragma warning(disable:4100)

    virtual void CopyStdParams( Shader* pFrom )=0;
    
    // these are the standard shader params

    virtual void SetLockDS(BOOL lock)=0;
    
    virtual BOOL GetLockDS()=0;

    virtual void SetLockAD(BOOL lock)=0;

    virtual BOOL GetLockAD()=0;
    
    virtual void SetLockADTex(BOOL lock)=0;

    virtual BOOL GetLockADTex()=0;

    virtual void SetSelfIllum(float v, TimeValue t)=0;      

    virtual void SetSelfIllumClrOn( BOOL on )=0;

    virtual void SetSelfIllumClr(Color c, TimeValue t)=0;       

    virtual void SetAmbientClr(Color c, TimeValue t)=0;     

    virtual void SetDiffuseClr(Color c, TimeValue t)=0;     

    virtual void SetSpecularClr(Color c, TimeValue t)=0;

    virtual void SetGlossiness(float v, TimeValue t)=0;     

    virtual void SetSpecularLevel(float v, TimeValue t)=0;      

    virtual void SetSoftenLevel(float v, TimeValue t)=0;
        
    virtual BOOL IsSelfIllumClrOn(int mtlNum, BOOL backFace)=0;

    virtual Color GetAmbientClr(int mtlNum, BOOL backFace)=0;       
    
    virtual Color GetDiffuseClr(int mtlNum, BOOL backFace)=0;       

    virtual Color GetSpecularClr(int mtlNum, BOOL backFace)=0;
    
    virtual Color GetSelfIllumClr(int mtlNum, BOOL backFace)=0;
    
    virtual float GetSelfIllum(int mtlNum, BOOL backFace)=0;
    
    virtual float GetGlossiness(int mtlNum, BOOL backFace)=0;   
    
    virtual float GetSpecularLevel(int mtlNum, BOOL backFace)=0;
    
    virtual float GetSoftenLevel(int mtlNum, BOOL backFace)=0;

    virtual BOOL IsSelfIllumClrOn()=0;
    
    virtual Color GetAmbientClr(TimeValue t)=0;     
    
    virtual Color GetDiffuseClr(TimeValue t)=0;     
    
    virtual Color GetSpecularClr(TimeValue t)=0;
    
    virtual float GetGlossiness( TimeValue t)=0;        
    virtual float GetSpecularLevel(TimeValue t)=0;
    
    virtual float GetSoftenLevel(TimeValue t)=0;
    
    virtual float GetSelfIllum(TimeValue t)=0;      
    
    virtual Color GetSelfIllumClr(TimeValue t)=0;       

    virtual float EvalHiliteCurve(float x){ return 0.0f; }

    virtual float EvalHiliteCurve2(float x, float y, int level = 0 ){ return 0.0f; }

    CoreExport void ShadeReflection(ShadeContext &sc, IllumParams &ip, Color &mapClr);
    CoreExport void ShadeTransmission(ShadeContext &sc, IllumParams &ip, Color &mapClr, float amount);

    // Reshading
    void PreShade(ShadeContext& sc, IReshadeFragment* pFrag){}
    void PostShade(ShadeContext& sc, IReshadeFragment* pFrag, int& nextTexIndex, IllumParams* ip){ Illum( sc, *ip ); }
    #pragma warning(pop)
    // [dl | 13march2003] Adding this inlined definition to resolve compile errors
    BaseInterface* GetInterface(Interface_ID id) { return BaseShader::GetInterface(id); }
    void* GetInterface(ULONG id){
        if( id == IID_IReshading )
            return (IReshading*)( this );
    //  else if ( id == IID_IValidityToken )
    //      return (IValidityToken*)( this );
        else
            return BaseShader::GetInterface(id);
    }
};