paintengine.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/pixelformat.h>
#include <promeki/sharedptr.h>
#include <promeki/array.h>
#include <promeki/list.h>
#include <promeki/size2d.h>
#include <promeki/point.h>
#include <promeki/line.h>
#include <promeki/rect.h>
#include <promeki/color.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Image;
class UncompressedVideoPayload;
 
class PaintEngine {
        public:
                using Ptr = SharedPtr<PaintEngine>;
 
                static constexpr size_t MaxPixelBytes = 16;
 
                struct Pixel {
                                uint8_t _data[MaxPixelBytes] = {};
                                uint8_t _size = 0;
 
                                bool isEmpty() const { return _size == 0; }
 
                                size_t size() const { return _size; }
 
                                const uint8_t *data() const { return _data; }
 
                                uint8_t *data() { return _data; }
 
                                uint8_t &operator[](size_t i) { return _data[i]; }
                                uint8_t  operator[](size_t i) const { return _data[i]; }
 
                                void resize(size_t n) { _size = static_cast<uint8_t>(n); }
                };
 
                using PointList = ::promeki::List<Point2Di32>;
 
                using AlphaList = ::promeki::List<float>;
 
                class Impl {
                                PROMEKI_SHARED_BASE(Impl)
                        public:
                                virtual ~Impl();
 
                                virtual bool blit(const Point2Di32 &destTopLeft, const UncompressedVideoPayload &src,
                                                  const Point2Di32 &srcTopLeft, const Size2Du32 &srcSize) const;
 
                                virtual Pixel createPixel(const uint16_t *comps, size_t compCount) const;
 
                                virtual size_t drawPoints(const Pixel &pixel, const Point2Di32 *points,
                                                          size_t pointCount) const;
 
                                virtual size_t compositePoints(const Pixel &pixel, const Point2Di32 *points,
                                                               const float *alphas, size_t pointCount) const;
 
                                virtual bool fill(const Pixel &pixel) const;
 
                                virtual size_t drawLines(const Pixel &pixel, const Line2Di32 *lines,
                                                         size_t count) const;
 
                                virtual size_t drawRect(const Pixel &pixel, const Rect<int32_t> &rect) const;
 
                                virtual size_t fillRect(const Pixel &pixel, const Rect<int32_t> &rect) const;
 
                                virtual size_t drawCircle(const Pixel &pixel, const Point2Di32 &center,
                                                          int radius) const;
 
                                virtual size_t fillCircle(const Pixel &pixel, const Point2Di32 &center,
                                                          int radius) const;
 
                                virtual size_t drawEllipse(const Pixel &pixel, const Point2Di32 &center,
                                                           const Size2Du32 &size) const;
 
                                virtual size_t fillEllipse(const Pixel &pixel, const Point2Di32 &center,
                                                           const Size2Du32 &size) const;
 
                                virtual const PixelFormat &pixelFormat() const;
 
                        protected:
                };
 
                static PointList plotLine(int x1, int y1, int x2, int y2);
 
                PaintEngine() : d(SharedPtr<Impl, false>::create()) {};
 
                PaintEngine(Impl *impl) : d(SharedPtr<Impl, false>::takeOwnership(impl)) {}
 
                const PixelFormat &pixelFormat() const { return d->pixelFormat(); }
 
                Pixel createPixel(const uint16_t *comps, size_t compCount) const {
                        return d->createPixel(comps, compCount);
                }
 
                Pixel createPixel(uint16_t c1) const { return d->createPixel(&c1, 1); }
 
                Pixel createPixel(uint16_t c1, uint16_t c2) const {
                        uint16_t data[] = {c1, c2};
                        return d->createPixel(data, 2);
                }
 
                Pixel createPixel(uint16_t c1, uint16_t c2, uint16_t c3) const {
                        uint16_t data[] = {c1, c2, c3};
                        return d->createPixel(data, 3);
                }
 
