vello/pgpu-render/pgpu.h

/** Automatically generated from pgpu-render/src/lib.rs 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);
#endif

#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);
#endif

/// 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"