ImageView.h

Go to the documentation of this file.

#pragma once

#include <Platform.h>
#include <Vector.h>
#include <string.h> // memcpy & memset

namespace WorldStone
{
template<class Color>
struct ImageView
{
    static_assert(std::is_trivially_copyable<Color>::value, "Color must be trivially copyable for memcpy/memset");
    Color* buffer = nullptr; 
    size_t width  = 0;       
    size_t height = 0;       
    size_t stride = 0;       

    ImageView() = default;

    ImageView(Color* _buffer, size_t _width, size_t _height, size_t _stride)
        : buffer(_buffer), width(_width), height(_height), stride(_stride)
    {
    }

    bool isValid() const { return buffer && width && height && width <= stride; }

    bool operator==(const ImageView& rhs) const
    {
        return buffer == rhs.buffer && width == rhs.width && height == rhs.height &&
               stride == rhs.stride;
    }
    bool operator!=(const ImageView& rhs) const { return !(*this == rhs); }

    operator ImageView<const Color>() const { return {buffer, width, height, stride}; }

    ImageView subView(size_t xOffset, size_t yOffset, size_t subWidth, size_t subHeight) const
    {
        if (xOffset + subWidth > width || yOffset + subHeight > height) return {};
        return {buffer + xOffset + yOffset * stride, subWidth, subHeight, stride};
    }

    Color& operator()(size_t x, size_t y) const { return buffer[x + y * stride]; }

    void copyTo(ImageView destination) const
    {
        for (size_t y = 0; y < height; y++)
        {
            memcpy(destination.buffer + y * destination.stride, buffer + y * stride,
                   width * sizeof(Color));
        }
    }

    void fill(size_t x, size_t y, size_t columns, size_t rows, Color colorValue)
    {
        Color* lineStart = buffer + x + y * stride;
        for (size_t row = 0; row < rows; ++row)
        {
            for (size_t column = 0; column < columns; column++)
            {
                lineStart[column] = colorValue;
            }
            lineStart += stride;
        }
    }

    void fillBytes(size_t x, size_t y, size_t columns, size_t rows, uint8_t byteValue)
    {
        Color* dstPtr = buffer + x + y * stride;
        for (size_t row = 0; row < rows; ++row)
        {
            memset(dstPtr, byteValue, columns * sizeof(Color));
            dstPtr += stride;
        }
    }
};

template<class Color>
class IImageProvider
{
public:
    virtual ImageView<Color> getNewImage(size_t width, size_t height) = 0;
    virtual ~IImageProvider() {}
};

template<class Color>
class SimpleImageProvider : public IImageProvider<Color>
{
    struct Image
    {
        size_t        width  = 0;
        size_t        height = 0;
        Vector<Color> buffer;
        Image(size_t _width, size_t _height)
            : width(_width), height(_height), buffer(_width * _height)
        {
        }
    };
    Vector<Image> images;

public:
    ImageView<Color> getNewImage(size_t width, size_t height) override
    {
        if (!width || !height) return {};
        // if (!width || !height) return ImageView<Color>::getInvalidView();
        images.emplace_back(width, height);
        return {images.back().buffer.data(), width, height, width};
    }

    size_t getImagesNumber() const { return images.size(); }

    ImageView<Color> getImage(size_t imageIndex)
    {
        Image& img = images[imageIndex];
        return {img.buffer.data(), img.width, img.height, img.width};
    }
    ImageView<const Color> getImage(size_t imageIndex) const
    {
        const Image& img = images[imageIndex];
        return {img.buffer.data(), img.width, img.height, img.width};
    }

    Vector<Color> moveImageBuffer(size_t imageIndex)
    {
        // We could swap with back() to free memory, but that would invalidate indices.
        Image& img = images[imageIndex];
        img.width  = 0;
        img.height = 0;
        return std::move(img.buffer);
    }
};
}