blob: 7d0976e3fdf0a0589d2b2bd0622fb91721e5fabc [file] [log] [blame]
/** Automatically generated from pgpu-render/src/ with cbindgen. **/
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
enum class PgpuBrushKind {
Solid = 0,
enum class PgpuFill {
NonZero = 0,
EvenOdd = 1,
enum class PgpuPathVerb {
MoveTo = 0,
LineTo = 1,
QuadTo = 2,
CurveTo = 3,
Close = 4,
/// Encoded (possibly color) outline for a glyph.
struct PgpuGlyph;
/// Context for loading and scaling glyphs.
struct PgpuGlyphContext;
/// Context for loading a scaling glyphs from a specific font.
struct PgpuGlyphProvider;
/// State and resources for rendering a scene.
struct PgpuRenderer;
/// Encoded streams and resources describing a vector graphics scene.
struct PgpuScene;
/// Builder for constructing an encoded scene.
struct PgpuSceneBuilder;
/// Encoded streams and resources describing a vector graphics scene fragment.
struct PgpuSceneFragment;
/// Affine transformation matrix.
struct PgpuTransform {
float xx;
float yx;
float xy;
float yy;
float dx;
float dy;
struct PgpuColor {
uint8_t r;
uint8_t g;
uint8_t b;
uint8_t a;
union PgpuBrushData {
PgpuColor solid;
struct PgpuBrush {
PgpuBrushKind kind;
PgpuBrushData data;
struct PgpuPoint {
float x;
float y;
struct PgpuPathElement {
PgpuPathVerb verb;
PgpuPoint points[3];
struct PgpuPathIter {
void *context;
bool (*next_element)(void*, PgpuPathElement*);
/// Tag and value for a font variation axis.
struct PgpuFontVariation {
/// Tag that specifies the axis.
uint32_t tag;
/// Requested setting for the axis.
float value;
/// Description of a font.
struct PgpuFontDesc {
/// Pointer to the context of the font file.
const uint8_t *data;
/// Size of the font file data in bytes.
uintptr_t data_len;
/// Index of the requested font in the font file.
uint32_t index;
/// Unique identifier for the font.
uint64_t unique_id;
/// Requested size in pixels per em unit. Set to 0.0 for
/// unscaled outlines.
float ppem;
/// Pointer to array of font variation settings.
const PgpuFontVariation *variations;
/// Number of font variation settings.
uintptr_t variations_len;
/// Rectangle defined by minimum and maximum points.
struct PgpuRect {
float x0;
float y0;
float x1;
float y1;
extern "C" {
#if defined(__APPLE__)
/// Creates a new piet-gpu renderer for the specified Metal device and
/// command queue.
/// device: MTLDevice*
/// queue: MTLCommandQueue*
PgpuRenderer *pgpu_renderer_new(void *device, void *queue);
#if defined(__APPLE__)
/// Renders a prepared scene into a texture target. Commands for rendering are
/// recorded into the specified command buffer. Returns an id representing
/// resources that may have been allocated during this process. After the
/// command buffer has been retired, call `pgpu_renderer_release` with this id
/// to drop any associated resources.
/// target: MTLTexture*
/// cmdbuf: MTLCommandBuffer*
uint32_t pgpu_renderer_render(PgpuRenderer *renderer,
const PgpuScene *scene,
void *target,
void *cmdbuf);
/// Releases the internal resources associated with the specified id from a
/// previous render operation.
void pgpu_renderer_release(PgpuRenderer *renderer, uint32_t id);
/// Destroys the piet-gpu renderer.
void pgpu_renderer_destroy(PgpuRenderer *renderer);
/// Creates a new, empty piet-gpu scene.
PgpuScene *pgpu_scene_new();
/// Destroys the piet-gpu scene.
void pgpu_scene_destroy(PgpuScene *scene);
/// Creates a new, empty piet-gpu scene fragment.
PgpuSceneFragment *pgpu_scene_fragment_new();
/// Destroys the piet-gpu scene fragment.
void pgpu_scene_fragment_destroy(PgpuSceneFragment *fragment);
/// Creates a new builder for filling a piet-gpu scene. The specified scene
/// should not be accessed while the builder is live.
PgpuSceneBuilder *pgpu_scene_builder_for_scene(PgpuScene *scene);
/// Creates a new builder for filling a piet-gpu scene fragment. The specified
/// scene fragment should not be accessed while the builder is live.
PgpuSceneBuilder *pgpu_scene_builder_for_fragment(PgpuSceneFragment *fragment);
/// Adds a glyph with the specified transform to the underlying scene.
void pgpu_scene_builder_add_glyph(PgpuSceneBuilder *builder,
const PgpuGlyph *glyph,
const PgpuTransform *transform);
/// Sets the current absolute transform for the scene builder.
void pgpu_scene_builder_transform(PgpuSceneBuilder *builder, const PgpuTransform *transform);
/// Fills a path using the specified fill style and brush. If the brush
/// parameter is nullptr, a solid color white brush will be used. The
/// brush_transform may be nullptr.
void pgpu_scene_builder_fill_path(PgpuSceneBuilder *builder,
PgpuFill fill,
const PgpuBrush *brush,
const PgpuTransform *brush_transform,
PgpuPathIter *path);
/// Appends a scene fragment to the underlying scene or fragment. The
/// transform parameter represents an absolute transform to apply to
/// the fragment. If it is nullptr, the fragment will be appended to
/// the scene with an assumed identity transform regardless of the
/// current transform state.
void pgpu_scene_builder_append_fragment(PgpuSceneBuilder *builder,
const PgpuSceneFragment *fragment,
const PgpuTransform *transform);
/// Finalizes the scene builder, making the underlying scene ready for
/// rendering. This takes ownership and consumes the builder.
void pgpu_scene_builder_finish(PgpuSceneBuilder *builder);
/// Creates a new context for loading glyph outlines.
PgpuGlyphContext *pgpu_glyph_context_new();
/// Destroys the glyph context.
void pgpu_glyph_context_destroy(PgpuGlyphContext *gcx);
/// Creates a new glyph provider for the specified glyph context and font
/// descriptor. May return nullptr if the font data is invalid. Only one glyph
/// provider may be live for a glyph context.
PgpuGlyphProvider *pgpu_glyph_provider_new(PgpuGlyphContext *gcx, const PgpuFontDesc *font);
/// Returns an encoded outline for the specified glyph provider and glyph id.
/// May return nullptr if the requested glyph is not available.
PgpuGlyph *pgpu_glyph_provider_get(PgpuGlyphProvider *provider, uint16_t gid);
/// Returns an encoded color outline for the specified glyph provider, color
/// palette index and glyph id. May return nullptr if the requested glyph is
/// not available.
PgpuGlyph *pgpu_glyph_provider_get_color(PgpuGlyphProvider *provider,
uint16_t palette_index,
uint16_t gid);
/// Destroys the glyph provider.
void pgpu_glyph_provider_destroy(PgpuGlyphProvider *provider);
/// Computes the bounding box for the glyph after applying the specified
/// transform.
PgpuRect pgpu_glyph_bbox(const PgpuGlyph *glyph, const float (*transform)[6]);
/// Destroys the glyph.
void pgpu_glyph_destroy(PgpuGlyph *glyph);
} // extern "C"