RTMax.h

Go to the documentation of this file.

/**********************************************************************
*<
FILE: RTMax.h

DESCRIPTION:    Main Include for DirectX and MS Effect related code
                
CREATED BY:     Neil Hazzard

HISTORY:        February 2004

*>  Copyright (c) 2004, All Rights Reserved.
**********************************************************************/
#pragma once

#include <d3dx9.h>
#include "export.h"
#include "maxheap.h"
#include "stdmat.h"
#include "DeprecatedRealtimeMaterialTexturemapShaderAPI.h"


#define SAFE_DELETE(p)          { if (p) { delete (p);      (p)=NULL; } }
#define SAFE_DELETE_ARRAY(p)    { if (p) { delete[] (p);    (p)=NULL; } }
#define SAFE_RELEASE(p)         { if (p) { (p)->Release();  (p)=NULL; } }

#define SUMMER_SDK



class ILightManager;
class IRenderMesh;
class IEffectParser;
class IParameterManager;

enum MaxSemantics
{
    kSemanticUnknown,
    kSemanticDirection,
    kSemanticPosition,
    kSemanticWorld,
    kSemanticView,
    kSemanticPerspective,
    kSemanticWorldView,
    kSemanticProjection,
    kSemanticProjectionI,
    kSemanticProjectionIT,
    kSemanticViewI,
    kSemanticWorldI,
    kSemanticWorldViewI,
    kSemanticWorldViewProj,
    kSemanticWorldViewIT,
    kSemanticViewIT,
    kSemanticWorldIT,
    kSemanticWorldViewT,
    kSemanticWorldT,
    kSemanticViewT,
    kSemanticProjectionT,
    kSemanticWorldCamPos,
    kSemanticLightColor,
    kSemanticNormalMap,
    kSemanticBumpMap,
    kSemanticDiffuseMap,
    kSemanticSpecularMap,
    kSemanticOpacityMap,
    kSemanticLightMap,
    kSemanticDisplacementMap,
    kSemanticGlobalTime,
    kSemanticGlobalBkgrd,
    kSemanticLocalBBMin,
    kSemanticLocalBBMax,
    kSemanticLocalBBSize,
    kSemanticRecipLocalBBSize,
    kSemanticBitmapOverride,
    kSemanticColorOverride,
    kSemanticViewportDimensions,
    kSemanticATan,
    kSemanticDiffuse,
    kSemanticAmbient,
    kSemanticSpecular,
    kSemanticSpecularLevel,
    kSemanticGlossLevel,
    kSemanticOpacity,
    kSemanticEmissive,
    kSemanticReflectionMap,
    kSemanticLightFallOff,
    kSemanticLightHotSpot,
    kSemanticDirectionLocal,
    kSemanticPositionLocal,
    kSemanticLightAttenuation,  
    kSemanticPositionView,
    kSemanticDirectionView,
    kSemanticShadowData
};


class IEffectManager: public MaxHeapOperators{

public:
    enum{
        kDirectX9,
        kDirectX10,
    };
    virtual ~IEffectManager() {;}

    virtual void SetFloatParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName, float val,float min, float max, float step,MaxSemantics semantic )=0;

    virtual void SetIntParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,int val,int min, int max, int step,MaxSemantics semantic )=0;

    virtual void SetColorParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,D3DXVECTOR4 color,MaxSemantics semantic)=0;

    virtual void SetPoint4Param(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,D3DXVECTOR4 val,float min, float max, float step,MaxSemantics semantic) = 0;

    virtual void SetBooleanParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,BOOL val,MaxSemantics semantic) = 0;
    
    virtual void SetTextureParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,MCHAR * filename, MaxSemantics semantic, bool mappingEnabled = false, int mappingChannel=1)=0;

    virtual void SetLightParam(D3DXHANDLE handle, MCHAR * paramName, MCHAR * uiName,bool target,MaxSemantics semantic) = 0;

    virtual void SetTransformParam(D3DXHANDLE handle,MaxSemantics semantic)=0;

    virtual void SetGeometryParam(D3DXHANDLE handle,MaxSemantics semantic)=0;

    virtual void SetEnvironmentParam(D3DXHANDLE handle,MaxSemantics semantic)=0;

    virtual void SetTechnique(D3DXHANDLE handle, MCHAR * techniqueName, bool bDefault) =0;


    virtual UINT GetDirectXVersion()=0;

};

class IEffectParser: public MaxHeapOperators
{
public:
    virtual bool ParseEffectFile(LPVOID pDevice, const MaxSDK::AssetManagement::AssetUser& file, IEffectManager * em)=0;

