pixels.hpp

#if !defined(_BTK_PIXELS_HPP_)
#define _BTK_PIXELS_HPP_
#include <string_view>
#include <cstdlib>
#include <cstddef>
#include <iosfwd>
#include <SDL2/SDL_pixels.h>
#include <SDL2/SDL_surface.h>
#include "defs.hpp"
#include "rect.hpp"
struct SDL_Surface;
struct BtkTexture;
namespace Btk{
    class RWops;
    struct Color:public SDL_Color{
        Color() = default;
        Color(Uint8 r,Uint8 g,Uint8 b,Uint8 a = 255){
            this->r = r;
            this->g = g;
            this->b = b;
            this->a = a;
        }
        Color(const SDL_Color &c):Color(c.r,c.g,c.b,c.a){}
        Color(const Color &) = default;
        Color &operator =(const Color &) = default;
    };
    //PixelBuffer
    class BTKAPI PixBuf{
        public:
            PixBuf(SDL_Surface *s = nullptr):surf(s){};//empty 
            PixBuf(int w,int h,Uint32 format);//Create a buffer
            //LoadFromFile
            PixBuf(std::string_view file);
            //Move construct
            PixBuf(const PixBuf &) = delete;
            PixBuf(PixBuf && s){
                surf = s.surf;
                s.surf = nullptr;
            };
            ~PixBuf();
            //Get a copy of this PixBuf
            PixBuf clone() const;
            //Get a ref of this PixBuf
            PixBuf ref() const;
            //operators

            //save PixBuf
            void save_png(RWops &,int quality);
            void save_jpg(RWops &,int quality);
            void save_bmp(RWops &);

            void save_png(std::string_view fname,int quality);
            void save_jpg(std::string_view fname,int quality);
            void save_bmp(std::string_view fname);
            
            PixBuf &operator =(SDL_Surface *);//assign
            PixBuf &operator =(PixBuf &&);//assign
            //check empty
            bool empty() const noexcept{
                return surf == nullptr;
            }
            //Get informations
            Size size() const noexcept{
                return {surf->w,surf->h};
            }
            int w() const noexcept{
                return surf->w;
            }
            int h() const noexcept{
                return surf->h;
            }
            int refcount() const noexcept{
                return surf->refcount;
            }
            int pitch() const noexcept{
                return surf->pitch;
            }
            //return its pixels size
            size_t pixels_size() const noexcept{
                return pitch() * h();
            }
            //must lock it before access its pixels
            bool must_lock() const noexcept{
                return SDL_MUSTLOCK(surf);
            }
            //get pixels
            template<class T = void>
            T *pixels() const noexcept{
                return static_cast<T*>(surf->pixels);
            }
            SDL_Surface *get() const noexcept{
                return surf;
            }
            SDL_Surface *operator ->() const noexcept{
                return surf;
            }
            //Lock and Unlock
            void lock() const;
            void unlock() const noexcept;
            //Set RLE
            void set_rle(bool val = true);
            PixBuf convert(Uint32 fmt) const;
            //Some static method to load image
            static PixBuf FromFile(std::string_view file);
            static PixBuf FromFile(FILE *f);
            static PixBuf FromMem(const void *mem,size_t size);
            static PixBuf FromRWops(RWops &);
            static PixBuf FromXPMArray(const char *const*);
        private:
            SDL_Surface *surf;
    };
    struct PixelFormat{
        PixelFormat() = default;
        PixelFormat(Uint32 val):fmt(val){}
        
        operator Uint32() const noexcept{
            return fmt;
        }
        Uint32 fmt;
    };
    class BTKAPI PixFmt{
        public:
            //Create a pixel format
            PixFmt(Uint32 pix_fmt);
            PixFmt(const PixFmt &pixfmt):
                PixFmt(pixfmt.fmt->format){};
            PixFmt(PixFmt &&f){
                fmt = f.fmt;
                f.fmt = nullptr;
            }
            ~PixFmt();

            //Map RPG
            Uint32 map_rgb (Uint8 r,Uint8 g,Uint8 b) const;
            Uint32 map_rgba(Uint8 r,Uint8 g,Uint8 b,Uint8 a) const;

            Uint32 map_rgb(Color color) const{
                return map_rgb(
                    color.r,
                    color.g,
                    color.b
                );
            };
            Uint32 map_rgba(Color color) const{
                return map_rgba(
                    color.r,
                    color.g,
                    color.b,
                    color.a
                );
            };
            //Get its name
            std::string_view name() const;
            SDL_PixelFormat *operator ->() const noexcept{
                return fmt;
            }
            operator Uint32() const noexcept{
                return fmt->format;
            };
        private:
            SDL_PixelFormat *fmt;
    };
    enum class TextureAccess:int{
        Static,
        Streaming,
        Target
    };
    //RendererTexture
    class BTKAPI Texture{
        public:
            struct Information{
                TextureAccess access;//< Texture access
                PixelFormat   format;//< Pixels format
                int w;
                int h;
            };
        public:
            Texture(BtkTexture *t = nullptr):texture(t){};
            Texture(const Texture &) = delete;
            Texture(Texture &&t){
                texture = t.texture;
                t.texture = nullptr;
            }
            ~Texture();
            Size size() const{
                auto inf = information();
                return {inf.w,inf.h};   
            }
            int w() const{
                return size().w;
            }
            int h() const{
                return size().h;
            }
            //check is empty
            bool empty() const noexcept{
                return texture == nullptr;
            }
            //assign
            Texture &operator =(BtkTexture*);
            Texture &operator =(Texture &&);
            //Get pointer
            BtkTexture *get() const noexcept{
                return texture;
            }
            void update(const Rect *r,void *pixels,int pitch);
            void lock(const Rect *rect,void **pixels,int *pitch);

            void lock(const Rect &rect,void **pixels,int *pitch){
                lock(&rect,pixels,pitch);
            }
            void lock(void **pixels,int *pitch){
                lock(nullptr,pixels,pitch);
            }
            void update(const Rect &r,void *pixels,int pitch){
                update(&r,pixels,pitch);
            }
            void update(void *pixels,int pitch){
                update(nullptr,pixels,pitch);
            }
            void unlock();
            Information information() const;
        private:
            BtkTexture *texture;
        friend struct Renderer;
    };
    class BTKAPI Gif{
        public:
            Gif():pimpl(nullptr){};
            ~Gif();
            static Gif FromRwops(RWops &);
        private:
            void *pimpl;
    };
    template<class T>
    struct LockGuard{
        LockGuard(T &m):mtx(m){
            mtx.lock();
        }
        LockGuard(const LockGuard &) = delete;
        ~LockGuard(){
            mtx.unlock();
        }
        T &mtx;
    };
    template<>
    struct LockGuard<Texture>{
        LockGuard(Texture &t,const Rect *rect = nullptr):texture(t){
            texture.lock(rect,&pixels,&pitch);
        }
        LockGuard(Texture &t,const Rect &rect):
            texture(t){

            texture.lock(rect,&pixels,&pitch);
        }
        LockGuard(const LockGuard &) = delete;
        ~LockGuard(){
            texture.unlock();
        }
        Texture &texture;
        void *   pixels;
        int      pitch;
    };

    template<class T>
    using lock_guard = LockGuard<T>;
};

#endif // _BTK_PIXELS_HPP_