OgreVertexIndexData.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef __VertexIndexData_H__
#define __VertexIndexData_H__

#include "OgrePrerequisites.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreHardwareIndexBuffer.h"

namespace Ogre {
    
    typedef std::vector<HardwareBuffer::Usage> BufferUsageList;


    class _OgreExport VertexData
    {
    private:
        VertexData(const VertexData& rhs); /* do nothing, should not use */
        VertexData& operator=(const VertexData& rhs); /* do not use */
    public:
        VertexData();
        ~VertexData();

        VertexDeclaration* vertexDeclaration;
        VertexBufferBinding* vertexBufferBinding;
        size_t vertexStart;
        size_t vertexCount;


        struct HardwareAnimationData
        {
            const VertexElement* targetVertexElement;
            Real parametric;
        };
        typedef std::vector<HardwareAnimationData> HardwareAnimationDataList;
        HardwareAnimationDataList hwAnimationDataList;
        size_t hwAnimDataItemsUsed;
        
        VertexData* clone(bool copyData = true) const;

        void prepareForShadowVolume(void);

        HardwareVertexBufferSharedPtr hardwareShadowVolWBuffer;


        void reorganiseBuffers(VertexDeclaration* newDeclaration, const BufferUsageList& bufferUsage);

        void reorganiseBuffers(VertexDeclaration* newDeclaration);

        void convertPackedColour(VertexElementType srcType, VertexElementType destType);


        void allocateHardwareAnimationElements(ushort count);



    };

    class _OgreExport IndexData 
    {
    protected:
        IndexData(const IndexData& rhs); /* do nothing, should not use */
        IndexData& operator=(const IndexData& rhs); /* do not use */
    public:
        IndexData();
        ~IndexData();
        HardwareIndexBufferSharedPtr indexBuffer;

        size_t indexStart;

        size_t indexCount;

        IndexData* clone(bool copyData = true) const;

        void optimiseVertexCacheTriList(void);
    
    };

    class _OgreExport VertexCacheProfiler
    {
        public:
            enum CacheType {
                FIFO, LRU
            };

            VertexCacheProfiler(unsigned int cachesize = 16, CacheType cachetype = FIFO )
                : size ( cachesize ), type ( cachetype ), tail (0), buffersize (0), hit (0), miss (0)
            {
                cache = new uint32[size];
            };

            ~VertexCacheProfiler()
            {
                delete[] cache;
            }

            void profile(const HardwareIndexBufferSharedPtr indexBuffer);
            void reset() { hit = 0; miss = 0; tail = 0; buffersize = 0; };
            void flush() { tail = 0; buffersize = 0; };

            unsigned int getHits() { return hit; };
            unsigned int getMisses() { return miss; };
            unsigned int getSize() { return size; };
        private:
            unsigned int size;
            uint32 *cache;
            CacheType type;

            unsigned int tail, buffersize;
            unsigned int hit, miss;

            bool inCache(unsigned int index);
    };
}
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:51 2006