                Pixel createPixel(uint16_t c1, uint16_t c2, uint16_t c3, uint16_t c4) const {
                        uint16_t data[] = {c1, c2, c3, c4};
                        return d->createPixel(data, 4);
                }
 
                Pixel createPixel(const Color &color) const {
                        const PixelFormat &pd = d->pixelFormat();
                        const ColorModel  &targetModel = pd.isValid() ? pd.colorModel() : ColorModel(ColorModel::sRGB);
                        Color              c = (color.model() == targetModel) ? color : color.convert(targetModel);
                        size_t             count = pd.isValid() ? pd.compCount() : 4;
                        uint16_t           data[PixelMemLayout::MaxComps] = {};
                        for (size_t i = 0; i < count && i < 3; i++) {
                                float v = c.comp(i) * 65535.0f;
                                if (v < 0.0f) v = 0.0f;
                                if (v > 65535.0f) v = 65535.0f;
                                data[i] = static_cast<uint16_t>(v);
                        }
                        if (count >= 4) {
                                float a = c.alpha() * 65535.0f;
                                if (a < 0.0f) a = 0.0f;
                                if (a > 65535.0f) a = 65535.0f;
                                data[3] = static_cast<uint16_t>(a);
                        }
                        return d->createPixel(data, count);
                }
 
                size_t drawPoints(const Pixel &pixel, const Point2Di32 *points, size_t pointCount) const {
                        return d->drawPoints(pixel, points, pointCount);
                }
 
                size_t drawPoints(const Pixel &pixel, const PointList &points) const {
                        return d->drawPoints(pixel, points.data(), points.size());
                }
 
                size_t compositePoints(const Pixel &pixel, const Point2Di32 *points, const float *alphas,
                                       size_t pointCount) const {
                        return d->compositePoints(pixel, points, alphas, pointCount);
                }
 
                size_t compositePoints(const Pixel &pixel, const PointList &points, const AlphaList &alphas) const {
                        return d->compositePoints(pixel, points.data(), alphas.data(), points.size());
                }
 
                size_t drawLines(const Pixel &pixel, const Line2Di32 *lines, size_t lineCount) const {
                        return d->drawLines(pixel, lines, lineCount);
                }
 
                size_t drawLine(const Pixel &pixel, const Line2Di32 &line) const {
                        return d->drawLines(pixel, &line, 1);
                }
 
                size_t drawLine(const Pixel &pixel, int x1, int y1, int x2, int y2) const {
                        Line2Di32 line(Point2Di32(x1, y1), Point2Di32(x2, y2));
                        return d->drawLines(pixel, &line, 1);
                }
 
                bool fill(const Pixel &pixel) { return d->fill(pixel); }
 
                size_t drawRect(const Pixel &pixel, const Rect<int32_t> &rect) const {
                        return d->drawRect(pixel, rect);
                }
 
                size_t fillRect(const Pixel &pixel, const Rect<int32_t> &rect) const {
                        return d->fillRect(pixel, rect);
                }
 
                size_t drawCircle(const Pixel &pixel, const Point2Di32 &center, int radius) const {
                        return d->drawCircle(pixel, center, radius);
                }
 
                size_t fillCircle(const Pixel &pixel, const Point2Di32 &center, int radius) const {
                        return d->fillCircle(pixel, center, radius);
                }
 
                size_t drawEllipse(const Pixel &pixel, const Point2Di32 &center, const Size2Du32 &size) const {
                        return d->drawEllipse(pixel, center, size);
                }
 
                size_t fillEllipse(const Pixel &pixel, const Point2Di32 &center, const Size2Du32 &size) const {
                        return d->fillEllipse(pixel, center, size);
                }
 
                bool blit(const Point2Di32 &destTopLeft, const UncompressedVideoPayload &src,
                          const Point2Di32 &srcTopLeft = Point2Di32(0, 0),
                          const Size2Du32  &srcSize = Size2Du32()) const {
                        return d->blit(destTopLeft, src, srcTopLeft, srcSize);
                }
 
        private:
                SharedPtr<Impl, false> d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV