HWMesh.h

Go to the documentation of this file.

/**********************************************************************
*<
FILE: HWMesh.h

DESCRIPTION: Hardware Mesh Interface Implementation

CREATED BY: Peter Watje

HISTORY: Created June 13, 2008

Copyright 2008 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.   


These classes are designed to allow the creation of a retained hardware mesh that the display system 
can quickly display.  With the old code you had an mesh/mnmesh which had a hardwaremesh interface.  
The mesh then made a copy of itself but a tuple version and that was stored in the hardwaremesh interface.
That interface was then passed the gfx layer which would then split the mesh based on size and material
id's into index and vertex buffers that the gfx layer could consume.

The new hwmesh pushes more of the work on the mesh end. This is to prevent the massive amount of
copying we had with the old scheme.  Instead of copy the entire mesh into the hardware mesh and then 
turning it into a tuple mesh.  The mesh passes a chunk to the hardware mesh.  This chunk is based on
MatID and vertex buffer count (typically less then a dword).  The hardware mesh then turns this chunk 
into a tuple mesh which is then passed to the gfx layer to have the hw vertex and index buffer created.
Once that is done the tuple mesh is deleted and the next chunk is passed in.

Mesh : HardwareMesh
            HWTupleMeshContainer - which is container that holds all our sub meshes.  Each entry is 1 matID and
                                is typically has less than 65,500 vertex indices so we can use WORD indices to
                                reduce memory foot print
                Tab<GFX_MESH::HWTupleMesh *> this is the list of sub meshes.  Each sub mesh contains
                                    1 vertex buffer 
                                    2 index buffer 1 for shaded faces and 1 for wireframe(lineLis)
                                    IHWDrawMesh which is a pointer back to the raw hardware buffers that the device created.

So to create a HWTupleMesh
    1.  The mesh first gets a list a faces that all have the same MatID and have less than the MaxVerts
    2.  That chunk is then converted into a tuple mesh and stored GFX_MESH::HWMesh
    3.  The GFX_MESH::HWMesh is then passed to the graphics window which tries a graphics window specific
        buffers.  If this is successfull the HWMesh tuple data is deleted.  If it fails the data is kept
        and when the data will be used to draw the mesh in immediate mode.  This can happen is we run out 
        of memory.
    4.  Repeat step one till you have no more faces to process

When the mesh is drawn it just calls draw on each GFX_MESH::HWMesh entry.  If the entry contains graphic
window specific buffers.  That is just immediately blasted out, if the hardware specific data is not there
the tuple data is still there and can be drawn in immediate mode.
                    

**********************************************************************/
#pragma once

#include "maxheap.h" 
#include "tab.h" 
#include "HWVertex.h"
#include "HWIndex.h"
// forward declarations
class BitArray;
class GraphicsWindow;
class Point3; 

namespace GFX_MESH
{



    class IHWDrawMesh : public  MaxHeapOperators
    {
        
    public:
        DllExport IHWDrawMesh();
        virtual ~IHWDrawMesh() { ; }

        virtual void Draw(GraphicsWindow *gw, DWORD attribute) = 0;


        virtual void UpdateVertexBuffer(Point3 *vertexList,Point3 *gfxNormalList, Point3 *faceNormalList, BitArray &changedVerts, int count,
                                        unsigned int *vertMapList,  int *normalsMapList) = 0;

        virtual void Release() = 0;
        
        DllExport void MakeRef();


    protected:      

        
        DllExport void DecRefCount();

        
        DllExport bool CanDelete();

        int mRefCount;  //this is just a simple ref counter, when it is zero we can safely delete this class

    };


    class IHWSubMesh : public  MaxHeapOperators
    {

    public:
        virtual ~IHWSubMesh()   {   }
        

        virtual void Draw(GraphicsWindow *gw, DWORD attribute) = 0;


        virtual void UpdateVertexBuffer(Point3 *vertexList,Point3 *gfxNormalList, Point3 *faceNormalList, BitArray &changedVerts, int count,
            unsigned int *vertMapList,  int *normalsMapList) = 0;

    

    };




    class HWTupleMesh : public  MaxHeapOperators
    {
    public:

        DllExport HWTupleMesh(DWORD vertexType);

        DllExport ~HWTupleMesh();

        DllExport unsigned int Size();


        DllExport HWVertexBuffer*   GetHWVertexBuffer();


        DllExport unsigned int AddHWIndexBuffer(unsigned int numberPrimitives, PrimitiveType primitive, bool use16Bit);

        DllExport HWIndexBuffer*    GetHWIndexBuffer(unsigned int id);  

        DllExport bool              ReleaseHWIndexBuffer(unsigned int id);  

        DllExport unsigned int      GetHWIndexCount();  


        DllExport DWORD GetMatID(); 

        DllExport void  SetMatID(DWORD matID);  


        DllExport void  SetGFXMesh(IHWSubMesh *msh);

        DllExport IHWSubMesh* GetGFXMesh();


        DllExport void UpdateVertexBuffer(Point3 *vertexList,Point3 *gfxNormalList, Point3 *faceNormalList, BitArray &changedVerts, int count);


        

    private:
        DWORD                   mMatID;             //the matid associated with this chunk.  We only allow one material per chunk
        HWVertexBuffer          *mHWVertexBuffer;   // our vertex buffer
        Tab<HWIndexBuffer*>     mPrimitives;    // our array of index buffers


        IHWSubMesh              *mHWDrawMesh;       //pointer to the class that contains our graphics hardware specific buffers

    };




    class HWTupleMeshContainer : public IHWDrawMesh
    {
    public:
        DllExport HWTupleMeshContainer();
        DllExport ~HWTupleMeshContainer();  

        DllExport void FreeMeshes();    

        DllExport unsigned int Count();
        DllExport GFX_MESH::HWTupleMesh *Get(unsigned int id);

        DllExport void Append(GFX_MESH::HWTupleMesh *hwMesh);




        DllExport void Draw(GraphicsWindow *gw, DWORD attribute);


        DllExport void UpdateVertexBuffer(Point3 *vertexList,Point3 *gfxNormalList, Point3 *faceNormalList, BitArray &changedVerts, int count,
            unsigned int *vertMapList, int *normalsMapList);

         DllExport void Release();

    private:
        //new hw mesh representation
        Tab<GFX_MESH::HWTupleMesh *> mHWTupleMesh; //this is an array of all our sub mesh. a sub mesh are faces thathave the same mat ID
    };





};