    virtual bool LoadTexture(LPVOID pDevice, MCHAR * paramName, MCHAR * filename, bool forceReload, PBBitmap *pBitmap=NULL)=0;

    virtual void DestroyParser()=0;

    virtual bool PreRender(LPVOID pDevice, IRenderMesh * rmesh, ILightManager * lm, IParameterManager * pm, D3DCOLOR bkgColor, int width, int height ) = 0;

    virtual bool Render(LPVOID pDevice, IRenderMesh * rmesh, D3DXHANDLE primaryTechnique)=0;

    virtual void SetMappingChannel(D3DXHANDLE handle, int Channel)=0;

    virtual void SetUseLPRT(bool state){ UNUSED_PARAM(state); };


    virtual bool LoadEffect(LPVOID pDevice, IEffectManager * em, const MCHAR * effect, bool fileType, bool forceReload) =0;

    virtual const MCHAR * GetLastParserError() =0;

    virtual ~IEffectParser() {}

    


    virtual int GetNumberOfLightParameters() = 0;

    virtual MaxSemantics GetLightSemantic(int index)=0;

    virtual const MCHAR * GetLightHandle(int index)=0;

    virtual void OnLostDevice() = 0;

    virtual void OnResetDevice() = 0;


    virtual bool LoadTexture(LPVOID pTexture, const MCHAR* paramName) =0;

};


class ILightingData: public MaxHeapOperators{
public:
    virtual ~ILightingData() {;}

    virtual D3DXVECTOR4 GetPosition()=0;

    virtual D3DXVECTOR4 GetDirection()=0;

    virtual D3DXVECTOR4 GetColor()=0;

    virtual float GetFallOff()=0;

    virtual float GetHotSpot()=0;


    virtual D3DXVECTOR4 GetAttenuation() =0;

};


class IShadowLightData: public MaxHeapOperators
{
public:
    virtual ~IShadowLightData() {;}

    virtual void UpdateShadowParam(LPVOID pEffect) = 0;
    virtual void ResetShadowData(LPVOID pEffect) = 0;
};


class ILightManager: public MaxHeapOperators{

public:
    virtual ~ILightManager() {;}


    virtual ILightingData * GetLightingData(const MCHAR * paramName)=0;

};

class IParameterManager: public MaxHeapOperators{
public:
    enum{
        kPType_Unknown,
        kPType_Float,
        kPType_Int,
        kPType_Bool,
        kPType_Point4,
        kPType_Matrix,
        kPType_Color,
        kPType_Struct,
        kPType_Texture,
    };

    virtual ~IParameterManager() {;}


    virtual int GetNumberOfParams()=0;


    virtual MaxSemantics GetParamSemantics(int index)=0;


    virtual const MCHAR * GetParamName(int index)=0;


    virtual bool GetParamData(LPVOID data, int index)=0;
    

    virtual bool GetParamData(LPVOID data, const MCHAR * paramName)=0;


    virtual int GetParamType(int index) = 0;


    virtual int GetParamType(const MCHAR * parmName) =0;


    virtual int GetParamSize(int index) = 0;
};



#include "iFnPub.h"

#define PARSER_LOADER_INTERFACE Interface_ID(0x7fbe42d6, 0x3e7f412b)

class EffectDescriptor: public MaxHeapOperators
{
public:
    virtual ~EffectDescriptor() {;}


    virtual IEffectParser * CreateParser() = 0;


    virtual ULONG GetParserID()=0;


    virtual const MCHAR * GetParserFileFilterName()=0;


    virtual const MCHAR * GetParserFileExtension()=0;

};

class IParserLoader : public FPStaticInterface
{
public:

    virtual int GetNumberOfParsers()=0;


    virtual IEffectParser * GetParser(ULONG parserID) =0;

    virtual void LoadDLLs()=0;

    virtual void UnloadDLLs()=0;


    virtual const MCHAR * GetParserFilter(int index)=0;


    virtual const MCHAR * GetParserExtension(int index) =0;
};

inline IParserLoader* GetParserLoader() { return (IParserLoader*)GetCOREInterface(PARSER_LOADER_INTERFACE); }

class IRenderMesh: public MaxHeapOperators
{

public:

    enum MeshType{
        kMesh,
        kScreenQuad,
    };

    virtual ~IRenderMesh() {;}

    /*
    \returns A pointer to the IRenderMesh interface
    */
    DllExport static IRenderMesh * GetRenderMesh();


    virtual void SetMeshType(MeshType type)=0;


    virtual bool Evaluate(LPVOID Device, int width, int height, int texWidth, int texHeight)=0;


    virtual bool Evaluate(LPVOID Device, Mesh *aMesh, int MatIndex, bool NegScale)=0;


