PIndexBuffer.hpp

// Copyright (C) 2008-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_P_INDEX_BUFFER_HPP_INCLUDED
#define DCPP_P_INDEX_BUFFER_HPP_INCLUDED
 
#include <duckcpp/core/engine/IIndexBuffer.hpp>
 
namespace dcpp
{
namespace scene
{
 
    class PIndexBuffer : public IIndexBuffer
    {
        // Virtual function wrapper around dcpp::nub::array
        class IIndexList
        {
        public:
            virtual ~IIndexList(){};
 
            virtual dcpp::uint32_kt stride() const =0;
            virtual dcpp::uint32_kt size() const =0;
            virtual void push_back(dcpp::uint32_kt value) =0;
            virtual dcpp::uint32_kt operator [](dcpp::uint32_kt index) const =0;
            virtual dcpp::uint32_kt getLast() =0;
            virtual void setValue(dcpp::uint32_kt index, dcpp::uint32_kt value) =0;
            virtual void set_used(dcpp::uint32_kt usedNow) =0;
            virtual void reallocate(dcpp::uint32_kt new_size, bool canShrink=true) =0;
            virtual dcpp::uint32_kt allocated_size() const =0;
            virtual void* pointer() =0;
            virtual const void* const_pointer() const =0;
            virtual dcpp::video::E_INDEX_TYPE getType() const =0;
        };
 
        template <class T>
        class PSpecificIndexList : public IIndexList
        {
        public:
            dcpp::nub::array<T> Indices;
 
            virtual dcpp::uint32_kt stride() const override {return sizeof(T);}
 
            virtual dcpp::uint32_kt size() const override {return Indices.size();}
 
            virtual void push_back(dcpp::uint32_kt value) override
            {
                Indices.push_back((T)value);
            }
 
            virtual dcpp::uint32_kt operator [](dcpp::uint32_kt index) const override
            {
                return (dcpp::uint32_kt)(Indices[index]);
            }
 
            virtual dcpp::uint32_kt getLast() override {return (dcpp::uint32_kt)Indices.getLast();}
 
            virtual void setValue(dcpp::uint32_kt index, dcpp::uint32_kt value) override
            {
                Indices[index]=(T)value;
            }
 
            virtual void set_used(dcpp::uint32_kt usedNow) override
            {
                Indices.set_used(usedNow);
            }
 
            virtual void reallocate(dcpp::uint32_kt new_size, bool canShrink) override
            {
                Indices.reallocate(new_size, canShrink);
            }
 
            virtual dcpp::uint32_kt allocated_size() const override
            {
                return Indices.allocated_size();
            }
 
            virtual void* pointer() override  { return Indices.pointer(); }
            virtual const void* const_pointer() const override  { return Indices.const_pointer(); }
 
            virtual dcpp::video::E_INDEX_TYPE getType() const override
            {
                if (sizeof(T)==sizeof(dcpp::uint16_kt))
                    return dcpp::video::EIT_16BIT;
                else
                    return dcpp::video::EIT_32BIT;
            }
        };
 
    public:
        IIndexList *Indices;
 
        PIndexBuffer(dcpp::video::E_INDEX_TYPE IndexType) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
        {
            setType(IndexType);
        }
 
        PIndexBuffer(const IIndexBuffer &IndexBufferCopy) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
        {
            setType(IndexBufferCopy.getType());
            reallocate(IndexBufferCopy.size());
 
            for (dcpp::uint32_kt n=0;n<IndexBufferCopy.size();++n)
                push_back(IndexBufferCopy[n]);
        }
 
        virtual ~PIndexBuffer()
        {
            delete Indices;
        }
 
        virtual void setType(dcpp::video::E_INDEX_TYPE indexType) override
        {
            if ( Indices && Indices->getType() == indexType )
                return;
 
            IIndexList *NewIndices=0;
 
            switch (indexType)
            {
                case dcpp::video::EIT_16BIT:
                {
                    NewIndices=new PSpecificIndexList<dcpp::uint16_kt>;
                    break;
                }
                case dcpp::video::EIT_32BIT:
                {
                    NewIndices=new PSpecificIndexList<dcpp::uint32_kt>;
                    break;
                }
            }
 
            if (Indices)
            {
                NewIndices->reallocate( Indices->size() );
 
                for(dcpp::uint32_kt n=0;n<Indices->size();++n)
                    NewIndices->push_back((*Indices)[n]);
 
                delete Indices;
            }
 
            Indices=NewIndices;
        }
 
        virtual void* getData() override {return Indices->pointer();}
        virtual const void* getData() const override { return Indices->const_pointer(); }
 
        virtual dcpp::video::E_INDEX_TYPE getType() const override {return Indices->getType();}
 
        virtual dcpp::uint32_kt stride() const override {return Indices->stride();}
 
        virtual dcpp::uint32_kt size() const override
        {
            return Indices->size();
        }
 
        virtual void push_back(dcpp::uint32_kt value) override
        {
            Indices->push_back(value);
        }
 
        virtual dcpp::uint32_kt operator [](dcpp::uint32_kt index) const override
        {
            return (*Indices)[index];
        }
 
        virtual dcpp::uint32_kt getLast() override
        {
            return Indices->getLast();
        }
 
        virtual void setValue(dcpp::uint32_kt index, dcpp::uint32_kt value) override
        {
            Indices->setValue(index, value);
        }
 
        virtual void set_used(dcpp::uint32_kt usedNow) override
        {
            Indices->set_used(usedNow);
        }
 
        virtual void reallocate(dcpp::uint32_kt new_size, bool canShrink=true) override
        {
            Indices->reallocate(new_size, canShrink);
        }
 
        virtual dcpp::uint32_kt allocated_size() const override
        {
            return Indices->allocated_size();
        }
 
        virtual E_HARDWARE_MAPPING getHardwareMappingHint() const override
        {
            return MappingHint;
        }
 
        virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override
        {
            MappingHint=NewMappingHint;
        }
 
        virtual void setDirty() override
        {
            ++ChangedID;
        }
 
 
        virtual dcpp::uint32_kt getChangedID() const override {return ChangedID;}
 
        E_HARDWARE_MAPPING MappingHint;
        dcpp::uint32_kt ChangedID;
    };
 
 
} // end namespace scene
} // end namespace dcpp
 
#endif