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
//=============================================================================