bitmap.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "color.h"
#include "surfacedescriptor.h"
 
// External Includes
#include <nap/resource.h>
#include <utility/dllexport.h>
#include <nap/signalslot.h>
 
 
namespace nap
{
    class Texture2D;
    struct SurfaceDescriptor;
 
    class NAPAPI Bitmap : public Resource
    {
        friend class BitmapFileBuffer;
        RTTI_ENABLE(Resource)
    public:
 
        virtual ~Bitmap();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool initFromFile(const std::string& path, nap::utility::ErrorState& errorState);
 
        void initFromDescriptor(const SurfaceDescriptor& surfaceDescriptor);
 
        bool save(const std::string& path, utility::ErrorState& errorState);
 
        rtti::TypeInfo getColorType() const                                 { return mColorType; }
 
        bool empty() const                                                  { return mData.empty(); }
 
        int getWidth() const                                                { return mSurfaceDescriptor.getWidth(); }
 
        int getHeight() const                                               { return mSurfaceDescriptor.getHeight(); }
 
        int getNumberOfChannels() const                                     { return mSurfaceDescriptor.getNumChannels(); }
 
        void* getData()                                                     { return mData.data(); }
 
        const void* getData() const                                         { return mData.data(); }
 
        size_t getSizeInBytes() const;
 
        const SurfaceDescriptor& getDescriptor() const                      { return mSurfaceDescriptor; }
 
        std::unique_ptr<BaseColor> makePixel() const;
 
        void getPixel(int x, int y, BaseColor& outPixel) const;
 
        template<typename T>
        T getPixel(int x, int y) const;
 
        void setPixel(int x, int y, const BaseColor& color);
 
        template<typename T>
        void setPixelColor(int x, int y, const T& color);
 
        template<typename Type>
        void getRGBColor(int x, int y, RGBColor<Type>& outColor) const;
 
        template<typename Type>
        RGBColor<Type> getRGBColor(int x, int y) const;
 
        template<typename Type>
        void getRGBAColor(int x, int y, RGBAColor<Type>& outColor) const;
 
        template<typename Type>
        RGBAColor<Type> getRGBAColor(int x, int y) const;
 
        template<typename Type>
        void getColorValue(int x, int y, nap::EColorChannel channel, RColor<Type>& outValue) const;
 
        template<typename Type>
        RColor<Type> getColorValue(int x, int y, nap::EColorChannel channel) const;
 
        SurfaceDescriptor mSurfaceDescriptor;
 
        Signal<> mBitmapUpdated;
 
    private:
        void updatePixelFormat();
 
        template<typename T>
        T* getPixelData(unsigned int x, unsigned int y) const
        {
            assert(sizeof(T) == mSurfaceDescriptor.getChannelSize());
            if (x >= mSurfaceDescriptor.getWidth() || y >= mSurfaceDescriptor.getHeight())
                return nullptr;
 
            // Get index in to array offset by number of channels (pixel level)
            unsigned int offset = ((y * mSurfaceDescriptor.getWidth()) + x) * mSurfaceDescriptor.getBytesPerPixel();
 
            // Update offset (pixel * num_channels * data_size)
            unsigned char* data_ptr = (unsigned char*)(mData.data()) + offset;
            return (T*)(data_ptr);
        }
            
        template<typename Type>
        void getRGBColorData(int x, int y, RGBColor<Type*>& outColorData) const;
 
        template<typename Type>
        void getRGBAColorData(int x, int y, RGBAColor<Type*>& outColorData) const;
 
        template<typename Type>
        RGBAColor<Type*> getRGBAColorData(int x, int y) const;
 
        template<typename Type>
        RGBColor<Type*> getRGBColorData(int x, int y) const;
 
        template<typename Type>
        void getColorValueData(int x, int y, nap::EColorChannel channel, RColor<Type*>& outValue) const;
 
        template<typename Type>
        RColor<Type*> getColorValueData(int x, int y, nap::EColorChannel channel) const;
 
        template<typename T>
        void setPixelData(int x, int y, const nap::BaseColor& color);
 
        rtti::TypeInfo mColorType = rtti::TypeInfo::empty();    
        rtti::TypeInfo mValueType = rtti::TypeInfo::empty();    
 
    private:
        std::vector<uint8_t>    mData;
    };
 
