GPUCacheOptimizer.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
#ifndef ACG_GPU_CACHE_OPT_HH
#define ACG_GPU_CACHE_OPT_HH
 
 
//== INCLUDES =================================================================
 
#include <ACG/Config/ACGDefines.hh>
 
//== FORWARDDECLARATIONS ======================================================
 
//== NAMESPACES ===============================================================
 
namespace ACG {
 
//== CLASS DEFINITION =========================================================
 
 
class ACGDLLEXPORT GPUCacheOptimizer
{
private:
  // copy ops are private to prevent copying
  GPUCacheOptimizer(const GPUCacheOptimizer&);            // no implementation
  GPUCacheOptimizer& operator=(const GPUCacheOptimizer&); // no implementation
public:
 
        GPUCacheOptimizer(unsigned int NumTris, unsigned int NumVerts, unsigned int IndexSize, const void* pIndices);
        virtual ~GPUCacheOptimizer(void);
 
        
        const unsigned int* GetTriangleMap() const {return m_pTriMap;}
 
        void WriteIndexBuffer(unsigned int DstIndexSize, void* pDst);
 
 
        static void OptimizeVertices(unsigned int NumTris, unsigned int NumVerts, unsigned int IndexSize,
                                                                 const void* pIndices, unsigned int* pVertMap);
        // this function is declared static to be able to operate on the whole model
        // instead of just a subset of it
        // example use:
        // - optimize triangle list per material group
  // - optimize vertex buffer on whole mesh independently of material subsets
 
 
        static void RemapVertices(unsigned int NumTris, unsigned int NumVerts, const unsigned int* pVertMap,
                unsigned int IndexSize, void* pInOutIndices, unsigned int VertexStride, void* pInOutVertices);
 
 
        unsigned int ComputeNumberOfVertexTransformations(unsigned int VertexCacheSize = 16);
 
        float ComputeACMR(unsigned int VertexCacheSize = 16);
 
        float ComputeATVR(unsigned int VertexCacheSize = 16);
 
protected:
        // look up  m_pIndices w.r.t. index size at location 'i'
        unsigned int GetIndex(unsigned int i) const;
 
        static unsigned int GetIndex(unsigned int i, unsigned int IndexSize, const void* pIB);
        static void SetIndex(unsigned int i, unsigned int val, unsigned int IndexSize, void* pIB);
 
        virtual void MakeAbstract() = 0;
 
protected:
 
 
        unsigned int m_NumVerts;
        unsigned int m_NumTris;
        
        unsigned int* m_pTriMap;
 
private:
        unsigned int m_IndexSize;
        const void* m_pIndices;
 
 
        unsigned int m_NumTransformations;
 
 
protected:
        struct Opt_Vertex
        {
                // Opt_Vertex(): iCachePos(-1), fScore(0.0f), iNumTrisTotal(0), iNumTrisLeft(0), pTris(0) {}
                // ~Opt_Vertex() {delete [] pTris;}
 
                int iCachePos;
                float fScore;
                int iNumTrisTotal;
                int iNumTrisLeft;
                unsigned int* pTris;
 
                void FindScore(unsigned int MaxSizeVertexCache);
 
                void RemoveTriFromList(unsigned int tri);
        };
 
        struct Opt_Tris
        {
                Opt_Tris() : bAdded(0), fScore(0.0f) 
                { v[0] = v[1] = v[2] = 0xDEADBEEF;}
 
                int bAdded;
                float fScore;
                unsigned int v[3];
 
                inline void FindScore(const Opt_Vertex* pVertices)
                {
                        fScore = 0.0f;
                        for (int i = 0; i < 3; ++i)
                                fScore += pVertices[v[i]].fScore;
                }
        };
};
 
 
class ACGDLLEXPORT GPUCacheOptimizerTipsify : public GPUCacheOptimizer
{
public:
 
        GPUCacheOptimizerTipsify(unsigned int CacheSize,
                                 unsigned int NumTris,
                                 unsigned int NumVerts,
                                 unsigned int IndexSize,
                                 const void* pIndices);
 
private:
 
        void MakeAbstract(){}
 
        struct RingStack
        {
        private:
                unsigned int* pStack;
                unsigned int uiStart, uiLen;
                unsigned int uiSize;
 
                inline unsigned int pos(unsigned int i) const
                {
                        unsigned int t = uiStart + i;
                        if (t >= uiLen) t -= uiLen;
                        return t;
                }
 
        public:
                explicit RingStack(unsigned int _uiSize) :
                  uiStart(0),
                  uiLen(0),
                  uiSize(_uiSize)
    {
      pStack = new unsigned int[uiSize];
    }
 
    RingStack(const RingStack& _other)
    {
      // Copy meta data
      uiSize  = _other.uiSize;
      uiLen   = _other.uiLen;
      uiStart = _other.uiStart;
 
      // Create empty storage
      pStack = new unsigned int[uiSize];
 
      // Copy storage from original to current storage
      for (unsigned int  i = 0 ; i < uiSize; ++i )
        pStack[i] = _other.pStack[i];
 
    }
 
                ~RingStack() {delete [] pStack;}
 
                unsigned int length() const {return uiLen;} 
                unsigned int size() const {return uiSize;}  
 
                inline void push(unsigned int v)
                {
                        if (uiLen == uiSize)
                        {
                                pStack[uiStart++] = v;
                                if (uiStart == uiSize) uiStart = 0;
                        }
                        else
                                pStack[pos(uiLen++)] = v; // pos(uiLen) gives the index of the last element + 1
                }
 
                inline unsigned int pop()
                {
                        if (uiSize && uiLen) return pStack[pos(--uiLen)];
                        return 0xFFFFFFFF;
                }
        };
};
 
class ACGDLLEXPORT GPUCacheEfficiencyTester : public GPUCacheOptimizer
{
public:
        GPUCacheEfficiencyTester(unsigned int NumTris, unsigned int NumVerts, unsigned int IndexSize, const void* pIndices);
 
private:
        void MakeAbstract(){}
};
 
 
 
//=============================================================================
} // namespace ACG
//=============================================================================
#endif // ACG_GPU_CACHE_OPT_HH defined
//=============================================================================