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

Go to the documentation of this file.

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

#ifndef __SP_VIDEO_IMAGEBUFFER_H__
#define __SP_VIDEO_IMAGEBUFFER_H__


#include "Base/spStandard.hpp"
#include "Base/spDimension.hpp"
#include "Base/spImageManagement.hpp"
#include "Base/spMath.hpp"
#include "Base/spMaterialColor.hpp"
#include "RenderSystem/spTextureFlags.hpp"
#include "FileFormats/Image/spImageFormatInterfaces.hpp"


namespace sp
{
namespace video
{


class SP_EXPORT ImageBuffer
{
    
    public:
        
        virtual ~ImageBuffer();
        
        /* === Functions === */
        
        dim::point2di getPixelCoord(const dim::point2df &Pos) const;
        
        void setPixelColor(const s32 Pos, const color &Color);
        void setPixelColor(const dim::point2di &Pos, const color &Color);
        void setPixelColor(const dim::vector3di &Pos, const color &Color);
        
        void setPixelVector(const s32 Pos, const dim::vector4df &Color);
        void setPixelVector(const dim::point2di &Pos, const dim::vector4df &Color);
        void setPixelVector(const dim::vector3di &Pos, const dim::vector4df &Color);
        
        color getPixelColor(const s32 Pos) const;
        color getPixelColor(const dim::point2di &Pos) const;
        color getPixelColor(const dim::vector3di &Pos) const;
        
        dim::vector4df getPixelVector(const s32 Pos) const;
        dim::vector4df getPixelVector(const dim::point2di &Pos) const;
        dim::vector4df getPixelVector(const dim::vector3di &Pos) const;
        
        dim::vector4df getInterpolatedPixel(const dim::point2df &Pos) const;
        
        void setBuffer(const void* ImageBuffer);
        
        virtual bool isSizePOT() const;
        
        virtual dim::size2di getSizePOT() const;
        
        virtual void setSizePOT();
        
        virtual void adjustFormatD3D();
        
        /* === Abstract functions === */
        
        virtual ImageBuffer* copy() const = 0;
        virtual void copy(const ImageBuffer* Other) = 0;
        
        virtual bool setFormat(const EPixelFormats Format) = 0;
        virtual void setSize(const dim::size2di &Size) = 0;
        virtual bool setDepth(u32 Depth) = 0;
        
        virtual void invertColors() = 0;
        virtual void flipColors() = 0;
        virtual void flipImageHorizontal() = 0;
        virtual void flipImageVertical() = 0;
        virtual void turnImage(const EImageTurnDegrees Degree) = 0;
        
        virtual u32 getDataTypeSize() const = 0;
        
        virtual void* getBuffer() = 0;
        virtual const void* getBuffer() const = 0;
        
        virtual void setBuffer(const void* ImageBuffer, const dim::point2di &Pos, const dim::size2di &Size) = 0;
        
        virtual void getBuffer(void* ImageBuffer, const dim::point2di &Pos, const dim::size2di &Size) const = 0;
        
        virtual bool appendImageBuffer(const ImageBuffer* AdditionalBuffer, bool isAppendBottom = true) = 0;
        
        virtual void setColorKey(const color &Color, u8 Tolerance = 0);
        virtual void setColorKey(const dim::point2di &Pos, u8 Alpha = 0, u8 Tolerance = 0);
        virtual void setColorKeyAlpha(const EAlphaBlendingTypes Mode = BLENDING_BRIGHT);
        virtual void setColorKeyMask(ImageBuffer* MaskImage, const EAlphaBlendingTypes Mode = BLENDING_BRIGHT);
        
        virtual void grayToAlpha() = 0;
        
        virtual void createBuffer(const void* InitBuffer = 0) = 0;
        virtual void deleteBuffer() = 0;
        
        /* === Static functions === */
        
        static u32 getFormatSize(const EPixelFormats Format);
        static bool hasAlphaChannel(const EPixelFormats Format);
        
        /* === Inline functions === */
        
        inline EImageBufferTypes getType() const
        {
            return Type_;
        }
        
        inline dim::size2di getSize() const
        {
            return Size_;
        }
        inline dim::vector3di getSizeVector() const
        {
            return dim::vector3di(Size_.Width, Size_.Height, Depth_);
        }
        inline u32 getPixelCount() const
        {
            return getSize().getArea() * Depth_;
        }
        inline u32 getPixelSize() const
        {
            return getFormatSize() * getDataTypeSize();
        }
        inline u32 getBufferSize() const
        {
            return getPixelCount() * getPixelSize();
        }
        inline u32 getDepth() const
        {
            return Depth_;
        }
        
        inline EPixelFormats getFormat() const
        {
            return Format_;
        }
        inline u32 getFormatSize() const
        {
            return FormatSize_;
        }
        inline bool hasAlphaChannel() const
        {
            return ImageBuffer::hasAlphaChannel(Format_);
        }
        
        inline color getColorKey() const
        {
            return ColorKey_;
        }
        
    protected:
        
        ImageBuffer(const EImageBufferTypes Type);
        ImageBuffer(const EImageBufferTypes Type, const EPixelFormats Format, const dim::size2di &Size, u32 Depth = 1);
        
        /* === Functions === */
        
        bool copyBase(const ImageBuffer &Other);
        
        /* === Members === */
        
        EImageBufferTypes Type_;
        
        EPixelFormats Format_;  
        u32 FormatSize_;        
        
        dim::size2di Size_;     
        u32 Depth_;             
        
        color ColorKey_;
        
};


} // /namespace video

} // /namespace sp


#endif



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