    class NAPAPI BitmapFromFile : public Bitmap
    {
        RTTI_ENABLE(Bitmap)
    public:
        virtual bool init(utility::ErrorState& errorState) override;
 
        std::string mPath;                          
    };
 
 
    // Template definitions
 
    template<typename Type>
    void nap::Bitmap::getRGBAColor(int x, int y, RGBAColor<Type>& outColor) const
    {
        RGBAColor<Type*> color_data;
        getRGBAColorData<Type>(x, y, color_data);
 
        outColor.setValue(EColorChannel::Red,   *(color_data.getValue(EColorChannel::Red)));
        outColor.setValue(EColorChannel::Green, *(color_data.getValue(EColorChannel::Green)));
        outColor.setValue(EColorChannel::Blue,  *(color_data.getValue(EColorChannel::Blue)));
        outColor.setValue(EColorChannel::Alpha, *(color_data.getValue(EColorChannel::Alpha)));
    }
 
 
    template<typename Type>
    void nap::Bitmap::getRGBColor(int x, int y, RGBColor<Type>& outColor) const
    {
        RGBColor<Type*> color_data;
        getRGBColorData<Type>(x, y, color_data);
 
        outColor.setValue(EColorChannel::Red,   *(color_data.getValue(EColorChannel::Red)));
        outColor.setValue(EColorChannel::Green, *(color_data.getValue(EColorChannel::Green)));
        outColor.setValue(EColorChannel::Blue,  *(color_data.getValue(EColorChannel::Blue)));
    }
 
 
    template<typename Type>
    void nap::Bitmap::getColorValue(int x, int y, nap::EColorChannel channel, RColor<Type>& outValue) const
    {
        RColor<Type*> color_value;
        getColorValueData<Type>(x, y, channel, color_value);
        outValue.setValue(EColorChannel::Red, *(color_value.getValue(EColorChannel::Red)));
    }
 
 
    template<typename Type>
    RGBColor<Type> nap::Bitmap::getRGBColor(int x, int y) const
    {
        RGBColor<Type> color;
        getRGBColor<Type>(x, y, color);
        return color;
    }
 
 
    template<typename Type>
    RGBAColor<Type> nap::Bitmap::getRGBAColor(int x, int y) const
    {
        RGBAColor<Type> color;
        getRGBAColor<Type>(x, y, color);
        return color;
    }
 
 
    template<typename Type>
    void nap::Bitmap::getRGBAColorData(int x, int y, RGBAColor<Type*>& outColor) const
    {
        assert(mSurfaceDescriptor.getNumChannels() >= outColor.getNumberOfChannels());
        assert(outColor.getValueType() == RTTI_OF(Type));
 
        Type* pixel_data = getPixelData<Type>(x, y);
        switch (mSurfaceDescriptor.getChannels())
        {
        case ESurfaceChannels::BGRA:
        {
            outColor.setValue(EColorChannel::Red,  pixel_data + 2);
            outColor.setValue(EColorChannel::Blue, pixel_data + 0);
            break;
        }
        case ESurfaceChannels::RGBA:
        {
            outColor.setValue(EColorChannel::Red,  pixel_data + 0);
            outColor.setValue(EColorChannel::Blue, pixel_data + 2);
            break;
        }
        default:
            assert(false);
        }
        outColor.setValue(EColorChannel::Green, pixel_data + 1);
        outColor.setValue(EColorChannel::Alpha, pixel_data + 3);
    }
 
 
    template<typename Type>
    RGBAColor<Type*> nap::Bitmap::getRGBAColorData(int x, int y) const
    {
        RGBAColor<Type*> rcolor;
        getRGBAColorData<Type>(x, y, rcolor);
        return rcolor;
    }
 
 
    template<typename Type>
    void nap::Bitmap::getRGBColorData(int x, int y, RGBColor<Type*>& outColor) const
    {
        assert(mSurfaceDescriptor.getNumChannels() >= outColor.getNumberOfChannels());
        assert(outColor.getValueType() == RTTI_OF(Type));
 
        Type* pixel_data = getPixelData<Type>(x, y);
        switch (mSurfaceDescriptor.getChannels())
        {
        case ESurfaceChannels::BGRA:
        {
            outColor.setValue(EColorChannel::Red,  pixel_data + 2);
            outColor.setValue(EColorChannel::Blue, pixel_data + 0);
            break;
        }
        case ESurfaceChannels::RGBA:
        {
            outColor.setValue(EColorChannel::Red,  pixel_data + 0);
            outColor.setValue(EColorChannel::Blue, pixel_data + 2);
            break;
        }
        default:
            assert(false);
        }
        outColor.setValue(EColorChannel::Green, pixel_data + 1);
    }
 
 
    template<typename Type>
    RGBColor<Type*> nap::Bitmap::getRGBColorData(int x, int y) const
    {
        RGBColor<Type*> rcolor;
        getRGBColorData<Type>(x, y, rcolor);
        return rcolor;
    }
 
 
    template<typename Type>
    void nap::Bitmap::getColorValueData(int x, int y, nap::EColorChannel channel, RColor<Type*>& outValue) const
    {
        assert(outValue.getValueType() == RTTI_OF(Type));
        assert(static_cast<int>(channel) < mSurfaceDescriptor.getNumChannels());
 
        int idx = static_cast<int>(channel);
        switch (mSurfaceDescriptor.getChannels())
        {
            case ESurfaceChannels::BGRA:
            {
                idx = channel == EColorChannel::Red  ? 2 : 
                      channel == EColorChannel::Blue ? 0 : idx;
                break;
            }
            default:
                break;
        }
        Type* pixel_data = getPixelData<Type>(x, y);
        outValue.setValue(EColorChannel::Red, pixel_data + idx);
    }
 
 
    template<typename Type> 
    RColor<Type> nap::Bitmap::getColorValue(int x, int y, nap::EColorChannel channel) const
    {
        RColor<Type> rvalue;
        getColorValue<Type>(x, y, channel, rvalue);
        return rvalue;
    }
 
 
    template<typename Type>
    RColor<Type*> nap::Bitmap::getColorValueData(int x, int y, nap::EColorChannel channel) const
    {
        RColor<Type*> rvalue;
        getColorValueData(x, y, channel, rvalue);
        return rvalue;
    }
 
 
    template<typename T>
    T nap::Bitmap::getPixel(int x, int y) const
    {
        // Create a pixel and fill it
        std::unique_ptr<BaseColor> pixel = makePixel();
        getPixel(x, y, *pixel);
 
        // If they are of the same type it's safe to cast and return
        if (pixel->get_type().is_derived_from(RTTI_OF(T)))
        {
            return *(static_cast<T*>(pixel.get()));
        }
        // Otherwise we need to convert
        return pixel->convert<T>();
    }
 
 
    template<typename T>
    void nap::Bitmap::setPixelColor(int x, int y, const T& color)
    {
        if (color.getValueType() == mValueType && !(color.isPointer()))
        {
            setPixel(x, y, color);
            return;
        }
 
        std::unique_ptr<BaseColor> new_pixel = makePixel();
        const BaseColor& source_color = static_cast<const BaseColor&>(color);
        source_color.convert(*new_pixel);
        setPixel(x, y, *new_pixel);
    }
 
 
    template<typename T>
    void nap::Bitmap::setPixelData(int x, int y, const nap::BaseColor& color)
    {
        // We need to make sure that the underlying color value types match
        // The incoming color can't be a pointer
        assert(mValueType == color.getValueType());
        assert(!color.isPointer());
 
        switch (color.getNumberOfChannels())
        {
        case 1:
        {
            const nap::RColor<T>* clr = static_cast<const nap::RColor<T>*>(&color);
            nap::RColor<T*> data = this->getColorValueData<T>(x, y, nap::EColorChannel::Red);
            (*data.getRed())    = clr->getRed();
            break;
        }
        case 3:
        {
            const nap::RGBColor<T>* clr = static_cast<const nap::RGBColor<T>*>(&color);
            nap::RGBColor<T*> data = this->getRGBColorData<T>(x, y);
            (*data.getRed())    = clr->getRed();
            (*data.getGreen())  = clr->getGreen();
            (*data.getBlue())   = clr->getBlue();
            break;
        }
        case 4:
        {
            const nap::RGBAColor<T>* clr = static_cast<const nap::RGBAColor<T>*>(&color);
            nap::RGBAColor<T*> data = this->getRGBAColorData<T>(x, y);
            (*data.getRed())    = clr->getRed();
            (*data.getGreen())  = clr->getGreen();
            (*data.getBlue())   = clr->getBlue();
            (*data.getAlpha())  = clr->getAlpha();
            break;
        }
        default:
            assert(false);
        }
    }
}