pixel_buffer.h

/*
**  UICore
**  Copyright (c) 1997-2015 The UICore Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries UICore may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
**    Mark Page
*/

#pragma once

#include <memory>
#include "../../Core/Math/rect.h"
#include "texture_format.h"

namespace uicore
{
    class Size;
    class Rect;
    class PixelFormat;
    class Color;
    class Colorf;
    class PixelBuffer;
    class IODevice;
    class GraphicContext;
    typedef std::shared_ptr<GraphicContext> GraphicContextPtr;
    class PixelConverter;
    typedef std::shared_ptr<PixelConverter> PixelConverterPtr;

    class PixelBuffer
    {
    public:
        static std::shared_ptr<PixelBuffer> create(int width, int height, TextureFormat texture_format, const void *data = nullptr, bool only_reference_data = false);

        std::shared_ptr<PixelBuffer> copy() const;
        std::shared_ptr<PixelBuffer> copy(const Rect &rect) const;

        virtual int width() const = 0;

        virtual int height() const = 0;

        Size size() const { return Size{ width(), height() }; }

        virtual int pitch() const = 0;

        virtual float pixel_ratio() const = 0;

        float dip_width() const { return width() / pixel_ratio(); }

        float dip_height() const { return height() / pixel_ratio(); }

        Sizef dip_size() const { return Sizef{ dip_width(), dip_height() }; }

        virtual void *data() = 0;
        virtual const void *data() const = 0;

        template<typename Type> Type *data() { return reinterpret_cast<Type*>(data()); }
        template<typename Type> const Type *data() const { return reinterpret_cast<const Type*>(data()); }

        unsigned char *data_uint8() { return reinterpret_cast<unsigned char*>(data()); }
        const unsigned char *data_uint8() const { return reinterpret_cast<const unsigned char*>(data()); }

        unsigned short *data_uint16() { return reinterpret_cast<unsigned short*>(data()); }
        const unsigned short *data_uint16() const { return reinterpret_cast<const unsigned short*>(data()); }

        unsigned int *data_uint32() { return reinterpret_cast<unsigned int*>(data()); }
        const unsigned int *data_uint32() const { return reinterpret_cast<const unsigned int*>(data()); }

        void *line(int line) { unsigned char *d = data_uint8(); return d + line * pitch(); }
        const void *line(int line) const { const unsigned char *d = data_uint8(); return d + line * pitch(); }

        template<typename T> T *line(int line) { unsigned char *d = data_uint8(); return reinterpret_cast<T*>(d + line * pitch()); }
        template<typename T> const T *line(int line) const { const unsigned char *d = data_uint8(); return reinterpret_cast<const T*>(d + line * pitch()); }

        unsigned char *line_uint8(int index) { return reinterpret_cast<unsigned char*>(line(index)); }
        const unsigned char *line_uint8(int index) const { return reinterpret_cast<const unsigned char*>(line(index)); }

        unsigned short *line_uint16(int index) { return reinterpret_cast<unsigned short*>(line(index)); }
        const unsigned short *line_uint16(int index) const { return reinterpret_cast<const unsigned short*>(line(index)); }

        unsigned int *line_uint32(int index) { return reinterpret_cast<unsigned int*>(line(index)); }
        const unsigned int *line_uint32(int index) const { return reinterpret_cast<const unsigned int*>(line(index)); }

        bool has_transparency() const;

        unsigned int bytes_per_pixel() const;

        unsigned int bytes_per_block() const;

        unsigned int data_size() const;

        static unsigned int data_size(const Size &size, TextureFormat texture_format);

        static unsigned int bytes_per_pixel(TextureFormat texture_format);

        static unsigned int bytes_per_block(TextureFormat texture_format);

        bool is_compressed() const;

        static bool is_compressed(TextureFormat texture_format);

        virtual TextureFormat format() const = 0;

        void set_image(const std::shared_ptr<PixelBuffer> &source);

        void set_image(const std::shared_ptr<PixelBuffer> &source, const PixelConverterPtr &converter);

        void set_subimage(const std::shared_ptr<PixelBuffer> &source, const Point &dest_pos, const Rect &src_rect);

        void set_subimage(const std::shared_ptr<PixelBuffer> &source, const Point &dest_pos, const Rect &src_rect, const PixelConverterPtr &converter);

        std::shared_ptr<PixelBuffer> to_format(TextureFormat texture_format) const;

        std::shared_ptr<PixelBuffer> to_format(TextureFormat texture_format, const PixelConverterPtr &converter) const;

        void flip_vertical();

        void premultiply_alpha();

        void premultiply_gamma(float gamma);

        virtual void set_pixel_ratio(float ratio) = 0;

        static std::shared_ptr<PixelBuffer> add_border(const std::shared_ptr<PixelBuffer> &pb, int border_size, const Rect &rect);
    };

    typedef std::shared_ptr<PixelBuffer> PixelBufferPtr;
}