ihardwarerenderer.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: IHardwareRenderer.h

    DESCRIPTION: Hardware Renderer Extension Interface class

    CREATED BY: Norbert Jeske

    HISTORY:

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

#include "ihardwareshader.h"
#include "HWMesh.h"

// forward declarations
struct D3DXCOLOR;
class IHardwareMesh;
class IHardwareMaterial;
class HardwareMaterial;
class Matrix3;

#define HARDWARE_RENDERER_INTERFACE_ID Interface_ID(0x7f78405c, 0x43894b27)

#define HARDWARE_RENDERER_ST_INTERFACE_ID Interface_ID(0x14716452, 0x65f35430)

#define D3DHWMESHCACHEMANAGER_INTERFACE_ID Interface_ID(0x7f7840ef, 0x11894b11)

class IHardwareRenderer : public IHardwareShader
{
public:
    virtual Interface_ID    GetID() { return HARDWARE_RENDERER_INTERFACE_ID; }

    // Interface Lifetime
    virtual LifetimeType    LifetimeControl() { return noRelease; }

    // Device Information
    virtual int     GetMaxTexStages() = 0;

    // Active Viewport Windows
    virtual int     GetNumActiveWindows() = 0;

    // Screen Update
    virtual bool    UpdateScreen(GFX_ESCAPE_FN fn) = 0;

    // Depth Peeling for Transparency
    virtual bool    CanDepthPeel() = 0;
    virtual void    CreateLayer(int layerNum) = 0;
    virtual void    BlendLayers() = 0;

    // Start and End of Drawing a Node
    virtual void    StartNode() = 0;
    virtual void    EndNode(GFX_ESCAPE_FN fn) = 0;

    // Material Settings
    virtual void    SetColor(ColorType t, D3DXCOLOR *pClr) = 0;
    virtual void    SetMaterial(HardwareMaterial *pMtl) = 0;

    virtual D3DXCOLOR   *GetDiffuseColor() = 0;

    //return Display All Triangle Edges in DirectX mode for objects that are not selected and in the modifier panel
    //if this is the case all edges will be drawn
    virtual bool    DisplayAllTriangleEdges() = 0;
    virtual void    SetDisplayAllTriangleEdges(bool displayAllEdges) = 0;

    // Cached Mesh Data
    virtual bool    CanCacheMeshData() = 0;

    // Draw a 3ds max Mesh
    //
    //  type = D3DPRIMITIVETYPE type of primitive
    //  nPrim = number of primitives
    //  pAttr = array of length nPrim indicating which primitives share
    //      attributes, e.g. color, material, effect
    //  nComp = number of separate vertex data arrays
    //  pUse = array of length nComp indicating D3DDECLUSAGE of each data array
    //  ppInd = array of nComp arrays each the same length and long enough
    //      to handle nPrim, the connectivity data for the IndexBuffer
    //  fComp = bit flags for number of float components in each data array,
    //      e.g. 0x00 = 4 floats, 0x01 = 1 float, 0x02 = 2 floats, and
    //      0x03 = 3 floats, enough space for 16 flags
    //  pLen = array of nComp values giving lengths of data arrays
    //  ppData = array of nComp float arrays with data, each being 1X, 2X, 3X,
    //      or 4X the length specified in pLen depending on the fComp bit flag
    //  attr = which attribute set to draw

    virtual void    DrawMesh(DWORD type, DWORD nPrim, DWORD *pAttr,
        DWORD nComp, DWORD *pUse, DWORD **ppInd, DWORD fComp, DWORD *pLen,
        float **ppData, DWORD attr, GFX_ESCAPE_FN fn) = 0;

    // Build a D3DXMesh from a 3ds max Mesh
    //
    //  Returns a pointer to a GFX D3DXMesh class that wraps the D3DXMesh
    //  object