    virtual void SetMappingData(Tab <int> &map)=0;


    virtual bool Render(LPVOID Device)=0;

    virtual void Invalidate()=0;


    virtual bool GetVertexFormat(void ** pFormat, int * itemCount)=0;
};



class IRenderMeshCache: public MaxHeapOperators{

public:
    /*
    \returns A pointer to the IRenderMeshCache interface
    */
    DllExport static  IRenderMeshCache *  GetRenderMeshCache();


    virtual void SetMeshType(IRenderMesh::MeshType type)=0;


    virtual int SetCachedMNMesh (MNMesh *mnMesh, INode *node, TimeValue time, bool & meshChanged)=0;


    virtual int SetCachedMesh (Mesh *mesh, INode *node, TimeValue time, bool & meshChanged)=0;


    virtual int GetCacheSize()=0;


    virtual IRenderMesh * GetActiveRenderMesh(int index)=0;

    virtual INode * GetActiveNode(int index)=0;

    virtual Mesh * GetActiveMesh(int index)=0;

    virtual void SetDirectXVersion(UINT version)=0;

    virtual ~IRenderMeshCache() {}

    virtual void Release()=0;

    virtual void DeleteRenderMeshCache(INode * node)=0;

};



#define EFFECT_FILE_INTERFACE Interface_ID(0xc3d2425, 0x637366bc)


class IEffectFile : public BaseInterface
{
public:
    // Interface Lifetime
    virtual Interface_ID    GetID() { return EFFECT_FILE_INTERFACE; }


    virtual bool SaveEffectFile(MCHAR * fileName)=0;

};

class IValidateNodeCallback: public MaxHeapOperators
{
public:
    virtual ~IValidateNodeCallback() {;}

    virtual bool NodeValid(INode * node, ViewExp * vpt)=0;

    virtual void NodeSort(Tab <INode *> & nodeList){ UNUSED_PARAM(nodeList); };
};

class IDxSceneTransformManager: public MaxHeapOperators
{
public:
    enum TransformType{
        kWorldXform,
        kViewXform,
        kProjectionXform
    };
    virtual ~IDxSceneTransformManager() {;}


    virtual D3DXMATRIX GetD3DMatrix(TransformType matType)=0;


    virtual void SetD3DMatrix(MCHAR * paramName)=0;


    virtual void SetD3DMatrix(D3DXMATRIX mat, TransformType matType)=0;


    virtual D3DXMATRIX GetD3DMatrix(MCHAR * paramName, TransformType matType) = 0;


};


class IDxSceneManager: public MaxHeapOperators
{
public:
    enum DXEffectType{
        kPreEffect, 
        kPostEffect,
        kEnvEffect 
    };

    enum DXPassType{
        kStandard, 
        kEnvironment, 
        kEnvironmentLast,   
    };

    virtual ~IDxSceneManager() {;}

    virtual void StoreSceneEffect(Mtl * dxMtl, DXEffectType effectType = kPostEffect, int numberOfPasses=0)=0;

    virtual void StoreSceneEffect(Tab<Mtl*> &dxMtl)=0;

    virtual int GetNumberOfSceneEffects(DXEffectType effectType = kPostEffect) = 0;

    virtual Mtl * GetSceneEffect(int index, DXEffectType effectType = kPostEffect) = 0;

    virtual void ResetSceneEffects()=0;


    virtual void RemoveSceneEffect(int index, DXEffectType effectType = kPostEffect) =0;
    
    virtual void StartScene(GraphicsWindow *gw )=0;

    
    virtual void EndScene(GraphicsWindow *gw ) = 0;


    virtual LPDIRECT3DBASETEXTURE9 GetSceneRenderTarget(bool env = false, MCHAR * paramName = NULL)=0;
    

    virtual void SetSceneRenderTarget(LPDIRECT3DBASETEXTURE9 texture, MCHAR * paramName)=0;


    virtual void EnableDebugMode(bool onOff, MCHAR * outputPath, MCHAR * namePrefix) = 0;

    virtual void EnableSceneTraversal(bool state, IValidateNodeCallback * proc)=0;
    

    virtual IDxSceneTransformManager * GetTransformManager() = 0;

    virtual void SceneInitialize(GraphicsWindow * gw) =0;

    virtual int GetNumberOfPasses()=0;

    virtual int GetCurrentPassNumber()=0;

    virtual IDxSceneManager::DXPassType GetActivePassType()=0;


    virtual bool IsSceneEffectValid() = 0;



    DllExport static IDxSceneManager * GetIDxSceneManager();
};

struct DxGeneralFunctions{
    DllExport  static MCHAR * GetDXResourceFilename(MCHAR * fileName);
};