blob: 9bcb3eeca88647c7a33ab47c39f20ceea8008b36 [file] [log] [blame]
#ifndef _RIVE_RENDERER_HPP_
#define _RIVE_RENDERER_HPP_
#include "rive/shapes/paint/color.hpp"
#include "rive/command_path.hpp"
#include "rive/layout.hpp"
#include "rive/refcnt.hpp"
#include "rive/span.hpp"
#include "rive/math/aabb.hpp"
#include "rive/math/mat2d.hpp"
#include "rive/math/raw_path.hpp"
#include "rive/shapes/paint/blend_mode.hpp"
#include "rive/shapes/paint/stroke_cap.hpp"
#include "rive/shapes/paint/stroke_join.hpp"
#include <cmath>
#include <stdio.h>
#include <cstdint>
namespace rive {
class Vec2D;
// A render buffer holds an immutable array of values
class RenderBuffer : public RefCnt {
const size_t m_Count;
public:
RenderBuffer(size_t count) : m_Count(count) {}
size_t count() const { return m_Count; }
};
extern rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>);
extern rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>);
extern rcp<RenderBuffer> makeBufferF32(Span<const float>);
enum class RenderPaintStyle { stroke, fill };
enum class RenderTileMode {
clamp,
repeat,
mirror,
decal, // fill outside the domain with transparent
};
/*
* Base class for Render objects that specify the src colors.
*
* Shaders are immutable, and sharable between multiple paints, etc.
*
* It is common that a shader may be created with a 'localMatrix'. If this is
* not null, then it is applied to the shader's domain before the Renderer's CTM.
*/
class RenderShader : public RefCnt {};
extern rcp<RenderShader> makeLinearGradient(float sx,
float sy,
float ex,
float ey,
const ColorInt colors[], // [count]
const float stops[], // [count]
int count,
RenderTileMode,
const Mat2D* localMatrix = nullptr);
extern rcp<RenderShader> makeRadialGradient(float cx,
float cy,
float radius,
const ColorInt colors[], // [count]
const float stops[], // [count]
int count,
RenderTileMode,
const Mat2D* localMatrix = nullptr);
extern rcp<RenderShader> makeSweepGradient(float cx,
float cy,
const ColorInt colors[], // [count]
const float stops[], // [count]
int count,
const Mat2D* localMatrix = nullptr);
class RenderPaint {
public:
virtual void style(RenderPaintStyle style) = 0;
virtual void color(ColorInt value) = 0;
virtual void thickness(float value) = 0;
virtual void join(StrokeJoin value) = 0;
virtual void cap(StrokeCap value) = 0;
virtual void blendMode(BlendMode value) = 0;
virtual void shader(rcp<RenderShader>) = 0;
virtual ~RenderPaint() {}
};
class RenderImage {
protected:
int m_Width = 0;
int m_Height = 0;
public:
virtual ~RenderImage() {}
virtual bool decode(Span<const uint8_t>) = 0;
int width() const { return m_Width; }
int height() const { return m_Height; }
virtual rcp<RenderShader> makeShader(RenderTileMode tx,
RenderTileMode ty,
const Mat2D* localMatrix = nullptr) const = 0;
};
class RenderPath : public CommandPath {
public:
RenderPath* renderPath() override { return this; }
void addPath(CommandPath* path, const Mat2D& transform) override {
addRenderPath(path->renderPath(), transform);
}
virtual void addRenderPath(RenderPath* path, const Mat2D& transform) = 0;
};
class Renderer {
public:
virtual ~Renderer() {}
virtual void save() = 0;
virtual void restore() = 0;
virtual void transform(const Mat2D& transform) = 0;
virtual void drawPath(RenderPath* path, RenderPaint* paint) = 0;
virtual void clipPath(RenderPath* path) = 0;
virtual void drawImage(const RenderImage*, BlendMode, float opacity) = 0;
virtual void drawImageMesh(const RenderImage*,
rcp<RenderBuffer> vertices_f32,
rcp<RenderBuffer> uvCoords_f32,
rcp<RenderBuffer> indices_u16,
BlendMode,
float opacity) = 0;
// helpers
void translate(float x, float y);
void scale(float sx, float sy);
void rotate(float radians);
void computeAlignment(Mat2D& result,
Fit fit,
const Alignment& alignment,
const AABB& frame,
const AABB& content);
void align(Fit fit, const Alignment& alignment, const AABB& frame, const AABB& content);
};
// Returns a full-formed RenderPath -- can be treated as immutable
extern RenderPath*
makeRenderPath(Span<const Vec2D> points, Span<const uint8_t> verbs, FillRule);
extern RenderPath* makeRenderPath();
extern RenderPaint* makeRenderPaint();
extern RenderImage* makeRenderImage();
} // namespace rive
#endif