paintengine.h

Go to the documentation of this file.

 
#pragma once
#include <promeki/core/namespace.h>
#include <promeki/proav/pixelformat.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/list.h>
#include <promeki/core/size2d.h>
#include <promeki/core/point.h>
#include <promeki/core/line.h>
#include <promeki/core/rect.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Image;
 
class PaintEngine {
    public:
                using Ptr = SharedPtr<PaintEngine>;
 
                using Pixel = List<uint8_t>;
 
                using PointList = List<Point2Di32>;
 
                using AlphaList = List<float>;
 
                class Impl {
                        PROMEKI_SHARED(Impl)
                        public:
                                virtual ~Impl();
 
                                const PixelFormat *pixelFormat() const { return _pixelFormat; }
 
                                virtual bool blit(const Point2Di32 &destTopLeft, const Image &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;
 
                        protected:
                                const PixelFormat       *_pixelFormat = nullptr;
                };
 
                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);
                }
 
                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 Image &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