    virtual DWORD_PTR   BuildMesh(DWORD nFaces, DWORD *pAttr, DWORD nComp,
        DWORD *pUse, DWORD **ppInd, DWORD fComp, DWORD *pLen, float **ppData,
        GFX_ESCAPE_FN fn) = 0;

    virtual DWORD_PTR   BuildMesh(IHardwareMesh *pHWMesh,
        GFX_ESCAPE_FN fn) = 0;

    // Draw a D3DXMesh or part of a D3DXMesh
    //
    //  pMesh = pointer to a GFX D3DMesh class
    //  attr = attribute value to match with primitive attributes

    virtual void    DrawMesh(DWORD_PTR pMesh, DWORD attr,
        GFX_ESCAPE_FN fn) = 0;

    // Load a D3DXMesh from a .X file
    //
    //  Returns a pointer to a GFX D3DXMesh class that wraps the D3DXMesh
    //  object

    virtual DWORD_PTR   LoadMesh(LPCTSTR filename) = 0;

    // Save a D3DXMesh to a .X file
    //
    //  pMesh = pointer to a GFX D3DMesh class

    virtual void    SaveMesh(LPCTSTR filename, DWORD_PTR pMesh) = 0;

    // Free a D3DXMesh
    //
    //  pMesh = pointer to a GFX D3DMesh class

    virtual void    FreeMesh(DWORD_PTR pMesh) = 0;

    // Build a GFX IndexedBuffer, a VertexBuffer and IndexBuffer pair
    //
    //  Returns a pointer to a GFX D3DIndexedBuffer class

    virtual DWORD_PTR   BuildIndexedBuffer(DWORD type, DWORD nPrim,
        DWORD *pAttr, DWORD nComp, DWORD *pUse, DWORD **ppInd, DWORD fComp,
        DWORD *pLen, float **ppData, GFX_ESCAPE_FN fn) = 0;

    // Draw an IndexedBuffer or part of an IndexedBuffer
    virtual void    DrawIndexedBuffer(DWORD_PTR pBuffer, DWORD attr,
        GFX_ESCAPE_FN fn) = 0;

    // Free an IndexedBuffer
    virtual void    FreeIndexedBuffer(DWORD_PTR pBuffer) = 0;

    // Build a D3DTexture from a 3ds max texture
    //
    //  bmi = 3ds max bitmap texture
    //  mipLevels = number of MipMap levels to build
    //  usage = type, e.g. Texture, RenderTarget, DepthStencil
    //  format = pixel format, e.g. A8R8G8B8
    //
    //  Returns a pointer to a GFX D3DTexture class
    virtual DWORD_PTR   BuildTexture(BITMAPINFO *bmi, UINT mipLevels,
        DWORD usage, DWORD format) = 0;

    // Load a D3DTexture from a file, includes CubeMaps
    //
    //  Returns a pointer to a GFX D3DTexture class
    virtual DWORD_PTR   LoadTexture(LPCTSTR filename) = 0;

    // Save a D3DTexture to a file, includes CubeMaps
    virtual void    SaveTexture(LPCTSTR filename, DWORD_PTR pTex) = 0;

    // Free a D3DTexture, includes CubeMaps
    virtual void    FreeTexture(DWORD_PTR pTex) = 0;

    // Build a D3DCubeMap from a set of D3DTextures
    //
    //  size = edge size, e.g. width and height
    //  mipLevels = number of MipMap levels to build
    //  usage = type, e.g. Texture, RenderTarget, DepthStencil
    //  format = pixel format, e.g. A8R8G8B8
    //  pTex = array of six D3DTextures to use for the faces
    //
    //  Returns a pointer to a GFX D3DCubeMap class

    virtual DWORD_PTR   BuildCubeMap(UINT size, UINT mipLevels, DWORD usage,
        DWORD format, DWORD_PTR *pTex) = 0;

    // Set a face of a D3DCubeMap
    //
    //  pCubeMap = pointer to a GFX D3DCubeMap class
    //  face = face to set, e.g. positive X
    //  mipLevel = number of MipMap levels to build
    //  pTex = D3DTexture to use for the face

    virtual void    SetCubeMapFace(DWORD_PTR pCubeMap, DWORD face,
        UINT mipLevel, DWORD_PTR pTex) = 0;

    // Build a D3DVertexDeclaration
    //
    //  nComp = number of separate vertex data components
    //  pUse = array of length nComp indicating D3DDECLUSAGE of each data array
    //  fComp = bit flags for number of float components in each data array,
    //      e.g. 0x00 = 4 floats, 0x01 = 1 float, 0x02 = 2 floats, and
    //      0x03 = 3 floats, enough space for 16 flags
    //
    //  Returns a pointer to a GFX D3DVertexDecl class

    virtual DWORD_PTR   BuildVertexDecl(DWORD nComp, DWORD *pUse,
        DWORD fComp) = 0;

    // Set a D3DVertexDeclaration
    virtual void    SetVertexDecl(DWORD_PTR pVertexDecl) = 0;

    // Free a D3DVertexDeclaration
    virtual void    FreeVertexDecl(DWORD_PTR pVertexDecl) = 0;

    // Build a D3DVertexShader
    //
    //  code = string with Shader instructions
    //
    //  Returns a pointer to a GFX D3DVertexShader class

    virtual DWORD_PTR   BuildVertexShader(LPCSTR code) = 0;

    // Load a D3DVertexShader from a file
    //
    //  Returns a pointer to a GFX D3DVertexShader class

    virtual DWORD_PTR   LoadVertexShader(LPCTSTR filename) = 0;

    // Save a D3DVertexShader to a file
    virtual void    SaveVertexShader(LPCTSTR filename, DWORD_PTR pVertexShader) = 0;

    // Set a D3DVertexShader
    virtual void    SetVertexShader(DWORD_PTR pVertexShader) = 0;

    // Set D3DVertexShader Constants
    //
    //  nReg is the number of the register where the data loading starts,
    //  type is the D3DXPARAMETERTYPE of the parameter, pData is the actual
    //  data and nData is the number of four 32 bit sets of data
    //
    virtual void    SetVertexShaderConstant(DWORD_PTR pVertexShader,
        DWORD nReg, DWORD type, void *pData, DWORD nData) = 0;

    // Free a D3DVertexShader
    virtual void    FreeVertexShader(DWORD_PTR pVertexShader) = 0;

    // Build a D3DPixelShader
    //
    //  code = string with Shader instructions
    //
    //  Returns a pointer to a GFX D3DPixelShader class

    virtual DWORD_PTR   BuildPixelShader(LPCSTR code) = 0;

    // Load a D3DPixelShader
    //
    //  Returns a pointer to a GFX D3DPixelShader class

    virtual DWORD_PTR   LoadPixelShader(LPCTSTR filename) = 0;

    // Save a D3DPixelShader to a file
    virtual void    SavePixelShader(LPCTSTR filename, DWORD_PTR pPixelShader) = 0;

    // Set a D3DPixelShader
    virtual void    SetPixelShader(DWORD_PTR pPixelShader) = 0;

    // Set D3DPixelShader Constants
    //
    //  nReg is the number of the register where the data loading starts,
    //  type is the D3DXPARAMETERTYPE of the parameter, pData is the actual
    //  data and nData is the number of four 32 bit sets of data
    //
    virtual void    SetPixelShaderConstant(DWORD_PTR pPixelShader,
        DWORD nReg, DWORD type, void *pData, DWORD nData) = 0;

    // Free a D3DPixelShader
    virtual void    FreePixelShader(DWORD_PTR pPixelShader) = 0;

    // Build a D3DXEffect
    //
    //  Returns a pointer to a GFX D3DEffect class

    virtual DWORD_PTR   BuildEffect(LPCSTR code) = 0;

