D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spDimensionUniversalBuffer.hpp

Go to the documentation of this file.

/*
 * Universal buffer header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_DIMENSION_UNIVERSALBUFFER_H__
#define __SP_DIMENSION_UNIVERSALBUFFER_H__


#include "Base/spStandard.hpp"

#include <vector>
#include <cstring>


namespace sp
{
namespace dim
{


class UniversalBuffer
{
    
    public:
        
        UniversalBuffer() :
            Stride_(1)
        {
        }
        UniversalBuffer(const UniversalBuffer &Other) :
            Stride_(Other.Stride_),
            Buffer_(Other.Buffer_)
        {
        }
        ~UniversalBuffer()
        {
        }
        
        inline UniversalBuffer& operator = (const UniversalBuffer &Other)
        {
            Stride_ = Other.Stride_;
            Buffer_ = Other.Buffer_;
            return *this;
        }
        
        inline bool setStride(u32 Stride)
        {
            if (Stride > 0)
            {
                Stride_ = Stride;
                return true;
            }
            return false;
        }
        inline u32 getStride() const
        {
            return Stride_;
        }
        
        template <typename T> inline void set(u32 Offset, const T &Value)
        {
            if (Offset + sizeof(T) <= Buffer_.size())
                memcpy(&Buffer_[Offset], &Value, sizeof(T));
        }
        template <typename T> inline T get(u32 Offset) const
        {
            if (Offset + sizeof(T) <= Buffer_.size())
                return *((T*)&Buffer_[Offset]);
            return T(0);
        }
        
        template <typename T> inline void set(u32 Index, u32 Offset, const T &Value)
        {
            set<T>(Index * Stride_ + Offset, Value);
        }
        template <typename T> inline T get(u32 Index, u32 Offset) const
        {
            return get<T>(Index * Stride_ + Offset);
        }
        
        template <typename T> inline void set(u32 Index, u32 Offset, u32 MaxSize, const T &Value)
        {
            const u32 Size = (sizeof(T) > MaxSize ? MaxSize : sizeof(T));
            Offset += Index * Stride_;
            if (Offset + Size <= Buffer_.size())
                memcpy(&Buffer_[Offset], &Value, Size);
        }
        template <typename T> inline T get(u32 Index, u32 Offset, u32 MaxSize) const
        {
            const u32 Size = (sizeof(T) > MaxSize ? MaxSize : sizeof(T));
            Offset += Index * Stride_;
            if (Offset + Size <= Buffer_.size())
                return *((T*)&Buffer_[Offset]);
            return T(0);
        }
        
        inline void setBuffer(u32 Offset, const void* Buffer, u32 Size)
        {
            if (Offset + Size <= Buffer_.size())
                memcpy(&Buffer_[Offset], Buffer, Size);
        }
        inline void getBuffer(u32 Offset, void* Buffer, u32 Size) const
        {
            if (Offset + Size <= Buffer_.size())
                memcpy(Buffer, &Buffer_[Offset], Size);
        }
        
        inline void setBuffer(u32 Index, u32 Offset, const void* Buffer, u32 Size)
        {
            setBuffer(Index * Stride_ + Offset, Buffer, Size);
        }
        inline void getBuffer(u32 Index, u32 Offset, void* Buffer, u32 Size) const
        {
            getBuffer(Index * Stride_ + Offset, Buffer, Size);
        }
        
        template <typename T> inline void add(const T &Value)
        {
            const u32 Offset = Buffer_.size();
            Buffer_.resize(Buffer_.size() + sizeof(T));
            set(Offset, Value);
        }
        template <typename T> inline void remove(u32 Index, u32 Offset)
        {
            const u32 FinalOffset = Index * Stride_ + Offset;
            Buffer_.erase(Buffer_.begin() + FinalOffset, Buffer_.end() + FinalOffset + sizeof(T));
        }
        
        inline void add(const UniversalBuffer &Other)
        {
            if (Stride_ == Other.Stride_)
            {
                const u32 PrevSize = Buffer_.size();
                Buffer_.resize(PrevSize + Other.Buffer_.size());
                memcpy(&Buffer_[PrevSize], &Other.Buffer_[0], Other.Buffer_.size());
            }
        }
        
        inline void removeBuffer(u32 Offset, u32 Size)
        {
            Buffer_.erase(Buffer_.begin() + Offset, Buffer_.begin() + Offset + Size);
        }
        inline void removeBuffer(u32 Index, u32 Offset, u32 Size)
        {
            const u32 FinalOffset = Index * Stride_ + Offset;
            Buffer_.erase(Buffer_.begin() + FinalOffset, Buffer_.begin() + FinalOffset + Size);
        }
        
        inline s8* getArray()
        {
            return Buffer_.size() ? &Buffer_[0] : 0;
        }
        inline const s8* getArray() const
        {
            return Buffer_.size() ? &Buffer_[0] : 0;
        }
        
        inline s8* getArray(u32 Offset)
        {
            return Buffer_.size() ? &Buffer_[Offset] : 0;
        }
        inline const s8* getArray(u32 Offset) const
        {
            return Buffer_.size() ? &Buffer_[Offset] : 0;
        }
        
        inline s8* getArray(u32 Index, u32 Offset)
        {
            return Buffer_.size() ? &Buffer_[Index * Stride_ + Offset] : 0;
        }
        inline const s8* getArray(u32 Index, u32 Offset) const
        {
            return Buffer_.size() ? &Buffer_[Index * Stride_ + Offset] : 0;
        }
        
        inline void setSize(u32 Size)
        {
            Buffer_.resize(Size);
        }
        
        inline u32 getSize() const
        {
            return Buffer_.size();
        }
        
        inline void setCount(u32 Count)
        {
            Buffer_.resize(Count * Stride_);
        }
        
        inline u32 getCount() const
        {
            return Buffer_.size() / Stride_;
        }
        
        inline void fill(u32 Offset, u32 Size)
        {
            if (Buffer_.size() >= Offset + Size)
                memset(&Buffer_[Offset], 0, Size);
        }
        
        inline void clear()
        {
            Buffer_.clear();
        }
        
        inline bool empty() const
        {
            return Buffer_.empty();
        }
        
        inline std::vector<s8>& getContainer()
        {
            return Buffer_;
        }
        inline const std::vector<s8>& getContainer() const
        {
            return Buffer_;
        }
        
    private:
        
        /* Members */
        
        u32 Stride_; // 1 (byte), 2 (short), 4 (int) etc.
        std::vector<s8> Buffer_;
        
};


} // /namespace dim

} // /namespace sp


#endif



// ================================================================================