    // Load a D3DXEffect from a file
    virtual DWORD_PTR   LoadEffect(LPCTSTR filename) = 0;

    // Save a D3DXEffect to a file
    virtual void    SaveEffect(LPCTSTR filename, DWORD_PTR pEffect) = 0;

    // Set D3DXEffect Parameters
    //
    //  name is the name of the parameter, type is the D3DXPARAMETERTYPE of the
    //  parameter, pData is the actual data
    //
    virtual void    SetEffectParameter(DWORD_PTR pEffect, LPCTSTR name,
        DWORD type, void *pData) = 0;

    // Set D3DXEffect Technique
    //
    //  name is the name of the technique
    //
    virtual void    SetEffectTechnique(DWORD_PTR pEffect, LPCTSTR name) = 0;

    // Begin a D3DXEffect
    virtual void    BeginEffect(DWORD_PTR pEffect) = 0;

    // Set a D3DXEffect Pass
    virtual void    SetEffectPass(DWORD_PTR pEffect, DWORD nPass) = 0;

    // End a D3DXEffect
    virtual void    EndEffect(DWORD_PTR pEffect) = 0;

    // Free a D3DXEffect
    virtual void    FreeEffect(DWORD_PTR pEffect) = 0;

    // Begin D3DXEffect access
    //
    //  The D3DXEffect associated with the GFX D3DEffect is returned
    //
    virtual DWORD_PTR   BeginEffectAccess(DWORD_PTR pEffect, GFX_ESCAPE_FN fn) = 0;

    // End D3DXEffect access
    virtual void    EndEffectAccess(GFX_ESCAPE_FN fn) = 0;

    // Begin Direct3D Device access
    //
    //  The Direct3DDevice is returned
    //
    virtual DWORD_PTR   BeginDeviceAccess(GFX_ESCAPE_FN fn) = 0;

    // End Direct3D Device access
    virtual void    EndDeviceAccess(GFX_ESCAPE_FN fn) = 0;


    virtual bool ObjectDrawnByShader() = 0;


    virtual void DXCacheUpdateVertexBuffer(DWORD_PTR pMesh, Point3 *vertexList,Point3 *gfxNormalList, Point3 *faceNormalList, BitArray &changedVerts, int count) = 0;

};

class IHardwareRendererST : public IHardwareRenderer
{
public:
    virtual Interface_ID    GetID() { return HARDWARE_RENDERER_ST_INTERFACE_ID; }
};


class ID3DHWMeshCacheManager : public BaseInterface
{
public:

    virtual Interface_ID    GetID() { return D3DHWMESHCACHEMANAGER_INTERFACE_ID; }

    // Interface Lifetime
    virtual LifetimeType    LifetimeControl() { return noRelease; }

    //

    virtual void D3DHWMeshCacheManagerReset(BOOL clearBlock = FALSE) = 0;


    virtual BOOL D3DHWMeshCacheManagerAddHWMesh( INode *node, GFX_MESH::IHWDrawMesh *pMesh, Material *mtl, HardwareMaterial *pHWMat, Point3 wireframeColor, Matrix3 *tmOverRide, DWORD attr, DWORD renderLimit) = 0;


    virtual void D3DHWMeshCacheManagerSetRenderLimit(DWORD limit) = 0;


    virtual DWORD D3DHWMeshCacheManagerGetRenderLimit() = 0;


    virtual void D3DHWMeshCacheManagerRegisterMaterial(HardwareMaterial *mtl, Point3 wireframeColor) = 0;


//  virtual void D3DHWMeshCacheManagerDeleteHWMesh(DWORD_PTR pMesh) = 0;
    virtual void D3DHWMeshCacheManagerDeleteHWMesh(GFX_MESH::IHWDrawMesh * pMesh) = 0;


    virtual void D3DHWMeshCacheManagerDisplay(GraphicsWindow *gw) = 0;

    virtual int D3DHWMeshCacheManagerTotalBlocksDrawn() = 0;
};