From 588a0e4924db3d847e8268ce3b0480a962a1088a Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 21:46:02 -0600 Subject: [PATCH 1/9] add genny --- figdraw.nimble | 2 ++ 1 file changed, 2 insertions(+) diff --git a/figdraw.nimble b/figdraw.nimble index db8f2b1..bc6db7c 100644 --- a/figdraw.nimble +++ b/figdraw.nimble @@ -43,4 +43,6 @@ feature "vulkan": feature "metal": requires "https://github.com/elcritch/metalx#head" +feature "sharedlib": + requires "genny" From 8699755f0207e2d0166ea7aa9e7563861362396c Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 21:53:47 -0600 Subject: [PATCH 2/9] add genny --- .gitignore | 2 + bindings/bindings.nim | 14 +++++++ bindings/generated/fig_draw.h | 16 ++++++++ bindings/generated/fig_draw.hpp | 46 ++++++++++++++++++++++ bindings/generated/fig_draw.js | 64 ++++++++++++++++++++++++++++++ bindings/generated/fig_draw.nim | 45 +++++++++++++++++++++ bindings/generated/fig_draw.py | 69 +++++++++++++++++++++++++++++++++ bindings/generated/fig_draw.zig | 32 +++++++++++++++ bindings/generated/internal.nim | 23 +++++++++++ config.nims | 17 ++++++++ 10 files changed, 328 insertions(+) create mode 100644 bindings/bindings.nim create mode 100644 bindings/generated/fig_draw.h create mode 100644 bindings/generated/fig_draw.hpp create mode 100644 bindings/generated/fig_draw.js create mode 100644 bindings/generated/fig_draw.nim create mode 100644 bindings/generated/fig_draw.py create mode 100644 bindings/generated/fig_draw.zig create mode 100644 bindings/generated/internal.nim diff --git a/.gitignore b/.gitignore index eaf0815..0dd1071 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,5 @@ nimbledeps /examples/emscripten/*.html !/examples/emscripten/emscripten.html .DS_Store +/bindings/generated/libfigdraw.dylib +/bindings/generated/libfigdraw.dylib.* diff --git a/bindings/bindings.nim b/bindings/bindings.nim new file mode 100644 index 0000000..151831a --- /dev/null +++ b/bindings/bindings.nim @@ -0,0 +1,14 @@ +import genny +import figdraw/commons + +exportProcs: + figDataDir + setFigDataDir + figUiScale + setFigUiScale + scaled(float32) + descaled(float32) + +writeFiles("bindings/generated", "FigDraw") + +include generated/internal diff --git a/bindings/generated/fig_draw.h b/bindings/generated/fig_draw.h new file mode 100644 index 0000000..14954a6 --- /dev/null +++ b/bindings/generated/fig_draw.h @@ -0,0 +1,16 @@ +#ifndef INCLUDE_FIGDRAW_H +#define INCLUDE_FIGDRAW_H + +char* fig_draw_fig_data_dir(); + +void fig_draw_set_fig_data_dir(char* dir); + +float fig_draw_fig_ui_scale(); + +void fig_draw_set_fig_ui_scale(float scale); + +float fig_draw_scaled(float a); + +float fig_draw_descaled(float a); + +#endif diff --git a/bindings/generated/fig_draw.hpp b/bindings/generated/fig_draw.hpp new file mode 100644 index 0000000..eceea2f --- /dev/null +++ b/bindings/generated/fig_draw.hpp @@ -0,0 +1,46 @@ +#ifndef INCLUDE_FIGDRAW_H +#define INCLUDE_FIGDRAW_H + +#include + +extern "C" { + +const char* fig_draw_fig_data_dir(); + +void fig_draw_set_fig_data_dir(const char* dir); + +float fig_draw_fig_ui_scale(); + +void fig_draw_set_fig_ui_scale(float scale); + +float fig_draw_scaled(float a); + +float fig_draw_descaled(float a); + +} + +const char* figDataDir() { + return fig_draw_fig_data_dir(); +}; + +setFigDataDir(const char* dir) { + fig_draw_set_fig_data_dir(dir); +}; + +float figUiScale() { + return fig_draw_fig_ui_scale(); +}; + +setFigUiScale(float scale) { + fig_draw_set_fig_ui_scale(scale); +}; + +float scaled(float a) { + return fig_draw_scaled(a); +}; + +float descaled(float a) { + return fig_draw_descaled(a); +}; + +#endif diff --git a/bindings/generated/fig_draw.js b/bindings/generated/fig_draw.js new file mode 100644 index 0000000..14ef0e6 --- /dev/null +++ b/bindings/generated/fig_draw.js @@ -0,0 +1,64 @@ +var ffi = require('ffi-napi'); +var Struct = require("ref-struct-napi"); +var ArrayType = require('ref-array-napi'); + +var dll = {}; + +function FigDrawException(message) { + this.message = message; + this.name = 'FigDrawException'; +} + +function figDataDir(){ + result = dll.fig_draw_fig_data_dir() + return result +} + +function setFigDataDir(dir){ + dll.fig_draw_set_fig_data_dir(dir) +} + +function figUiScale(){ + result = dll.fig_draw_fig_ui_scale() + return result +} + +function setFigUiScale(scale){ + dll.fig_draw_set_fig_ui_scale(scale) +} + +function scaled(a){ + result = dll.fig_draw_scaled(a) + return result +} + +function descaled(a){ + result = dll.fig_draw_descaled(a) + return result +} + + +var dllPath = "" +if(process.platform == "win32") { + dllPath = __dirname + '/fig_draw.dll' +} else if (process.platform == "darwin") { + dllPath = __dirname + '/libfig_draw.dylib' +} else { + dllPath = __dirname + '/libfig_draw.so' +} + +dll = ffi.Library(dllPath, { + 'fig_draw_fig_data_dir': ['string', []], + 'fig_draw_set_fig_data_dir': ['void', ['string']], + 'fig_draw_fig_ui_scale': ['float', []], + 'fig_draw_set_fig_ui_scale': ['void', ['float']], + 'fig_draw_scaled': ['float', ['float']], + 'fig_draw_descaled': ['float', ['float']], +}); + +exports.figDataDir = figDataDir +exports.setFigDataDir = setFigDataDir +exports.figUiScale = figUiScale +exports.setFigUiScale = setFigUiScale +exports.scaled = scaled +exports.descaled = descaled diff --git a/bindings/generated/fig_draw.nim b/bindings/generated/fig_draw.nim new file mode 100644 index 0000000..04bae89 --- /dev/null +++ b/bindings/generated/fig_draw.nim @@ -0,0 +1,45 @@ +import bumpy, chroma, unicode, vmath + +export bumpy, chroma, unicode, vmath + +when defined(windows): + const libName = "fig_draw.dll" +elif defined(macosx): + const libName = "libfig_draw.dylib" +else: + const libName = "libfig_draw.so" + +{.push dynlib: libName.} + +type FigDrawError = object of ValueError + +proc fig_draw_fig_data_dir(): cstring {.importc: "fig_draw_fig_data_dir", cdecl.} + +proc figDataDir*(): cstring {.inline.} = + result = fig_draw_fig_data_dir() + +proc fig_draw_set_fig_data_dir(dir: cstring) {.importc: "fig_draw_set_fig_data_dir", cdecl.} + +proc setFigDataDir*(dir: string) {.inline.} = + fig_draw_set_fig_data_dir(dir.cstring) + +proc fig_draw_fig_ui_scale(): float32 {.importc: "fig_draw_fig_ui_scale", cdecl.} + +proc figUiScale*(): float32 {.inline.} = + result = fig_draw_fig_ui_scale() + +proc fig_draw_set_fig_ui_scale(scale: float32) {.importc: "fig_draw_set_fig_ui_scale", cdecl.} + +proc setFigUiScale*(scale: float32) {.inline.} = + fig_draw_set_fig_ui_scale(scale) + +proc fig_draw_scaled(a: float32): float32 {.importc: "fig_draw_scaled", cdecl.} + +proc scaled*(a: float32): float32 {.inline.} = + result = fig_draw_scaled(a) + +proc fig_draw_descaled(a: float32): float32 {.importc: "fig_draw_descaled", cdecl.} + +proc descaled*(a: float32): float32 {.inline.} = + result = fig_draw_descaled(a) + diff --git a/bindings/generated/fig_draw.py b/bindings/generated/fig_draw.py new file mode 100644 index 0000000..eb48e7d --- /dev/null +++ b/bindings/generated/fig_draw.py @@ -0,0 +1,69 @@ +from ctypes import * +import os, sys + +dir = os.path.dirname(sys.modules["fig_draw"].__file__) +if sys.platform == "win32": + libName = "fig_draw.dll" +elif sys.platform == "darwin": + libName = "libfig_draw.dylib" +else: + libName = "libfig_draw.so" +dll = cdll.LoadLibrary(os.path.join(dir, libName)) + +class FigDrawError(Exception): + pass + +class SeqIterator(object): + def __init__(self, seq): + self.idx = 0 + self.seq = seq + def __iter__(self): + return self + def __next__(self): + if self.idx < len(self.seq): + self.idx += 1 + return self.seq[self.idx - 1] + else: + self.idx = 0 + raise StopIteration + +def fig_data_dir(): + result = dll.fig_draw_fig_data_dir().decode("utf8") + return result + +def set_fig_data_dir(dir): + dll.fig_draw_set_fig_data_dir(dir.encode("utf8")) + +def fig_ui_scale(): + result = dll.fig_draw_fig_ui_scale() + return result + +def set_fig_ui_scale(scale): + dll.fig_draw_set_fig_ui_scale(scale) + +def scaled(a): + result = dll.fig_draw_scaled(a) + return result + +def descaled(a): + result = dll.fig_draw_descaled(a) + return result + +dll.fig_draw_fig_data_dir.argtypes = [] +dll.fig_draw_fig_data_dir.restype = c_char_p + +dll.fig_draw_set_fig_data_dir.argtypes = [c_char_p] +dll.fig_draw_set_fig_data_dir.restype = None + +dll.fig_draw_fig_ui_scale.argtypes = [] +dll.fig_draw_fig_ui_scale.restype = c_float + +dll.fig_draw_set_fig_ui_scale.argtypes = [c_float] +dll.fig_draw_set_fig_ui_scale.restype = None + +dll.fig_draw_scaled.argtypes = [c_float] +dll.fig_draw_scaled.restype = c_float + +dll.fig_draw_descaled.argtypes = [c_float] +dll.fig_draw_descaled.restype = c_float + diff --git a/bindings/generated/fig_draw.zig b/bindings/generated/fig_draw.zig new file mode 100644 index 0000000..fdbc56e --- /dev/null +++ b/bindings/generated/fig_draw.zig @@ -0,0 +1,32 @@ +const std = @import("std"); + +extern fn fig_draw_fig_data_dir() callconv(.C) [*:0]const u8; +pub inline fn figDataDir() [:0]const u8 { + return std.mem.span(fig_draw_fig_data_dir()); +} + +extern fn fig_draw_set_fig_data_dir(dir: [*:0]const u8) callconv(.C) void; +pub inline fn setFigDataDir(dir: [:0]const u8) void { + return fig_draw_set_fig_data_dir(dir.ptr); +} + +extern fn fig_draw_fig_ui_scale() callconv(.C) f32; +pub inline fn figUiScale() f32 { + return fig_draw_fig_ui_scale(); +} + +extern fn fig_draw_set_fig_ui_scale(scale: f32) callconv(.C) void; +pub inline fn setFigUiScale(scale: f32) void { + return fig_draw_set_fig_ui_scale(scale); +} + +extern fn fig_draw_scaled(a: f32) callconv(.C) f32; +pub inline fn scaled(a: f32) f32 { + return fig_draw_scaled(a); +} + +extern fn fig_draw_descaled(a: f32) callconv(.C) f32; +pub inline fn descaled(a: f32) f32 { + return fig_draw_descaled(a); +} + diff --git a/bindings/generated/internal.nim b/bindings/generated/internal.nim new file mode 100644 index 0000000..e112faa --- /dev/null +++ b/bindings/generated/internal.nim @@ -0,0 +1,23 @@ +when not defined(gcArc) and not defined(gcOrc): + {.error: "Please use --gc:arc or --gc:orc when using Genny.".} + +when (NimMajor, NimMinor, NimPatch) == (1, 6, 2): + {.error: "Nim 1.6.2 not supported with Genny due to FFI issues.".} +proc fig_draw_fig_data_dir*(): cstring {.raises: [], cdecl, exportc, dynlib.} = + figDataDir().cstring + +proc fig_draw_set_fig_data_dir*(dir: cstring) {.raises: [], cdecl, exportc, dynlib.} = + setFigDataDir(dir.`$`) + +proc fig_draw_fig_ui_scale*(): float32 {.raises: [], cdecl, exportc, dynlib.} = + figUiScale() + +proc fig_draw_set_fig_ui_scale*(scale: float32) {.raises: [], cdecl, exportc, dynlib.} = + setFigUiScale(scale) + +proc fig_draw_scaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = + scaled(a) + +proc fig_draw_descaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = + descaled(a) + diff --git a/config.nims b/config.nims index e3ee779..5575327 100644 --- a/config.nims +++ b/config.nims @@ -59,3 +59,20 @@ task test_emscripten, "build emscripten examples": for file in listFiles("examples"): if file.startsWith("examples/windy_") and file.endsWith(".nim"): nimExec("c", file, "-d:emscripten") + +task bindings, "Generate bindings": + proc compile(libName: string, flags = "") = + exec "nim c -f " & flags & + " --path:src -d:release --app:lib --gc:arc --tlsEmulation:off --out:" & libName & + " --outdir:bindings/generated bindings/bindings.nim" + + when defined(windows): + compile "figdraw.dll" + elif defined(macosx): + compile "libfigdraw.dylib.arm", + "--cpu:arm64 -l:'-target arm64-apple-macos11' -t:'-target arm64-apple-macos11'" + compile "libfigdraw.dylib.x64", + "--cpu:amd64 -l:'-target x86_64-apple-macos10.12' -t:'-target x86_64-apple-macos10.12'" + exec "lipo bindings/generated/libfigdraw.dylib.arm bindings/generated/libfigdraw.dylib.x64 -output bindings/generated/libfigdraw.dylib -create" + else: + compile "libfigdraw.so" From 85e57eee3a31796b05fd92c2438f87f81d6fac52 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:06:52 -0600 Subject: [PATCH 3/9] add genny --- bindings/bindings.nim | 254 ++++++++++++++++++++++++ bindings/generated/fig_draw.h | 87 ++++++++ bindings/generated/fig_draw.hpp | 339 ++++++++++++++++++++++++++++++++ bindings/generated/fig_draw.js | 273 +++++++++++++++++++++++++ bindings/generated/fig_draw.nim | 213 ++++++++++++++++++++ bindings/generated/fig_draw.py | 293 +++++++++++++++++++++++++++ bindings/generated/fig_draw.zig | 205 +++++++++++++++++++ bindings/generated/internal.nim | 117 +++++++++++ config.nims | 6 + 9 files changed, 1787 insertions(+) diff --git a/bindings/bindings.nim b/bindings/bindings.nim index 151831a..3a90c43 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -1,7 +1,256 @@ import genny +import std/tables +import std/hashes import figdraw/commons +import figdraw/fignodes as fdn + +const ExportSiwinShim* {.booldefine: "figdraw.bindings.siwinshim".} = false + +when ExportSiwinShim: + import figdraw/windowing/siwinshim + +type + FigKind* = fdn.FigKind + ZLevel* = int8 + + Fig* = ref object + inner: fdn.Fig + + RenderList* = ref object + inner: fdn.RenderList + + Renders* = ref object + inner: fdn.Renders + +proc newFig(): Fig = + Fig(inner: fdn.Fig(kind: fdn.nkFrame)) + +proc newRectangleFig(x, y, w, h: float32): Fig = + Fig( + inner: fdn.Fig( + kind: fdn.nkRectangle, + screenBox: rect(x, y, w, h), + fill: fill(rgba(255, 255, 255, 255)), + ), + ) + +proc newTextFig(x, y, w, h: float32): Fig = + Fig( + inner: fdn.Fig( + kind: fdn.nkText, + screenBox: rect(x, y, w, h), + fill: fill(rgba(255, 255, 255, 255)), + textLayout: GlyphArrangement(), + ), + ) + +proc newImageFig(x, y, w, h: float32, imageId: int64): Fig = + Fig( + inner: fdn.Fig( + kind: fdn.nkImage, + screenBox: rect(x, y, w, h), + fill: fill(rgba(255, 255, 255, 255)), + image: ImageStyle( + id: cast[ImageId](Hash(imageId)), + fill: fill(rgba(255, 255, 255, 255)), + ), + ), + ) + +proc newTransformFig(x, y, w, h: float32, tx, ty: float32): Fig = + Fig( + inner: fdn.Fig( + kind: fdn.nkTransform, + screenBox: rect(x, y, w, h), + fill: fill(rgba(255, 255, 255, 255)), + transform: TransformStyle( + translation: vec2(tx, ty), + useMatrix: false, + ), + ), + ) + +when ExportSiwinShim: + proc siwinBackendNameBinding(): string = + siwinBackendName() + + proc siwinWindowTitleBinding(suffix: string): string = + siwinWindowTitle(suffix = suffix) + +proc copy(fig: Fig): Fig = + Fig(inner: fig.inner) + +proc figWithKind(src: fdn.Fig, kind: FigKind): fdn.Fig = + result = fdn.Fig(kind: fdn.FigKind(kind)) + result.zlevel = src.zlevel + result.parent = src.parent + result.flags = src.flags + result.childCount = src.childCount + result.screenBox = src.screenBox + result.rotation = src.rotation + result.fill = src.fill + result.corners = src.corners + +proc kind(fig: Fig): FigKind = + fig.inner.kind + +proc setKind(fig: Fig, kind: FigKind) = + fig.inner = figWithKind(fig.inner, kind) + +proc zLevel(fig: Fig): ZLevel = + fig.inner.zlevel.int8 + +proc setZLevel(fig: Fig, zLevel: ZLevel) = + fig.inner.zlevel = fdn.ZLevel(zLevel) + +proc x(fig: Fig): float32 = + fig.inner.screenBox.x + +proc y(fig: Fig): float32 = + fig.inner.screenBox.y + +proc width(fig: Fig): float32 = + fig.inner.screenBox.w + +proc height(fig: Fig): float32 = + fig.inner.screenBox.h + +proc setScreenBox(fig: Fig, x, y, w, h: float32) = + fig.inner.screenBox = rect(x, y, w, h) + +proc setFillColor(fig: Fig, r, g, b, a: uint8) = + fig.inner.fill = fill(rgba(r, g, b, a)) + +proc setRotation(fig: Fig, rotation: float32) = + fig.inner.rotation = rotation + +proc newRenderList(): RenderList = + RenderList(inner: fdn.RenderList()) + +proc copy(list: RenderList): RenderList = + RenderList(inner: list.inner) + +proc clear(list: RenderList) = + list.inner = fdn.RenderList() + +proc nodeCount(list: RenderList): int = + list.inner.nodes.len + +proc rootCount(list: RenderList): int = + list.inner.rootIds.len + +proc addRoot(list: RenderList, root: Fig): int16 = + list.inner.addRoot(root.inner).int16 + +proc addChild(list: RenderList, parentIdx: int16, child: Fig): int16 = + try: + list.inner.addChild(fdn.FigIdx(parentIdx), child.inner).int16 + except ValueError: + -1'i16 + +proc getNode(list: RenderList, nodeIdx: int16): Fig = + Fig(inner: list.inner.nodes[nodeIdx.int]) + +proc getRootId(list: RenderList, rootIdx: int16): int16 = + list.inner.rootIds[rootIdx.int].int16 + +proc newRenders(): Renders = + Renders(inner: fdn.Renders(layers: initOrderedTable[fdn.ZLevel, fdn.RenderList]())) + +proc clear(renders: Renders) = + renders.inner.layers.clear() + +proc containsLayer(renders: Renders, zLevel: ZLevel): bool = + renders.inner.contains(fdn.ZLevel(zLevel)) + +proc addRoot(renders: Renders, zLevel: ZLevel, root: Fig): int16 = + try: + renders.inner.addRoot(fdn.ZLevel(zLevel), root.inner).int16 + except CatchableError: + -1'i16 + +proc addChild(renders: Renders, zLevel: ZLevel, parentIdx: int16, child: Fig): int16 = + try: + renders.inner.addChild( + fdn.ZLevel(zLevel), + fdn.FigIdx(parentIdx), + child.inner, + ).int16 + except CatchableError: + -1'i16 + +proc layerNodeCount(renders: Renders, zLevel: ZLevel): int = + try: + if not renders.containsLayer(zLevel): + return 0 + renders.inner[fdn.ZLevel(zLevel)].nodes.len + except CatchableError: + 0 + +proc layerRootCount(renders: Renders, zLevel: ZLevel): int = + try: + if not renders.containsLayer(zLevel): + return 0 + renders.inner[fdn.ZLevel(zLevel)].rootIds.len + except CatchableError: + 0 + +proc getLayerNode(renders: Renders, zLevel: ZLevel, nodeIdx: int16): Fig = + try: + Fig(inner: renders.inner[fdn.ZLevel(zLevel)].nodes[nodeIdx.int]) + except CatchableError: + newFig() + +exportEnums: + FigKind + +exportRefObject Fig: + constructor: + newFig() + procs: + copy(Fig) + kind(Fig) + setKind(Fig, FigKind) + zLevel(Fig) + setZLevel(Fig, ZLevel) + x(Fig) + y(Fig) + width(Fig) + height(Fig) + setScreenBox(Fig, float32, float32, float32, float32) + setFillColor(Fig, uint8, uint8, uint8, uint8) + setRotation(Fig, float32) + +exportRefObject RenderList: + constructor: + newRenderList() + procs: + copy(RenderList) + clear(RenderList) + nodeCount(RenderList) + rootCount(RenderList) + addRoot(RenderList, Fig) + addChild(RenderList, int16, Fig) + getNode(RenderList, int16) + getRootId(RenderList, int16) + +exportRefObject Renders: + constructor: + newRenders() + procs: + clear(Renders) + containsLayer(Renders, ZLevel) + addRoot(Renders, ZLevel, Fig) + addChild(Renders, ZLevel, int16, Fig) + layerNodeCount(Renders, ZLevel) + layerRootCount(Renders, ZLevel) + getLayerNode(Renders, ZLevel, int16) exportProcs: + newRectangleFig + newTextFig + newImageFig + newTransformFig figDataDir setFigDataDir figUiScale @@ -9,6 +258,11 @@ exportProcs: scaled(float32) descaled(float32) +when ExportSiwinShim: + exportProcs: + siwinBackendNameBinding + siwinWindowTitleBinding + writeFiles("bindings/generated", "FigDraw") include generated/internal diff --git a/bindings/generated/fig_draw.h b/bindings/generated/fig_draw.h index 14954a6..9e597f2 100644 --- a/bindings/generated/fig_draw.h +++ b/bindings/generated/fig_draw.h @@ -1,6 +1,89 @@ #ifndef INCLUDE_FIGDRAW_H #define INCLUDE_FIGDRAW_H +typedef char FigKind; +#define FIG_KIND 0 + +typedef long long Fig; + +typedef long long RenderList; + +typedef long long Renders; + +void fig_draw_fig_unref(Fig fig); + +Fig fig_draw_new_fig(); + +Fig fig_draw_fig_copy(Fig fig); + +FigKind fig_draw_fig_kind(Fig fig); + +void fig_draw_fig_set_kind(Fig fig, FigKind kind); + +ZLevel fig_draw_fig_z_level(Fig fig); + +void fig_draw_fig_set_zlevel(Fig fig, ZLevel z_level); + +float fig_draw_fig_x(Fig fig); + +float fig_draw_fig_y(Fig fig); + +float fig_draw_fig_width(Fig fig); + +float fig_draw_fig_height(Fig fig); + +void fig_draw_fig_set_screen_box(Fig fig, float x, float y, float w, float h); + +void fig_draw_fig_set_fill_color(Fig fig, unsigned char r, unsigned char g, unsigned char b, unsigned char a); + +void fig_draw_fig_set_rotation(Fig fig, float rotation); + +void fig_draw_render_list_unref(RenderList render_list); + +RenderList fig_draw_new_render_list(); + +RenderList fig_draw_render_list_copy(RenderList list); + +void fig_draw_render_list_clear(RenderList list); + +long long fig_draw_render_list_node_count(RenderList list); + +long long fig_draw_render_list_root_count(RenderList list); + +short fig_draw_render_list_add_root(RenderList list, Fig root); + +short fig_draw_render_list_add_child(RenderList list, short parent_idx, Fig child); + +Fig fig_draw_render_list_get_node(RenderList list, short node_idx); + +short fig_draw_render_list_get_root_id(RenderList list, short root_idx); + +void fig_draw_renders_unref(Renders renders); + +Renders fig_draw_new_renders(); + +void fig_draw_renders_clear(Renders renders); + +char fig_draw_renders_contains_layer(Renders renders, ZLevel z_level); + +short fig_draw_renders_add_root(Renders renders, ZLevel z_level, Fig root); + +short fig_draw_renders_add_child(Renders renders, ZLevel z_level, short parent_idx, Fig child); + +long long fig_draw_renders_layer_node_count(Renders renders, ZLevel z_level); + +long long fig_draw_renders_layer_root_count(Renders renders, ZLevel z_level); + +Fig fig_draw_renders_get_layer_node(Renders renders, ZLevel z_level, short node_idx); + +Fig fig_draw_new_rectangle_fig(float x, float y, float w, float h); + +Fig fig_draw_new_text_fig(float x, float y, float w, float h); + +Fig fig_draw_new_image_fig(float x, float y, float w, float h, long long image_id); + +Fig fig_draw_new_transform_fig(float x, float y, float w, float h, float tx, float ty); + char* fig_draw_fig_data_dir(); void fig_draw_set_fig_data_dir(char* dir); @@ -13,4 +96,8 @@ float fig_draw_scaled(float a); float fig_draw_descaled(float a); +char* fig_draw_siwin_backend_name_binding(); + +char* fig_draw_siwin_window_title_binding(char* suffix); + #endif diff --git a/bindings/generated/fig_draw.hpp b/bindings/generated/fig_draw.hpp index eceea2f..3b44f75 100644 --- a/bindings/generated/fig_draw.hpp +++ b/bindings/generated/fig_draw.hpp @@ -3,8 +3,187 @@ #include +typedef char FigKind; +#define FIG_KIND 0 + +struct Fig; + +struct RenderList; + +struct Renders; + +struct Fig { + + private: + + uint64_t reference; + + public: + + Fig(); + + void free(); + + Fig copy(); + + FigKind kind(); + + void setKind(FigKind kind); + + ZLevel zLevel(); + + void setZLevel(ZLevel zLevel); + + float x(); + + float y(); + + float width(); + + float height(); + + void setScreenBox(float x, float y, float w, float h); + + void setFillColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a); + + void setRotation(float rotation); + +}; + +struct RenderList { + + private: + + uint64_t reference; + + public: + + RenderList(); + + void free(); + + RenderList copy(); + + void clear(); + + int64_t nodeCount(); + + int64_t rootCount(); + + int16_t addRoot(Fig root); + + int16_t addChild(int16_t parentIdx, Fig child); + + Fig getNode(int16_t nodeIdx); + + int16_t getRootId(int16_t rootIdx); + +}; + +struct Renders { + + private: + + uint64_t reference; + + public: + + Renders(); + + void free(); + + void clear(); + + bool containsLayer(ZLevel zLevel); + + int16_t addRoot(ZLevel zLevel, Fig root); + + int16_t addChild(ZLevel zLevel, int16_t parentIdx, Fig child); + + int64_t layerNodeCount(ZLevel zLevel); + + int64_t layerRootCount(ZLevel zLevel); + + Fig getLayerNode(ZLevel zLevel, int16_t nodeIdx); + +}; + extern "C" { +void fig_draw_fig_unref(Fig fig); + +Fig fig_draw_new_fig(); + +Fig fig_draw_fig_copy(Fig fig); + +FigKind fig_draw_fig_kind(Fig fig); + +void fig_draw_fig_set_kind(Fig fig, FigKind kind); + +ZLevel fig_draw_fig_z_level(Fig fig); + +void fig_draw_fig_set_zlevel(Fig fig, ZLevel z_level); + +float fig_draw_fig_x(Fig fig); + +float fig_draw_fig_y(Fig fig); + +float fig_draw_fig_width(Fig fig); + +float fig_draw_fig_height(Fig fig); + +void fig_draw_fig_set_screen_box(Fig fig, float x, float y, float w, float h); + +void fig_draw_fig_set_fill_color(Fig fig, uint8_t r, uint8_t g, uint8_t b, uint8_t a); + +void fig_draw_fig_set_rotation(Fig fig, float rotation); + +void fig_draw_render_list_unref(RenderList render_list); + +RenderList fig_draw_new_render_list(); + +RenderList fig_draw_render_list_copy(RenderList list); + +void fig_draw_render_list_clear(RenderList list); + +int64_t fig_draw_render_list_node_count(RenderList list); + +int64_t fig_draw_render_list_root_count(RenderList list); + +int16_t fig_draw_render_list_add_root(RenderList list, Fig root); + +int16_t fig_draw_render_list_add_child(RenderList list, int16_t parent_idx, Fig child); + +Fig fig_draw_render_list_get_node(RenderList list, int16_t node_idx); + +int16_t fig_draw_render_list_get_root_id(RenderList list, int16_t root_idx); + +void fig_draw_renders_unref(Renders renders); + +Renders fig_draw_new_renders(); + +void fig_draw_renders_clear(Renders renders); + +bool fig_draw_renders_contains_layer(Renders renders, ZLevel z_level); + +int16_t fig_draw_renders_add_root(Renders renders, ZLevel z_level, Fig root); + +int16_t fig_draw_renders_add_child(Renders renders, ZLevel z_level, int16_t parent_idx, Fig child); + +int64_t fig_draw_renders_layer_node_count(Renders renders, ZLevel z_level); + +int64_t fig_draw_renders_layer_root_count(Renders renders, ZLevel z_level); + +Fig fig_draw_renders_get_layer_node(Renders renders, ZLevel z_level, int16_t node_idx); + +Fig fig_draw_new_rectangle_fig(float x, float y, float w, float h); + +Fig fig_draw_new_text_fig(float x, float y, float w, float h); + +Fig fig_draw_new_image_fig(float x, float y, float w, float h, int64_t image_id); + +Fig fig_draw_new_transform_fig(float x, float y, float w, float h, float tx, float ty); + const char* fig_draw_fig_data_dir(); void fig_draw_set_fig_data_dir(const char* dir); @@ -17,8 +196,160 @@ float fig_draw_scaled(float a); float fig_draw_descaled(float a); +const char* fig_draw_siwin_backend_name_binding(); + +const char* fig_draw_siwin_window_title_binding(const char* suffix); + +} + +Fig::Fig() { + this->reference = fig_draw_new_fig().reference; +} + +void Fig::free(){ + fig_draw_fig_unref(*this); +} + +Fig Fig::copy() { + return fig_draw_fig_copy(*this); +}; + +FigKind Fig::kind() { + return fig_draw_fig_kind(*this); +}; + +void Fig::setKind(FigKind kind) { + fig_draw_fig_set_kind(*this, kind); +}; + +ZLevel Fig::zLevel() { + return fig_draw_fig_z_level(*this); +}; + +void Fig::setZLevel(ZLevel zLevel) { + fig_draw_fig_set_zlevel(*this, zLevel); +}; + +float Fig::x() { + return fig_draw_fig_x(*this); +}; + +float Fig::y() { + return fig_draw_fig_y(*this); +}; + +float Fig::width() { + return fig_draw_fig_width(*this); +}; + +float Fig::height() { + return fig_draw_fig_height(*this); +}; + +void Fig::setScreenBox(float x, float y, float w, float h) { + fig_draw_fig_set_screen_box(*this, x, y, w, h); +}; + +void Fig::setFillColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { + fig_draw_fig_set_fill_color(*this, r, g, b, a); +}; + +void Fig::setRotation(float rotation) { + fig_draw_fig_set_rotation(*this, rotation); +}; + +RenderList::RenderList() { + this->reference = fig_draw_new_render_list().reference; +} + +void RenderList::free(){ + fig_draw_render_list_unref(*this); +} + +RenderList RenderList::copy() { + return fig_draw_render_list_copy(*this); +}; + +void RenderList::clear() { + fig_draw_render_list_clear(*this); +}; + +int64_t RenderList::nodeCount() { + return fig_draw_render_list_node_count(*this); +}; + +int64_t RenderList::rootCount() { + return fig_draw_render_list_root_count(*this); +}; + +int16_t RenderList::addRoot(Fig root) { + return fig_draw_render_list_add_root(*this, root); +}; + +int16_t RenderList::addChild(int16_t parentIdx, Fig child) { + return fig_draw_render_list_add_child(*this, parentIdx, child); +}; + +Fig RenderList::getNode(int16_t nodeIdx) { + return fig_draw_render_list_get_node(*this, nodeIdx); +}; + +int16_t RenderList::getRootId(int16_t rootIdx) { + return fig_draw_render_list_get_root_id(*this, rootIdx); +}; + +Renders::Renders() { + this->reference = fig_draw_new_renders().reference; +} + +void Renders::free(){ + fig_draw_renders_unref(*this); } +void Renders::clear() { + fig_draw_renders_clear(*this); +}; + +bool Renders::containsLayer(ZLevel zLevel) { + return fig_draw_renders_contains_layer(*this, zLevel); +}; + +int16_t Renders::addRoot(ZLevel zLevel, Fig root) { + return fig_draw_renders_add_root(*this, zLevel, root); +}; + +int16_t Renders::addChild(ZLevel zLevel, int16_t parentIdx, Fig child) { + return fig_draw_renders_add_child(*this, zLevel, parentIdx, child); +}; + +int64_t Renders::layerNodeCount(ZLevel zLevel) { + return fig_draw_renders_layer_node_count(*this, zLevel); +}; + +int64_t Renders::layerRootCount(ZLevel zLevel) { + return fig_draw_renders_layer_root_count(*this, zLevel); +}; + +Fig Renders::getLayerNode(ZLevel zLevel, int16_t nodeIdx) { + return fig_draw_renders_get_layer_node(*this, zLevel, nodeIdx); +}; + +Fig newRectangleFig(float x, float y, float w, float h) { + return fig_draw_new_rectangle_fig(x, y, w, h); +}; + +Fig newTextFig(float x, float y, float w, float h) { + return fig_draw_new_text_fig(x, y, w, h); +}; + +Fig newImageFig(float x, float y, float w, float h, int64_t imageId) { + return fig_draw_new_image_fig(x, y, w, h, imageId); +}; + +Fig newTransformFig(float x, float y, float w, float h, float tx, float ty) { + return fig_draw_new_transform_fig(x, y, w, h, tx, ty); +}; + const char* figDataDir() { return fig_draw_fig_data_dir(); }; @@ -43,4 +374,12 @@ float descaled(float a) { return fig_draw_descaled(a); }; +const char* siwinBackendNameBinding() { + return fig_draw_siwin_backend_name_binding(); +}; + +const char* siwinWindowTitleBinding(const char* suffix) { + return fig_draw_siwin_window_title_binding(suffix); +}; + #endif diff --git a/bindings/generated/fig_draw.js b/bindings/generated/fig_draw.js index 14ef0e6..fc9b479 100644 --- a/bindings/generated/fig_draw.js +++ b/bindings/generated/fig_draw.js @@ -9,6 +9,216 @@ function FigDrawException(message) { this.name = 'FigDrawException'; } +const FigKind = 'int8' + +Fig = Struct({'nimRef': 'uint64'}); +Fig.prototype.isNull = function(){ + return this.nimRef == 0; +}; +Fig.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +Fig.prototype.unref = function(){ + return dll.fig_draw_fig_unref(this) +}; +function newFig(){ + var result = dll.fig_draw_new_fig() + const registry = new FinalizationRegistry(function(obj) { + console.log("js unref") + obj.unref() + }); + registry.register(result, null); + return result +} + +Fig.prototype.copy = function(){ + result = dll.fig_draw_fig_copy(this) + return result +} + +Fig.prototype.kind = function(){ + result = dll.fig_draw_fig_kind(this) + return result +} + +Fig.prototype.setKind = function(kind){ + dll.fig_draw_fig_set_kind(this, kind) +} + +Fig.prototype.zlevel = function(){ + result = dll.fig_draw_fig_z_level(this) + return result +} + +Fig.prototype.setZLevel = function(z_level){ + dll.fig_draw_fig_set_zlevel(this, z_level) +} + +Fig.prototype.x = function(){ + result = dll.fig_draw_fig_x(this) + return result +} + +Fig.prototype.y = function(){ + result = dll.fig_draw_fig_y(this) + return result +} + +Fig.prototype.width = function(){ + result = dll.fig_draw_fig_width(this) + return result +} + +Fig.prototype.height = function(){ + result = dll.fig_draw_fig_height(this) + return result +} + +Fig.prototype.setScreenBox = function(x, y, w, h){ + dll.fig_draw_fig_set_screen_box(this, x, y, w, h) +} + +Fig.prototype.setFillColor = function(r, g, b, a){ + dll.fig_draw_fig_set_fill_color(this, r, g, b, a) +} + +Fig.prototype.setRotation = function(rotation){ + dll.fig_draw_fig_set_rotation(this, rotation) +} + +RenderList = Struct({'nimRef': 'uint64'}); +RenderList.prototype.isNull = function(){ + return this.nimRef == 0; +}; +RenderList.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +RenderList.prototype.unref = function(){ + return dll.fig_draw_render_list_unref(this) +}; +function newRenderList(){ + var result = dll.fig_draw_new_render_list() + const registry = new FinalizationRegistry(function(obj) { + console.log("js unref") + obj.unref() + }); + registry.register(result, null); + return result +} + +RenderList.prototype.copy = function(){ + result = dll.fig_draw_render_list_copy(this) + return result +} + +RenderList.prototype.clear = function(){ + dll.fig_draw_render_list_clear(this) +} + +RenderList.prototype.nodeCount = function(){ + result = dll.fig_draw_render_list_node_count(this) + return result +} + +RenderList.prototype.rootCount = function(){ + result = dll.fig_draw_render_list_root_count(this) + return result +} + +RenderList.prototype.addRoot = function(root){ + result = dll.fig_draw_render_list_add_root(this, root) + return result +} + +RenderList.prototype.addChild = function(parent_idx, child){ + result = dll.fig_draw_render_list_add_child(this, parent_idx, child) + return result +} + +RenderList.prototype.getNode = function(node_idx){ + result = dll.fig_draw_render_list_get_node(this, node_idx) + return result +} + +RenderList.prototype.getRootId = function(root_idx){ + result = dll.fig_draw_render_list_get_root_id(this, root_idx) + return result +} + +Renders = Struct({'nimRef': 'uint64'}); +Renders.prototype.isNull = function(){ + return this.nimRef == 0; +}; +Renders.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +Renders.prototype.unref = function(){ + return dll.fig_draw_renders_unref(this) +}; +function newRenders(){ + var result = dll.fig_draw_new_renders() + const registry = new FinalizationRegistry(function(obj) { + console.log("js unref") + obj.unref() + }); + registry.register(result, null); + return result +} + +Renders.prototype.clear = function(){ + dll.fig_draw_renders_clear(this) +} + +Renders.prototype.containsLayer = function(z_level){ + result = dll.fig_draw_renders_contains_layer(this, z_level) + return result +} + +Renders.prototype.addRoot = function(z_level, root){ + result = dll.fig_draw_renders_add_root(this, z_level, root) + return result +} + +Renders.prototype.addChild = function(z_level, parent_idx, child){ + result = dll.fig_draw_renders_add_child(this, z_level, parent_idx, child) + return result +} + +Renders.prototype.layerNodeCount = function(z_level){ + result = dll.fig_draw_renders_layer_node_count(this, z_level) + return result +} + +Renders.prototype.layerRootCount = function(z_level){ + result = dll.fig_draw_renders_layer_root_count(this, z_level) + return result +} + +Renders.prototype.getLayerNode = function(z_level, node_idx){ + result = dll.fig_draw_renders_get_layer_node(this, z_level, node_idx) + return result +} + +function newRectangleFig(x, y, w, h){ + result = dll.fig_draw_new_rectangle_fig(x, y, w, h) + return result +} + +function newTextFig(x, y, w, h){ + result = dll.fig_draw_new_text_fig(x, y, w, h) + return result +} + +function newImageFig(x, y, w, h, image_id){ + result = dll.fig_draw_new_image_fig(x, y, w, h, image_id) + return result +} + +function newTransformFig(x, y, w, h, tx, ty){ + result = dll.fig_draw_new_transform_fig(x, y, w, h, tx, ty) + return result +} + function figDataDir(){ result = dll.fig_draw_fig_data_dir() return result @@ -37,6 +247,16 @@ function descaled(a){ return result } +function siwinBackendNameBinding(){ + result = dll.fig_draw_siwin_backend_name_binding() + return result +} + +function siwinWindowTitleBinding(suffix){ + result = dll.fig_draw_siwin_window_title_binding(suffix) + return result +} + var dllPath = "" if(process.platform == "win32") { @@ -48,17 +268,70 @@ if(process.platform == "win32") { } dll = ffi.Library(dllPath, { + 'fig_draw_fig_unref': ['void', [Fig]], + 'fig_draw_new_fig': [Fig, []], + 'fig_draw_fig_copy': [Fig, [Fig]], + 'fig_draw_fig_kind': [FigKind, [Fig]], + 'fig_draw_fig_set_kind': ['void', [Fig, FigKind]], + 'fig_draw_fig_z_level': [ZLevel, [Fig]], + 'fig_draw_fig_set_zlevel': ['void', [Fig, ZLevel]], + 'fig_draw_fig_x': ['float', [Fig]], + 'fig_draw_fig_y': ['float', [Fig]], + 'fig_draw_fig_width': ['float', [Fig]], + 'fig_draw_fig_height': ['float', [Fig]], + 'fig_draw_fig_set_screen_box': ['void', [Fig, 'float', 'float', 'float', 'float']], + 'fig_draw_fig_set_fill_color': ['void', [Fig, 'uint8', 'uint8', 'uint8', 'uint8']], + 'fig_draw_fig_set_rotation': ['void', [Fig, 'float']], + 'fig_draw_render_list_unref': ['void', [RenderList]], + 'fig_draw_new_render_list': [RenderList, []], + 'fig_draw_render_list_copy': [RenderList, [RenderList]], + 'fig_draw_render_list_clear': ['void', [RenderList]], + 'fig_draw_render_list_node_count': ['int64', [RenderList]], + 'fig_draw_render_list_root_count': ['int64', [RenderList]], + 'fig_draw_render_list_add_root': ['int16', [RenderList, Fig]], + 'fig_draw_render_list_add_child': ['int16', [RenderList, 'int16', Fig]], + 'fig_draw_render_list_get_node': [Fig, [RenderList, 'int16']], + 'fig_draw_render_list_get_root_id': ['int16', [RenderList, 'int16']], + 'fig_draw_renders_unref': ['void', [Renders]], + 'fig_draw_new_renders': [Renders, []], + 'fig_draw_renders_clear': ['void', [Renders]], + 'fig_draw_renders_contains_layer': ['bool', [Renders, ZLevel]], + 'fig_draw_renders_add_root': ['int16', [Renders, ZLevel, Fig]], + 'fig_draw_renders_add_child': ['int16', [Renders, ZLevel, 'int16', Fig]], + 'fig_draw_renders_layer_node_count': ['int64', [Renders, ZLevel]], + 'fig_draw_renders_layer_root_count': ['int64', [Renders, ZLevel]], + 'fig_draw_renders_get_layer_node': [Fig, [Renders, ZLevel, 'int16']], + 'fig_draw_new_rectangle_fig': [Fig, ['float', 'float', 'float', 'float']], + 'fig_draw_new_text_fig': [Fig, ['float', 'float', 'float', 'float']], + 'fig_draw_new_image_fig': [Fig, ['float', 'float', 'float', 'float', 'int64']], + 'fig_draw_new_transform_fig': [Fig, ['float', 'float', 'float', 'float', 'float', 'float']], 'fig_draw_fig_data_dir': ['string', []], 'fig_draw_set_fig_data_dir': ['void', ['string']], 'fig_draw_fig_ui_scale': ['float', []], 'fig_draw_set_fig_ui_scale': ['void', ['float']], 'fig_draw_scaled': ['float', ['float']], 'fig_draw_descaled': ['float', ['float']], + 'fig_draw_siwin_backend_name_binding': ['string', []], + 'fig_draw_siwin_window_title_binding': ['string', ['string']], }); +exports.FigKind = FigKind +exports.FIG_KIND = 0 +exports.FigType = Fig +exports.Fig = newFig +exports.RenderListType = RenderList +exports.RenderList = newRenderList +exports.RendersType = Renders +exports.Renders = newRenders +exports.newRectangleFig = newRectangleFig +exports.newTextFig = newTextFig +exports.newImageFig = newImageFig +exports.newTransformFig = newTransformFig exports.figDataDir = figDataDir exports.setFigDataDir = setFigDataDir exports.figUiScale = figUiScale exports.setFigUiScale = setFigUiScale exports.scaled = scaled exports.descaled = descaled +exports.siwinBackendNameBinding = siwinBackendNameBinding +exports.siwinWindowTitleBinding = siwinWindowTitleBinding diff --git a/bindings/generated/fig_draw.nim b/bindings/generated/fig_draw.nim index 04bae89..e13151b 100644 --- a/bindings/generated/fig_draw.nim +++ b/bindings/generated/fig_draw.nim @@ -13,6 +13,209 @@ else: type FigDrawError = object of ValueError +type FigKind* = enum + FigKind + +type FigObj = object + reference: pointer + +type Fig* = ref FigObj + +proc fig_draw_fig_unref(x: FigObj) {.importc: "fig_draw_fig_unref", cdecl.} + +proc `=destroy`(x: var FigObj) = + fig_draw_fig_unref(x) + +type RenderListObj = object + reference: pointer + +type RenderList* = ref RenderListObj + +proc fig_draw_render_list_unref(x: RenderListObj) {.importc: "fig_draw_render_list_unref", cdecl.} + +proc `=destroy`(x: var RenderListObj) = + fig_draw_render_list_unref(x) + +type RendersObj = object + reference: pointer + +type Renders* = ref RendersObj + +proc fig_draw_renders_unref(x: RendersObj) {.importc: "fig_draw_renders_unref", cdecl.} + +proc `=destroy`(x: var RendersObj) = + fig_draw_renders_unref(x) + +proc fig_draw_new_fig(): Fig {.importc: "fig_draw_new_fig", cdecl.} + +proc newFig*(): Fig {.inline.} = + result = fig_draw_new_fig() + +proc fig_draw_fig_copy(fig: Fig): Fig {.importc: "fig_draw_fig_copy", cdecl.} + +proc copy*(fig: Fig): Fig {.inline.} = + result = fig_draw_fig_copy(fig) + +proc fig_draw_fig_kind(fig: Fig): FigKind {.importc: "fig_draw_fig_kind", cdecl.} + +proc kind*(fig: Fig): FigKind {.inline.} = + result = fig_draw_fig_kind(fig) + +proc fig_draw_fig_set_kind(fig: Fig, kind: FigKind) {.importc: "fig_draw_fig_set_kind", cdecl.} + +proc setKind*(fig: Fig, kind: FigKind) {.inline.} = + fig_draw_fig_set_kind(fig, kind) + +proc fig_draw_fig_z_level(fig: Fig): ZLevel {.importc: "fig_draw_fig_z_level", cdecl.} + +proc zLevel*(fig: Fig): ZLevel {.inline.} = + result = fig_draw_fig_z_level(fig) + +proc fig_draw_fig_set_zlevel(fig: Fig, z_level: ZLevel) {.importc: "fig_draw_fig_set_zlevel", cdecl.} + +proc setZLevel*(fig: Fig, zLevel: ZLevel) {.inline.} = + fig_draw_fig_set_zlevel(fig, zLevel) + +proc fig_draw_fig_x(fig: Fig): float32 {.importc: "fig_draw_fig_x", cdecl.} + +proc x*(fig: Fig): float32 {.inline.} = + result = fig_draw_fig_x(fig) + +proc fig_draw_fig_y(fig: Fig): float32 {.importc: "fig_draw_fig_y", cdecl.} + +proc y*(fig: Fig): float32 {.inline.} = + result = fig_draw_fig_y(fig) + +proc fig_draw_fig_width(fig: Fig): float32 {.importc: "fig_draw_fig_width", cdecl.} + +proc width*(fig: Fig): float32 {.inline.} = + result = fig_draw_fig_width(fig) + +proc fig_draw_fig_height(fig: Fig): float32 {.importc: "fig_draw_fig_height", cdecl.} + +proc height*(fig: Fig): float32 {.inline.} = + result = fig_draw_fig_height(fig) + +proc fig_draw_fig_set_screen_box(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.importc: "fig_draw_fig_set_screen_box", cdecl.} + +proc setScreenBox*(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.inline.} = + fig_draw_fig_set_screen_box(fig, x, y, w, h) + +proc fig_draw_fig_set_fill_color(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.importc: "fig_draw_fig_set_fill_color", cdecl.} + +proc setFillColor*(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.inline.} = + fig_draw_fig_set_fill_color(fig, r, g, b, a) + +proc fig_draw_fig_set_rotation(fig: Fig, rotation: float32) {.importc: "fig_draw_fig_set_rotation", cdecl.} + +proc setRotation*(fig: Fig, rotation: float32) {.inline.} = + fig_draw_fig_set_rotation(fig, rotation) + +proc fig_draw_new_render_list(): RenderList {.importc: "fig_draw_new_render_list", cdecl.} + +proc newRenderList*(): RenderList {.inline.} = + result = fig_draw_new_render_list() + +proc fig_draw_render_list_copy(list: RenderList): RenderList {.importc: "fig_draw_render_list_copy", cdecl.} + +proc copy*(list: RenderList): RenderList {.inline.} = + result = fig_draw_render_list_copy(list) + +proc fig_draw_render_list_clear(list: RenderList) {.importc: "fig_draw_render_list_clear", cdecl.} + +proc clear*(list: RenderList) {.inline.} = + fig_draw_render_list_clear(list) + +proc fig_draw_render_list_node_count(list: RenderList): int {.importc: "fig_draw_render_list_node_count", cdecl.} + +proc nodeCount*(list: RenderList): int {.inline.} = + result = fig_draw_render_list_node_count(list) + +proc fig_draw_render_list_root_count(list: RenderList): int {.importc: "fig_draw_render_list_root_count", cdecl.} + +proc rootCount*(list: RenderList): int {.inline.} = + result = fig_draw_render_list_root_count(list) + +proc fig_draw_render_list_add_root(list: RenderList, root: Fig): int16 {.importc: "fig_draw_render_list_add_root", cdecl.} + +proc addRoot*(list: RenderList, root: Fig): int16 {.inline.} = + result = fig_draw_render_list_add_root(list, root) + +proc fig_draw_render_list_add_child(list: RenderList, parent_idx: int16, child: Fig): int16 {.importc: "fig_draw_render_list_add_child", cdecl.} + +proc addChild*(list: RenderList, parentIdx: int16, child: Fig): int16 {.inline.} = + result = fig_draw_render_list_add_child(list, parentIdx, child) + +proc fig_draw_render_list_get_node(list: RenderList, node_idx: int16): Fig {.importc: "fig_draw_render_list_get_node", cdecl.} + +proc getNode*(list: RenderList, nodeIdx: int16): Fig {.inline.} = + result = fig_draw_render_list_get_node(list, nodeIdx) + +proc fig_draw_render_list_get_root_id(list: RenderList, root_idx: int16): int16 {.importc: "fig_draw_render_list_get_root_id", cdecl.} + +proc getRootId*(list: RenderList, rootIdx: int16): int16 {.inline.} = + result = fig_draw_render_list_get_root_id(list, rootIdx) + +proc fig_draw_new_renders(): Renders {.importc: "fig_draw_new_renders", cdecl.} + +proc newRenders*(): Renders {.inline.} = + result = fig_draw_new_renders() + +proc fig_draw_renders_clear(renders: Renders) {.importc: "fig_draw_renders_clear", cdecl.} + +proc clear*(renders: Renders) {.inline.} = + fig_draw_renders_clear(renders) + +proc fig_draw_renders_contains_layer(renders: Renders, z_level: ZLevel): bool {.importc: "fig_draw_renders_contains_layer", cdecl.} + +proc containsLayer*(renders: Renders, zLevel: ZLevel): bool {.inline.} = + result = fig_draw_renders_contains_layer(renders, zLevel) + +proc fig_draw_renders_add_root(renders: Renders, z_level: ZLevel, root: Fig): int16 {.importc: "fig_draw_renders_add_root", cdecl.} + +proc addRoot*(renders: Renders, zLevel: ZLevel, root: Fig): int16 {.inline.} = + result = fig_draw_renders_add_root(renders, zLevel, root) + +proc fig_draw_renders_add_child(renders: Renders, z_level: ZLevel, parent_idx: int16, child: Fig): int16 {.importc: "fig_draw_renders_add_child", cdecl.} + +proc addChild*(renders: Renders, zLevel: ZLevel, parentIdx: int16, child: Fig): int16 {.inline.} = + result = fig_draw_renders_add_child(renders, zLevel, parentIdx, child) + +proc fig_draw_renders_layer_node_count(renders: Renders, z_level: ZLevel): int {.importc: "fig_draw_renders_layer_node_count", cdecl.} + +proc layerNodeCount*(renders: Renders, zLevel: ZLevel): int {.inline.} = + result = fig_draw_renders_layer_node_count(renders, zLevel) + +proc fig_draw_renders_layer_root_count(renders: Renders, z_level: ZLevel): int {.importc: "fig_draw_renders_layer_root_count", cdecl.} + +proc layerRootCount*(renders: Renders, zLevel: ZLevel): int {.inline.} = + result = fig_draw_renders_layer_root_count(renders, zLevel) + +proc fig_draw_renders_get_layer_node(renders: Renders, z_level: ZLevel, node_idx: int16): Fig {.importc: "fig_draw_renders_get_layer_node", cdecl.} + +proc getLayerNode*(renders: Renders, zLevel: ZLevel, nodeIdx: int16): Fig {.inline.} = + result = fig_draw_renders_get_layer_node(renders, zLevel, nodeIdx) + +proc fig_draw_new_rectangle_fig(x: float32, y: float32, w: float32, h: float32): Fig {.importc: "fig_draw_new_rectangle_fig", cdecl.} + +proc newRectangleFig*(x: float32, y: float32, w: float32, h: float32): Fig {.inline.} = + result = fig_draw_new_rectangle_fig(x, y, w, h) + +proc fig_draw_new_text_fig(x: float32, y: float32, w: float32, h: float32): Fig {.importc: "fig_draw_new_text_fig", cdecl.} + +proc newTextFig*(x: float32, y: float32, w: float32, h: float32): Fig {.inline.} = + result = fig_draw_new_text_fig(x, y, w, h) + +proc fig_draw_new_image_fig(x: float32, y: float32, w: float32, h: float32, image_id: int64): Fig {.importc: "fig_draw_new_image_fig", cdecl.} + +proc newImageFig*(x: float32, y: float32, w: float32, h: float32, imageId: int64): Fig {.inline.} = + result = fig_draw_new_image_fig(x, y, w, h, imageId) + +proc fig_draw_new_transform_fig(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.importc: "fig_draw_new_transform_fig", cdecl.} + +proc newTransformFig*(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.inline.} = + result = fig_draw_new_transform_fig(x, y, w, h, tx, ty) + proc fig_draw_fig_data_dir(): cstring {.importc: "fig_draw_fig_data_dir", cdecl.} proc figDataDir*(): cstring {.inline.} = @@ -43,3 +246,13 @@ proc fig_draw_descaled(a: float32): float32 {.importc: "fig_draw_descaled", cdec proc descaled*(a: float32): float32 {.inline.} = result = fig_draw_descaled(a) +proc fig_draw_siwin_backend_name_binding(): cstring {.importc: "fig_draw_siwin_backend_name_binding", cdecl.} + +proc siwinBackendNameBinding*(): cstring {.inline.} = + result = fig_draw_siwin_backend_name_binding() + +proc fig_draw_siwin_window_title_binding(suffix: cstring): cstring {.importc: "fig_draw_siwin_window_title_binding", cdecl.} + +proc siwinWindowTitleBinding*(suffix: string): cstring {.inline.} = + result = fig_draw_siwin_window_title_binding(suffix.cstring) + diff --git a/bindings/generated/fig_draw.py b/bindings/generated/fig_draw.py index eb48e7d..a0ebb90 100644 --- a/bindings/generated/fig_draw.py +++ b/bindings/generated/fig_draw.py @@ -27,6 +27,174 @@ def __next__(self): self.idx = 0 raise StopIteration +FigKind = c_byte +FIG_KIND = 0 + +class Fig(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_fig_unref(self) + + def __init__(self): + result = dll.fig_draw_new_fig() + self.ref = result + + def copy(self): + result = dll.fig_draw_fig_copy(self) + return result + + def kind(self): + result = dll.fig_draw_fig_kind(self) + return result + + def set_kind(self, kind): + dll.fig_draw_fig_set_kind(self, kind) + + def z_level(self): + result = dll.fig_draw_fig_z_level(self) + return result + + def set_zlevel(self, z_level): + dll.fig_draw_fig_set_zlevel(self, z_level) + + def x(self): + result = dll.fig_draw_fig_x(self) + return result + + def y(self): + result = dll.fig_draw_fig_y(self) + return result + + def width(self): + result = dll.fig_draw_fig_width(self) + return result + + def height(self): + result = dll.fig_draw_fig_height(self) + return result + + def set_screen_box(self, x, y, w, h): + dll.fig_draw_fig_set_screen_box(self, x, y, w, h) + + def set_fill_color(self, r, g, b, a): + dll.fig_draw_fig_set_fill_color(self, r, g, b, a) + + def set_rotation(self, rotation): + dll.fig_draw_fig_set_rotation(self, rotation) + +class RenderList(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_render_list_unref(self) + + def __init__(self): + result = dll.fig_draw_new_render_list() + self.ref = result + + def copy(self): + result = dll.fig_draw_render_list_copy(self) + return result + + def clear(self): + dll.fig_draw_render_list_clear(self) + + def node_count(self): + result = dll.fig_draw_render_list_node_count(self) + return result + + def root_count(self): + result = dll.fig_draw_render_list_root_count(self) + return result + + def add_root(self, root): + result = dll.fig_draw_render_list_add_root(self, root) + return result + + def add_child(self, parent_idx, child): + result = dll.fig_draw_render_list_add_child(self, parent_idx, child) + return result + + def get_node(self, node_idx): + result = dll.fig_draw_render_list_get_node(self, node_idx) + return result + + def get_root_id(self, root_idx): + result = dll.fig_draw_render_list_get_root_id(self, root_idx) + return result + +class Renders(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_renders_unref(self) + + def __init__(self): + result = dll.fig_draw_new_renders() + self.ref = result + + def clear(self): + dll.fig_draw_renders_clear(self) + + def contains_layer(self, z_level): + result = dll.fig_draw_renders_contains_layer(self, z_level) + return result + + def add_root(self, z_level, root): + result = dll.fig_draw_renders_add_root(self, z_level, root) + return result + + def add_child(self, z_level, parent_idx, child): + result = dll.fig_draw_renders_add_child(self, z_level, parent_idx, child) + return result + + def layer_node_count(self, z_level): + result = dll.fig_draw_renders_layer_node_count(self, z_level) + return result + + def layer_root_count(self, z_level): + result = dll.fig_draw_renders_layer_root_count(self, z_level) + return result + + def get_layer_node(self, z_level, node_idx): + result = dll.fig_draw_renders_get_layer_node(self, z_level, node_idx) + return result + +def new_rectangle_fig(x, y, w, h): + result = dll.fig_draw_new_rectangle_fig(x, y, w, h) + return result + +def new_text_fig(x, y, w, h): + result = dll.fig_draw_new_text_fig(x, y, w, h) + return result + +def new_image_fig(x, y, w, h, image_id): + result = dll.fig_draw_new_image_fig(x, y, w, h, image_id) + return result + +def new_transform_fig(x, y, w, h, tx, ty): + result = dll.fig_draw_new_transform_fig(x, y, w, h, tx, ty) + return result + def fig_data_dir(): result = dll.fig_draw_fig_data_dir().decode("utf8") return result @@ -49,6 +217,125 @@ def descaled(a): result = dll.fig_draw_descaled(a) return result +def siwin_backend_name_binding(): + result = dll.fig_draw_siwin_backend_name_binding().decode("utf8") + return result + +def siwin_window_title_binding(suffix): + result = dll.fig_draw_siwin_window_title_binding(suffix.encode("utf8")).decode("utf8") + return result + +dll.fig_draw_fig_unref.argtypes = [Fig] +dll.fig_draw_fig_unref.restype = None + +dll.fig_draw_new_fig.argtypes = [] +dll.fig_draw_new_fig.restype = c_ulonglong + +dll.fig_draw_fig_copy.argtypes = [Fig] +dll.fig_draw_fig_copy.restype = Fig + +dll.fig_draw_fig_kind.argtypes = [Fig] +dll.fig_draw_fig_kind.restype = FigKind + +dll.fig_draw_fig_set_kind.argtypes = [Fig, FigKind] +dll.fig_draw_fig_set_kind.restype = None + +dll.fig_draw_fig_z_level.argtypes = [Fig] +dll.fig_draw_fig_z_level.restype = ZLevel + +dll.fig_draw_fig_set_zlevel.argtypes = [Fig, ZLevel] +dll.fig_draw_fig_set_zlevel.restype = None + +dll.fig_draw_fig_x.argtypes = [Fig] +dll.fig_draw_fig_x.restype = c_float + +dll.fig_draw_fig_y.argtypes = [Fig] +dll.fig_draw_fig_y.restype = c_float + +dll.fig_draw_fig_width.argtypes = [Fig] +dll.fig_draw_fig_width.restype = c_float + +dll.fig_draw_fig_height.argtypes = [Fig] +dll.fig_draw_fig_height.restype = c_float + +dll.fig_draw_fig_set_screen_box.argtypes = [Fig, c_float, c_float, c_float, c_float] +dll.fig_draw_fig_set_screen_box.restype = None + +dll.fig_draw_fig_set_fill_color.argtypes = [Fig, c_ubyte, c_ubyte, c_ubyte, c_ubyte] +dll.fig_draw_fig_set_fill_color.restype = None + +dll.fig_draw_fig_set_rotation.argtypes = [Fig, c_float] +dll.fig_draw_fig_set_rotation.restype = None + +dll.fig_draw_render_list_unref.argtypes = [RenderList] +dll.fig_draw_render_list_unref.restype = None + +dll.fig_draw_new_render_list.argtypes = [] +dll.fig_draw_new_render_list.restype = c_ulonglong + +dll.fig_draw_render_list_copy.argtypes = [RenderList] +dll.fig_draw_render_list_copy.restype = RenderList + +dll.fig_draw_render_list_clear.argtypes = [RenderList] +dll.fig_draw_render_list_clear.restype = None + +dll.fig_draw_render_list_node_count.argtypes = [RenderList] +dll.fig_draw_render_list_node_count.restype = c_longlong + +dll.fig_draw_render_list_root_count.argtypes = [RenderList] +dll.fig_draw_render_list_root_count.restype = c_longlong + +dll.fig_draw_render_list_add_root.argtypes = [RenderList, Fig] +dll.fig_draw_render_list_add_root.restype = c_short + +dll.fig_draw_render_list_add_child.argtypes = [RenderList, c_short, Fig] +dll.fig_draw_render_list_add_child.restype = c_short + +dll.fig_draw_render_list_get_node.argtypes = [RenderList, c_short] +dll.fig_draw_render_list_get_node.restype = Fig + +dll.fig_draw_render_list_get_root_id.argtypes = [RenderList, c_short] +dll.fig_draw_render_list_get_root_id.restype = c_short + +dll.fig_draw_renders_unref.argtypes = [Renders] +dll.fig_draw_renders_unref.restype = None + +dll.fig_draw_new_renders.argtypes = [] +dll.fig_draw_new_renders.restype = c_ulonglong + +dll.fig_draw_renders_clear.argtypes = [Renders] +dll.fig_draw_renders_clear.restype = None + +dll.fig_draw_renders_contains_layer.argtypes = [Renders, ZLevel] +dll.fig_draw_renders_contains_layer.restype = c_bool + +dll.fig_draw_renders_add_root.argtypes = [Renders, ZLevel, Fig] +dll.fig_draw_renders_add_root.restype = c_short + +dll.fig_draw_renders_add_child.argtypes = [Renders, ZLevel, c_short, Fig] +dll.fig_draw_renders_add_child.restype = c_short + +dll.fig_draw_renders_layer_node_count.argtypes = [Renders, ZLevel] +dll.fig_draw_renders_layer_node_count.restype = c_longlong + +dll.fig_draw_renders_layer_root_count.argtypes = [Renders, ZLevel] +dll.fig_draw_renders_layer_root_count.restype = c_longlong + +dll.fig_draw_renders_get_layer_node.argtypes = [Renders, ZLevel, c_short] +dll.fig_draw_renders_get_layer_node.restype = Fig + +dll.fig_draw_new_rectangle_fig.argtypes = [c_float, c_float, c_float, c_float] +dll.fig_draw_new_rectangle_fig.restype = Fig + +dll.fig_draw_new_text_fig.argtypes = [c_float, c_float, c_float, c_float] +dll.fig_draw_new_text_fig.restype = Fig + +dll.fig_draw_new_image_fig.argtypes = [c_float, c_float, c_float, c_float, c_longlong] +dll.fig_draw_new_image_fig.restype = Fig + +dll.fig_draw_new_transform_fig.argtypes = [c_float, c_float, c_float, c_float, c_float, c_float] +dll.fig_draw_new_transform_fig.restype = Fig + dll.fig_draw_fig_data_dir.argtypes = [] dll.fig_draw_fig_data_dir.restype = c_char_p @@ -67,3 +354,9 @@ def descaled(a): dll.fig_draw_descaled.argtypes = [c_float] dll.fig_draw_descaled.restype = c_float +dll.fig_draw_siwin_backend_name_binding.argtypes = [] +dll.fig_draw_siwin_backend_name_binding.restype = c_char_p + +dll.fig_draw_siwin_window_title_binding.argtypes = [c_char_p] +dll.fig_draw_siwin_window_title_binding.restype = c_char_p + diff --git a/bindings/generated/fig_draw.zig b/bindings/generated/fig_draw.zig index fdbc56e..4972e96 100644 --- a/bindings/generated/fig_draw.zig +++ b/bindings/generated/fig_draw.zig @@ -1,5 +1,200 @@ const std = @import("std"); +pub const FigKind = enum(u8) { + fig_kind = 0, +}; + +pub const Fig = opaque { + extern fn fig_draw_fig_unref(self: *Fig) callconv(.C) void; + pub inline fn deinit(self: *Fig) void { + return fig_draw_fig_unref(self); + } + + extern fn fig_draw_new_fig() callconv(.C) *Fig; + pub inline fn init() *Fig { + return fig_draw_new_fig(); + } + + extern fn fig_draw_fig_copy(self: *Fig) callconv(.C) *Fig; + pub inline fn copy(self: *Fig) *Fig { + return fig_draw_fig_copy(self); + } + + extern fn fig_draw_fig_kind(self: *Fig) callconv(.C) FigKind; + pub inline fn kind(self: *Fig) FigKind { + return fig_draw_fig_kind(self); + } + + extern fn fig_draw_fig_set_kind(self: *Fig, kind: FigKind) callconv(.C) void; + pub inline fn setKind(self: *Fig, kind: FigKind) void { + return fig_draw_fig_set_kind(self, kind); + } + + extern fn fig_draw_fig_z_level(self: *Fig) callconv(.C) ZLevel; + pub inline fn zLevel(self: *Fig) ZLevel { + return fig_draw_fig_z_level(self); + } + + extern fn fig_draw_fig_set_zlevel(self: *Fig, z_level: ZLevel) callconv(.C) void; + pub inline fn setZLevel(self: *Fig, z_level: ZLevel) void { + return fig_draw_fig_set_zlevel(self, z_level); + } + + extern fn fig_draw_fig_x(self: *Fig) callconv(.C) f32; + pub inline fn x(self: *Fig) f32 { + return fig_draw_fig_x(self); + } + + extern fn fig_draw_fig_y(self: *Fig) callconv(.C) f32; + pub inline fn y(self: *Fig) f32 { + return fig_draw_fig_y(self); + } + + extern fn fig_draw_fig_width(self: *Fig) callconv(.C) f32; + pub inline fn width(self: *Fig) f32 { + return fig_draw_fig_width(self); + } + + extern fn fig_draw_fig_height(self: *Fig) callconv(.C) f32; + pub inline fn height(self: *Fig) f32 { + return fig_draw_fig_height(self); + } + + extern fn fig_draw_fig_set_screen_box(self: *Fig, x: f32, y: f32, w: f32, h: f32) callconv(.C) void; + pub inline fn setScreenBox(self: *Fig, x: f32, y: f32, w: f32, h: f32) void { + return fig_draw_fig_set_screen_box(self, x, y, w, h); + } + + extern fn fig_draw_fig_set_fill_color(self: *Fig, r: u8, g: u8, b: u8, a: u8) callconv(.C) void; + pub inline fn setFillColor(self: *Fig, r: u8, g: u8, b: u8, a: u8) void { + return fig_draw_fig_set_fill_color(self, r, g, b, a); + } + + extern fn fig_draw_fig_set_rotation(self: *Fig, rotation: f32) callconv(.C) void; + pub inline fn setRotation(self: *Fig, rotation: f32) void { + return fig_draw_fig_set_rotation(self, rotation); + } +}; + +pub const RenderList = opaque { + extern fn fig_draw_render_list_unref(self: *RenderList) callconv(.C) void; + pub inline fn deinit(self: *RenderList) void { + return fig_draw_render_list_unref(self); + } + + extern fn fig_draw_new_render_list() callconv(.C) *RenderList; + pub inline fn init() *RenderList { + return fig_draw_new_render_list(); + } + + extern fn fig_draw_render_list_copy(self: *RenderList) callconv(.C) *RenderList; + pub inline fn copy(self: *RenderList) *RenderList { + return fig_draw_render_list_copy(self); + } + + extern fn fig_draw_render_list_clear(self: *RenderList) callconv(.C) void; + pub inline fn clear(self: *RenderList) void { + return fig_draw_render_list_clear(self); + } + + extern fn fig_draw_render_list_node_count(self: *RenderList) callconv(.C) isize; + pub inline fn nodeCount(self: *RenderList) isize { + return fig_draw_render_list_node_count(self); + } + + extern fn fig_draw_render_list_root_count(self: *RenderList) callconv(.C) isize; + pub inline fn rootCount(self: *RenderList) isize { + return fig_draw_render_list_root_count(self); + } + + extern fn fig_draw_render_list_add_root(self: *RenderList, root: *Fig) callconv(.C) i16; + pub inline fn addRoot(self: *RenderList, root: *Fig) i16 { + return fig_draw_render_list_add_root(self, root); + } + + extern fn fig_draw_render_list_add_child(self: *RenderList, parent_idx: i16, child: *Fig) callconv(.C) i16; + pub inline fn addChild(self: *RenderList, parent_idx: i16, child: *Fig) i16 { + return fig_draw_render_list_add_child(self, parent_idx, child); + } + + extern fn fig_draw_render_list_get_node(self: *RenderList, node_idx: i16) callconv(.C) *Fig; + pub inline fn getNode(self: *RenderList, node_idx: i16) *Fig { + return fig_draw_render_list_get_node(self, node_idx); + } + + extern fn fig_draw_render_list_get_root_id(self: *RenderList, root_idx: i16) callconv(.C) i16; + pub inline fn getRootId(self: *RenderList, root_idx: i16) i16 { + return fig_draw_render_list_get_root_id(self, root_idx); + } +}; + +pub const Renders = opaque { + extern fn fig_draw_renders_unref(self: *Renders) callconv(.C) void; + pub inline fn deinit(self: *Renders) void { + return fig_draw_renders_unref(self); + } + + extern fn fig_draw_new_renders() callconv(.C) *Renders; + pub inline fn init() *Renders { + return fig_draw_new_renders(); + } + + extern fn fig_draw_renders_clear(self: *Renders) callconv(.C) void; + pub inline fn clear(self: *Renders) void { + return fig_draw_renders_clear(self); + } + + extern fn fig_draw_renders_contains_layer(self: *Renders, z_level: ZLevel) callconv(.C) bool; + pub inline fn containsLayer(self: *Renders, z_level: ZLevel) bool { + return fig_draw_renders_contains_layer(self, z_level); + } + + extern fn fig_draw_renders_add_root(self: *Renders, z_level: ZLevel, root: *Fig) callconv(.C) i16; + pub inline fn addRoot(self: *Renders, z_level: ZLevel, root: *Fig) i16 { + return fig_draw_renders_add_root(self, z_level, root); + } + + extern fn fig_draw_renders_add_child(self: *Renders, z_level: ZLevel, parent_idx: i16, child: *Fig) callconv(.C) i16; + pub inline fn addChild(self: *Renders, z_level: ZLevel, parent_idx: i16, child: *Fig) i16 { + return fig_draw_renders_add_child(self, z_level, parent_idx, child); + } + + extern fn fig_draw_renders_layer_node_count(self: *Renders, z_level: ZLevel) callconv(.C) isize; + pub inline fn layerNodeCount(self: *Renders, z_level: ZLevel) isize { + return fig_draw_renders_layer_node_count(self, z_level); + } + + extern fn fig_draw_renders_layer_root_count(self: *Renders, z_level: ZLevel) callconv(.C) isize; + pub inline fn layerRootCount(self: *Renders, z_level: ZLevel) isize { + return fig_draw_renders_layer_root_count(self, z_level); + } + + extern fn fig_draw_renders_get_layer_node(self: *Renders, z_level: ZLevel, node_idx: i16) callconv(.C) *Fig; + pub inline fn getLayerNode(self: *Renders, z_level: ZLevel, node_idx: i16) *Fig { + return fig_draw_renders_get_layer_node(self, z_level, node_idx); + } +}; + +extern fn fig_draw_new_rectangle_fig(x: f32, y: f32, w: f32, h: f32) callconv(.C) *Fig; +pub inline fn newRectangleFig(x: f32, y: f32, w: f32, h: f32) *Fig { + return fig_draw_new_rectangle_fig(x, y, w, h); +} + +extern fn fig_draw_new_text_fig(x: f32, y: f32, w: f32, h: f32) callconv(.C) *Fig; +pub inline fn newTextFig(x: f32, y: f32, w: f32, h: f32) *Fig { + return fig_draw_new_text_fig(x, y, w, h); +} + +extern fn fig_draw_new_image_fig(x: f32, y: f32, w: f32, h: f32, image_id: i63) callconv(.C) *Fig; +pub inline fn newImageFig(x: f32, y: f32, w: f32, h: f32, image_id: i63) *Fig { + return fig_draw_new_image_fig(x, y, w, h, image_id); +} + +extern fn fig_draw_new_transform_fig(x: f32, y: f32, w: f32, h: f32, tx: f32, ty: f32) callconv(.C) *Fig; +pub inline fn newTransformFig(x: f32, y: f32, w: f32, h: f32, tx: f32, ty: f32) *Fig { + return fig_draw_new_transform_fig(x, y, w, h, tx, ty); +} + extern fn fig_draw_fig_data_dir() callconv(.C) [*:0]const u8; pub inline fn figDataDir() [:0]const u8 { return std.mem.span(fig_draw_fig_data_dir()); @@ -30,3 +225,13 @@ pub inline fn descaled(a: f32) f32 { return fig_draw_descaled(a); } +extern fn fig_draw_siwin_backend_name_binding() callconv(.C) [*:0]const u8; +pub inline fn siwinBackendNameBinding() [:0]const u8 { + return std.mem.span(fig_draw_siwin_backend_name_binding()); +} + +extern fn fig_draw_siwin_window_title_binding(suffix: [*:0]const u8) callconv(.C) [*:0]const u8; +pub inline fn siwinWindowTitleBinding(suffix: [:0]const u8) [:0]const u8 { + return std.mem.span(fig_draw_siwin_window_title_binding(suffix.ptr)); +} + diff --git a/bindings/generated/internal.nim b/bindings/generated/internal.nim index e112faa..f19ff66 100644 --- a/bindings/generated/internal.nim +++ b/bindings/generated/internal.nim @@ -3,6 +3,117 @@ when not defined(gcArc) and not defined(gcOrc): when (NimMajor, NimMinor, NimPatch) == (1, 6, 2): {.error: "Nim 1.6.2 not supported with Genny due to FFI issues.".} +proc fig_draw_fig_unref*(x: Fig) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_new_fig*(): Fig {.raises: [], cdecl, exportc, dynlib.} = + newFig() + +proc fig_draw_fig_copy*(fig: Fig): Fig {.raises: [], cdecl, exportc, dynlib.} = + copy(fig) + +proc fig_draw_fig_kind*(fig: Fig): FigKind {.raises: [], cdecl, exportc, dynlib.} = + kind(fig) + +proc fig_draw_fig_set_kind*(fig: Fig, kind: FigKind) {.raises: [], cdecl, exportc, dynlib.} = + setKind(fig, kind) + +proc fig_draw_fig_z_level*(fig: Fig): ZLevel {.raises: [], cdecl, exportc, dynlib.} = + zLevel(fig) + +proc fig_draw_fig_set_zlevel*(fig: Fig, z_level: ZLevel) {.raises: [], cdecl, exportc, dynlib.} = + setZLevel(fig, z_level) + +proc fig_draw_fig_x*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = + x(fig) + +proc fig_draw_fig_y*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = + y(fig) + +proc fig_draw_fig_width*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = + width(fig) + +proc fig_draw_fig_height*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = + height(fig) + +proc fig_draw_fig_set_screen_box*(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.raises: [], cdecl, exportc, dynlib.} = + setScreenBox(fig, x, y, w, h) + +proc fig_draw_fig_set_fill_color*(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.raises: [], cdecl, exportc, dynlib.} = + setFillColor(fig, r, g, b, a) + +proc fig_draw_fig_set_rotation*(fig: Fig, rotation: float32) {.raises: [], cdecl, exportc, dynlib.} = + setRotation(fig, rotation) + +proc fig_draw_render_list_unref*(x: RenderList) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_new_render_list*(): RenderList {.raises: [], cdecl, exportc, dynlib.} = + newRenderList() + +proc fig_draw_render_list_copy*(list: RenderList): RenderList {.raises: [], cdecl, exportc, dynlib.} = + copy(list) + +proc fig_draw_render_list_clear*(list: RenderList) {.raises: [], cdecl, exportc, dynlib.} = + clear(list) + +proc fig_draw_render_list_node_count*(list: RenderList): int {.raises: [], cdecl, exportc, dynlib.} = + nodeCount(list) + +proc fig_draw_render_list_root_count*(list: RenderList): int {.raises: [], cdecl, exportc, dynlib.} = + rootCount(list) + +proc fig_draw_render_list_add_root*(list: RenderList, root: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = + addRoot(list, root) + +proc fig_draw_render_list_add_child*(list: RenderList, parent_idx: int16, child: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = + addChild(list, parent_idx, child) + +proc fig_draw_render_list_get_node*(list: RenderList, node_idx: int16): Fig {.raises: [], cdecl, exportc, dynlib.} = + getNode(list, node_idx) + +proc fig_draw_render_list_get_root_id*(list: RenderList, root_idx: int16): int16 {.raises: [], cdecl, exportc, dynlib.} = + getRootId(list, root_idx) + +proc fig_draw_renders_unref*(x: Renders) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_new_renders*(): Renders {.raises: [], cdecl, exportc, dynlib.} = + newRenders() + +proc fig_draw_renders_clear*(renders: Renders) {.raises: [], cdecl, exportc, dynlib.} = + clear(renders) + +proc fig_draw_renders_contains_layer*(renders: Renders, z_level: ZLevel): bool {.raises: [], cdecl, exportc, dynlib.} = + containsLayer(renders, z_level) + +proc fig_draw_renders_add_root*(renders: Renders, z_level: ZLevel, root: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = + addRoot(renders, z_level, root) + +proc fig_draw_renders_add_child*(renders: Renders, z_level: ZLevel, parent_idx: int16, child: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = + addChild(renders, z_level, parent_idx, child) + +proc fig_draw_renders_layer_node_count*(renders: Renders, z_level: ZLevel): int {.raises: [], cdecl, exportc, dynlib.} = + layerNodeCount(renders, z_level) + +proc fig_draw_renders_layer_root_count*(renders: Renders, z_level: ZLevel): int {.raises: [], cdecl, exportc, dynlib.} = + layerRootCount(renders, z_level) + +proc fig_draw_renders_get_layer_node*(renders: Renders, z_level: ZLevel, node_idx: int16): Fig {.raises: [], cdecl, exportc, dynlib.} = + getLayerNode(renders, z_level, node_idx) + +proc fig_draw_new_rectangle_fig*(x: float32, y: float32, w: float32, h: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = + newRectangleFig(x, y, w, h) + +proc fig_draw_new_text_fig*(x: float32, y: float32, w: float32, h: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = + newTextFig(x, y, w, h) + +proc fig_draw_new_image_fig*(x: float32, y: float32, w: float32, h: float32, image_id: int64): Fig {.raises: [], cdecl, exportc, dynlib.} = + newImageFig(x, y, w, h, image_id) + +proc fig_draw_new_transform_fig*(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = + newTransformFig(x, y, w, h, tx, ty) + proc fig_draw_fig_data_dir*(): cstring {.raises: [], cdecl, exportc, dynlib.} = figDataDir().cstring @@ -21,3 +132,9 @@ proc fig_draw_scaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib. proc fig_draw_descaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = descaled(a) +proc fig_draw_siwin_backend_name_binding*(): cstring {.raises: [], cdecl, exportc, dynlib.} = + siwinBackendNameBinding().cstring + +proc fig_draw_siwin_window_title_binding*(suffix: cstring): cstring {.raises: [], cdecl, exportc, dynlib.} = + siwinWindowTitleBinding(suffix.`$`).cstring + diff --git a/config.nims b/config.nims index 5575327..1f5abf5 100644 --- a/config.nims +++ b/config.nims @@ -61,8 +61,14 @@ task test_emscripten, "build emscripten examples": nimExec("c", file, "-d:emscripten") task bindings, "Generate bindings": + let includeSiwinShim = + getEnv("FIGDRAW_BINDINGS_SIWINSHIM").strip().toLowerAscii() in + ["1", "true", "yes", "on"] + let siwinShimFlag = if includeSiwinShim: " -d:figdraw.bindings.siwinshim" else: "" + proc compile(libName: string, flags = "") = exec "nim c -f " & flags & + siwinShimFlag & " --path:src -d:release --app:lib --gc:arc --tlsEmulation:off --out:" & libName & " --outdir:bindings/generated bindings/bindings.nim" From aea23fd8fe6774567d764a18ac14e8ac39d9f6c8 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:15:37 -0600 Subject: [PATCH 4/9] add bindings --- bindings/bindings.nim | 14 +- bindings/generated/fig_draw.h | 62 +++++++ bindings/generated/fig_draw.hpp | 250 +++++++++++++++++++++++++ bindings/generated/fig_draw.js | 184 +++++++++++++++++++ bindings/generated/fig_draw.nim | 155 ++++++++++++++++ bindings/generated/fig_draw.py | 210 +++++++++++++++++++++ bindings/generated/fig_draw.zig | 146 +++++++++++++++ bindings/generated/internal.nim | 84 +++++++++ bindings/siwinshim_bindings.nim | 315 ++++++++++++++++++++++++++++++++ 9 files changed, 1407 insertions(+), 13 deletions(-) create mode 100644 bindings/siwinshim_bindings.nim diff --git a/bindings/bindings.nim b/bindings/bindings.nim index 3a90c43..ab0a494 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -6,9 +6,6 @@ import figdraw/fignodes as fdn const ExportSiwinShim* {.booldefine: "figdraw.bindings.siwinshim".} = false -when ExportSiwinShim: - import figdraw/windowing/siwinshim - type FigKind* = fdn.FigKind ZLevel* = int8 @@ -70,13 +67,6 @@ proc newTransformFig(x, y, w, h: float32, tx, ty: float32): Fig = ), ) -when ExportSiwinShim: - proc siwinBackendNameBinding(): string = - siwinBackendName() - - proc siwinWindowTitleBinding(suffix: string): string = - siwinWindowTitle(suffix = suffix) - proc copy(fig: Fig): Fig = Fig(inner: fig.inner) @@ -259,9 +249,7 @@ exportProcs: descaled(float32) when ExportSiwinShim: - exportProcs: - siwinBackendNameBinding - siwinWindowTitleBinding + include siwinshim_bindings writeFiles("bindings/generated", "FigDraw") diff --git a/bindings/generated/fig_draw.h b/bindings/generated/fig_draw.h index 9e597f2..7d97b51 100644 --- a/bindings/generated/fig_draw.h +++ b/bindings/generated/fig_draw.h @@ -10,6 +10,12 @@ typedef long long RenderList; typedef long long Renders; +typedef long long SiwinWindowRef; + +typedef long long SiwinRendererRef; + +typedef long long SiwinMetalLayerRef; + void fig_draw_fig_unref(Fig fig); Fig fig_draw_new_fig(); @@ -96,8 +102,64 @@ float fig_draw_scaled(float a); float fig_draw_descaled(float a); +void fig_draw_siwin_window_ref_unref(SiwinWindowRef siwin_window_ref); + +void fig_draw_siwin_window_ref_close_window_binding(SiwinWindowRef window); + +void fig_draw_siwin_window_ref_step_window_binding(SiwinWindowRef window); + +void fig_draw_siwin_window_ref_make_current_window_binding(SiwinWindowRef window); + +char fig_draw_siwin_window_ref_window_is_open_binding(SiwinWindowRef window); + +char* fig_draw_siwin_window_ref_siwin_display_server_name_binding(SiwinWindowRef window); + +int fig_draw_siwin_window_ref_backing_width_binding(SiwinWindowRef window); + +int fig_draw_siwin_window_ref_backing_height_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_logical_width_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_logical_height_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_content_scale_binding(SiwinWindowRef window); + +char fig_draw_siwin_window_ref_configure_ui_scale_binding(SiwinWindowRef window, char* env_var); + +void fig_draw_siwin_window_ref_refresh_ui_scale_binding(SiwinWindowRef window, char auto_scale); + +void fig_draw_siwin_window_ref_present_now_binding(SiwinWindowRef window); + +void fig_draw_siwin_renderer_ref_unref(SiwinRendererRef siwin_renderer_ref); + +char* fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(SiwinRendererRef renderer); + +char* fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(SiwinRendererRef renderer, SiwinWindowRef window, char* suffix); + +void fig_draw_siwin_renderer_ref_setup_backend_binding(SiwinRendererRef renderer, SiwinWindowRef window); + +void fig_draw_siwin_renderer_ref_begin_frame_binding(SiwinRendererRef renderer); + +void fig_draw_siwin_renderer_ref_end_frame_binding(SiwinRendererRef renderer); + +void fig_draw_siwin_metal_layer_ref_unref(SiwinMetalLayerRef siwin_metal_layer_ref); + +void fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(SiwinMetalLayerRef layer, SiwinWindowRef window); + +void fig_draw_siwin_metal_layer_ref_set_opaque_binding(SiwinMetalLayerRef layer, char opaque); + char* fig_draw_siwin_backend_name_binding(); char* fig_draw_siwin_window_title_binding(char* suffix); +unsigned long long fig_draw_shared_siwin_globals_ptr_binding(); + +SiwinRendererRef fig_draw_new_siwin_renderer_binding(long long atlas_size, float pixel_scale); + +SiwinWindowRef fig_draw_new_siwin_window_binding(int width, int height, char fullscreen, char* title, char vsync, int msaa, char resizable, char frameless, char transparent); + +SiwinWindowRef fig_draw_new_siwin_window_for_renderer_binding(SiwinRendererRef renderer, int width, int height, char fullscreen, char* title, char vsync, int msaa, char resizable, char frameless, char transparent); + +SiwinMetalLayerRef fig_draw_attach_metal_layer_binding(SiwinWindowRef window, unsigned long long device_ptr); + #endif diff --git a/bindings/generated/fig_draw.hpp b/bindings/generated/fig_draw.hpp index 3b44f75..1403ada 100644 --- a/bindings/generated/fig_draw.hpp +++ b/bindings/generated/fig_draw.hpp @@ -12,6 +12,12 @@ struct RenderList; struct Renders; +struct SiwinWindowRef; + +struct SiwinRendererRef; + +struct SiwinMetalLayerRef; + struct Fig { private: @@ -108,6 +114,82 @@ struct Renders { }; +struct SiwinWindowRef { + + private: + + uint64_t reference; + + public: + + void free(); + + void closeWindowBinding(); + + void stepWindowBinding(); + + void makeCurrentWindowBinding(); + + bool windowIsOpenBinding(); + + const char* siwinDisplayServerNameBinding(); + + int32_t backingWidthBinding(); + + int32_t backingHeightBinding(); + + float logicalWidthBinding(); + + float logicalHeightBinding(); + + float contentScaleBinding(); + + bool configureUiScaleBinding(const char* envVar); + + void refreshUiScaleBinding(bool autoScale); + + void presentNowBinding(); + +}; + +struct SiwinRendererRef { + + private: + + uint64_t reference; + + public: + + void free(); + + const char* siwinBackendNameForRendererBinding(); + + const char* siwinWindowTitleForRendererBinding(SiwinWindowRef window, const char* suffix); + + void setupBackendBinding(SiwinWindowRef window); + + void beginFrameBinding(); + + void endFrameBinding(); + +}; + +struct SiwinMetalLayerRef { + + private: + + uint64_t reference; + + public: + + void free(); + + void updateMetalLayerBinding(SiwinWindowRef window); + + void setOpaqueBinding(bool opaque); + +}; + extern "C" { void fig_draw_fig_unref(Fig fig); @@ -196,10 +278,66 @@ float fig_draw_scaled(float a); float fig_draw_descaled(float a); +void fig_draw_siwin_window_ref_unref(SiwinWindowRef siwin_window_ref); + +void fig_draw_siwin_window_ref_close_window_binding(SiwinWindowRef window); + +void fig_draw_siwin_window_ref_step_window_binding(SiwinWindowRef window); + +void fig_draw_siwin_window_ref_make_current_window_binding(SiwinWindowRef window); + +bool fig_draw_siwin_window_ref_window_is_open_binding(SiwinWindowRef window); + +const char* fig_draw_siwin_window_ref_siwin_display_server_name_binding(SiwinWindowRef window); + +int32_t fig_draw_siwin_window_ref_backing_width_binding(SiwinWindowRef window); + +int32_t fig_draw_siwin_window_ref_backing_height_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_logical_width_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_logical_height_binding(SiwinWindowRef window); + +float fig_draw_siwin_window_ref_content_scale_binding(SiwinWindowRef window); + +bool fig_draw_siwin_window_ref_configure_ui_scale_binding(SiwinWindowRef window, const char* env_var); + +void fig_draw_siwin_window_ref_refresh_ui_scale_binding(SiwinWindowRef window, bool auto_scale); + +void fig_draw_siwin_window_ref_present_now_binding(SiwinWindowRef window); + +void fig_draw_siwin_renderer_ref_unref(SiwinRendererRef siwin_renderer_ref); + +const char* fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(SiwinRendererRef renderer); + +const char* fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(SiwinRendererRef renderer, SiwinWindowRef window, const char* suffix); + +void fig_draw_siwin_renderer_ref_setup_backend_binding(SiwinRendererRef renderer, SiwinWindowRef window); + +void fig_draw_siwin_renderer_ref_begin_frame_binding(SiwinRendererRef renderer); + +void fig_draw_siwin_renderer_ref_end_frame_binding(SiwinRendererRef renderer); + +void fig_draw_siwin_metal_layer_ref_unref(SiwinMetalLayerRef siwin_metal_layer_ref); + +void fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(SiwinMetalLayerRef layer, SiwinWindowRef window); + +void fig_draw_siwin_metal_layer_ref_set_opaque_binding(SiwinMetalLayerRef layer, bool opaque); + const char* fig_draw_siwin_backend_name_binding(); const char* fig_draw_siwin_window_title_binding(const char* suffix); +uint64_t fig_draw_shared_siwin_globals_ptr_binding(); + +SiwinRendererRef fig_draw_new_siwin_renderer_binding(int64_t atlas_size, float pixel_scale); + +SiwinWindowRef fig_draw_new_siwin_window_binding(int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent); + +SiwinWindowRef fig_draw_new_siwin_window_for_renderer_binding(SiwinRendererRef renderer, int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent); + +SiwinMetalLayerRef fig_draw_attach_metal_layer_binding(SiwinWindowRef window, uint64_t device_ptr); + } Fig::Fig() { @@ -374,6 +512,98 @@ float descaled(float a) { return fig_draw_descaled(a); }; +void SiwinWindowRef::free(){ + fig_draw_siwin_window_ref_unref(*this); +} + +void SiwinWindowRef::closeWindowBinding() { + fig_draw_siwin_window_ref_close_window_binding(*this); +}; + +void SiwinWindowRef::stepWindowBinding() { + fig_draw_siwin_window_ref_step_window_binding(*this); +}; + +void SiwinWindowRef::makeCurrentWindowBinding() { + fig_draw_siwin_window_ref_make_current_window_binding(*this); +}; + +bool SiwinWindowRef::windowIsOpenBinding() { + return fig_draw_siwin_window_ref_window_is_open_binding(*this); +}; + +const char* SiwinWindowRef::siwinDisplayServerNameBinding() { + return fig_draw_siwin_window_ref_siwin_display_server_name_binding(*this); +}; + +int32_t SiwinWindowRef::backingWidthBinding() { + return fig_draw_siwin_window_ref_backing_width_binding(*this); +}; + +int32_t SiwinWindowRef::backingHeightBinding() { + return fig_draw_siwin_window_ref_backing_height_binding(*this); +}; + +float SiwinWindowRef::logicalWidthBinding() { + return fig_draw_siwin_window_ref_logical_width_binding(*this); +}; + +float SiwinWindowRef::logicalHeightBinding() { + return fig_draw_siwin_window_ref_logical_height_binding(*this); +}; + +float SiwinWindowRef::contentScaleBinding() { + return fig_draw_siwin_window_ref_content_scale_binding(*this); +}; + +bool SiwinWindowRef::configureUiScaleBinding(const char* envVar) { + return fig_draw_siwin_window_ref_configure_ui_scale_binding(*this, envVar); +}; + +void SiwinWindowRef::refreshUiScaleBinding(bool autoScale) { + fig_draw_siwin_window_ref_refresh_ui_scale_binding(*this, autoScale); +}; + +void SiwinWindowRef::presentNowBinding() { + fig_draw_siwin_window_ref_present_now_binding(*this); +}; + +void SiwinRendererRef::free(){ + fig_draw_siwin_renderer_ref_unref(*this); +} + +const char* SiwinRendererRef::siwinBackendNameForRendererBinding() { + return fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(*this); +}; + +const char* SiwinRendererRef::siwinWindowTitleForRendererBinding(SiwinWindowRef window, const char* suffix) { + return fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(*this, window, suffix); +}; + +void SiwinRendererRef::setupBackendBinding(SiwinWindowRef window) { + fig_draw_siwin_renderer_ref_setup_backend_binding(*this, window); +}; + +void SiwinRendererRef::beginFrameBinding() { + fig_draw_siwin_renderer_ref_begin_frame_binding(*this); +}; + +void SiwinRendererRef::endFrameBinding() { + fig_draw_siwin_renderer_ref_end_frame_binding(*this); +}; + +void SiwinMetalLayerRef::free(){ + fig_draw_siwin_metal_layer_ref_unref(*this); +} + +void SiwinMetalLayerRef::updateMetalLayerBinding(SiwinWindowRef window) { + fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(*this, window); +}; + +void SiwinMetalLayerRef::setOpaqueBinding(bool opaque) { + fig_draw_siwin_metal_layer_ref_set_opaque_binding(*this, opaque); +}; + const char* siwinBackendNameBinding() { return fig_draw_siwin_backend_name_binding(); }; @@ -382,4 +612,24 @@ const char* siwinWindowTitleBinding(const char* suffix) { return fig_draw_siwin_window_title_binding(suffix); }; +uint64_t sharedSiwinGlobalsPtrBinding() { + return fig_draw_shared_siwin_globals_ptr_binding(); +}; + +SiwinRendererRef newSiwinRendererBinding(int64_t atlasSize, float pixelScale) { + return fig_draw_new_siwin_renderer_binding(atlasSize, pixelScale); +}; + +SiwinWindowRef newSiwinWindowBinding(int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent) { + return fig_draw_new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent); +}; + +SiwinWindowRef newSiwinWindowForRendererBinding(SiwinRendererRef renderer, int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent) { + return fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent); +}; + +SiwinMetalLayerRef attachMetalLayerBinding(SiwinWindowRef window, uint64_t devicePtr) { + return fig_draw_attach_metal_layer_binding(window, devicePtr); +}; + #endif diff --git a/bindings/generated/fig_draw.js b/bindings/generated/fig_draw.js index fc9b479..9c01429 100644 --- a/bindings/generated/fig_draw.js +++ b/bindings/generated/fig_draw.js @@ -247,6 +247,129 @@ function descaled(a){ return result } +SiwinWindowRef = Struct({'nimRef': 'uint64'}); +SiwinWindowRef.prototype.isNull = function(){ + return this.nimRef == 0; +}; +SiwinWindowRef.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +SiwinWindowRef.prototype.unref = function(){ + return dll.fig_draw_siwin_window_ref_unref(this) +}; + +SiwinWindowRef.prototype.closeWindowBinding = function(){ + dll.fig_draw_siwin_window_ref_close_window_binding(this) +} + +SiwinWindowRef.prototype.stepWindowBinding = function(){ + dll.fig_draw_siwin_window_ref_step_window_binding(this) +} + +SiwinWindowRef.prototype.makeCurrentWindowBinding = function(){ + dll.fig_draw_siwin_window_ref_make_current_window_binding(this) +} + +SiwinWindowRef.prototype.windowIsOpenBinding = function(){ + result = dll.fig_draw_siwin_window_ref_window_is_open_binding(this) + return result +} + +SiwinWindowRef.prototype.siwinDisplayServerNameBinding = function(){ + result = dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding(this) + return result +} + +SiwinWindowRef.prototype.backingWidthBinding = function(){ + result = dll.fig_draw_siwin_window_ref_backing_width_binding(this) + return result +} + +SiwinWindowRef.prototype.backingHeightBinding = function(){ + result = dll.fig_draw_siwin_window_ref_backing_height_binding(this) + return result +} + +SiwinWindowRef.prototype.logicalWidthBinding = function(){ + result = dll.fig_draw_siwin_window_ref_logical_width_binding(this) + return result +} + +SiwinWindowRef.prototype.logicalHeightBinding = function(){ + result = dll.fig_draw_siwin_window_ref_logical_height_binding(this) + return result +} + +SiwinWindowRef.prototype.contentScaleBinding = function(){ + result = dll.fig_draw_siwin_window_ref_content_scale_binding(this) + return result +} + +SiwinWindowRef.prototype.configureUiScaleBinding = function(env_var){ + result = dll.fig_draw_siwin_window_ref_configure_ui_scale_binding(this, env_var) + return result +} + +SiwinWindowRef.prototype.refreshUiScaleBinding = function(auto_scale){ + dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding(this, auto_scale) +} + +SiwinWindowRef.prototype.presentNowBinding = function(){ + dll.fig_draw_siwin_window_ref_present_now_binding(this) +} + +SiwinRendererRef = Struct({'nimRef': 'uint64'}); +SiwinRendererRef.prototype.isNull = function(){ + return this.nimRef == 0; +}; +SiwinRendererRef.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +SiwinRendererRef.prototype.unref = function(){ + return dll.fig_draw_siwin_renderer_ref_unref(this) +}; + +SiwinRendererRef.prototype.siwinBackendNameForRendererBinding = function(){ + result = dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(this) + return result +} + +SiwinRendererRef.prototype.siwinWindowTitleForRendererBinding = function(window, suffix){ + result = dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(this, window, suffix) + return result +} + +SiwinRendererRef.prototype.setupBackendBinding = function(window){ + dll.fig_draw_siwin_renderer_ref_setup_backend_binding(this, window) +} + +SiwinRendererRef.prototype.beginFrameBinding = function(){ + dll.fig_draw_siwin_renderer_ref_begin_frame_binding(this) +} + +SiwinRendererRef.prototype.endFrameBinding = function(){ + dll.fig_draw_siwin_renderer_ref_end_frame_binding(this) +} + +SiwinMetalLayerRef = Struct({'nimRef': 'uint64'}); +SiwinMetalLayerRef.prototype.isNull = function(){ + return this.nimRef == 0; +}; +SiwinMetalLayerRef.prototype.isEqual = function(other){ + return this.nimRef == other.nimRef; +}; +SiwinMetalLayerRef.prototype.unref = function(){ + return dll.fig_draw_siwin_metal_layer_ref_unref(this) +}; + +SiwinMetalLayerRef.prototype.updateMetalLayerBinding = function(window){ + dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(this, window) +} + +SiwinMetalLayerRef.prototype.setOpaqueBinding = function(opaque){ + dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding(this, opaque) +} + function siwinBackendNameBinding(){ result = dll.fig_draw_siwin_backend_name_binding() return result @@ -257,6 +380,31 @@ function siwinWindowTitleBinding(suffix){ return result } +function sharedSiwinGlobalsPtrBinding(){ + result = dll.fig_draw_shared_siwin_globals_ptr_binding() + return result +} + +function newSiwinRendererBinding(atlas_size, pixel_scale){ + result = dll.fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale) + return result +} + +function newSiwinWindowBinding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent){ + result = dll.fig_draw_new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent) + return result +} + +function newSiwinWindowForRendererBinding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent){ + result = dll.fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent) + return result +} + +function attachMetalLayerBinding(window, device_ptr){ + result = dll.fig_draw_attach_metal_layer_binding(window, device_ptr) + return result +} + var dllPath = "" if(process.platform == "win32") { @@ -311,8 +459,36 @@ dll = ffi.Library(dllPath, { 'fig_draw_set_fig_ui_scale': ['void', ['float']], 'fig_draw_scaled': ['float', ['float']], 'fig_draw_descaled': ['float', ['float']], + 'fig_draw_siwin_window_ref_unref': ['void', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_close_window_binding': ['void', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_step_window_binding': ['void', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_make_current_window_binding': ['void', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_window_is_open_binding': ['bool', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_siwin_display_server_name_binding': ['string', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_backing_width_binding': ['int32', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_backing_height_binding': ['int32', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_logical_width_binding': ['float', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_logical_height_binding': ['float', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_content_scale_binding': ['float', [SiwinWindowRef]], + 'fig_draw_siwin_window_ref_configure_ui_scale_binding': ['bool', [SiwinWindowRef, 'string']], + 'fig_draw_siwin_window_ref_refresh_ui_scale_binding': ['void', [SiwinWindowRef, 'bool']], + 'fig_draw_siwin_window_ref_present_now_binding': ['void', [SiwinWindowRef]], + 'fig_draw_siwin_renderer_ref_unref': ['void', [SiwinRendererRef]], + 'fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding': ['string', [SiwinRendererRef]], + 'fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding': ['string', [SiwinRendererRef, SiwinWindowRef, 'string']], + 'fig_draw_siwin_renderer_ref_setup_backend_binding': ['void', [SiwinRendererRef, SiwinWindowRef]], + 'fig_draw_siwin_renderer_ref_begin_frame_binding': ['void', [SiwinRendererRef]], + 'fig_draw_siwin_renderer_ref_end_frame_binding': ['void', [SiwinRendererRef]], + 'fig_draw_siwin_metal_layer_ref_unref': ['void', [SiwinMetalLayerRef]], + 'fig_draw_siwin_metal_layer_ref_update_metal_layer_binding': ['void', [SiwinMetalLayerRef, SiwinWindowRef]], + 'fig_draw_siwin_metal_layer_ref_set_opaque_binding': ['void', [SiwinMetalLayerRef, 'bool']], 'fig_draw_siwin_backend_name_binding': ['string', []], 'fig_draw_siwin_window_title_binding': ['string', ['string']], + 'fig_draw_shared_siwin_globals_ptr_binding': ['uint64', []], + 'fig_draw_new_siwin_renderer_binding': [SiwinRendererRef, ['int64', 'float']], + 'fig_draw_new_siwin_window_binding': [SiwinWindowRef, ['int32', 'int32', 'bool', 'string', 'bool', 'int32', 'bool', 'bool', 'bool']], + 'fig_draw_new_siwin_window_for_renderer_binding': [SiwinWindowRef, [SiwinRendererRef, 'int32', 'int32', 'bool', 'string', 'bool', 'int32', 'bool', 'bool', 'bool']], + 'fig_draw_attach_metal_layer_binding': [SiwinMetalLayerRef, [SiwinWindowRef, 'uint64']], }); exports.FigKind = FigKind @@ -333,5 +509,13 @@ exports.figUiScale = figUiScale exports.setFigUiScale = setFigUiScale exports.scaled = scaled exports.descaled = descaled +exports.SiwinWindowRefType = SiwinWindowRef +exports.SiwinRendererRefType = SiwinRendererRef +exports.SiwinMetalLayerRefType = SiwinMetalLayerRef exports.siwinBackendNameBinding = siwinBackendNameBinding exports.siwinWindowTitleBinding = siwinWindowTitleBinding +exports.sharedSiwinGlobalsPtrBinding = sharedSiwinGlobalsPtrBinding +exports.newSiwinRendererBinding = newSiwinRendererBinding +exports.newSiwinWindowBinding = newSiwinWindowBinding +exports.newSiwinWindowForRendererBinding = newSiwinWindowForRendererBinding +exports.attachMetalLayerBinding = attachMetalLayerBinding diff --git a/bindings/generated/fig_draw.nim b/bindings/generated/fig_draw.nim index e13151b..936fb02 100644 --- a/bindings/generated/fig_draw.nim +++ b/bindings/generated/fig_draw.nim @@ -46,6 +46,36 @@ proc fig_draw_renders_unref(x: RendersObj) {.importc: "fig_draw_renders_unref", proc `=destroy`(x: var RendersObj) = fig_draw_renders_unref(x) +type SiwinWindowRefObj = object + reference: pointer + +type SiwinWindowRef* = ref SiwinWindowRefObj + +proc fig_draw_siwin_window_ref_unref(x: SiwinWindowRefObj) {.importc: "fig_draw_siwin_window_ref_unref", cdecl.} + +proc `=destroy`(x: var SiwinWindowRefObj) = + fig_draw_siwin_window_ref_unref(x) + +type SiwinRendererRefObj = object + reference: pointer + +type SiwinRendererRef* = ref SiwinRendererRefObj + +proc fig_draw_siwin_renderer_ref_unref(x: SiwinRendererRefObj) {.importc: "fig_draw_siwin_renderer_ref_unref", cdecl.} + +proc `=destroy`(x: var SiwinRendererRefObj) = + fig_draw_siwin_renderer_ref_unref(x) + +type SiwinMetalLayerRefObj = object + reference: pointer + +type SiwinMetalLayerRef* = ref SiwinMetalLayerRefObj + +proc fig_draw_siwin_metal_layer_ref_unref(x: SiwinMetalLayerRefObj) {.importc: "fig_draw_siwin_metal_layer_ref_unref", cdecl.} + +proc `=destroy`(x: var SiwinMetalLayerRefObj) = + fig_draw_siwin_metal_layer_ref_unref(x) + proc fig_draw_new_fig(): Fig {.importc: "fig_draw_new_fig", cdecl.} proc newFig*(): Fig {.inline.} = @@ -246,6 +276,106 @@ proc fig_draw_descaled(a: float32): float32 {.importc: "fig_draw_descaled", cdec proc descaled*(a: float32): float32 {.inline.} = result = fig_draw_descaled(a) +proc fig_draw_siwin_window_ref_close_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_close_window_binding", cdecl.} + +proc closeWindowBinding*(window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_window_ref_close_window_binding(window) + +proc fig_draw_siwin_window_ref_step_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_step_window_binding", cdecl.} + +proc stepWindowBinding*(window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_window_ref_step_window_binding(window) + +proc fig_draw_siwin_window_ref_make_current_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_make_current_window_binding", cdecl.} + +proc makeCurrentWindowBinding*(window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_window_ref_make_current_window_binding(window) + +proc fig_draw_siwin_window_ref_window_is_open_binding(window: SiwinWindowRef): bool {.importc: "fig_draw_siwin_window_ref_window_is_open_binding", cdecl.} + +proc windowIsOpenBinding*(window: SiwinWindowRef): bool {.inline.} = + result = fig_draw_siwin_window_ref_window_is_open_binding(window) + +proc fig_draw_siwin_window_ref_siwin_display_server_name_binding(window: SiwinWindowRef): cstring {.importc: "fig_draw_siwin_window_ref_siwin_display_server_name_binding", cdecl.} + +proc siwinDisplayServerNameBinding*(window: SiwinWindowRef): cstring {.inline.} = + result = fig_draw_siwin_window_ref_siwin_display_server_name_binding(window) + +proc fig_draw_siwin_window_ref_backing_width_binding(window: SiwinWindowRef): int32 {.importc: "fig_draw_siwin_window_ref_backing_width_binding", cdecl.} + +proc backingWidthBinding*(window: SiwinWindowRef): int32 {.inline.} = + result = fig_draw_siwin_window_ref_backing_width_binding(window) + +proc fig_draw_siwin_window_ref_backing_height_binding(window: SiwinWindowRef): int32 {.importc: "fig_draw_siwin_window_ref_backing_height_binding", cdecl.} + +proc backingHeightBinding*(window: SiwinWindowRef): int32 {.inline.} = + result = fig_draw_siwin_window_ref_backing_height_binding(window) + +proc fig_draw_siwin_window_ref_logical_width_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_logical_width_binding", cdecl.} + +proc logicalWidthBinding*(window: SiwinWindowRef): float32 {.inline.} = + result = fig_draw_siwin_window_ref_logical_width_binding(window) + +proc fig_draw_siwin_window_ref_logical_height_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_logical_height_binding", cdecl.} + +proc logicalHeightBinding*(window: SiwinWindowRef): float32 {.inline.} = + result = fig_draw_siwin_window_ref_logical_height_binding(window) + +proc fig_draw_siwin_window_ref_content_scale_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_content_scale_binding", cdecl.} + +proc contentScaleBinding*(window: SiwinWindowRef): float32 {.inline.} = + result = fig_draw_siwin_window_ref_content_scale_binding(window) + +proc fig_draw_siwin_window_ref_configure_ui_scale_binding(window: SiwinWindowRef, env_var: cstring): bool {.importc: "fig_draw_siwin_window_ref_configure_ui_scale_binding", cdecl.} + +proc configureUiScaleBinding*(window: SiwinWindowRef, envVar: string): bool {.inline.} = + result = fig_draw_siwin_window_ref_configure_ui_scale_binding(window, envVar.cstring) + +proc fig_draw_siwin_window_ref_refresh_ui_scale_binding(window: SiwinWindowRef, auto_scale: bool) {.importc: "fig_draw_siwin_window_ref_refresh_ui_scale_binding", cdecl.} + +proc refreshUiScaleBinding*(window: SiwinWindowRef, autoScale: bool) {.inline.} = + fig_draw_siwin_window_ref_refresh_ui_scale_binding(window, autoScale) + +proc fig_draw_siwin_window_ref_present_now_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_present_now_binding", cdecl.} + +proc presentNowBinding*(window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_window_ref_present_now_binding(window) + +proc fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(renderer: SiwinRendererRef): cstring {.importc: "fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding", cdecl.} + +proc siwinBackendNameForRendererBinding*(renderer: SiwinRendererRef): cstring {.inline.} = + result = fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(renderer) + +proc fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: cstring): cstring {.importc: "fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding", cdecl.} + +proc siwinWindowTitleForRendererBinding*(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: string): cstring {.inline.} = + result = fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(renderer, window, suffix.cstring) + +proc fig_draw_siwin_renderer_ref_setup_backend_binding(renderer: SiwinRendererRef, window: SiwinWindowRef) {.importc: "fig_draw_siwin_renderer_ref_setup_backend_binding", cdecl.} + +proc setupBackendBinding*(renderer: SiwinRendererRef, window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_renderer_ref_setup_backend_binding(renderer, window) + +proc fig_draw_siwin_renderer_ref_begin_frame_binding(renderer: SiwinRendererRef) {.importc: "fig_draw_siwin_renderer_ref_begin_frame_binding", cdecl.} + +proc beginFrameBinding*(renderer: SiwinRendererRef) {.inline.} = + fig_draw_siwin_renderer_ref_begin_frame_binding(renderer) + +proc fig_draw_siwin_renderer_ref_end_frame_binding(renderer: SiwinRendererRef) {.importc: "fig_draw_siwin_renderer_ref_end_frame_binding", cdecl.} + +proc endFrameBinding*(renderer: SiwinRendererRef) {.inline.} = + fig_draw_siwin_renderer_ref_end_frame_binding(renderer) + +proc fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.importc: "fig_draw_siwin_metal_layer_ref_update_metal_layer_binding", cdecl.} + +proc updateMetalLayerBinding*(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.inline.} = + fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(layer, window) + +proc fig_draw_siwin_metal_layer_ref_set_opaque_binding(layer: SiwinMetalLayerRef, opaque: bool) {.importc: "fig_draw_siwin_metal_layer_ref_set_opaque_binding", cdecl.} + +proc setOpaqueBinding*(layer: SiwinMetalLayerRef, opaque: bool) {.inline.} = + fig_draw_siwin_metal_layer_ref_set_opaque_binding(layer, opaque) + proc fig_draw_siwin_backend_name_binding(): cstring {.importc: "fig_draw_siwin_backend_name_binding", cdecl.} proc siwinBackendNameBinding*(): cstring {.inline.} = @@ -256,3 +386,28 @@ proc fig_draw_siwin_window_title_binding(suffix: cstring): cstring {.importc: "f proc siwinWindowTitleBinding*(suffix: string): cstring {.inline.} = result = fig_draw_siwin_window_title_binding(suffix.cstring) +proc fig_draw_shared_siwin_globals_ptr_binding(): uint64 {.importc: "fig_draw_shared_siwin_globals_ptr_binding", cdecl.} + +proc sharedSiwinGlobalsPtrBinding*(): uint64 {.inline.} = + result = fig_draw_shared_siwin_globals_ptr_binding() + +proc fig_draw_new_siwin_renderer_binding(atlas_size: int, pixel_scale: float32): SiwinRendererRef {.importc: "fig_draw_new_siwin_renderer_binding", cdecl.} + +proc newSiwinRendererBinding*(atlasSize: int, pixelScale: float32): SiwinRendererRef {.inline.} = + result = fig_draw_new_siwin_renderer_binding(atlasSize, pixelScale) + +proc fig_draw_new_siwin_window_binding(width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.importc: "fig_draw_new_siwin_window_binding", cdecl.} + +proc newSiwinWindowBinding*(width: int32, height: int32, fullscreen: bool, title: string, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.inline.} = + result = fig_draw_new_siwin_window_binding(width, height, fullscreen, title.cstring, vsync, msaa, resizable, frameless, transparent) + +proc fig_draw_new_siwin_window_for_renderer_binding(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.importc: "fig_draw_new_siwin_window_for_renderer_binding", cdecl.} + +proc newSiwinWindowForRendererBinding*(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: string, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.inline.} = + result = fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.cstring, vsync, msaa, resizable, frameless, transparent) + +proc fig_draw_attach_metal_layer_binding(window: SiwinWindowRef, device_ptr: uint64): SiwinMetalLayerRef {.importc: "fig_draw_attach_metal_layer_binding", cdecl.} + +proc attachMetalLayerBinding*(window: SiwinWindowRef, devicePtr: uint64): SiwinMetalLayerRef {.inline.} = + result = fig_draw_attach_metal_layer_binding(window, devicePtr) + diff --git a/bindings/generated/fig_draw.py b/bindings/generated/fig_draw.py index a0ebb90..6f9d637 100644 --- a/bindings/generated/fig_draw.py +++ b/bindings/generated/fig_draw.py @@ -217,6 +217,112 @@ def descaled(a): result = dll.fig_draw_descaled(a) return result +class SiwinWindowRef(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_siwin_window_ref_unref(self) + + def close_window_binding(self): + dll.fig_draw_siwin_window_ref_close_window_binding(self) + + def step_window_binding(self): + dll.fig_draw_siwin_window_ref_step_window_binding(self) + + def make_current_window_binding(self): + dll.fig_draw_siwin_window_ref_make_current_window_binding(self) + + def window_is_open_binding(self): + result = dll.fig_draw_siwin_window_ref_window_is_open_binding(self) + return result + + def siwin_display_server_name_binding(self): + result = dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding(self).decode("utf8") + return result + + def backing_width_binding(self): + result = dll.fig_draw_siwin_window_ref_backing_width_binding(self) + return result + + def backing_height_binding(self): + result = dll.fig_draw_siwin_window_ref_backing_height_binding(self) + return result + + def logical_width_binding(self): + result = dll.fig_draw_siwin_window_ref_logical_width_binding(self) + return result + + def logical_height_binding(self): + result = dll.fig_draw_siwin_window_ref_logical_height_binding(self) + return result + + def content_scale_binding(self): + result = dll.fig_draw_siwin_window_ref_content_scale_binding(self) + return result + + def configure_ui_scale_binding(self, env_var): + result = dll.fig_draw_siwin_window_ref_configure_ui_scale_binding(self, env_var.encode("utf8")) + return result + + def refresh_ui_scale_binding(self, auto_scale): + dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding(self, auto_scale) + + def present_now_binding(self): + dll.fig_draw_siwin_window_ref_present_now_binding(self) + +class SiwinRendererRef(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_siwin_renderer_ref_unref(self) + + def siwin_backend_name_for_renderer_binding(self): + result = dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self).decode("utf8") + return result + + def siwin_window_title_for_renderer_binding(self, window, suffix): + result = dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self, window, suffix.encode("utf8")).decode("utf8") + return result + + def setup_backend_binding(self, window): + dll.fig_draw_siwin_renderer_ref_setup_backend_binding(self, window) + + def begin_frame_binding(self): + dll.fig_draw_siwin_renderer_ref_begin_frame_binding(self) + + def end_frame_binding(self): + dll.fig_draw_siwin_renderer_ref_end_frame_binding(self) + +class SiwinMetalLayerRef(Structure): + _fields_ = [("ref", c_ulonglong)] + + def __bool__(self): + return self.ref != None + + def __eq__(self, obj): + return self.ref == obj.ref + + def __del__(self): + dll.fig_draw_siwin_metal_layer_ref_unref(self) + + def update_metal_layer_binding(self, window): + dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self, window) + + def set_opaque_binding(self, opaque): + dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding(self, opaque) + def siwin_backend_name_binding(): result = dll.fig_draw_siwin_backend_name_binding().decode("utf8") return result @@ -225,6 +331,26 @@ def siwin_window_title_binding(suffix): result = dll.fig_draw_siwin_window_title_binding(suffix.encode("utf8")).decode("utf8") return result +def shared_siwin_globals_ptr_binding(): + result = dll.fig_draw_shared_siwin_globals_ptr_binding() + return result + +def new_siwin_renderer_binding(atlas_size, pixel_scale): + result = dll.fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale) + return result + +def new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent): + result = dll.fig_draw_new_siwin_window_binding(width, height, fullscreen, title.encode("utf8"), vsync, msaa, resizable, frameless, transparent) + return result + +def new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent): + result = dll.fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.encode("utf8"), vsync, msaa, resizable, frameless, transparent) + return result + +def attach_metal_layer_binding(window, device_ptr): + result = dll.fig_draw_attach_metal_layer_binding(window, device_ptr) + return result + dll.fig_draw_fig_unref.argtypes = [Fig] dll.fig_draw_fig_unref.restype = None @@ -354,9 +480,93 @@ def siwin_window_title_binding(suffix): dll.fig_draw_descaled.argtypes = [c_float] dll.fig_draw_descaled.restype = c_float +dll.fig_draw_siwin_window_ref_unref.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_unref.restype = None + +dll.fig_draw_siwin_window_ref_close_window_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_close_window_binding.restype = None + +dll.fig_draw_siwin_window_ref_step_window_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_step_window_binding.restype = None + +dll.fig_draw_siwin_window_ref_make_current_window_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_make_current_window_binding.restype = None + +dll.fig_draw_siwin_window_ref_window_is_open_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_window_is_open_binding.restype = c_bool + +dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding.restype = c_char_p + +dll.fig_draw_siwin_window_ref_backing_width_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_backing_width_binding.restype = c_int + +dll.fig_draw_siwin_window_ref_backing_height_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_backing_height_binding.restype = c_int + +dll.fig_draw_siwin_window_ref_logical_width_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_logical_width_binding.restype = c_float + +dll.fig_draw_siwin_window_ref_logical_height_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_logical_height_binding.restype = c_float + +dll.fig_draw_siwin_window_ref_content_scale_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_content_scale_binding.restype = c_float + +dll.fig_draw_siwin_window_ref_configure_ui_scale_binding.argtypes = [SiwinWindowRef, c_char_p] +dll.fig_draw_siwin_window_ref_configure_ui_scale_binding.restype = c_bool + +dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding.argtypes = [SiwinWindowRef, c_bool] +dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding.restype = None + +dll.fig_draw_siwin_window_ref_present_now_binding.argtypes = [SiwinWindowRef] +dll.fig_draw_siwin_window_ref_present_now_binding.restype = None + +dll.fig_draw_siwin_renderer_ref_unref.argtypes = [SiwinRendererRef] +dll.fig_draw_siwin_renderer_ref_unref.restype = None + +dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding.argtypes = [SiwinRendererRef] +dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding.restype = c_char_p + +dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding.argtypes = [SiwinRendererRef, SiwinWindowRef, c_char_p] +dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding.restype = c_char_p + +dll.fig_draw_siwin_renderer_ref_setup_backend_binding.argtypes = [SiwinRendererRef, SiwinWindowRef] +dll.fig_draw_siwin_renderer_ref_setup_backend_binding.restype = None + +dll.fig_draw_siwin_renderer_ref_begin_frame_binding.argtypes = [SiwinRendererRef] +dll.fig_draw_siwin_renderer_ref_begin_frame_binding.restype = None + +dll.fig_draw_siwin_renderer_ref_end_frame_binding.argtypes = [SiwinRendererRef] +dll.fig_draw_siwin_renderer_ref_end_frame_binding.restype = None + +dll.fig_draw_siwin_metal_layer_ref_unref.argtypes = [SiwinMetalLayerRef] +dll.fig_draw_siwin_metal_layer_ref_unref.restype = None + +dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding.argtypes = [SiwinMetalLayerRef, SiwinWindowRef] +dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding.restype = None + +dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding.argtypes = [SiwinMetalLayerRef, c_bool] +dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding.restype = None + dll.fig_draw_siwin_backend_name_binding.argtypes = [] dll.fig_draw_siwin_backend_name_binding.restype = c_char_p dll.fig_draw_siwin_window_title_binding.argtypes = [c_char_p] dll.fig_draw_siwin_window_title_binding.restype = c_char_p +dll.fig_draw_shared_siwin_globals_ptr_binding.argtypes = [] +dll.fig_draw_shared_siwin_globals_ptr_binding.restype = c_ulonglong + +dll.fig_draw_new_siwin_renderer_binding.argtypes = [c_longlong, c_float] +dll.fig_draw_new_siwin_renderer_binding.restype = SiwinRendererRef + +dll.fig_draw_new_siwin_window_binding.argtypes = [c_int, c_int, c_bool, c_char_p, c_bool, c_int, c_bool, c_bool, c_bool] +dll.fig_draw_new_siwin_window_binding.restype = SiwinWindowRef + +dll.fig_draw_new_siwin_window_for_renderer_binding.argtypes = [SiwinRendererRef, c_int, c_int, c_bool, c_char_p, c_bool, c_int, c_bool, c_bool, c_bool] +dll.fig_draw_new_siwin_window_for_renderer_binding.restype = SiwinWindowRef + +dll.fig_draw_attach_metal_layer_binding.argtypes = [SiwinWindowRef, c_ulonglong] +dll.fig_draw_attach_metal_layer_binding.restype = SiwinMetalLayerRef + diff --git a/bindings/generated/fig_draw.zig b/bindings/generated/fig_draw.zig index 4972e96..18f92ce 100644 --- a/bindings/generated/fig_draw.zig +++ b/bindings/generated/fig_draw.zig @@ -225,6 +225,127 @@ pub inline fn descaled(a: f32) f32 { return fig_draw_descaled(a); } +pub const SiwinWindowRef = opaque { + extern fn fig_draw_siwin_window_ref_unref(self: *SiwinWindowRef) callconv(.C) void; + pub inline fn deinit(self: *SiwinWindowRef) void { + return fig_draw_siwin_window_ref_unref(self); + } + + extern fn fig_draw_siwin_window_ref_close_window_binding(self: *SiwinWindowRef) callconv(.C) void; + pub inline fn closeWindowBinding(self: *SiwinWindowRef) void { + return fig_draw_siwin_window_ref_close_window_binding(self); + } + + extern fn fig_draw_siwin_window_ref_step_window_binding(self: *SiwinWindowRef) callconv(.C) void; + pub inline fn stepWindowBinding(self: *SiwinWindowRef) void { + return fig_draw_siwin_window_ref_step_window_binding(self); + } + + extern fn fig_draw_siwin_window_ref_make_current_window_binding(self: *SiwinWindowRef) callconv(.C) void; + pub inline fn makeCurrentWindowBinding(self: *SiwinWindowRef) void { + return fig_draw_siwin_window_ref_make_current_window_binding(self); + } + + extern fn fig_draw_siwin_window_ref_window_is_open_binding(self: *SiwinWindowRef) callconv(.C) bool; + pub inline fn windowIsOpenBinding(self: *SiwinWindowRef) bool { + return fig_draw_siwin_window_ref_window_is_open_binding(self); + } + + extern fn fig_draw_siwin_window_ref_siwin_display_server_name_binding(self: *SiwinWindowRef) callconv(.C) [*:0]const u8; + pub inline fn siwinDisplayServerNameBinding(self: *SiwinWindowRef) [:0]const u8 { + return std.mem.span(fig_draw_siwin_window_ref_siwin_display_server_name_binding(self)); + } + + extern fn fig_draw_siwin_window_ref_backing_width_binding(self: *SiwinWindowRef) callconv(.C) i32; + pub inline fn backingWidthBinding(self: *SiwinWindowRef) i32 { + return fig_draw_siwin_window_ref_backing_width_binding(self); + } + + extern fn fig_draw_siwin_window_ref_backing_height_binding(self: *SiwinWindowRef) callconv(.C) i32; + pub inline fn backingHeightBinding(self: *SiwinWindowRef) i32 { + return fig_draw_siwin_window_ref_backing_height_binding(self); + } + + extern fn fig_draw_siwin_window_ref_logical_width_binding(self: *SiwinWindowRef) callconv(.C) f32; + pub inline fn logicalWidthBinding(self: *SiwinWindowRef) f32 { + return fig_draw_siwin_window_ref_logical_width_binding(self); + } + + extern fn fig_draw_siwin_window_ref_logical_height_binding(self: *SiwinWindowRef) callconv(.C) f32; + pub inline fn logicalHeightBinding(self: *SiwinWindowRef) f32 { + return fig_draw_siwin_window_ref_logical_height_binding(self); + } + + extern fn fig_draw_siwin_window_ref_content_scale_binding(self: *SiwinWindowRef) callconv(.C) f32; + pub inline fn contentScaleBinding(self: *SiwinWindowRef) f32 { + return fig_draw_siwin_window_ref_content_scale_binding(self); + } + + extern fn fig_draw_siwin_window_ref_configure_ui_scale_binding(self: *SiwinWindowRef, env_var: [*:0]const u8) callconv(.C) bool; + pub inline fn configureUiScaleBinding(self: *SiwinWindowRef, env_var: [:0]const u8) bool { + return fig_draw_siwin_window_ref_configure_ui_scale_binding(self, env_var.ptr); + } + + extern fn fig_draw_siwin_window_ref_refresh_ui_scale_binding(self: *SiwinWindowRef, auto_scale: bool) callconv(.C) void; + pub inline fn refreshUiScaleBinding(self: *SiwinWindowRef, auto_scale: bool) void { + return fig_draw_siwin_window_ref_refresh_ui_scale_binding(self, auto_scale); + } + + extern fn fig_draw_siwin_window_ref_present_now_binding(self: *SiwinWindowRef) callconv(.C) void; + pub inline fn presentNowBinding(self: *SiwinWindowRef) void { + return fig_draw_siwin_window_ref_present_now_binding(self); + } +}; + +pub const SiwinRendererRef = opaque { + extern fn fig_draw_siwin_renderer_ref_unref(self: *SiwinRendererRef) callconv(.C) void; + pub inline fn deinit(self: *SiwinRendererRef) void { + return fig_draw_siwin_renderer_ref_unref(self); + } + + extern fn fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self: *SiwinRendererRef) callconv(.C) [*:0]const u8; + pub inline fn siwinBackendNameForRendererBinding(self: *SiwinRendererRef) [:0]const u8 { + return std.mem.span(fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self)); + } + + extern fn fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self: *SiwinRendererRef, window: *SiwinWindowRef, suffix: [*:0]const u8) callconv(.C) [*:0]const u8; + pub inline fn siwinWindowTitleForRendererBinding(self: *SiwinRendererRef, window: *SiwinWindowRef, suffix: [:0]const u8) [:0]const u8 { + return std.mem.span(fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self, window, suffix.ptr)); + } + + extern fn fig_draw_siwin_renderer_ref_setup_backend_binding(self: *SiwinRendererRef, window: *SiwinWindowRef) callconv(.C) void; + pub inline fn setupBackendBinding(self: *SiwinRendererRef, window: *SiwinWindowRef) void { + return fig_draw_siwin_renderer_ref_setup_backend_binding(self, window); + } + + extern fn fig_draw_siwin_renderer_ref_begin_frame_binding(self: *SiwinRendererRef) callconv(.C) void; + pub inline fn beginFrameBinding(self: *SiwinRendererRef) void { + return fig_draw_siwin_renderer_ref_begin_frame_binding(self); + } + + extern fn fig_draw_siwin_renderer_ref_end_frame_binding(self: *SiwinRendererRef) callconv(.C) void; + pub inline fn endFrameBinding(self: *SiwinRendererRef) void { + return fig_draw_siwin_renderer_ref_end_frame_binding(self); + } +}; + +pub const SiwinMetalLayerRef = opaque { + extern fn fig_draw_siwin_metal_layer_ref_unref(self: *SiwinMetalLayerRef) callconv(.C) void; + pub inline fn deinit(self: *SiwinMetalLayerRef) void { + return fig_draw_siwin_metal_layer_ref_unref(self); + } + + extern fn fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self: *SiwinMetalLayerRef, window: *SiwinWindowRef) callconv(.C) void; + pub inline fn updateMetalLayerBinding(self: *SiwinMetalLayerRef, window: *SiwinWindowRef) void { + return fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self, window); + } + + extern fn fig_draw_siwin_metal_layer_ref_set_opaque_binding(self: *SiwinMetalLayerRef, opaque: bool) callconv(.C) void; + pub inline fn setOpaqueBinding(self: *SiwinMetalLayerRef, opaque: bool) void { + return fig_draw_siwin_metal_layer_ref_set_opaque_binding(self, opaque); + } +}; + extern fn fig_draw_siwin_backend_name_binding() callconv(.C) [*:0]const u8; pub inline fn siwinBackendNameBinding() [:0]const u8 { return std.mem.span(fig_draw_siwin_backend_name_binding()); @@ -235,3 +356,28 @@ pub inline fn siwinWindowTitleBinding(suffix: [:0]const u8) [:0]const u8 { return std.mem.span(fig_draw_siwin_window_title_binding(suffix.ptr)); } +extern fn fig_draw_shared_siwin_globals_ptr_binding() callconv(.C) u64; +pub inline fn sharedSiwinGlobalsPtrBinding() u64 { + return fig_draw_shared_siwin_globals_ptr_binding(); +} + +extern fn fig_draw_new_siwin_renderer_binding(atlas_size: isize, pixel_scale: f32) callconv(.C) *SiwinRendererRef; +pub inline fn newSiwinRendererBinding(atlas_size: isize, pixel_scale: f32) *SiwinRendererRef { + return fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale); +} + +extern fn fig_draw_new_siwin_window_binding(width: i32, height: i32, fullscreen: bool, title: [*:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) callconv(.C) *SiwinWindowRef; +pub inline fn newSiwinWindowBinding(width: i32, height: i32, fullscreen: bool, title: [:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) *SiwinWindowRef { + return fig_draw_new_siwin_window_binding(width, height, fullscreen, title.ptr, vsync, msaa, resizable, frameless, transparent); +} + +extern fn fig_draw_new_siwin_window_for_renderer_binding(renderer: *SiwinRendererRef, width: i32, height: i32, fullscreen: bool, title: [*:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) callconv(.C) *SiwinWindowRef; +pub inline fn newSiwinWindowForRendererBinding(renderer: *SiwinRendererRef, width: i32, height: i32, fullscreen: bool, title: [:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) *SiwinWindowRef { + return fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.ptr, vsync, msaa, resizable, frameless, transparent); +} + +extern fn fig_draw_attach_metal_layer_binding(window: *SiwinWindowRef, device_ptr: u64) callconv(.C) *SiwinMetalLayerRef; +pub inline fn attachMetalLayerBinding(window: *SiwinWindowRef, device_ptr: u64) *SiwinMetalLayerRef { + return fig_draw_attach_metal_layer_binding(window, device_ptr); +} + diff --git a/bindings/generated/internal.nim b/bindings/generated/internal.nim index f19ff66..a84ddc8 100644 --- a/bindings/generated/internal.nim +++ b/bindings/generated/internal.nim @@ -132,9 +132,93 @@ proc fig_draw_scaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib. proc fig_draw_descaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = descaled(a) +proc fig_draw_siwin_window_ref_unref*(x: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_siwin_window_ref_close_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + closeWindowBinding(window) + +proc fig_draw_siwin_window_ref_step_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + stepWindowBinding(window) + +proc fig_draw_siwin_window_ref_make_current_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + makeCurrentWindowBinding(window) + +proc fig_draw_siwin_window_ref_window_is_open_binding*(window: SiwinWindowRef): bool {.raises: [], cdecl, exportc, dynlib.} = + windowIsOpenBinding(window) + +proc fig_draw_siwin_window_ref_siwin_display_server_name_binding*(window: SiwinWindowRef): cstring {.raises: [], cdecl, exportc, dynlib.} = + siwinDisplayServerNameBinding(window).cstring + +proc fig_draw_siwin_window_ref_backing_width_binding*(window: SiwinWindowRef): int32 {.raises: [], cdecl, exportc, dynlib.} = + backingWidthBinding(window) + +proc fig_draw_siwin_window_ref_backing_height_binding*(window: SiwinWindowRef): int32 {.raises: [], cdecl, exportc, dynlib.} = + backingHeightBinding(window) + +proc fig_draw_siwin_window_ref_logical_width_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = + logicalWidthBinding(window) + +proc fig_draw_siwin_window_ref_logical_height_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = + logicalHeightBinding(window) + +proc fig_draw_siwin_window_ref_content_scale_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = + contentScaleBinding(window) + +proc fig_draw_siwin_window_ref_configure_ui_scale_binding*(window: SiwinWindowRef, env_var: cstring): bool {.raises: [], cdecl, exportc, dynlib.} = + configureUiScaleBinding(window, env_var.`$`) + +proc fig_draw_siwin_window_ref_refresh_ui_scale_binding*(window: SiwinWindowRef, auto_scale: bool) {.raises: [], cdecl, exportc, dynlib.} = + refreshUiScaleBinding(window, auto_scale) + +proc fig_draw_siwin_window_ref_present_now_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + presentNowBinding(window) + +proc fig_draw_siwin_renderer_ref_unref*(x: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding*(renderer: SiwinRendererRef): cstring {.raises: [], cdecl, exportc, dynlib.} = + siwinBackendNameForRendererBinding(renderer).cstring + +proc fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding*(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: cstring): cstring {.raises: [], cdecl, exportc, dynlib.} = + siwinWindowTitleForRendererBinding(renderer, window, suffix.`$`).cstring + +proc fig_draw_siwin_renderer_ref_setup_backend_binding*(renderer: SiwinRendererRef, window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + setupBackendBinding(renderer, window) + +proc fig_draw_siwin_renderer_ref_begin_frame_binding*(renderer: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = + beginFrameBinding(renderer) + +proc fig_draw_siwin_renderer_ref_end_frame_binding*(renderer: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = + endFrameBinding(renderer) + +proc fig_draw_siwin_metal_layer_ref_unref*(x: SiwinMetalLayerRef) {.raises: [], cdecl, exportc, dynlib.} = + GC_unref(x) + +proc fig_draw_siwin_metal_layer_ref_update_metal_layer_binding*(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = + updateMetalLayerBinding(layer, window) + +proc fig_draw_siwin_metal_layer_ref_set_opaque_binding*(layer: SiwinMetalLayerRef, opaque: bool) {.raises: [], cdecl, exportc, dynlib.} = + setOpaqueBinding(layer, opaque) + proc fig_draw_siwin_backend_name_binding*(): cstring {.raises: [], cdecl, exportc, dynlib.} = siwinBackendNameBinding().cstring proc fig_draw_siwin_window_title_binding*(suffix: cstring): cstring {.raises: [], cdecl, exportc, dynlib.} = siwinWindowTitleBinding(suffix.`$`).cstring +proc fig_draw_shared_siwin_globals_ptr_binding*(): uint64 {.raises: [], cdecl, exportc, dynlib.} = + sharedSiwinGlobalsPtrBinding() + +proc fig_draw_new_siwin_renderer_binding*(atlas_size: int, pixel_scale: float32): SiwinRendererRef {.raises: [], cdecl, exportc, dynlib.} = + newSiwinRendererBinding(atlas_size, pixel_scale) + +proc fig_draw_new_siwin_window_binding*(width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.raises: [], cdecl, exportc, dynlib.} = + newSiwinWindowBinding(width, height, fullscreen, title.`$`, vsync, msaa, resizable, frameless, transparent) + +proc fig_draw_new_siwin_window_for_renderer_binding*(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.raises: [], cdecl, exportc, dynlib.} = + newSiwinWindowForRendererBinding(renderer, width, height, fullscreen, title.`$`, vsync, msaa, resizable, frameless, transparent) + +proc fig_draw_attach_metal_layer_binding*(window: SiwinWindowRef, device_ptr: uint64): SiwinMetalLayerRef {.raises: [], cdecl, exportc, dynlib.} = + attachMetalLayerBinding(window, device_ptr) + diff --git a/bindings/siwinshim_bindings.nim b/bindings/siwinshim_bindings.nim new file mode 100644 index 0000000..f5d92c6 --- /dev/null +++ b/bindings/siwinshim_bindings.nim @@ -0,0 +1,315 @@ +import figdraw/windowing/siwinshim +import figdraw/figrender as fgr +when defined(macosx) and UseMetalBackend: + import figdraw/windowing/siwinmetal + +type + SiwinWindowRef* = ref object + inner: Window + + SiwinRendererRef* = ref object + inner: fgr.FigRenderer[SiwinRenderBackend] + +when defined(macosx) and UseMetalBackend: + type + SiwinMetalLayerRef* = ref object + inner: MetalLayerHandle + +proc siwinBackendNameBinding(): string = + try: + siwinBackendName() + except Exception: + "" + +proc siwinWindowTitleBinding(suffix: string): string = + try: + siwinWindowTitle(suffix = suffix) + except Exception: + "" + +proc sharedSiwinGlobalsPtrBinding(): uint64 = + try: + cast[uint64](sharedSiwinGlobals()) + except Exception: + 0'u64 + +proc newSiwinRendererBinding(atlasSize: int, pixelScale: float32): SiwinRendererRef = + try: + SiwinRendererRef( + inner: fgr.newFigRenderer(atlasSize, SiwinRenderBackend(), pixelScale) + ) + except Exception: + nil + +proc siwinBackendNameForRendererBinding(renderer: SiwinRendererRef): string = + if renderer.isNil or renderer.inner.isNil: + return "" + try: + siwinBackendName(renderer.inner) + except Exception: + "" + +proc newSiwinWindowBinding( + width, height: int32, + fullscreen: bool, + title: string, + vsync: bool, + msaa: int32, + resizable: bool, + frameless: bool, + transparent: bool, +): SiwinWindowRef = + try: + SiwinWindowRef( + inner: newSiwinWindow( + size = ivec2(width, height), + fullscreen = fullscreen, + title = title, + vsync = vsync, + msaa = msaa, + resizable = resizable, + frameless = frameless, + transparent = transparent, + ) + ) + except Exception: + nil + +proc newSiwinWindowForRendererBinding( + renderer: SiwinRendererRef, + width, height: int32, + fullscreen: bool, + title: string, + vsync: bool, + msaa: int32, + resizable: bool, + frameless: bool, + transparent: bool, +): SiwinWindowRef = + if renderer.isNil or renderer.inner.isNil: + return nil + try: + SiwinWindowRef( + inner: newSiwinWindow( + renderer = renderer.inner, + size = ivec2(width, height), + fullscreen = fullscreen, + title = title, + vsync = vsync, + msaa = msaa, + resizable = resizable, + frameless = frameless, + transparent = transparent, + ) + ) + except Exception: + nil + +proc closeWindowBinding(window: SiwinWindowRef) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.close() + except Exception: + discard + +proc stepWindowBinding(window: SiwinWindowRef) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.step() + except Exception: + discard + +proc makeCurrentWindowBinding(window: SiwinWindowRef) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.makeCurrent() + except Exception: + discard + +proc windowIsOpenBinding(window: SiwinWindowRef): bool = + if window.isNil or window.inner.isNil: + return false + window.inner.opened() + +proc siwinDisplayServerNameBinding(window: SiwinWindowRef): string = + if window.isNil or window.inner.isNil: + return "" + try: + siwinDisplayServerName(window.inner) + except Exception: + "" + +proc siwinWindowTitleForRendererBinding( + renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: string +): string = + if renderer.isNil or renderer.inner.isNil or window.isNil or window.inner.isNil: + return "" + try: + siwinWindowTitle(renderer.inner, window.inner, suffix = suffix) + except Exception: + "" + +proc backingWidthBinding(window: SiwinWindowRef): int32 = + if window.isNil or window.inner.isNil: + return 0'i32 + try: + window.inner.backingSize().x + except Exception: + 0'i32 + +proc backingHeightBinding(window: SiwinWindowRef): int32 = + if window.isNil or window.inner.isNil: + return 0'i32 + try: + window.inner.backingSize().y + except Exception: + 0'i32 + +proc logicalWidthBinding(window: SiwinWindowRef): float32 = + if window.isNil or window.inner.isNil: + return 0'f32 + try: + window.inner.logicalSize().x + except Exception: + 0'f32 + +proc logicalHeightBinding(window: SiwinWindowRef): float32 = + if window.isNil or window.inner.isNil: + return 0'f32 + try: + window.inner.logicalSize().y + except Exception: + 0'f32 + +proc contentScaleBinding(window: SiwinWindowRef): float32 = + if window.isNil or window.inner.isNil: + return 1'f32 + try: + window.inner.contentScale() + except Exception: + 1'f32 + +proc configureUiScaleBinding(window: SiwinWindowRef, envVar: string): bool = + if window.isNil or window.inner.isNil: + return false + try: + window.inner.configureUiScale(envVar = envVar) + except Exception: + false + +proc refreshUiScaleBinding(window: SiwinWindowRef, autoScale: bool) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.refreshUiScale(autoScale) + except Exception: + discard + +proc presentNowBinding(window: SiwinWindowRef) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.presentNow() + except Exception: + discard + +proc setupBackendBinding(renderer: SiwinRendererRef, window: SiwinWindowRef) = + if renderer.isNil or renderer.inner.isNil or window.isNil or window.inner.isNil: + return + try: + setupBackend(renderer.inner, window.inner) + except Exception: + discard + +proc beginFrameBinding(renderer: SiwinRendererRef) = + if renderer.isNil or renderer.inner.isNil: + return + try: + beginFrame(renderer.inner) + except Exception: + discard + +proc endFrameBinding(renderer: SiwinRendererRef) = + if renderer.isNil or renderer.inner.isNil: + return + try: + endFrame(renderer.inner) + except Exception: + discard + +when defined(macosx) and UseMetalBackend: + proc attachMetalLayerBinding( + window: SiwinWindowRef, devicePtr: uint64 + ): SiwinMetalLayerRef = + if window.isNil or window.inner.isNil or devicePtr == 0'u64: + return nil + try: + SiwinMetalLayerRef( + inner: attachMetalLayer( + window.inner, + cast[siwinmetal.MTLDevice](cast[pointer](devicePtr)), + ) + ) + except Exception: + nil + + proc updateMetalLayerBinding(layer: SiwinMetalLayerRef, window: SiwinWindowRef) = + if layer.isNil or window.isNil or window.inner.isNil: + return + try: + updateMetalLayer(layer.inner, window.inner) + except Exception: + discard + + proc setOpaqueBinding(layer: SiwinMetalLayerRef, opaque: bool) = + if layer.isNil: + return + try: + siwinshim.setOpaque(layer.inner, opaque) + except Exception: + discard + +exportRefObject SiwinWindowRef: + procs: + closeWindowBinding(SiwinWindowRef) + stepWindowBinding(SiwinWindowRef) + makeCurrentWindowBinding(SiwinWindowRef) + windowIsOpenBinding(SiwinWindowRef) + siwinDisplayServerNameBinding(SiwinWindowRef) + backingWidthBinding(SiwinWindowRef) + backingHeightBinding(SiwinWindowRef) + logicalWidthBinding(SiwinWindowRef) + logicalHeightBinding(SiwinWindowRef) + contentScaleBinding(SiwinWindowRef) + configureUiScaleBinding(SiwinWindowRef, string) + refreshUiScaleBinding(SiwinWindowRef, bool) + presentNowBinding(SiwinWindowRef) + +exportRefObject SiwinRendererRef: + procs: + siwinBackendNameForRendererBinding(SiwinRendererRef) + siwinWindowTitleForRendererBinding(SiwinRendererRef, SiwinWindowRef, string) + setupBackendBinding(SiwinRendererRef, SiwinWindowRef) + beginFrameBinding(SiwinRendererRef) + endFrameBinding(SiwinRendererRef) + +when defined(macosx) and UseMetalBackend: + exportRefObject SiwinMetalLayerRef: + procs: + updateMetalLayerBinding(SiwinMetalLayerRef, SiwinWindowRef) + setOpaqueBinding(SiwinMetalLayerRef, bool) + +exportProcs: + siwinBackendNameBinding + siwinWindowTitleBinding + sharedSiwinGlobalsPtrBinding + newSiwinRendererBinding + newSiwinWindowBinding + newSiwinWindowForRendererBinding + +when defined(macosx) and UseMetalBackend: + exportProcs: + attachMetalLayerBinding From 183ec0aa379a1de0fd05fddd04799faf61f27fbf Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:23:44 -0600 Subject: [PATCH 5/9] add bindings --- .gitignore | 2 - bindings/bindings.nim | 118 ++++++ bindings/generated/fig_draw.h | 165 --------- bindings/generated/fig_draw.hpp | 635 -------------------------------- bindings/generated/fig_draw.js | 521 -------------------------- bindings/generated/fig_draw.nim | 413 --------------------- bindings/generated/fig_draw.py | 572 ---------------------------- bindings/generated/fig_draw.zig | 383 ------------------- bindings/generated/internal.nim | 224 ----------- bindings/siwinshim_bindings.nim | 11 + 10 files changed, 129 insertions(+), 2915 deletions(-) delete mode 100644 bindings/generated/fig_draw.h delete mode 100644 bindings/generated/fig_draw.hpp delete mode 100644 bindings/generated/fig_draw.js delete mode 100644 bindings/generated/fig_draw.nim delete mode 100644 bindings/generated/fig_draw.py delete mode 100644 bindings/generated/fig_draw.zig delete mode 100644 bindings/generated/internal.nim diff --git a/.gitignore b/.gitignore index 0dd1071..eaf0815 100644 --- a/.gitignore +++ b/.gitignore @@ -24,5 +24,3 @@ nimbledeps /examples/emscripten/*.html !/examples/emscripten/emscripten.html .DS_Store -/bindings/generated/libfigdraw.dylib -/bindings/generated/libfigdraw.dylib.* diff --git a/bindings/bindings.nim b/bindings/bindings.nim index ab0a494..adfb888 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -3,6 +3,8 @@ import std/tables import std/hashes import figdraw/commons import figdraw/fignodes as fdn +import figdraw/common/fonttypes as fnt +import figdraw/common/fontutils as fut const ExportSiwinShim* {.booldefine: "figdraw.bindings.siwinshim".} = false @@ -19,6 +21,15 @@ type Renders* = ref object inner: fdn.Renders + TypefaceRef* = ref object + id: fnt.TypefaceId + + FigFontRef* = ref object + inner: fnt.FigFont + + GlyphLayoutRef* = ref object + inner: fnt.GlyphArrangement + proc newFig(): Fig = Fig(inner: fdn.Fig(kind: fdn.nkFrame)) @@ -67,6 +78,95 @@ proc newTransformFig(x, y, w, h: float32, tx, ty: float32): Fig = ), ) +proc loadTypefaceBinding(name: string): TypefaceRef = + try: + let fontId = fut.loadTypeface(name) + TypefaceRef(id: cast[fnt.TypefaceId](fontId)) + except CatchableError: + nil + +proc newFigFontBinding(typeface: TypefaceRef, size: float32): FigFontRef = + if typeface.isNil: + return nil + FigFontRef(inner: fnt.FigFont(typefaceId: typeface.id, size: size)) + +proc setFigFontLineHeightBinding(font: FigFontRef, lineHeight: float32) = + if font.isNil: + return + font.inner.lineHeight = lineHeight + +proc setFigFontCaseBinding(font: FigFontRef, fontCase: int8) = + if font.isNil: + return + case fontCase + of 1'i8: + font.inner.fontCase = fnt.FontCase.UpperCase + of 2'i8: + font.inner.fontCase = fnt.FontCase.LowerCase + of 3'i8: + font.inner.fontCase = fnt.FontCase.TitleCase + else: + font.inner.fontCase = fnt.FontCase.NormalCase + +proc typesetTextBinding( + width, height: float32, + font: FigFontRef, + text: string, + hAlign: int8 = 0, + vAlign: int8 = 0, + minContent = false, + wrap = false, +): GlyphLayoutRef = + if font.isNil: + return nil + var h = fnt.FontHorizontal.Left + case hAlign + of 1'i8: + h = fnt.FontHorizontal.Center + of 2'i8: + h = fnt.FontHorizontal.Right + else: + discard + + var v = fnt.FontVertical.Top + case vAlign + of 1'i8: + v = fnt.FontVertical.Middle + of 2'i8: + v = fnt.FontVertical.Bottom + else: + discard + + try: + let layout = fut.typeset( + box = rect(0'f32, 0'f32, width, height), + uiSpans = @[(font.inner, text)], + hAlign = h, + vAlign = v, + minContent = minContent, + wrap = wrap, + ) + GlyphLayoutRef(inner: layout) + except CatchableError: + nil + +proc setFigTextLayoutBinding(fig: Fig, layout: GlyphLayoutRef) = + if fig.isNil or layout.isNil: + return + if fig.inner.kind != fdn.nkText: + fig.inner.kind = fdn.nkText + fig.inner.textLayout = layout.inner + +proc textLayoutWidthBinding(layout: GlyphLayoutRef): float32 = + if layout.isNil: + return 0'f32 + layout.inner.bounding.w + +proc textLayoutHeightBinding(layout: GlyphLayoutRef): float32 = + if layout.isNil: + return 0'f32 + layout.inner.bounding.h + proc copy(fig: Fig): Fig = Fig(inner: fig.inner) @@ -236,11 +336,29 @@ exportRefObject Renders: layerRootCount(Renders, ZLevel) getLayerNode(Renders, ZLevel, int16) +exportRefObject TypefaceRef: + discard + +exportRefObject FigFontRef: + constructor: + newFigFontBinding(TypefaceRef, float32) + procs: + setFigFontLineHeightBinding(FigFontRef, float32) + setFigFontCaseBinding(FigFontRef, int8) + +exportRefObject GlyphLayoutRef: + procs: + textLayoutWidthBinding(GlyphLayoutRef) + textLayoutHeightBinding(GlyphLayoutRef) + exportProcs: newRectangleFig newTextFig newImageFig newTransformFig + loadTypefaceBinding + typesetTextBinding + setFigTextLayoutBinding figDataDir setFigDataDir figUiScale diff --git a/bindings/generated/fig_draw.h b/bindings/generated/fig_draw.h deleted file mode 100644 index 7d97b51..0000000 --- a/bindings/generated/fig_draw.h +++ /dev/null @@ -1,165 +0,0 @@ -#ifndef INCLUDE_FIGDRAW_H -#define INCLUDE_FIGDRAW_H - -typedef char FigKind; -#define FIG_KIND 0 - -typedef long long Fig; - -typedef long long RenderList; - -typedef long long Renders; - -typedef long long SiwinWindowRef; - -typedef long long SiwinRendererRef; - -typedef long long SiwinMetalLayerRef; - -void fig_draw_fig_unref(Fig fig); - -Fig fig_draw_new_fig(); - -Fig fig_draw_fig_copy(Fig fig); - -FigKind fig_draw_fig_kind(Fig fig); - -void fig_draw_fig_set_kind(Fig fig, FigKind kind); - -ZLevel fig_draw_fig_z_level(Fig fig); - -void fig_draw_fig_set_zlevel(Fig fig, ZLevel z_level); - -float fig_draw_fig_x(Fig fig); - -float fig_draw_fig_y(Fig fig); - -float fig_draw_fig_width(Fig fig); - -float fig_draw_fig_height(Fig fig); - -void fig_draw_fig_set_screen_box(Fig fig, float x, float y, float w, float h); - -void fig_draw_fig_set_fill_color(Fig fig, unsigned char r, unsigned char g, unsigned char b, unsigned char a); - -void fig_draw_fig_set_rotation(Fig fig, float rotation); - -void fig_draw_render_list_unref(RenderList render_list); - -RenderList fig_draw_new_render_list(); - -RenderList fig_draw_render_list_copy(RenderList list); - -void fig_draw_render_list_clear(RenderList list); - -long long fig_draw_render_list_node_count(RenderList list); - -long long fig_draw_render_list_root_count(RenderList list); - -short fig_draw_render_list_add_root(RenderList list, Fig root); - -short fig_draw_render_list_add_child(RenderList list, short parent_idx, Fig child); - -Fig fig_draw_render_list_get_node(RenderList list, short node_idx); - -short fig_draw_render_list_get_root_id(RenderList list, short root_idx); - -void fig_draw_renders_unref(Renders renders); - -Renders fig_draw_new_renders(); - -void fig_draw_renders_clear(Renders renders); - -char fig_draw_renders_contains_layer(Renders renders, ZLevel z_level); - -short fig_draw_renders_add_root(Renders renders, ZLevel z_level, Fig root); - -short fig_draw_renders_add_child(Renders renders, ZLevel z_level, short parent_idx, Fig child); - -long long fig_draw_renders_layer_node_count(Renders renders, ZLevel z_level); - -long long fig_draw_renders_layer_root_count(Renders renders, ZLevel z_level); - -Fig fig_draw_renders_get_layer_node(Renders renders, ZLevel z_level, short node_idx); - -Fig fig_draw_new_rectangle_fig(float x, float y, float w, float h); - -Fig fig_draw_new_text_fig(float x, float y, float w, float h); - -Fig fig_draw_new_image_fig(float x, float y, float w, float h, long long image_id); - -Fig fig_draw_new_transform_fig(float x, float y, float w, float h, float tx, float ty); - -char* fig_draw_fig_data_dir(); - -void fig_draw_set_fig_data_dir(char* dir); - -float fig_draw_fig_ui_scale(); - -void fig_draw_set_fig_ui_scale(float scale); - -float fig_draw_scaled(float a); - -float fig_draw_descaled(float a); - -void fig_draw_siwin_window_ref_unref(SiwinWindowRef siwin_window_ref); - -void fig_draw_siwin_window_ref_close_window_binding(SiwinWindowRef window); - -void fig_draw_siwin_window_ref_step_window_binding(SiwinWindowRef window); - -void fig_draw_siwin_window_ref_make_current_window_binding(SiwinWindowRef window); - -char fig_draw_siwin_window_ref_window_is_open_binding(SiwinWindowRef window); - -char* fig_draw_siwin_window_ref_siwin_display_server_name_binding(SiwinWindowRef window); - -int fig_draw_siwin_window_ref_backing_width_binding(SiwinWindowRef window); - -int fig_draw_siwin_window_ref_backing_height_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_logical_width_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_logical_height_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_content_scale_binding(SiwinWindowRef window); - -char fig_draw_siwin_window_ref_configure_ui_scale_binding(SiwinWindowRef window, char* env_var); - -void fig_draw_siwin_window_ref_refresh_ui_scale_binding(SiwinWindowRef window, char auto_scale); - -void fig_draw_siwin_window_ref_present_now_binding(SiwinWindowRef window); - -void fig_draw_siwin_renderer_ref_unref(SiwinRendererRef siwin_renderer_ref); - -char* fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(SiwinRendererRef renderer); - -char* fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(SiwinRendererRef renderer, SiwinWindowRef window, char* suffix); - -void fig_draw_siwin_renderer_ref_setup_backend_binding(SiwinRendererRef renderer, SiwinWindowRef window); - -void fig_draw_siwin_renderer_ref_begin_frame_binding(SiwinRendererRef renderer); - -void fig_draw_siwin_renderer_ref_end_frame_binding(SiwinRendererRef renderer); - -void fig_draw_siwin_metal_layer_ref_unref(SiwinMetalLayerRef siwin_metal_layer_ref); - -void fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(SiwinMetalLayerRef layer, SiwinWindowRef window); - -void fig_draw_siwin_metal_layer_ref_set_opaque_binding(SiwinMetalLayerRef layer, char opaque); - -char* fig_draw_siwin_backend_name_binding(); - -char* fig_draw_siwin_window_title_binding(char* suffix); - -unsigned long long fig_draw_shared_siwin_globals_ptr_binding(); - -SiwinRendererRef fig_draw_new_siwin_renderer_binding(long long atlas_size, float pixel_scale); - -SiwinWindowRef fig_draw_new_siwin_window_binding(int width, int height, char fullscreen, char* title, char vsync, int msaa, char resizable, char frameless, char transparent); - -SiwinWindowRef fig_draw_new_siwin_window_for_renderer_binding(SiwinRendererRef renderer, int width, int height, char fullscreen, char* title, char vsync, int msaa, char resizable, char frameless, char transparent); - -SiwinMetalLayerRef fig_draw_attach_metal_layer_binding(SiwinWindowRef window, unsigned long long device_ptr); - -#endif diff --git a/bindings/generated/fig_draw.hpp b/bindings/generated/fig_draw.hpp deleted file mode 100644 index 1403ada..0000000 --- a/bindings/generated/fig_draw.hpp +++ /dev/null @@ -1,635 +0,0 @@ -#ifndef INCLUDE_FIGDRAW_H -#define INCLUDE_FIGDRAW_H - -#include - -typedef char FigKind; -#define FIG_KIND 0 - -struct Fig; - -struct RenderList; - -struct Renders; - -struct SiwinWindowRef; - -struct SiwinRendererRef; - -struct SiwinMetalLayerRef; - -struct Fig { - - private: - - uint64_t reference; - - public: - - Fig(); - - void free(); - - Fig copy(); - - FigKind kind(); - - void setKind(FigKind kind); - - ZLevel zLevel(); - - void setZLevel(ZLevel zLevel); - - float x(); - - float y(); - - float width(); - - float height(); - - void setScreenBox(float x, float y, float w, float h); - - void setFillColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a); - - void setRotation(float rotation); - -}; - -struct RenderList { - - private: - - uint64_t reference; - - public: - - RenderList(); - - void free(); - - RenderList copy(); - - void clear(); - - int64_t nodeCount(); - - int64_t rootCount(); - - int16_t addRoot(Fig root); - - int16_t addChild(int16_t parentIdx, Fig child); - - Fig getNode(int16_t nodeIdx); - - int16_t getRootId(int16_t rootIdx); - -}; - -struct Renders { - - private: - - uint64_t reference; - - public: - - Renders(); - - void free(); - - void clear(); - - bool containsLayer(ZLevel zLevel); - - int16_t addRoot(ZLevel zLevel, Fig root); - - int16_t addChild(ZLevel zLevel, int16_t parentIdx, Fig child); - - int64_t layerNodeCount(ZLevel zLevel); - - int64_t layerRootCount(ZLevel zLevel); - - Fig getLayerNode(ZLevel zLevel, int16_t nodeIdx); - -}; - -struct SiwinWindowRef { - - private: - - uint64_t reference; - - public: - - void free(); - - void closeWindowBinding(); - - void stepWindowBinding(); - - void makeCurrentWindowBinding(); - - bool windowIsOpenBinding(); - - const char* siwinDisplayServerNameBinding(); - - int32_t backingWidthBinding(); - - int32_t backingHeightBinding(); - - float logicalWidthBinding(); - - float logicalHeightBinding(); - - float contentScaleBinding(); - - bool configureUiScaleBinding(const char* envVar); - - void refreshUiScaleBinding(bool autoScale); - - void presentNowBinding(); - -}; - -struct SiwinRendererRef { - - private: - - uint64_t reference; - - public: - - void free(); - - const char* siwinBackendNameForRendererBinding(); - - const char* siwinWindowTitleForRendererBinding(SiwinWindowRef window, const char* suffix); - - void setupBackendBinding(SiwinWindowRef window); - - void beginFrameBinding(); - - void endFrameBinding(); - -}; - -struct SiwinMetalLayerRef { - - private: - - uint64_t reference; - - public: - - void free(); - - void updateMetalLayerBinding(SiwinWindowRef window); - - void setOpaqueBinding(bool opaque); - -}; - -extern "C" { - -void fig_draw_fig_unref(Fig fig); - -Fig fig_draw_new_fig(); - -Fig fig_draw_fig_copy(Fig fig); - -FigKind fig_draw_fig_kind(Fig fig); - -void fig_draw_fig_set_kind(Fig fig, FigKind kind); - -ZLevel fig_draw_fig_z_level(Fig fig); - -void fig_draw_fig_set_zlevel(Fig fig, ZLevel z_level); - -float fig_draw_fig_x(Fig fig); - -float fig_draw_fig_y(Fig fig); - -float fig_draw_fig_width(Fig fig); - -float fig_draw_fig_height(Fig fig); - -void fig_draw_fig_set_screen_box(Fig fig, float x, float y, float w, float h); - -void fig_draw_fig_set_fill_color(Fig fig, uint8_t r, uint8_t g, uint8_t b, uint8_t a); - -void fig_draw_fig_set_rotation(Fig fig, float rotation); - -void fig_draw_render_list_unref(RenderList render_list); - -RenderList fig_draw_new_render_list(); - -RenderList fig_draw_render_list_copy(RenderList list); - -void fig_draw_render_list_clear(RenderList list); - -int64_t fig_draw_render_list_node_count(RenderList list); - -int64_t fig_draw_render_list_root_count(RenderList list); - -int16_t fig_draw_render_list_add_root(RenderList list, Fig root); - -int16_t fig_draw_render_list_add_child(RenderList list, int16_t parent_idx, Fig child); - -Fig fig_draw_render_list_get_node(RenderList list, int16_t node_idx); - -int16_t fig_draw_render_list_get_root_id(RenderList list, int16_t root_idx); - -void fig_draw_renders_unref(Renders renders); - -Renders fig_draw_new_renders(); - -void fig_draw_renders_clear(Renders renders); - -bool fig_draw_renders_contains_layer(Renders renders, ZLevel z_level); - -int16_t fig_draw_renders_add_root(Renders renders, ZLevel z_level, Fig root); - -int16_t fig_draw_renders_add_child(Renders renders, ZLevel z_level, int16_t parent_idx, Fig child); - -int64_t fig_draw_renders_layer_node_count(Renders renders, ZLevel z_level); - -int64_t fig_draw_renders_layer_root_count(Renders renders, ZLevel z_level); - -Fig fig_draw_renders_get_layer_node(Renders renders, ZLevel z_level, int16_t node_idx); - -Fig fig_draw_new_rectangle_fig(float x, float y, float w, float h); - -Fig fig_draw_new_text_fig(float x, float y, float w, float h); - -Fig fig_draw_new_image_fig(float x, float y, float w, float h, int64_t image_id); - -Fig fig_draw_new_transform_fig(float x, float y, float w, float h, float tx, float ty); - -const char* fig_draw_fig_data_dir(); - -void fig_draw_set_fig_data_dir(const char* dir); - -float fig_draw_fig_ui_scale(); - -void fig_draw_set_fig_ui_scale(float scale); - -float fig_draw_scaled(float a); - -float fig_draw_descaled(float a); - -void fig_draw_siwin_window_ref_unref(SiwinWindowRef siwin_window_ref); - -void fig_draw_siwin_window_ref_close_window_binding(SiwinWindowRef window); - -void fig_draw_siwin_window_ref_step_window_binding(SiwinWindowRef window); - -void fig_draw_siwin_window_ref_make_current_window_binding(SiwinWindowRef window); - -bool fig_draw_siwin_window_ref_window_is_open_binding(SiwinWindowRef window); - -const char* fig_draw_siwin_window_ref_siwin_display_server_name_binding(SiwinWindowRef window); - -int32_t fig_draw_siwin_window_ref_backing_width_binding(SiwinWindowRef window); - -int32_t fig_draw_siwin_window_ref_backing_height_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_logical_width_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_logical_height_binding(SiwinWindowRef window); - -float fig_draw_siwin_window_ref_content_scale_binding(SiwinWindowRef window); - -bool fig_draw_siwin_window_ref_configure_ui_scale_binding(SiwinWindowRef window, const char* env_var); - -void fig_draw_siwin_window_ref_refresh_ui_scale_binding(SiwinWindowRef window, bool auto_scale); - -void fig_draw_siwin_window_ref_present_now_binding(SiwinWindowRef window); - -void fig_draw_siwin_renderer_ref_unref(SiwinRendererRef siwin_renderer_ref); - -const char* fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(SiwinRendererRef renderer); - -const char* fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(SiwinRendererRef renderer, SiwinWindowRef window, const char* suffix); - -void fig_draw_siwin_renderer_ref_setup_backend_binding(SiwinRendererRef renderer, SiwinWindowRef window); - -void fig_draw_siwin_renderer_ref_begin_frame_binding(SiwinRendererRef renderer); - -void fig_draw_siwin_renderer_ref_end_frame_binding(SiwinRendererRef renderer); - -void fig_draw_siwin_metal_layer_ref_unref(SiwinMetalLayerRef siwin_metal_layer_ref); - -void fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(SiwinMetalLayerRef layer, SiwinWindowRef window); - -void fig_draw_siwin_metal_layer_ref_set_opaque_binding(SiwinMetalLayerRef layer, bool opaque); - -const char* fig_draw_siwin_backend_name_binding(); - -const char* fig_draw_siwin_window_title_binding(const char* suffix); - -uint64_t fig_draw_shared_siwin_globals_ptr_binding(); - -SiwinRendererRef fig_draw_new_siwin_renderer_binding(int64_t atlas_size, float pixel_scale); - -SiwinWindowRef fig_draw_new_siwin_window_binding(int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent); - -SiwinWindowRef fig_draw_new_siwin_window_for_renderer_binding(SiwinRendererRef renderer, int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent); - -SiwinMetalLayerRef fig_draw_attach_metal_layer_binding(SiwinWindowRef window, uint64_t device_ptr); - -} - -Fig::Fig() { - this->reference = fig_draw_new_fig().reference; -} - -void Fig::free(){ - fig_draw_fig_unref(*this); -} - -Fig Fig::copy() { - return fig_draw_fig_copy(*this); -}; - -FigKind Fig::kind() { - return fig_draw_fig_kind(*this); -}; - -void Fig::setKind(FigKind kind) { - fig_draw_fig_set_kind(*this, kind); -}; - -ZLevel Fig::zLevel() { - return fig_draw_fig_z_level(*this); -}; - -void Fig::setZLevel(ZLevel zLevel) { - fig_draw_fig_set_zlevel(*this, zLevel); -}; - -float Fig::x() { - return fig_draw_fig_x(*this); -}; - -float Fig::y() { - return fig_draw_fig_y(*this); -}; - -float Fig::width() { - return fig_draw_fig_width(*this); -}; - -float Fig::height() { - return fig_draw_fig_height(*this); -}; - -void Fig::setScreenBox(float x, float y, float w, float h) { - fig_draw_fig_set_screen_box(*this, x, y, w, h); -}; - -void Fig::setFillColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { - fig_draw_fig_set_fill_color(*this, r, g, b, a); -}; - -void Fig::setRotation(float rotation) { - fig_draw_fig_set_rotation(*this, rotation); -}; - -RenderList::RenderList() { - this->reference = fig_draw_new_render_list().reference; -} - -void RenderList::free(){ - fig_draw_render_list_unref(*this); -} - -RenderList RenderList::copy() { - return fig_draw_render_list_copy(*this); -}; - -void RenderList::clear() { - fig_draw_render_list_clear(*this); -}; - -int64_t RenderList::nodeCount() { - return fig_draw_render_list_node_count(*this); -}; - -int64_t RenderList::rootCount() { - return fig_draw_render_list_root_count(*this); -}; - -int16_t RenderList::addRoot(Fig root) { - return fig_draw_render_list_add_root(*this, root); -}; - -int16_t RenderList::addChild(int16_t parentIdx, Fig child) { - return fig_draw_render_list_add_child(*this, parentIdx, child); -}; - -Fig RenderList::getNode(int16_t nodeIdx) { - return fig_draw_render_list_get_node(*this, nodeIdx); -}; - -int16_t RenderList::getRootId(int16_t rootIdx) { - return fig_draw_render_list_get_root_id(*this, rootIdx); -}; - -Renders::Renders() { - this->reference = fig_draw_new_renders().reference; -} - -void Renders::free(){ - fig_draw_renders_unref(*this); -} - -void Renders::clear() { - fig_draw_renders_clear(*this); -}; - -bool Renders::containsLayer(ZLevel zLevel) { - return fig_draw_renders_contains_layer(*this, zLevel); -}; - -int16_t Renders::addRoot(ZLevel zLevel, Fig root) { - return fig_draw_renders_add_root(*this, zLevel, root); -}; - -int16_t Renders::addChild(ZLevel zLevel, int16_t parentIdx, Fig child) { - return fig_draw_renders_add_child(*this, zLevel, parentIdx, child); -}; - -int64_t Renders::layerNodeCount(ZLevel zLevel) { - return fig_draw_renders_layer_node_count(*this, zLevel); -}; - -int64_t Renders::layerRootCount(ZLevel zLevel) { - return fig_draw_renders_layer_root_count(*this, zLevel); -}; - -Fig Renders::getLayerNode(ZLevel zLevel, int16_t nodeIdx) { - return fig_draw_renders_get_layer_node(*this, zLevel, nodeIdx); -}; - -Fig newRectangleFig(float x, float y, float w, float h) { - return fig_draw_new_rectangle_fig(x, y, w, h); -}; - -Fig newTextFig(float x, float y, float w, float h) { - return fig_draw_new_text_fig(x, y, w, h); -}; - -Fig newImageFig(float x, float y, float w, float h, int64_t imageId) { - return fig_draw_new_image_fig(x, y, w, h, imageId); -}; - -Fig newTransformFig(float x, float y, float w, float h, float tx, float ty) { - return fig_draw_new_transform_fig(x, y, w, h, tx, ty); -}; - -const char* figDataDir() { - return fig_draw_fig_data_dir(); -}; - -setFigDataDir(const char* dir) { - fig_draw_set_fig_data_dir(dir); -}; - -float figUiScale() { - return fig_draw_fig_ui_scale(); -}; - -setFigUiScale(float scale) { - fig_draw_set_fig_ui_scale(scale); -}; - -float scaled(float a) { - return fig_draw_scaled(a); -}; - -float descaled(float a) { - return fig_draw_descaled(a); -}; - -void SiwinWindowRef::free(){ - fig_draw_siwin_window_ref_unref(*this); -} - -void SiwinWindowRef::closeWindowBinding() { - fig_draw_siwin_window_ref_close_window_binding(*this); -}; - -void SiwinWindowRef::stepWindowBinding() { - fig_draw_siwin_window_ref_step_window_binding(*this); -}; - -void SiwinWindowRef::makeCurrentWindowBinding() { - fig_draw_siwin_window_ref_make_current_window_binding(*this); -}; - -bool SiwinWindowRef::windowIsOpenBinding() { - return fig_draw_siwin_window_ref_window_is_open_binding(*this); -}; - -const char* SiwinWindowRef::siwinDisplayServerNameBinding() { - return fig_draw_siwin_window_ref_siwin_display_server_name_binding(*this); -}; - -int32_t SiwinWindowRef::backingWidthBinding() { - return fig_draw_siwin_window_ref_backing_width_binding(*this); -}; - -int32_t SiwinWindowRef::backingHeightBinding() { - return fig_draw_siwin_window_ref_backing_height_binding(*this); -}; - -float SiwinWindowRef::logicalWidthBinding() { - return fig_draw_siwin_window_ref_logical_width_binding(*this); -}; - -float SiwinWindowRef::logicalHeightBinding() { - return fig_draw_siwin_window_ref_logical_height_binding(*this); -}; - -float SiwinWindowRef::contentScaleBinding() { - return fig_draw_siwin_window_ref_content_scale_binding(*this); -}; - -bool SiwinWindowRef::configureUiScaleBinding(const char* envVar) { - return fig_draw_siwin_window_ref_configure_ui_scale_binding(*this, envVar); -}; - -void SiwinWindowRef::refreshUiScaleBinding(bool autoScale) { - fig_draw_siwin_window_ref_refresh_ui_scale_binding(*this, autoScale); -}; - -void SiwinWindowRef::presentNowBinding() { - fig_draw_siwin_window_ref_present_now_binding(*this); -}; - -void SiwinRendererRef::free(){ - fig_draw_siwin_renderer_ref_unref(*this); -} - -const char* SiwinRendererRef::siwinBackendNameForRendererBinding() { - return fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(*this); -}; - -const char* SiwinRendererRef::siwinWindowTitleForRendererBinding(SiwinWindowRef window, const char* suffix) { - return fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(*this, window, suffix); -}; - -void SiwinRendererRef::setupBackendBinding(SiwinWindowRef window) { - fig_draw_siwin_renderer_ref_setup_backend_binding(*this, window); -}; - -void SiwinRendererRef::beginFrameBinding() { - fig_draw_siwin_renderer_ref_begin_frame_binding(*this); -}; - -void SiwinRendererRef::endFrameBinding() { - fig_draw_siwin_renderer_ref_end_frame_binding(*this); -}; - -void SiwinMetalLayerRef::free(){ - fig_draw_siwin_metal_layer_ref_unref(*this); -} - -void SiwinMetalLayerRef::updateMetalLayerBinding(SiwinWindowRef window) { - fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(*this, window); -}; - -void SiwinMetalLayerRef::setOpaqueBinding(bool opaque) { - fig_draw_siwin_metal_layer_ref_set_opaque_binding(*this, opaque); -}; - -const char* siwinBackendNameBinding() { - return fig_draw_siwin_backend_name_binding(); -}; - -const char* siwinWindowTitleBinding(const char* suffix) { - return fig_draw_siwin_window_title_binding(suffix); -}; - -uint64_t sharedSiwinGlobalsPtrBinding() { - return fig_draw_shared_siwin_globals_ptr_binding(); -}; - -SiwinRendererRef newSiwinRendererBinding(int64_t atlasSize, float pixelScale) { - return fig_draw_new_siwin_renderer_binding(atlasSize, pixelScale); -}; - -SiwinWindowRef newSiwinWindowBinding(int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent) { - return fig_draw_new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent); -}; - -SiwinWindowRef newSiwinWindowForRendererBinding(SiwinRendererRef renderer, int32_t width, int32_t height, bool fullscreen, const char* title, bool vsync, int32_t msaa, bool resizable, bool frameless, bool transparent) { - return fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent); -}; - -SiwinMetalLayerRef attachMetalLayerBinding(SiwinWindowRef window, uint64_t devicePtr) { - return fig_draw_attach_metal_layer_binding(window, devicePtr); -}; - -#endif diff --git a/bindings/generated/fig_draw.js b/bindings/generated/fig_draw.js deleted file mode 100644 index 9c01429..0000000 --- a/bindings/generated/fig_draw.js +++ /dev/null @@ -1,521 +0,0 @@ -var ffi = require('ffi-napi'); -var Struct = require("ref-struct-napi"); -var ArrayType = require('ref-array-napi'); - -var dll = {}; - -function FigDrawException(message) { - this.message = message; - this.name = 'FigDrawException'; -} - -const FigKind = 'int8' - -Fig = Struct({'nimRef': 'uint64'}); -Fig.prototype.isNull = function(){ - return this.nimRef == 0; -}; -Fig.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -Fig.prototype.unref = function(){ - return dll.fig_draw_fig_unref(this) -}; -function newFig(){ - var result = dll.fig_draw_new_fig() - const registry = new FinalizationRegistry(function(obj) { - console.log("js unref") - obj.unref() - }); - registry.register(result, null); - return result -} - -Fig.prototype.copy = function(){ - result = dll.fig_draw_fig_copy(this) - return result -} - -Fig.prototype.kind = function(){ - result = dll.fig_draw_fig_kind(this) - return result -} - -Fig.prototype.setKind = function(kind){ - dll.fig_draw_fig_set_kind(this, kind) -} - -Fig.prototype.zlevel = function(){ - result = dll.fig_draw_fig_z_level(this) - return result -} - -Fig.prototype.setZLevel = function(z_level){ - dll.fig_draw_fig_set_zlevel(this, z_level) -} - -Fig.prototype.x = function(){ - result = dll.fig_draw_fig_x(this) - return result -} - -Fig.prototype.y = function(){ - result = dll.fig_draw_fig_y(this) - return result -} - -Fig.prototype.width = function(){ - result = dll.fig_draw_fig_width(this) - return result -} - -Fig.prototype.height = function(){ - result = dll.fig_draw_fig_height(this) - return result -} - -Fig.prototype.setScreenBox = function(x, y, w, h){ - dll.fig_draw_fig_set_screen_box(this, x, y, w, h) -} - -Fig.prototype.setFillColor = function(r, g, b, a){ - dll.fig_draw_fig_set_fill_color(this, r, g, b, a) -} - -Fig.prototype.setRotation = function(rotation){ - dll.fig_draw_fig_set_rotation(this, rotation) -} - -RenderList = Struct({'nimRef': 'uint64'}); -RenderList.prototype.isNull = function(){ - return this.nimRef == 0; -}; -RenderList.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -RenderList.prototype.unref = function(){ - return dll.fig_draw_render_list_unref(this) -}; -function newRenderList(){ - var result = dll.fig_draw_new_render_list() - const registry = new FinalizationRegistry(function(obj) { - console.log("js unref") - obj.unref() - }); - registry.register(result, null); - return result -} - -RenderList.prototype.copy = function(){ - result = dll.fig_draw_render_list_copy(this) - return result -} - -RenderList.prototype.clear = function(){ - dll.fig_draw_render_list_clear(this) -} - -RenderList.prototype.nodeCount = function(){ - result = dll.fig_draw_render_list_node_count(this) - return result -} - -RenderList.prototype.rootCount = function(){ - result = dll.fig_draw_render_list_root_count(this) - return result -} - -RenderList.prototype.addRoot = function(root){ - result = dll.fig_draw_render_list_add_root(this, root) - return result -} - -RenderList.prototype.addChild = function(parent_idx, child){ - result = dll.fig_draw_render_list_add_child(this, parent_idx, child) - return result -} - -RenderList.prototype.getNode = function(node_idx){ - result = dll.fig_draw_render_list_get_node(this, node_idx) - return result -} - -RenderList.prototype.getRootId = function(root_idx){ - result = dll.fig_draw_render_list_get_root_id(this, root_idx) - return result -} - -Renders = Struct({'nimRef': 'uint64'}); -Renders.prototype.isNull = function(){ - return this.nimRef == 0; -}; -Renders.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -Renders.prototype.unref = function(){ - return dll.fig_draw_renders_unref(this) -}; -function newRenders(){ - var result = dll.fig_draw_new_renders() - const registry = new FinalizationRegistry(function(obj) { - console.log("js unref") - obj.unref() - }); - registry.register(result, null); - return result -} - -Renders.prototype.clear = function(){ - dll.fig_draw_renders_clear(this) -} - -Renders.prototype.containsLayer = function(z_level){ - result = dll.fig_draw_renders_contains_layer(this, z_level) - return result -} - -Renders.prototype.addRoot = function(z_level, root){ - result = dll.fig_draw_renders_add_root(this, z_level, root) - return result -} - -Renders.prototype.addChild = function(z_level, parent_idx, child){ - result = dll.fig_draw_renders_add_child(this, z_level, parent_idx, child) - return result -} - -Renders.prototype.layerNodeCount = function(z_level){ - result = dll.fig_draw_renders_layer_node_count(this, z_level) - return result -} - -Renders.prototype.layerRootCount = function(z_level){ - result = dll.fig_draw_renders_layer_root_count(this, z_level) - return result -} - -Renders.prototype.getLayerNode = function(z_level, node_idx){ - result = dll.fig_draw_renders_get_layer_node(this, z_level, node_idx) - return result -} - -function newRectangleFig(x, y, w, h){ - result = dll.fig_draw_new_rectangle_fig(x, y, w, h) - return result -} - -function newTextFig(x, y, w, h){ - result = dll.fig_draw_new_text_fig(x, y, w, h) - return result -} - -function newImageFig(x, y, w, h, image_id){ - result = dll.fig_draw_new_image_fig(x, y, w, h, image_id) - return result -} - -function newTransformFig(x, y, w, h, tx, ty){ - result = dll.fig_draw_new_transform_fig(x, y, w, h, tx, ty) - return result -} - -function figDataDir(){ - result = dll.fig_draw_fig_data_dir() - return result -} - -function setFigDataDir(dir){ - dll.fig_draw_set_fig_data_dir(dir) -} - -function figUiScale(){ - result = dll.fig_draw_fig_ui_scale() - return result -} - -function setFigUiScale(scale){ - dll.fig_draw_set_fig_ui_scale(scale) -} - -function scaled(a){ - result = dll.fig_draw_scaled(a) - return result -} - -function descaled(a){ - result = dll.fig_draw_descaled(a) - return result -} - -SiwinWindowRef = Struct({'nimRef': 'uint64'}); -SiwinWindowRef.prototype.isNull = function(){ - return this.nimRef == 0; -}; -SiwinWindowRef.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -SiwinWindowRef.prototype.unref = function(){ - return dll.fig_draw_siwin_window_ref_unref(this) -}; - -SiwinWindowRef.prototype.closeWindowBinding = function(){ - dll.fig_draw_siwin_window_ref_close_window_binding(this) -} - -SiwinWindowRef.prototype.stepWindowBinding = function(){ - dll.fig_draw_siwin_window_ref_step_window_binding(this) -} - -SiwinWindowRef.prototype.makeCurrentWindowBinding = function(){ - dll.fig_draw_siwin_window_ref_make_current_window_binding(this) -} - -SiwinWindowRef.prototype.windowIsOpenBinding = function(){ - result = dll.fig_draw_siwin_window_ref_window_is_open_binding(this) - return result -} - -SiwinWindowRef.prototype.siwinDisplayServerNameBinding = function(){ - result = dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding(this) - return result -} - -SiwinWindowRef.prototype.backingWidthBinding = function(){ - result = dll.fig_draw_siwin_window_ref_backing_width_binding(this) - return result -} - -SiwinWindowRef.prototype.backingHeightBinding = function(){ - result = dll.fig_draw_siwin_window_ref_backing_height_binding(this) - return result -} - -SiwinWindowRef.prototype.logicalWidthBinding = function(){ - result = dll.fig_draw_siwin_window_ref_logical_width_binding(this) - return result -} - -SiwinWindowRef.prototype.logicalHeightBinding = function(){ - result = dll.fig_draw_siwin_window_ref_logical_height_binding(this) - return result -} - -SiwinWindowRef.prototype.contentScaleBinding = function(){ - result = dll.fig_draw_siwin_window_ref_content_scale_binding(this) - return result -} - -SiwinWindowRef.prototype.configureUiScaleBinding = function(env_var){ - result = dll.fig_draw_siwin_window_ref_configure_ui_scale_binding(this, env_var) - return result -} - -SiwinWindowRef.prototype.refreshUiScaleBinding = function(auto_scale){ - dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding(this, auto_scale) -} - -SiwinWindowRef.prototype.presentNowBinding = function(){ - dll.fig_draw_siwin_window_ref_present_now_binding(this) -} - -SiwinRendererRef = Struct({'nimRef': 'uint64'}); -SiwinRendererRef.prototype.isNull = function(){ - return this.nimRef == 0; -}; -SiwinRendererRef.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -SiwinRendererRef.prototype.unref = function(){ - return dll.fig_draw_siwin_renderer_ref_unref(this) -}; - -SiwinRendererRef.prototype.siwinBackendNameForRendererBinding = function(){ - result = dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(this) - return result -} - -SiwinRendererRef.prototype.siwinWindowTitleForRendererBinding = function(window, suffix){ - result = dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(this, window, suffix) - return result -} - -SiwinRendererRef.prototype.setupBackendBinding = function(window){ - dll.fig_draw_siwin_renderer_ref_setup_backend_binding(this, window) -} - -SiwinRendererRef.prototype.beginFrameBinding = function(){ - dll.fig_draw_siwin_renderer_ref_begin_frame_binding(this) -} - -SiwinRendererRef.prototype.endFrameBinding = function(){ - dll.fig_draw_siwin_renderer_ref_end_frame_binding(this) -} - -SiwinMetalLayerRef = Struct({'nimRef': 'uint64'}); -SiwinMetalLayerRef.prototype.isNull = function(){ - return this.nimRef == 0; -}; -SiwinMetalLayerRef.prototype.isEqual = function(other){ - return this.nimRef == other.nimRef; -}; -SiwinMetalLayerRef.prototype.unref = function(){ - return dll.fig_draw_siwin_metal_layer_ref_unref(this) -}; - -SiwinMetalLayerRef.prototype.updateMetalLayerBinding = function(window){ - dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(this, window) -} - -SiwinMetalLayerRef.prototype.setOpaqueBinding = function(opaque){ - dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding(this, opaque) -} - -function siwinBackendNameBinding(){ - result = dll.fig_draw_siwin_backend_name_binding() - return result -} - -function siwinWindowTitleBinding(suffix){ - result = dll.fig_draw_siwin_window_title_binding(suffix) - return result -} - -function sharedSiwinGlobalsPtrBinding(){ - result = dll.fig_draw_shared_siwin_globals_ptr_binding() - return result -} - -function newSiwinRendererBinding(atlas_size, pixel_scale){ - result = dll.fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale) - return result -} - -function newSiwinWindowBinding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent){ - result = dll.fig_draw_new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent) - return result -} - -function newSiwinWindowForRendererBinding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent){ - result = dll.fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent) - return result -} - -function attachMetalLayerBinding(window, device_ptr){ - result = dll.fig_draw_attach_metal_layer_binding(window, device_ptr) - return result -} - - -var dllPath = "" -if(process.platform == "win32") { - dllPath = __dirname + '/fig_draw.dll' -} else if (process.platform == "darwin") { - dllPath = __dirname + '/libfig_draw.dylib' -} else { - dllPath = __dirname + '/libfig_draw.so' -} - -dll = ffi.Library(dllPath, { - 'fig_draw_fig_unref': ['void', [Fig]], - 'fig_draw_new_fig': [Fig, []], - 'fig_draw_fig_copy': [Fig, [Fig]], - 'fig_draw_fig_kind': [FigKind, [Fig]], - 'fig_draw_fig_set_kind': ['void', [Fig, FigKind]], - 'fig_draw_fig_z_level': [ZLevel, [Fig]], - 'fig_draw_fig_set_zlevel': ['void', [Fig, ZLevel]], - 'fig_draw_fig_x': ['float', [Fig]], - 'fig_draw_fig_y': ['float', [Fig]], - 'fig_draw_fig_width': ['float', [Fig]], - 'fig_draw_fig_height': ['float', [Fig]], - 'fig_draw_fig_set_screen_box': ['void', [Fig, 'float', 'float', 'float', 'float']], - 'fig_draw_fig_set_fill_color': ['void', [Fig, 'uint8', 'uint8', 'uint8', 'uint8']], - 'fig_draw_fig_set_rotation': ['void', [Fig, 'float']], - 'fig_draw_render_list_unref': ['void', [RenderList]], - 'fig_draw_new_render_list': [RenderList, []], - 'fig_draw_render_list_copy': [RenderList, [RenderList]], - 'fig_draw_render_list_clear': ['void', [RenderList]], - 'fig_draw_render_list_node_count': ['int64', [RenderList]], - 'fig_draw_render_list_root_count': ['int64', [RenderList]], - 'fig_draw_render_list_add_root': ['int16', [RenderList, Fig]], - 'fig_draw_render_list_add_child': ['int16', [RenderList, 'int16', Fig]], - 'fig_draw_render_list_get_node': [Fig, [RenderList, 'int16']], - 'fig_draw_render_list_get_root_id': ['int16', [RenderList, 'int16']], - 'fig_draw_renders_unref': ['void', [Renders]], - 'fig_draw_new_renders': [Renders, []], - 'fig_draw_renders_clear': ['void', [Renders]], - 'fig_draw_renders_contains_layer': ['bool', [Renders, ZLevel]], - 'fig_draw_renders_add_root': ['int16', [Renders, ZLevel, Fig]], - 'fig_draw_renders_add_child': ['int16', [Renders, ZLevel, 'int16', Fig]], - 'fig_draw_renders_layer_node_count': ['int64', [Renders, ZLevel]], - 'fig_draw_renders_layer_root_count': ['int64', [Renders, ZLevel]], - 'fig_draw_renders_get_layer_node': [Fig, [Renders, ZLevel, 'int16']], - 'fig_draw_new_rectangle_fig': [Fig, ['float', 'float', 'float', 'float']], - 'fig_draw_new_text_fig': [Fig, ['float', 'float', 'float', 'float']], - 'fig_draw_new_image_fig': [Fig, ['float', 'float', 'float', 'float', 'int64']], - 'fig_draw_new_transform_fig': [Fig, ['float', 'float', 'float', 'float', 'float', 'float']], - 'fig_draw_fig_data_dir': ['string', []], - 'fig_draw_set_fig_data_dir': ['void', ['string']], - 'fig_draw_fig_ui_scale': ['float', []], - 'fig_draw_set_fig_ui_scale': ['void', ['float']], - 'fig_draw_scaled': ['float', ['float']], - 'fig_draw_descaled': ['float', ['float']], - 'fig_draw_siwin_window_ref_unref': ['void', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_close_window_binding': ['void', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_step_window_binding': ['void', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_make_current_window_binding': ['void', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_window_is_open_binding': ['bool', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_siwin_display_server_name_binding': ['string', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_backing_width_binding': ['int32', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_backing_height_binding': ['int32', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_logical_width_binding': ['float', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_logical_height_binding': ['float', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_content_scale_binding': ['float', [SiwinWindowRef]], - 'fig_draw_siwin_window_ref_configure_ui_scale_binding': ['bool', [SiwinWindowRef, 'string']], - 'fig_draw_siwin_window_ref_refresh_ui_scale_binding': ['void', [SiwinWindowRef, 'bool']], - 'fig_draw_siwin_window_ref_present_now_binding': ['void', [SiwinWindowRef]], - 'fig_draw_siwin_renderer_ref_unref': ['void', [SiwinRendererRef]], - 'fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding': ['string', [SiwinRendererRef]], - 'fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding': ['string', [SiwinRendererRef, SiwinWindowRef, 'string']], - 'fig_draw_siwin_renderer_ref_setup_backend_binding': ['void', [SiwinRendererRef, SiwinWindowRef]], - 'fig_draw_siwin_renderer_ref_begin_frame_binding': ['void', [SiwinRendererRef]], - 'fig_draw_siwin_renderer_ref_end_frame_binding': ['void', [SiwinRendererRef]], - 'fig_draw_siwin_metal_layer_ref_unref': ['void', [SiwinMetalLayerRef]], - 'fig_draw_siwin_metal_layer_ref_update_metal_layer_binding': ['void', [SiwinMetalLayerRef, SiwinWindowRef]], - 'fig_draw_siwin_metal_layer_ref_set_opaque_binding': ['void', [SiwinMetalLayerRef, 'bool']], - 'fig_draw_siwin_backend_name_binding': ['string', []], - 'fig_draw_siwin_window_title_binding': ['string', ['string']], - 'fig_draw_shared_siwin_globals_ptr_binding': ['uint64', []], - 'fig_draw_new_siwin_renderer_binding': [SiwinRendererRef, ['int64', 'float']], - 'fig_draw_new_siwin_window_binding': [SiwinWindowRef, ['int32', 'int32', 'bool', 'string', 'bool', 'int32', 'bool', 'bool', 'bool']], - 'fig_draw_new_siwin_window_for_renderer_binding': [SiwinWindowRef, [SiwinRendererRef, 'int32', 'int32', 'bool', 'string', 'bool', 'int32', 'bool', 'bool', 'bool']], - 'fig_draw_attach_metal_layer_binding': [SiwinMetalLayerRef, [SiwinWindowRef, 'uint64']], -}); - -exports.FigKind = FigKind -exports.FIG_KIND = 0 -exports.FigType = Fig -exports.Fig = newFig -exports.RenderListType = RenderList -exports.RenderList = newRenderList -exports.RendersType = Renders -exports.Renders = newRenders -exports.newRectangleFig = newRectangleFig -exports.newTextFig = newTextFig -exports.newImageFig = newImageFig -exports.newTransformFig = newTransformFig -exports.figDataDir = figDataDir -exports.setFigDataDir = setFigDataDir -exports.figUiScale = figUiScale -exports.setFigUiScale = setFigUiScale -exports.scaled = scaled -exports.descaled = descaled -exports.SiwinWindowRefType = SiwinWindowRef -exports.SiwinRendererRefType = SiwinRendererRef -exports.SiwinMetalLayerRefType = SiwinMetalLayerRef -exports.siwinBackendNameBinding = siwinBackendNameBinding -exports.siwinWindowTitleBinding = siwinWindowTitleBinding -exports.sharedSiwinGlobalsPtrBinding = sharedSiwinGlobalsPtrBinding -exports.newSiwinRendererBinding = newSiwinRendererBinding -exports.newSiwinWindowBinding = newSiwinWindowBinding -exports.newSiwinWindowForRendererBinding = newSiwinWindowForRendererBinding -exports.attachMetalLayerBinding = attachMetalLayerBinding diff --git a/bindings/generated/fig_draw.nim b/bindings/generated/fig_draw.nim deleted file mode 100644 index 936fb02..0000000 --- a/bindings/generated/fig_draw.nim +++ /dev/null @@ -1,413 +0,0 @@ -import bumpy, chroma, unicode, vmath - -export bumpy, chroma, unicode, vmath - -when defined(windows): - const libName = "fig_draw.dll" -elif defined(macosx): - const libName = "libfig_draw.dylib" -else: - const libName = "libfig_draw.so" - -{.push dynlib: libName.} - -type FigDrawError = object of ValueError - -type FigKind* = enum - FigKind - -type FigObj = object - reference: pointer - -type Fig* = ref FigObj - -proc fig_draw_fig_unref(x: FigObj) {.importc: "fig_draw_fig_unref", cdecl.} - -proc `=destroy`(x: var FigObj) = - fig_draw_fig_unref(x) - -type RenderListObj = object - reference: pointer - -type RenderList* = ref RenderListObj - -proc fig_draw_render_list_unref(x: RenderListObj) {.importc: "fig_draw_render_list_unref", cdecl.} - -proc `=destroy`(x: var RenderListObj) = - fig_draw_render_list_unref(x) - -type RendersObj = object - reference: pointer - -type Renders* = ref RendersObj - -proc fig_draw_renders_unref(x: RendersObj) {.importc: "fig_draw_renders_unref", cdecl.} - -proc `=destroy`(x: var RendersObj) = - fig_draw_renders_unref(x) - -type SiwinWindowRefObj = object - reference: pointer - -type SiwinWindowRef* = ref SiwinWindowRefObj - -proc fig_draw_siwin_window_ref_unref(x: SiwinWindowRefObj) {.importc: "fig_draw_siwin_window_ref_unref", cdecl.} - -proc `=destroy`(x: var SiwinWindowRefObj) = - fig_draw_siwin_window_ref_unref(x) - -type SiwinRendererRefObj = object - reference: pointer - -type SiwinRendererRef* = ref SiwinRendererRefObj - -proc fig_draw_siwin_renderer_ref_unref(x: SiwinRendererRefObj) {.importc: "fig_draw_siwin_renderer_ref_unref", cdecl.} - -proc `=destroy`(x: var SiwinRendererRefObj) = - fig_draw_siwin_renderer_ref_unref(x) - -type SiwinMetalLayerRefObj = object - reference: pointer - -type SiwinMetalLayerRef* = ref SiwinMetalLayerRefObj - -proc fig_draw_siwin_metal_layer_ref_unref(x: SiwinMetalLayerRefObj) {.importc: "fig_draw_siwin_metal_layer_ref_unref", cdecl.} - -proc `=destroy`(x: var SiwinMetalLayerRefObj) = - fig_draw_siwin_metal_layer_ref_unref(x) - -proc fig_draw_new_fig(): Fig {.importc: "fig_draw_new_fig", cdecl.} - -proc newFig*(): Fig {.inline.} = - result = fig_draw_new_fig() - -proc fig_draw_fig_copy(fig: Fig): Fig {.importc: "fig_draw_fig_copy", cdecl.} - -proc copy*(fig: Fig): Fig {.inline.} = - result = fig_draw_fig_copy(fig) - -proc fig_draw_fig_kind(fig: Fig): FigKind {.importc: "fig_draw_fig_kind", cdecl.} - -proc kind*(fig: Fig): FigKind {.inline.} = - result = fig_draw_fig_kind(fig) - -proc fig_draw_fig_set_kind(fig: Fig, kind: FigKind) {.importc: "fig_draw_fig_set_kind", cdecl.} - -proc setKind*(fig: Fig, kind: FigKind) {.inline.} = - fig_draw_fig_set_kind(fig, kind) - -proc fig_draw_fig_z_level(fig: Fig): ZLevel {.importc: "fig_draw_fig_z_level", cdecl.} - -proc zLevel*(fig: Fig): ZLevel {.inline.} = - result = fig_draw_fig_z_level(fig) - -proc fig_draw_fig_set_zlevel(fig: Fig, z_level: ZLevel) {.importc: "fig_draw_fig_set_zlevel", cdecl.} - -proc setZLevel*(fig: Fig, zLevel: ZLevel) {.inline.} = - fig_draw_fig_set_zlevel(fig, zLevel) - -proc fig_draw_fig_x(fig: Fig): float32 {.importc: "fig_draw_fig_x", cdecl.} - -proc x*(fig: Fig): float32 {.inline.} = - result = fig_draw_fig_x(fig) - -proc fig_draw_fig_y(fig: Fig): float32 {.importc: "fig_draw_fig_y", cdecl.} - -proc y*(fig: Fig): float32 {.inline.} = - result = fig_draw_fig_y(fig) - -proc fig_draw_fig_width(fig: Fig): float32 {.importc: "fig_draw_fig_width", cdecl.} - -proc width*(fig: Fig): float32 {.inline.} = - result = fig_draw_fig_width(fig) - -proc fig_draw_fig_height(fig: Fig): float32 {.importc: "fig_draw_fig_height", cdecl.} - -proc height*(fig: Fig): float32 {.inline.} = - result = fig_draw_fig_height(fig) - -proc fig_draw_fig_set_screen_box(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.importc: "fig_draw_fig_set_screen_box", cdecl.} - -proc setScreenBox*(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.inline.} = - fig_draw_fig_set_screen_box(fig, x, y, w, h) - -proc fig_draw_fig_set_fill_color(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.importc: "fig_draw_fig_set_fill_color", cdecl.} - -proc setFillColor*(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.inline.} = - fig_draw_fig_set_fill_color(fig, r, g, b, a) - -proc fig_draw_fig_set_rotation(fig: Fig, rotation: float32) {.importc: "fig_draw_fig_set_rotation", cdecl.} - -proc setRotation*(fig: Fig, rotation: float32) {.inline.} = - fig_draw_fig_set_rotation(fig, rotation) - -proc fig_draw_new_render_list(): RenderList {.importc: "fig_draw_new_render_list", cdecl.} - -proc newRenderList*(): RenderList {.inline.} = - result = fig_draw_new_render_list() - -proc fig_draw_render_list_copy(list: RenderList): RenderList {.importc: "fig_draw_render_list_copy", cdecl.} - -proc copy*(list: RenderList): RenderList {.inline.} = - result = fig_draw_render_list_copy(list) - -proc fig_draw_render_list_clear(list: RenderList) {.importc: "fig_draw_render_list_clear", cdecl.} - -proc clear*(list: RenderList) {.inline.} = - fig_draw_render_list_clear(list) - -proc fig_draw_render_list_node_count(list: RenderList): int {.importc: "fig_draw_render_list_node_count", cdecl.} - -proc nodeCount*(list: RenderList): int {.inline.} = - result = fig_draw_render_list_node_count(list) - -proc fig_draw_render_list_root_count(list: RenderList): int {.importc: "fig_draw_render_list_root_count", cdecl.} - -proc rootCount*(list: RenderList): int {.inline.} = - result = fig_draw_render_list_root_count(list) - -proc fig_draw_render_list_add_root(list: RenderList, root: Fig): int16 {.importc: "fig_draw_render_list_add_root", cdecl.} - -proc addRoot*(list: RenderList, root: Fig): int16 {.inline.} = - result = fig_draw_render_list_add_root(list, root) - -proc fig_draw_render_list_add_child(list: RenderList, parent_idx: int16, child: Fig): int16 {.importc: "fig_draw_render_list_add_child", cdecl.} - -proc addChild*(list: RenderList, parentIdx: int16, child: Fig): int16 {.inline.} = - result = fig_draw_render_list_add_child(list, parentIdx, child) - -proc fig_draw_render_list_get_node(list: RenderList, node_idx: int16): Fig {.importc: "fig_draw_render_list_get_node", cdecl.} - -proc getNode*(list: RenderList, nodeIdx: int16): Fig {.inline.} = - result = fig_draw_render_list_get_node(list, nodeIdx) - -proc fig_draw_render_list_get_root_id(list: RenderList, root_idx: int16): int16 {.importc: "fig_draw_render_list_get_root_id", cdecl.} - -proc getRootId*(list: RenderList, rootIdx: int16): int16 {.inline.} = - result = fig_draw_render_list_get_root_id(list, rootIdx) - -proc fig_draw_new_renders(): Renders {.importc: "fig_draw_new_renders", cdecl.} - -proc newRenders*(): Renders {.inline.} = - result = fig_draw_new_renders() - -proc fig_draw_renders_clear(renders: Renders) {.importc: "fig_draw_renders_clear", cdecl.} - -proc clear*(renders: Renders) {.inline.} = - fig_draw_renders_clear(renders) - -proc fig_draw_renders_contains_layer(renders: Renders, z_level: ZLevel): bool {.importc: "fig_draw_renders_contains_layer", cdecl.} - -proc containsLayer*(renders: Renders, zLevel: ZLevel): bool {.inline.} = - result = fig_draw_renders_contains_layer(renders, zLevel) - -proc fig_draw_renders_add_root(renders: Renders, z_level: ZLevel, root: Fig): int16 {.importc: "fig_draw_renders_add_root", cdecl.} - -proc addRoot*(renders: Renders, zLevel: ZLevel, root: Fig): int16 {.inline.} = - result = fig_draw_renders_add_root(renders, zLevel, root) - -proc fig_draw_renders_add_child(renders: Renders, z_level: ZLevel, parent_idx: int16, child: Fig): int16 {.importc: "fig_draw_renders_add_child", cdecl.} - -proc addChild*(renders: Renders, zLevel: ZLevel, parentIdx: int16, child: Fig): int16 {.inline.} = - result = fig_draw_renders_add_child(renders, zLevel, parentIdx, child) - -proc fig_draw_renders_layer_node_count(renders: Renders, z_level: ZLevel): int {.importc: "fig_draw_renders_layer_node_count", cdecl.} - -proc layerNodeCount*(renders: Renders, zLevel: ZLevel): int {.inline.} = - result = fig_draw_renders_layer_node_count(renders, zLevel) - -proc fig_draw_renders_layer_root_count(renders: Renders, z_level: ZLevel): int {.importc: "fig_draw_renders_layer_root_count", cdecl.} - -proc layerRootCount*(renders: Renders, zLevel: ZLevel): int {.inline.} = - result = fig_draw_renders_layer_root_count(renders, zLevel) - -proc fig_draw_renders_get_layer_node(renders: Renders, z_level: ZLevel, node_idx: int16): Fig {.importc: "fig_draw_renders_get_layer_node", cdecl.} - -proc getLayerNode*(renders: Renders, zLevel: ZLevel, nodeIdx: int16): Fig {.inline.} = - result = fig_draw_renders_get_layer_node(renders, zLevel, nodeIdx) - -proc fig_draw_new_rectangle_fig(x: float32, y: float32, w: float32, h: float32): Fig {.importc: "fig_draw_new_rectangle_fig", cdecl.} - -proc newRectangleFig*(x: float32, y: float32, w: float32, h: float32): Fig {.inline.} = - result = fig_draw_new_rectangle_fig(x, y, w, h) - -proc fig_draw_new_text_fig(x: float32, y: float32, w: float32, h: float32): Fig {.importc: "fig_draw_new_text_fig", cdecl.} - -proc newTextFig*(x: float32, y: float32, w: float32, h: float32): Fig {.inline.} = - result = fig_draw_new_text_fig(x, y, w, h) - -proc fig_draw_new_image_fig(x: float32, y: float32, w: float32, h: float32, image_id: int64): Fig {.importc: "fig_draw_new_image_fig", cdecl.} - -proc newImageFig*(x: float32, y: float32, w: float32, h: float32, imageId: int64): Fig {.inline.} = - result = fig_draw_new_image_fig(x, y, w, h, imageId) - -proc fig_draw_new_transform_fig(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.importc: "fig_draw_new_transform_fig", cdecl.} - -proc newTransformFig*(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.inline.} = - result = fig_draw_new_transform_fig(x, y, w, h, tx, ty) - -proc fig_draw_fig_data_dir(): cstring {.importc: "fig_draw_fig_data_dir", cdecl.} - -proc figDataDir*(): cstring {.inline.} = - result = fig_draw_fig_data_dir() - -proc fig_draw_set_fig_data_dir(dir: cstring) {.importc: "fig_draw_set_fig_data_dir", cdecl.} - -proc setFigDataDir*(dir: string) {.inline.} = - fig_draw_set_fig_data_dir(dir.cstring) - -proc fig_draw_fig_ui_scale(): float32 {.importc: "fig_draw_fig_ui_scale", cdecl.} - -proc figUiScale*(): float32 {.inline.} = - result = fig_draw_fig_ui_scale() - -proc fig_draw_set_fig_ui_scale(scale: float32) {.importc: "fig_draw_set_fig_ui_scale", cdecl.} - -proc setFigUiScale*(scale: float32) {.inline.} = - fig_draw_set_fig_ui_scale(scale) - -proc fig_draw_scaled(a: float32): float32 {.importc: "fig_draw_scaled", cdecl.} - -proc scaled*(a: float32): float32 {.inline.} = - result = fig_draw_scaled(a) - -proc fig_draw_descaled(a: float32): float32 {.importc: "fig_draw_descaled", cdecl.} - -proc descaled*(a: float32): float32 {.inline.} = - result = fig_draw_descaled(a) - -proc fig_draw_siwin_window_ref_close_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_close_window_binding", cdecl.} - -proc closeWindowBinding*(window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_window_ref_close_window_binding(window) - -proc fig_draw_siwin_window_ref_step_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_step_window_binding", cdecl.} - -proc stepWindowBinding*(window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_window_ref_step_window_binding(window) - -proc fig_draw_siwin_window_ref_make_current_window_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_make_current_window_binding", cdecl.} - -proc makeCurrentWindowBinding*(window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_window_ref_make_current_window_binding(window) - -proc fig_draw_siwin_window_ref_window_is_open_binding(window: SiwinWindowRef): bool {.importc: "fig_draw_siwin_window_ref_window_is_open_binding", cdecl.} - -proc windowIsOpenBinding*(window: SiwinWindowRef): bool {.inline.} = - result = fig_draw_siwin_window_ref_window_is_open_binding(window) - -proc fig_draw_siwin_window_ref_siwin_display_server_name_binding(window: SiwinWindowRef): cstring {.importc: "fig_draw_siwin_window_ref_siwin_display_server_name_binding", cdecl.} - -proc siwinDisplayServerNameBinding*(window: SiwinWindowRef): cstring {.inline.} = - result = fig_draw_siwin_window_ref_siwin_display_server_name_binding(window) - -proc fig_draw_siwin_window_ref_backing_width_binding(window: SiwinWindowRef): int32 {.importc: "fig_draw_siwin_window_ref_backing_width_binding", cdecl.} - -proc backingWidthBinding*(window: SiwinWindowRef): int32 {.inline.} = - result = fig_draw_siwin_window_ref_backing_width_binding(window) - -proc fig_draw_siwin_window_ref_backing_height_binding(window: SiwinWindowRef): int32 {.importc: "fig_draw_siwin_window_ref_backing_height_binding", cdecl.} - -proc backingHeightBinding*(window: SiwinWindowRef): int32 {.inline.} = - result = fig_draw_siwin_window_ref_backing_height_binding(window) - -proc fig_draw_siwin_window_ref_logical_width_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_logical_width_binding", cdecl.} - -proc logicalWidthBinding*(window: SiwinWindowRef): float32 {.inline.} = - result = fig_draw_siwin_window_ref_logical_width_binding(window) - -proc fig_draw_siwin_window_ref_logical_height_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_logical_height_binding", cdecl.} - -proc logicalHeightBinding*(window: SiwinWindowRef): float32 {.inline.} = - result = fig_draw_siwin_window_ref_logical_height_binding(window) - -proc fig_draw_siwin_window_ref_content_scale_binding(window: SiwinWindowRef): float32 {.importc: "fig_draw_siwin_window_ref_content_scale_binding", cdecl.} - -proc contentScaleBinding*(window: SiwinWindowRef): float32 {.inline.} = - result = fig_draw_siwin_window_ref_content_scale_binding(window) - -proc fig_draw_siwin_window_ref_configure_ui_scale_binding(window: SiwinWindowRef, env_var: cstring): bool {.importc: "fig_draw_siwin_window_ref_configure_ui_scale_binding", cdecl.} - -proc configureUiScaleBinding*(window: SiwinWindowRef, envVar: string): bool {.inline.} = - result = fig_draw_siwin_window_ref_configure_ui_scale_binding(window, envVar.cstring) - -proc fig_draw_siwin_window_ref_refresh_ui_scale_binding(window: SiwinWindowRef, auto_scale: bool) {.importc: "fig_draw_siwin_window_ref_refresh_ui_scale_binding", cdecl.} - -proc refreshUiScaleBinding*(window: SiwinWindowRef, autoScale: bool) {.inline.} = - fig_draw_siwin_window_ref_refresh_ui_scale_binding(window, autoScale) - -proc fig_draw_siwin_window_ref_present_now_binding(window: SiwinWindowRef) {.importc: "fig_draw_siwin_window_ref_present_now_binding", cdecl.} - -proc presentNowBinding*(window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_window_ref_present_now_binding(window) - -proc fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(renderer: SiwinRendererRef): cstring {.importc: "fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding", cdecl.} - -proc siwinBackendNameForRendererBinding*(renderer: SiwinRendererRef): cstring {.inline.} = - result = fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(renderer) - -proc fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: cstring): cstring {.importc: "fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding", cdecl.} - -proc siwinWindowTitleForRendererBinding*(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: string): cstring {.inline.} = - result = fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(renderer, window, suffix.cstring) - -proc fig_draw_siwin_renderer_ref_setup_backend_binding(renderer: SiwinRendererRef, window: SiwinWindowRef) {.importc: "fig_draw_siwin_renderer_ref_setup_backend_binding", cdecl.} - -proc setupBackendBinding*(renderer: SiwinRendererRef, window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_renderer_ref_setup_backend_binding(renderer, window) - -proc fig_draw_siwin_renderer_ref_begin_frame_binding(renderer: SiwinRendererRef) {.importc: "fig_draw_siwin_renderer_ref_begin_frame_binding", cdecl.} - -proc beginFrameBinding*(renderer: SiwinRendererRef) {.inline.} = - fig_draw_siwin_renderer_ref_begin_frame_binding(renderer) - -proc fig_draw_siwin_renderer_ref_end_frame_binding(renderer: SiwinRendererRef) {.importc: "fig_draw_siwin_renderer_ref_end_frame_binding", cdecl.} - -proc endFrameBinding*(renderer: SiwinRendererRef) {.inline.} = - fig_draw_siwin_renderer_ref_end_frame_binding(renderer) - -proc fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.importc: "fig_draw_siwin_metal_layer_ref_update_metal_layer_binding", cdecl.} - -proc updateMetalLayerBinding*(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.inline.} = - fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(layer, window) - -proc fig_draw_siwin_metal_layer_ref_set_opaque_binding(layer: SiwinMetalLayerRef, opaque: bool) {.importc: "fig_draw_siwin_metal_layer_ref_set_opaque_binding", cdecl.} - -proc setOpaqueBinding*(layer: SiwinMetalLayerRef, opaque: bool) {.inline.} = - fig_draw_siwin_metal_layer_ref_set_opaque_binding(layer, opaque) - -proc fig_draw_siwin_backend_name_binding(): cstring {.importc: "fig_draw_siwin_backend_name_binding", cdecl.} - -proc siwinBackendNameBinding*(): cstring {.inline.} = - result = fig_draw_siwin_backend_name_binding() - -proc fig_draw_siwin_window_title_binding(suffix: cstring): cstring {.importc: "fig_draw_siwin_window_title_binding", cdecl.} - -proc siwinWindowTitleBinding*(suffix: string): cstring {.inline.} = - result = fig_draw_siwin_window_title_binding(suffix.cstring) - -proc fig_draw_shared_siwin_globals_ptr_binding(): uint64 {.importc: "fig_draw_shared_siwin_globals_ptr_binding", cdecl.} - -proc sharedSiwinGlobalsPtrBinding*(): uint64 {.inline.} = - result = fig_draw_shared_siwin_globals_ptr_binding() - -proc fig_draw_new_siwin_renderer_binding(atlas_size: int, pixel_scale: float32): SiwinRendererRef {.importc: "fig_draw_new_siwin_renderer_binding", cdecl.} - -proc newSiwinRendererBinding*(atlasSize: int, pixelScale: float32): SiwinRendererRef {.inline.} = - result = fig_draw_new_siwin_renderer_binding(atlasSize, pixelScale) - -proc fig_draw_new_siwin_window_binding(width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.importc: "fig_draw_new_siwin_window_binding", cdecl.} - -proc newSiwinWindowBinding*(width: int32, height: int32, fullscreen: bool, title: string, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.inline.} = - result = fig_draw_new_siwin_window_binding(width, height, fullscreen, title.cstring, vsync, msaa, resizable, frameless, transparent) - -proc fig_draw_new_siwin_window_for_renderer_binding(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.importc: "fig_draw_new_siwin_window_for_renderer_binding", cdecl.} - -proc newSiwinWindowForRendererBinding*(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: string, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.inline.} = - result = fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.cstring, vsync, msaa, resizable, frameless, transparent) - -proc fig_draw_attach_metal_layer_binding(window: SiwinWindowRef, device_ptr: uint64): SiwinMetalLayerRef {.importc: "fig_draw_attach_metal_layer_binding", cdecl.} - -proc attachMetalLayerBinding*(window: SiwinWindowRef, devicePtr: uint64): SiwinMetalLayerRef {.inline.} = - result = fig_draw_attach_metal_layer_binding(window, devicePtr) - diff --git a/bindings/generated/fig_draw.py b/bindings/generated/fig_draw.py deleted file mode 100644 index 6f9d637..0000000 --- a/bindings/generated/fig_draw.py +++ /dev/null @@ -1,572 +0,0 @@ -from ctypes import * -import os, sys - -dir = os.path.dirname(sys.modules["fig_draw"].__file__) -if sys.platform == "win32": - libName = "fig_draw.dll" -elif sys.platform == "darwin": - libName = "libfig_draw.dylib" -else: - libName = "libfig_draw.so" -dll = cdll.LoadLibrary(os.path.join(dir, libName)) - -class FigDrawError(Exception): - pass - -class SeqIterator(object): - def __init__(self, seq): - self.idx = 0 - self.seq = seq - def __iter__(self): - return self - def __next__(self): - if self.idx < len(self.seq): - self.idx += 1 - return self.seq[self.idx - 1] - else: - self.idx = 0 - raise StopIteration - -FigKind = c_byte -FIG_KIND = 0 - -class Fig(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_fig_unref(self) - - def __init__(self): - result = dll.fig_draw_new_fig() - self.ref = result - - def copy(self): - result = dll.fig_draw_fig_copy(self) - return result - - def kind(self): - result = dll.fig_draw_fig_kind(self) - return result - - def set_kind(self, kind): - dll.fig_draw_fig_set_kind(self, kind) - - def z_level(self): - result = dll.fig_draw_fig_z_level(self) - return result - - def set_zlevel(self, z_level): - dll.fig_draw_fig_set_zlevel(self, z_level) - - def x(self): - result = dll.fig_draw_fig_x(self) - return result - - def y(self): - result = dll.fig_draw_fig_y(self) - return result - - def width(self): - result = dll.fig_draw_fig_width(self) - return result - - def height(self): - result = dll.fig_draw_fig_height(self) - return result - - def set_screen_box(self, x, y, w, h): - dll.fig_draw_fig_set_screen_box(self, x, y, w, h) - - def set_fill_color(self, r, g, b, a): - dll.fig_draw_fig_set_fill_color(self, r, g, b, a) - - def set_rotation(self, rotation): - dll.fig_draw_fig_set_rotation(self, rotation) - -class RenderList(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_render_list_unref(self) - - def __init__(self): - result = dll.fig_draw_new_render_list() - self.ref = result - - def copy(self): - result = dll.fig_draw_render_list_copy(self) - return result - - def clear(self): - dll.fig_draw_render_list_clear(self) - - def node_count(self): - result = dll.fig_draw_render_list_node_count(self) - return result - - def root_count(self): - result = dll.fig_draw_render_list_root_count(self) - return result - - def add_root(self, root): - result = dll.fig_draw_render_list_add_root(self, root) - return result - - def add_child(self, parent_idx, child): - result = dll.fig_draw_render_list_add_child(self, parent_idx, child) - return result - - def get_node(self, node_idx): - result = dll.fig_draw_render_list_get_node(self, node_idx) - return result - - def get_root_id(self, root_idx): - result = dll.fig_draw_render_list_get_root_id(self, root_idx) - return result - -class Renders(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_renders_unref(self) - - def __init__(self): - result = dll.fig_draw_new_renders() - self.ref = result - - def clear(self): - dll.fig_draw_renders_clear(self) - - def contains_layer(self, z_level): - result = dll.fig_draw_renders_contains_layer(self, z_level) - return result - - def add_root(self, z_level, root): - result = dll.fig_draw_renders_add_root(self, z_level, root) - return result - - def add_child(self, z_level, parent_idx, child): - result = dll.fig_draw_renders_add_child(self, z_level, parent_idx, child) - return result - - def layer_node_count(self, z_level): - result = dll.fig_draw_renders_layer_node_count(self, z_level) - return result - - def layer_root_count(self, z_level): - result = dll.fig_draw_renders_layer_root_count(self, z_level) - return result - - def get_layer_node(self, z_level, node_idx): - result = dll.fig_draw_renders_get_layer_node(self, z_level, node_idx) - return result - -def new_rectangle_fig(x, y, w, h): - result = dll.fig_draw_new_rectangle_fig(x, y, w, h) - return result - -def new_text_fig(x, y, w, h): - result = dll.fig_draw_new_text_fig(x, y, w, h) - return result - -def new_image_fig(x, y, w, h, image_id): - result = dll.fig_draw_new_image_fig(x, y, w, h, image_id) - return result - -def new_transform_fig(x, y, w, h, tx, ty): - result = dll.fig_draw_new_transform_fig(x, y, w, h, tx, ty) - return result - -def fig_data_dir(): - result = dll.fig_draw_fig_data_dir().decode("utf8") - return result - -def set_fig_data_dir(dir): - dll.fig_draw_set_fig_data_dir(dir.encode("utf8")) - -def fig_ui_scale(): - result = dll.fig_draw_fig_ui_scale() - return result - -def set_fig_ui_scale(scale): - dll.fig_draw_set_fig_ui_scale(scale) - -def scaled(a): - result = dll.fig_draw_scaled(a) - return result - -def descaled(a): - result = dll.fig_draw_descaled(a) - return result - -class SiwinWindowRef(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_siwin_window_ref_unref(self) - - def close_window_binding(self): - dll.fig_draw_siwin_window_ref_close_window_binding(self) - - def step_window_binding(self): - dll.fig_draw_siwin_window_ref_step_window_binding(self) - - def make_current_window_binding(self): - dll.fig_draw_siwin_window_ref_make_current_window_binding(self) - - def window_is_open_binding(self): - result = dll.fig_draw_siwin_window_ref_window_is_open_binding(self) - return result - - def siwin_display_server_name_binding(self): - result = dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding(self).decode("utf8") - return result - - def backing_width_binding(self): - result = dll.fig_draw_siwin_window_ref_backing_width_binding(self) - return result - - def backing_height_binding(self): - result = dll.fig_draw_siwin_window_ref_backing_height_binding(self) - return result - - def logical_width_binding(self): - result = dll.fig_draw_siwin_window_ref_logical_width_binding(self) - return result - - def logical_height_binding(self): - result = dll.fig_draw_siwin_window_ref_logical_height_binding(self) - return result - - def content_scale_binding(self): - result = dll.fig_draw_siwin_window_ref_content_scale_binding(self) - return result - - def configure_ui_scale_binding(self, env_var): - result = dll.fig_draw_siwin_window_ref_configure_ui_scale_binding(self, env_var.encode("utf8")) - return result - - def refresh_ui_scale_binding(self, auto_scale): - dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding(self, auto_scale) - - def present_now_binding(self): - dll.fig_draw_siwin_window_ref_present_now_binding(self) - -class SiwinRendererRef(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_siwin_renderer_ref_unref(self) - - def siwin_backend_name_for_renderer_binding(self): - result = dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self).decode("utf8") - return result - - def siwin_window_title_for_renderer_binding(self, window, suffix): - result = dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self, window, suffix.encode("utf8")).decode("utf8") - return result - - def setup_backend_binding(self, window): - dll.fig_draw_siwin_renderer_ref_setup_backend_binding(self, window) - - def begin_frame_binding(self): - dll.fig_draw_siwin_renderer_ref_begin_frame_binding(self) - - def end_frame_binding(self): - dll.fig_draw_siwin_renderer_ref_end_frame_binding(self) - -class SiwinMetalLayerRef(Structure): - _fields_ = [("ref", c_ulonglong)] - - def __bool__(self): - return self.ref != None - - def __eq__(self, obj): - return self.ref == obj.ref - - def __del__(self): - dll.fig_draw_siwin_metal_layer_ref_unref(self) - - def update_metal_layer_binding(self, window): - dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self, window) - - def set_opaque_binding(self, opaque): - dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding(self, opaque) - -def siwin_backend_name_binding(): - result = dll.fig_draw_siwin_backend_name_binding().decode("utf8") - return result - -def siwin_window_title_binding(suffix): - result = dll.fig_draw_siwin_window_title_binding(suffix.encode("utf8")).decode("utf8") - return result - -def shared_siwin_globals_ptr_binding(): - result = dll.fig_draw_shared_siwin_globals_ptr_binding() - return result - -def new_siwin_renderer_binding(atlas_size, pixel_scale): - result = dll.fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale) - return result - -def new_siwin_window_binding(width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent): - result = dll.fig_draw_new_siwin_window_binding(width, height, fullscreen, title.encode("utf8"), vsync, msaa, resizable, frameless, transparent) - return result - -def new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title, vsync, msaa, resizable, frameless, transparent): - result = dll.fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.encode("utf8"), vsync, msaa, resizable, frameless, transparent) - return result - -def attach_metal_layer_binding(window, device_ptr): - result = dll.fig_draw_attach_metal_layer_binding(window, device_ptr) - return result - -dll.fig_draw_fig_unref.argtypes = [Fig] -dll.fig_draw_fig_unref.restype = None - -dll.fig_draw_new_fig.argtypes = [] -dll.fig_draw_new_fig.restype = c_ulonglong - -dll.fig_draw_fig_copy.argtypes = [Fig] -dll.fig_draw_fig_copy.restype = Fig - -dll.fig_draw_fig_kind.argtypes = [Fig] -dll.fig_draw_fig_kind.restype = FigKind - -dll.fig_draw_fig_set_kind.argtypes = [Fig, FigKind] -dll.fig_draw_fig_set_kind.restype = None - -dll.fig_draw_fig_z_level.argtypes = [Fig] -dll.fig_draw_fig_z_level.restype = ZLevel - -dll.fig_draw_fig_set_zlevel.argtypes = [Fig, ZLevel] -dll.fig_draw_fig_set_zlevel.restype = None - -dll.fig_draw_fig_x.argtypes = [Fig] -dll.fig_draw_fig_x.restype = c_float - -dll.fig_draw_fig_y.argtypes = [Fig] -dll.fig_draw_fig_y.restype = c_float - -dll.fig_draw_fig_width.argtypes = [Fig] -dll.fig_draw_fig_width.restype = c_float - -dll.fig_draw_fig_height.argtypes = [Fig] -dll.fig_draw_fig_height.restype = c_float - -dll.fig_draw_fig_set_screen_box.argtypes = [Fig, c_float, c_float, c_float, c_float] -dll.fig_draw_fig_set_screen_box.restype = None - -dll.fig_draw_fig_set_fill_color.argtypes = [Fig, c_ubyte, c_ubyte, c_ubyte, c_ubyte] -dll.fig_draw_fig_set_fill_color.restype = None - -dll.fig_draw_fig_set_rotation.argtypes = [Fig, c_float] -dll.fig_draw_fig_set_rotation.restype = None - -dll.fig_draw_render_list_unref.argtypes = [RenderList] -dll.fig_draw_render_list_unref.restype = None - -dll.fig_draw_new_render_list.argtypes = [] -dll.fig_draw_new_render_list.restype = c_ulonglong - -dll.fig_draw_render_list_copy.argtypes = [RenderList] -dll.fig_draw_render_list_copy.restype = RenderList - -dll.fig_draw_render_list_clear.argtypes = [RenderList] -dll.fig_draw_render_list_clear.restype = None - -dll.fig_draw_render_list_node_count.argtypes = [RenderList] -dll.fig_draw_render_list_node_count.restype = c_longlong - -dll.fig_draw_render_list_root_count.argtypes = [RenderList] -dll.fig_draw_render_list_root_count.restype = c_longlong - -dll.fig_draw_render_list_add_root.argtypes = [RenderList, Fig] -dll.fig_draw_render_list_add_root.restype = c_short - -dll.fig_draw_render_list_add_child.argtypes = [RenderList, c_short, Fig] -dll.fig_draw_render_list_add_child.restype = c_short - -dll.fig_draw_render_list_get_node.argtypes = [RenderList, c_short] -dll.fig_draw_render_list_get_node.restype = Fig - -dll.fig_draw_render_list_get_root_id.argtypes = [RenderList, c_short] -dll.fig_draw_render_list_get_root_id.restype = c_short - -dll.fig_draw_renders_unref.argtypes = [Renders] -dll.fig_draw_renders_unref.restype = None - -dll.fig_draw_new_renders.argtypes = [] -dll.fig_draw_new_renders.restype = c_ulonglong - -dll.fig_draw_renders_clear.argtypes = [Renders] -dll.fig_draw_renders_clear.restype = None - -dll.fig_draw_renders_contains_layer.argtypes = [Renders, ZLevel] -dll.fig_draw_renders_contains_layer.restype = c_bool - -dll.fig_draw_renders_add_root.argtypes = [Renders, ZLevel, Fig] -dll.fig_draw_renders_add_root.restype = c_short - -dll.fig_draw_renders_add_child.argtypes = [Renders, ZLevel, c_short, Fig] -dll.fig_draw_renders_add_child.restype = c_short - -dll.fig_draw_renders_layer_node_count.argtypes = [Renders, ZLevel] -dll.fig_draw_renders_layer_node_count.restype = c_longlong - -dll.fig_draw_renders_layer_root_count.argtypes = [Renders, ZLevel] -dll.fig_draw_renders_layer_root_count.restype = c_longlong - -dll.fig_draw_renders_get_layer_node.argtypes = [Renders, ZLevel, c_short] -dll.fig_draw_renders_get_layer_node.restype = Fig - -dll.fig_draw_new_rectangle_fig.argtypes = [c_float, c_float, c_float, c_float] -dll.fig_draw_new_rectangle_fig.restype = Fig - -dll.fig_draw_new_text_fig.argtypes = [c_float, c_float, c_float, c_float] -dll.fig_draw_new_text_fig.restype = Fig - -dll.fig_draw_new_image_fig.argtypes = [c_float, c_float, c_float, c_float, c_longlong] -dll.fig_draw_new_image_fig.restype = Fig - -dll.fig_draw_new_transform_fig.argtypes = [c_float, c_float, c_float, c_float, c_float, c_float] -dll.fig_draw_new_transform_fig.restype = Fig - -dll.fig_draw_fig_data_dir.argtypes = [] -dll.fig_draw_fig_data_dir.restype = c_char_p - -dll.fig_draw_set_fig_data_dir.argtypes = [c_char_p] -dll.fig_draw_set_fig_data_dir.restype = None - -dll.fig_draw_fig_ui_scale.argtypes = [] -dll.fig_draw_fig_ui_scale.restype = c_float - -dll.fig_draw_set_fig_ui_scale.argtypes = [c_float] -dll.fig_draw_set_fig_ui_scale.restype = None - -dll.fig_draw_scaled.argtypes = [c_float] -dll.fig_draw_scaled.restype = c_float - -dll.fig_draw_descaled.argtypes = [c_float] -dll.fig_draw_descaled.restype = c_float - -dll.fig_draw_siwin_window_ref_unref.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_unref.restype = None - -dll.fig_draw_siwin_window_ref_close_window_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_close_window_binding.restype = None - -dll.fig_draw_siwin_window_ref_step_window_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_step_window_binding.restype = None - -dll.fig_draw_siwin_window_ref_make_current_window_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_make_current_window_binding.restype = None - -dll.fig_draw_siwin_window_ref_window_is_open_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_window_is_open_binding.restype = c_bool - -dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_siwin_display_server_name_binding.restype = c_char_p - -dll.fig_draw_siwin_window_ref_backing_width_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_backing_width_binding.restype = c_int - -dll.fig_draw_siwin_window_ref_backing_height_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_backing_height_binding.restype = c_int - -dll.fig_draw_siwin_window_ref_logical_width_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_logical_width_binding.restype = c_float - -dll.fig_draw_siwin_window_ref_logical_height_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_logical_height_binding.restype = c_float - -dll.fig_draw_siwin_window_ref_content_scale_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_content_scale_binding.restype = c_float - -dll.fig_draw_siwin_window_ref_configure_ui_scale_binding.argtypes = [SiwinWindowRef, c_char_p] -dll.fig_draw_siwin_window_ref_configure_ui_scale_binding.restype = c_bool - -dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding.argtypes = [SiwinWindowRef, c_bool] -dll.fig_draw_siwin_window_ref_refresh_ui_scale_binding.restype = None - -dll.fig_draw_siwin_window_ref_present_now_binding.argtypes = [SiwinWindowRef] -dll.fig_draw_siwin_window_ref_present_now_binding.restype = None - -dll.fig_draw_siwin_renderer_ref_unref.argtypes = [SiwinRendererRef] -dll.fig_draw_siwin_renderer_ref_unref.restype = None - -dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding.argtypes = [SiwinRendererRef] -dll.fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding.restype = c_char_p - -dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding.argtypes = [SiwinRendererRef, SiwinWindowRef, c_char_p] -dll.fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding.restype = c_char_p - -dll.fig_draw_siwin_renderer_ref_setup_backend_binding.argtypes = [SiwinRendererRef, SiwinWindowRef] -dll.fig_draw_siwin_renderer_ref_setup_backend_binding.restype = None - -dll.fig_draw_siwin_renderer_ref_begin_frame_binding.argtypes = [SiwinRendererRef] -dll.fig_draw_siwin_renderer_ref_begin_frame_binding.restype = None - -dll.fig_draw_siwin_renderer_ref_end_frame_binding.argtypes = [SiwinRendererRef] -dll.fig_draw_siwin_renderer_ref_end_frame_binding.restype = None - -dll.fig_draw_siwin_metal_layer_ref_unref.argtypes = [SiwinMetalLayerRef] -dll.fig_draw_siwin_metal_layer_ref_unref.restype = None - -dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding.argtypes = [SiwinMetalLayerRef, SiwinWindowRef] -dll.fig_draw_siwin_metal_layer_ref_update_metal_layer_binding.restype = None - -dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding.argtypes = [SiwinMetalLayerRef, c_bool] -dll.fig_draw_siwin_metal_layer_ref_set_opaque_binding.restype = None - -dll.fig_draw_siwin_backend_name_binding.argtypes = [] -dll.fig_draw_siwin_backend_name_binding.restype = c_char_p - -dll.fig_draw_siwin_window_title_binding.argtypes = [c_char_p] -dll.fig_draw_siwin_window_title_binding.restype = c_char_p - -dll.fig_draw_shared_siwin_globals_ptr_binding.argtypes = [] -dll.fig_draw_shared_siwin_globals_ptr_binding.restype = c_ulonglong - -dll.fig_draw_new_siwin_renderer_binding.argtypes = [c_longlong, c_float] -dll.fig_draw_new_siwin_renderer_binding.restype = SiwinRendererRef - -dll.fig_draw_new_siwin_window_binding.argtypes = [c_int, c_int, c_bool, c_char_p, c_bool, c_int, c_bool, c_bool, c_bool] -dll.fig_draw_new_siwin_window_binding.restype = SiwinWindowRef - -dll.fig_draw_new_siwin_window_for_renderer_binding.argtypes = [SiwinRendererRef, c_int, c_int, c_bool, c_char_p, c_bool, c_int, c_bool, c_bool, c_bool] -dll.fig_draw_new_siwin_window_for_renderer_binding.restype = SiwinWindowRef - -dll.fig_draw_attach_metal_layer_binding.argtypes = [SiwinWindowRef, c_ulonglong] -dll.fig_draw_attach_metal_layer_binding.restype = SiwinMetalLayerRef - diff --git a/bindings/generated/fig_draw.zig b/bindings/generated/fig_draw.zig deleted file mode 100644 index 18f92ce..0000000 --- a/bindings/generated/fig_draw.zig +++ /dev/null @@ -1,383 +0,0 @@ -const std = @import("std"); - -pub const FigKind = enum(u8) { - fig_kind = 0, -}; - -pub const Fig = opaque { - extern fn fig_draw_fig_unref(self: *Fig) callconv(.C) void; - pub inline fn deinit(self: *Fig) void { - return fig_draw_fig_unref(self); - } - - extern fn fig_draw_new_fig() callconv(.C) *Fig; - pub inline fn init() *Fig { - return fig_draw_new_fig(); - } - - extern fn fig_draw_fig_copy(self: *Fig) callconv(.C) *Fig; - pub inline fn copy(self: *Fig) *Fig { - return fig_draw_fig_copy(self); - } - - extern fn fig_draw_fig_kind(self: *Fig) callconv(.C) FigKind; - pub inline fn kind(self: *Fig) FigKind { - return fig_draw_fig_kind(self); - } - - extern fn fig_draw_fig_set_kind(self: *Fig, kind: FigKind) callconv(.C) void; - pub inline fn setKind(self: *Fig, kind: FigKind) void { - return fig_draw_fig_set_kind(self, kind); - } - - extern fn fig_draw_fig_z_level(self: *Fig) callconv(.C) ZLevel; - pub inline fn zLevel(self: *Fig) ZLevel { - return fig_draw_fig_z_level(self); - } - - extern fn fig_draw_fig_set_zlevel(self: *Fig, z_level: ZLevel) callconv(.C) void; - pub inline fn setZLevel(self: *Fig, z_level: ZLevel) void { - return fig_draw_fig_set_zlevel(self, z_level); - } - - extern fn fig_draw_fig_x(self: *Fig) callconv(.C) f32; - pub inline fn x(self: *Fig) f32 { - return fig_draw_fig_x(self); - } - - extern fn fig_draw_fig_y(self: *Fig) callconv(.C) f32; - pub inline fn y(self: *Fig) f32 { - return fig_draw_fig_y(self); - } - - extern fn fig_draw_fig_width(self: *Fig) callconv(.C) f32; - pub inline fn width(self: *Fig) f32 { - return fig_draw_fig_width(self); - } - - extern fn fig_draw_fig_height(self: *Fig) callconv(.C) f32; - pub inline fn height(self: *Fig) f32 { - return fig_draw_fig_height(self); - } - - extern fn fig_draw_fig_set_screen_box(self: *Fig, x: f32, y: f32, w: f32, h: f32) callconv(.C) void; - pub inline fn setScreenBox(self: *Fig, x: f32, y: f32, w: f32, h: f32) void { - return fig_draw_fig_set_screen_box(self, x, y, w, h); - } - - extern fn fig_draw_fig_set_fill_color(self: *Fig, r: u8, g: u8, b: u8, a: u8) callconv(.C) void; - pub inline fn setFillColor(self: *Fig, r: u8, g: u8, b: u8, a: u8) void { - return fig_draw_fig_set_fill_color(self, r, g, b, a); - } - - extern fn fig_draw_fig_set_rotation(self: *Fig, rotation: f32) callconv(.C) void; - pub inline fn setRotation(self: *Fig, rotation: f32) void { - return fig_draw_fig_set_rotation(self, rotation); - } -}; - -pub const RenderList = opaque { - extern fn fig_draw_render_list_unref(self: *RenderList) callconv(.C) void; - pub inline fn deinit(self: *RenderList) void { - return fig_draw_render_list_unref(self); - } - - extern fn fig_draw_new_render_list() callconv(.C) *RenderList; - pub inline fn init() *RenderList { - return fig_draw_new_render_list(); - } - - extern fn fig_draw_render_list_copy(self: *RenderList) callconv(.C) *RenderList; - pub inline fn copy(self: *RenderList) *RenderList { - return fig_draw_render_list_copy(self); - } - - extern fn fig_draw_render_list_clear(self: *RenderList) callconv(.C) void; - pub inline fn clear(self: *RenderList) void { - return fig_draw_render_list_clear(self); - } - - extern fn fig_draw_render_list_node_count(self: *RenderList) callconv(.C) isize; - pub inline fn nodeCount(self: *RenderList) isize { - return fig_draw_render_list_node_count(self); - } - - extern fn fig_draw_render_list_root_count(self: *RenderList) callconv(.C) isize; - pub inline fn rootCount(self: *RenderList) isize { - return fig_draw_render_list_root_count(self); - } - - extern fn fig_draw_render_list_add_root(self: *RenderList, root: *Fig) callconv(.C) i16; - pub inline fn addRoot(self: *RenderList, root: *Fig) i16 { - return fig_draw_render_list_add_root(self, root); - } - - extern fn fig_draw_render_list_add_child(self: *RenderList, parent_idx: i16, child: *Fig) callconv(.C) i16; - pub inline fn addChild(self: *RenderList, parent_idx: i16, child: *Fig) i16 { - return fig_draw_render_list_add_child(self, parent_idx, child); - } - - extern fn fig_draw_render_list_get_node(self: *RenderList, node_idx: i16) callconv(.C) *Fig; - pub inline fn getNode(self: *RenderList, node_idx: i16) *Fig { - return fig_draw_render_list_get_node(self, node_idx); - } - - extern fn fig_draw_render_list_get_root_id(self: *RenderList, root_idx: i16) callconv(.C) i16; - pub inline fn getRootId(self: *RenderList, root_idx: i16) i16 { - return fig_draw_render_list_get_root_id(self, root_idx); - } -}; - -pub const Renders = opaque { - extern fn fig_draw_renders_unref(self: *Renders) callconv(.C) void; - pub inline fn deinit(self: *Renders) void { - return fig_draw_renders_unref(self); - } - - extern fn fig_draw_new_renders() callconv(.C) *Renders; - pub inline fn init() *Renders { - return fig_draw_new_renders(); - } - - extern fn fig_draw_renders_clear(self: *Renders) callconv(.C) void; - pub inline fn clear(self: *Renders) void { - return fig_draw_renders_clear(self); - } - - extern fn fig_draw_renders_contains_layer(self: *Renders, z_level: ZLevel) callconv(.C) bool; - pub inline fn containsLayer(self: *Renders, z_level: ZLevel) bool { - return fig_draw_renders_contains_layer(self, z_level); - } - - extern fn fig_draw_renders_add_root(self: *Renders, z_level: ZLevel, root: *Fig) callconv(.C) i16; - pub inline fn addRoot(self: *Renders, z_level: ZLevel, root: *Fig) i16 { - return fig_draw_renders_add_root(self, z_level, root); - } - - extern fn fig_draw_renders_add_child(self: *Renders, z_level: ZLevel, parent_idx: i16, child: *Fig) callconv(.C) i16; - pub inline fn addChild(self: *Renders, z_level: ZLevel, parent_idx: i16, child: *Fig) i16 { - return fig_draw_renders_add_child(self, z_level, parent_idx, child); - } - - extern fn fig_draw_renders_layer_node_count(self: *Renders, z_level: ZLevel) callconv(.C) isize; - pub inline fn layerNodeCount(self: *Renders, z_level: ZLevel) isize { - return fig_draw_renders_layer_node_count(self, z_level); - } - - extern fn fig_draw_renders_layer_root_count(self: *Renders, z_level: ZLevel) callconv(.C) isize; - pub inline fn layerRootCount(self: *Renders, z_level: ZLevel) isize { - return fig_draw_renders_layer_root_count(self, z_level); - } - - extern fn fig_draw_renders_get_layer_node(self: *Renders, z_level: ZLevel, node_idx: i16) callconv(.C) *Fig; - pub inline fn getLayerNode(self: *Renders, z_level: ZLevel, node_idx: i16) *Fig { - return fig_draw_renders_get_layer_node(self, z_level, node_idx); - } -}; - -extern fn fig_draw_new_rectangle_fig(x: f32, y: f32, w: f32, h: f32) callconv(.C) *Fig; -pub inline fn newRectangleFig(x: f32, y: f32, w: f32, h: f32) *Fig { - return fig_draw_new_rectangle_fig(x, y, w, h); -} - -extern fn fig_draw_new_text_fig(x: f32, y: f32, w: f32, h: f32) callconv(.C) *Fig; -pub inline fn newTextFig(x: f32, y: f32, w: f32, h: f32) *Fig { - return fig_draw_new_text_fig(x, y, w, h); -} - -extern fn fig_draw_new_image_fig(x: f32, y: f32, w: f32, h: f32, image_id: i63) callconv(.C) *Fig; -pub inline fn newImageFig(x: f32, y: f32, w: f32, h: f32, image_id: i63) *Fig { - return fig_draw_new_image_fig(x, y, w, h, image_id); -} - -extern fn fig_draw_new_transform_fig(x: f32, y: f32, w: f32, h: f32, tx: f32, ty: f32) callconv(.C) *Fig; -pub inline fn newTransformFig(x: f32, y: f32, w: f32, h: f32, tx: f32, ty: f32) *Fig { - return fig_draw_new_transform_fig(x, y, w, h, tx, ty); -} - -extern fn fig_draw_fig_data_dir() callconv(.C) [*:0]const u8; -pub inline fn figDataDir() [:0]const u8 { - return std.mem.span(fig_draw_fig_data_dir()); -} - -extern fn fig_draw_set_fig_data_dir(dir: [*:0]const u8) callconv(.C) void; -pub inline fn setFigDataDir(dir: [:0]const u8) void { - return fig_draw_set_fig_data_dir(dir.ptr); -} - -extern fn fig_draw_fig_ui_scale() callconv(.C) f32; -pub inline fn figUiScale() f32 { - return fig_draw_fig_ui_scale(); -} - -extern fn fig_draw_set_fig_ui_scale(scale: f32) callconv(.C) void; -pub inline fn setFigUiScale(scale: f32) void { - return fig_draw_set_fig_ui_scale(scale); -} - -extern fn fig_draw_scaled(a: f32) callconv(.C) f32; -pub inline fn scaled(a: f32) f32 { - return fig_draw_scaled(a); -} - -extern fn fig_draw_descaled(a: f32) callconv(.C) f32; -pub inline fn descaled(a: f32) f32 { - return fig_draw_descaled(a); -} - -pub const SiwinWindowRef = opaque { - extern fn fig_draw_siwin_window_ref_unref(self: *SiwinWindowRef) callconv(.C) void; - pub inline fn deinit(self: *SiwinWindowRef) void { - return fig_draw_siwin_window_ref_unref(self); - } - - extern fn fig_draw_siwin_window_ref_close_window_binding(self: *SiwinWindowRef) callconv(.C) void; - pub inline fn closeWindowBinding(self: *SiwinWindowRef) void { - return fig_draw_siwin_window_ref_close_window_binding(self); - } - - extern fn fig_draw_siwin_window_ref_step_window_binding(self: *SiwinWindowRef) callconv(.C) void; - pub inline fn stepWindowBinding(self: *SiwinWindowRef) void { - return fig_draw_siwin_window_ref_step_window_binding(self); - } - - extern fn fig_draw_siwin_window_ref_make_current_window_binding(self: *SiwinWindowRef) callconv(.C) void; - pub inline fn makeCurrentWindowBinding(self: *SiwinWindowRef) void { - return fig_draw_siwin_window_ref_make_current_window_binding(self); - } - - extern fn fig_draw_siwin_window_ref_window_is_open_binding(self: *SiwinWindowRef) callconv(.C) bool; - pub inline fn windowIsOpenBinding(self: *SiwinWindowRef) bool { - return fig_draw_siwin_window_ref_window_is_open_binding(self); - } - - extern fn fig_draw_siwin_window_ref_siwin_display_server_name_binding(self: *SiwinWindowRef) callconv(.C) [*:0]const u8; - pub inline fn siwinDisplayServerNameBinding(self: *SiwinWindowRef) [:0]const u8 { - return std.mem.span(fig_draw_siwin_window_ref_siwin_display_server_name_binding(self)); - } - - extern fn fig_draw_siwin_window_ref_backing_width_binding(self: *SiwinWindowRef) callconv(.C) i32; - pub inline fn backingWidthBinding(self: *SiwinWindowRef) i32 { - return fig_draw_siwin_window_ref_backing_width_binding(self); - } - - extern fn fig_draw_siwin_window_ref_backing_height_binding(self: *SiwinWindowRef) callconv(.C) i32; - pub inline fn backingHeightBinding(self: *SiwinWindowRef) i32 { - return fig_draw_siwin_window_ref_backing_height_binding(self); - } - - extern fn fig_draw_siwin_window_ref_logical_width_binding(self: *SiwinWindowRef) callconv(.C) f32; - pub inline fn logicalWidthBinding(self: *SiwinWindowRef) f32 { - return fig_draw_siwin_window_ref_logical_width_binding(self); - } - - extern fn fig_draw_siwin_window_ref_logical_height_binding(self: *SiwinWindowRef) callconv(.C) f32; - pub inline fn logicalHeightBinding(self: *SiwinWindowRef) f32 { - return fig_draw_siwin_window_ref_logical_height_binding(self); - } - - extern fn fig_draw_siwin_window_ref_content_scale_binding(self: *SiwinWindowRef) callconv(.C) f32; - pub inline fn contentScaleBinding(self: *SiwinWindowRef) f32 { - return fig_draw_siwin_window_ref_content_scale_binding(self); - } - - extern fn fig_draw_siwin_window_ref_configure_ui_scale_binding(self: *SiwinWindowRef, env_var: [*:0]const u8) callconv(.C) bool; - pub inline fn configureUiScaleBinding(self: *SiwinWindowRef, env_var: [:0]const u8) bool { - return fig_draw_siwin_window_ref_configure_ui_scale_binding(self, env_var.ptr); - } - - extern fn fig_draw_siwin_window_ref_refresh_ui_scale_binding(self: *SiwinWindowRef, auto_scale: bool) callconv(.C) void; - pub inline fn refreshUiScaleBinding(self: *SiwinWindowRef, auto_scale: bool) void { - return fig_draw_siwin_window_ref_refresh_ui_scale_binding(self, auto_scale); - } - - extern fn fig_draw_siwin_window_ref_present_now_binding(self: *SiwinWindowRef) callconv(.C) void; - pub inline fn presentNowBinding(self: *SiwinWindowRef) void { - return fig_draw_siwin_window_ref_present_now_binding(self); - } -}; - -pub const SiwinRendererRef = opaque { - extern fn fig_draw_siwin_renderer_ref_unref(self: *SiwinRendererRef) callconv(.C) void; - pub inline fn deinit(self: *SiwinRendererRef) void { - return fig_draw_siwin_renderer_ref_unref(self); - } - - extern fn fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self: *SiwinRendererRef) callconv(.C) [*:0]const u8; - pub inline fn siwinBackendNameForRendererBinding(self: *SiwinRendererRef) [:0]const u8 { - return std.mem.span(fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding(self)); - } - - extern fn fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self: *SiwinRendererRef, window: *SiwinWindowRef, suffix: [*:0]const u8) callconv(.C) [*:0]const u8; - pub inline fn siwinWindowTitleForRendererBinding(self: *SiwinRendererRef, window: *SiwinWindowRef, suffix: [:0]const u8) [:0]const u8 { - return std.mem.span(fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding(self, window, suffix.ptr)); - } - - extern fn fig_draw_siwin_renderer_ref_setup_backend_binding(self: *SiwinRendererRef, window: *SiwinWindowRef) callconv(.C) void; - pub inline fn setupBackendBinding(self: *SiwinRendererRef, window: *SiwinWindowRef) void { - return fig_draw_siwin_renderer_ref_setup_backend_binding(self, window); - } - - extern fn fig_draw_siwin_renderer_ref_begin_frame_binding(self: *SiwinRendererRef) callconv(.C) void; - pub inline fn beginFrameBinding(self: *SiwinRendererRef) void { - return fig_draw_siwin_renderer_ref_begin_frame_binding(self); - } - - extern fn fig_draw_siwin_renderer_ref_end_frame_binding(self: *SiwinRendererRef) callconv(.C) void; - pub inline fn endFrameBinding(self: *SiwinRendererRef) void { - return fig_draw_siwin_renderer_ref_end_frame_binding(self); - } -}; - -pub const SiwinMetalLayerRef = opaque { - extern fn fig_draw_siwin_metal_layer_ref_unref(self: *SiwinMetalLayerRef) callconv(.C) void; - pub inline fn deinit(self: *SiwinMetalLayerRef) void { - return fig_draw_siwin_metal_layer_ref_unref(self); - } - - extern fn fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self: *SiwinMetalLayerRef, window: *SiwinWindowRef) callconv(.C) void; - pub inline fn updateMetalLayerBinding(self: *SiwinMetalLayerRef, window: *SiwinWindowRef) void { - return fig_draw_siwin_metal_layer_ref_update_metal_layer_binding(self, window); - } - - extern fn fig_draw_siwin_metal_layer_ref_set_opaque_binding(self: *SiwinMetalLayerRef, opaque: bool) callconv(.C) void; - pub inline fn setOpaqueBinding(self: *SiwinMetalLayerRef, opaque: bool) void { - return fig_draw_siwin_metal_layer_ref_set_opaque_binding(self, opaque); - } -}; - -extern fn fig_draw_siwin_backend_name_binding() callconv(.C) [*:0]const u8; -pub inline fn siwinBackendNameBinding() [:0]const u8 { - return std.mem.span(fig_draw_siwin_backend_name_binding()); -} - -extern fn fig_draw_siwin_window_title_binding(suffix: [*:0]const u8) callconv(.C) [*:0]const u8; -pub inline fn siwinWindowTitleBinding(suffix: [:0]const u8) [:0]const u8 { - return std.mem.span(fig_draw_siwin_window_title_binding(suffix.ptr)); -} - -extern fn fig_draw_shared_siwin_globals_ptr_binding() callconv(.C) u64; -pub inline fn sharedSiwinGlobalsPtrBinding() u64 { - return fig_draw_shared_siwin_globals_ptr_binding(); -} - -extern fn fig_draw_new_siwin_renderer_binding(atlas_size: isize, pixel_scale: f32) callconv(.C) *SiwinRendererRef; -pub inline fn newSiwinRendererBinding(atlas_size: isize, pixel_scale: f32) *SiwinRendererRef { - return fig_draw_new_siwin_renderer_binding(atlas_size, pixel_scale); -} - -extern fn fig_draw_new_siwin_window_binding(width: i32, height: i32, fullscreen: bool, title: [*:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) callconv(.C) *SiwinWindowRef; -pub inline fn newSiwinWindowBinding(width: i32, height: i32, fullscreen: bool, title: [:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) *SiwinWindowRef { - return fig_draw_new_siwin_window_binding(width, height, fullscreen, title.ptr, vsync, msaa, resizable, frameless, transparent); -} - -extern fn fig_draw_new_siwin_window_for_renderer_binding(renderer: *SiwinRendererRef, width: i32, height: i32, fullscreen: bool, title: [*:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) callconv(.C) *SiwinWindowRef; -pub inline fn newSiwinWindowForRendererBinding(renderer: *SiwinRendererRef, width: i32, height: i32, fullscreen: bool, title: [:0]const u8, vsync: bool, msaa: i32, resizable: bool, frameless: bool, transparent: bool) *SiwinWindowRef { - return fig_draw_new_siwin_window_for_renderer_binding(renderer, width, height, fullscreen, title.ptr, vsync, msaa, resizable, frameless, transparent); -} - -extern fn fig_draw_attach_metal_layer_binding(window: *SiwinWindowRef, device_ptr: u64) callconv(.C) *SiwinMetalLayerRef; -pub inline fn attachMetalLayerBinding(window: *SiwinWindowRef, device_ptr: u64) *SiwinMetalLayerRef { - return fig_draw_attach_metal_layer_binding(window, device_ptr); -} - diff --git a/bindings/generated/internal.nim b/bindings/generated/internal.nim deleted file mode 100644 index a84ddc8..0000000 --- a/bindings/generated/internal.nim +++ /dev/null @@ -1,224 +0,0 @@ -when not defined(gcArc) and not defined(gcOrc): - {.error: "Please use --gc:arc or --gc:orc when using Genny.".} - -when (NimMajor, NimMinor, NimPatch) == (1, 6, 2): - {.error: "Nim 1.6.2 not supported with Genny due to FFI issues.".} -proc fig_draw_fig_unref*(x: Fig) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_new_fig*(): Fig {.raises: [], cdecl, exportc, dynlib.} = - newFig() - -proc fig_draw_fig_copy*(fig: Fig): Fig {.raises: [], cdecl, exportc, dynlib.} = - copy(fig) - -proc fig_draw_fig_kind*(fig: Fig): FigKind {.raises: [], cdecl, exportc, dynlib.} = - kind(fig) - -proc fig_draw_fig_set_kind*(fig: Fig, kind: FigKind) {.raises: [], cdecl, exportc, dynlib.} = - setKind(fig, kind) - -proc fig_draw_fig_z_level*(fig: Fig): ZLevel {.raises: [], cdecl, exportc, dynlib.} = - zLevel(fig) - -proc fig_draw_fig_set_zlevel*(fig: Fig, z_level: ZLevel) {.raises: [], cdecl, exportc, dynlib.} = - setZLevel(fig, z_level) - -proc fig_draw_fig_x*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = - x(fig) - -proc fig_draw_fig_y*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = - y(fig) - -proc fig_draw_fig_width*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = - width(fig) - -proc fig_draw_fig_height*(fig: Fig): float32 {.raises: [], cdecl, exportc, dynlib.} = - height(fig) - -proc fig_draw_fig_set_screen_box*(fig: Fig, x: float32, y: float32, w: float32, h: float32) {.raises: [], cdecl, exportc, dynlib.} = - setScreenBox(fig, x, y, w, h) - -proc fig_draw_fig_set_fill_color*(fig: Fig, r: uint8, g: uint8, b: uint8, a: uint8) {.raises: [], cdecl, exportc, dynlib.} = - setFillColor(fig, r, g, b, a) - -proc fig_draw_fig_set_rotation*(fig: Fig, rotation: float32) {.raises: [], cdecl, exportc, dynlib.} = - setRotation(fig, rotation) - -proc fig_draw_render_list_unref*(x: RenderList) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_new_render_list*(): RenderList {.raises: [], cdecl, exportc, dynlib.} = - newRenderList() - -proc fig_draw_render_list_copy*(list: RenderList): RenderList {.raises: [], cdecl, exportc, dynlib.} = - copy(list) - -proc fig_draw_render_list_clear*(list: RenderList) {.raises: [], cdecl, exportc, dynlib.} = - clear(list) - -proc fig_draw_render_list_node_count*(list: RenderList): int {.raises: [], cdecl, exportc, dynlib.} = - nodeCount(list) - -proc fig_draw_render_list_root_count*(list: RenderList): int {.raises: [], cdecl, exportc, dynlib.} = - rootCount(list) - -proc fig_draw_render_list_add_root*(list: RenderList, root: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = - addRoot(list, root) - -proc fig_draw_render_list_add_child*(list: RenderList, parent_idx: int16, child: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = - addChild(list, parent_idx, child) - -proc fig_draw_render_list_get_node*(list: RenderList, node_idx: int16): Fig {.raises: [], cdecl, exportc, dynlib.} = - getNode(list, node_idx) - -proc fig_draw_render_list_get_root_id*(list: RenderList, root_idx: int16): int16 {.raises: [], cdecl, exportc, dynlib.} = - getRootId(list, root_idx) - -proc fig_draw_renders_unref*(x: Renders) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_new_renders*(): Renders {.raises: [], cdecl, exportc, dynlib.} = - newRenders() - -proc fig_draw_renders_clear*(renders: Renders) {.raises: [], cdecl, exportc, dynlib.} = - clear(renders) - -proc fig_draw_renders_contains_layer*(renders: Renders, z_level: ZLevel): bool {.raises: [], cdecl, exportc, dynlib.} = - containsLayer(renders, z_level) - -proc fig_draw_renders_add_root*(renders: Renders, z_level: ZLevel, root: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = - addRoot(renders, z_level, root) - -proc fig_draw_renders_add_child*(renders: Renders, z_level: ZLevel, parent_idx: int16, child: Fig): int16 {.raises: [], cdecl, exportc, dynlib.} = - addChild(renders, z_level, parent_idx, child) - -proc fig_draw_renders_layer_node_count*(renders: Renders, z_level: ZLevel): int {.raises: [], cdecl, exportc, dynlib.} = - layerNodeCount(renders, z_level) - -proc fig_draw_renders_layer_root_count*(renders: Renders, z_level: ZLevel): int {.raises: [], cdecl, exportc, dynlib.} = - layerRootCount(renders, z_level) - -proc fig_draw_renders_get_layer_node*(renders: Renders, z_level: ZLevel, node_idx: int16): Fig {.raises: [], cdecl, exportc, dynlib.} = - getLayerNode(renders, z_level, node_idx) - -proc fig_draw_new_rectangle_fig*(x: float32, y: float32, w: float32, h: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = - newRectangleFig(x, y, w, h) - -proc fig_draw_new_text_fig*(x: float32, y: float32, w: float32, h: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = - newTextFig(x, y, w, h) - -proc fig_draw_new_image_fig*(x: float32, y: float32, w: float32, h: float32, image_id: int64): Fig {.raises: [], cdecl, exportc, dynlib.} = - newImageFig(x, y, w, h, image_id) - -proc fig_draw_new_transform_fig*(x: float32, y: float32, w: float32, h: float32, tx: float32, ty: float32): Fig {.raises: [], cdecl, exportc, dynlib.} = - newTransformFig(x, y, w, h, tx, ty) - -proc fig_draw_fig_data_dir*(): cstring {.raises: [], cdecl, exportc, dynlib.} = - figDataDir().cstring - -proc fig_draw_set_fig_data_dir*(dir: cstring) {.raises: [], cdecl, exportc, dynlib.} = - setFigDataDir(dir.`$`) - -proc fig_draw_fig_ui_scale*(): float32 {.raises: [], cdecl, exportc, dynlib.} = - figUiScale() - -proc fig_draw_set_fig_ui_scale*(scale: float32) {.raises: [], cdecl, exportc, dynlib.} = - setFigUiScale(scale) - -proc fig_draw_scaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = - scaled(a) - -proc fig_draw_descaled*(a: float32): float32 {.raises: [], cdecl, exportc, dynlib.} = - descaled(a) - -proc fig_draw_siwin_window_ref_unref*(x: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_siwin_window_ref_close_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - closeWindowBinding(window) - -proc fig_draw_siwin_window_ref_step_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - stepWindowBinding(window) - -proc fig_draw_siwin_window_ref_make_current_window_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - makeCurrentWindowBinding(window) - -proc fig_draw_siwin_window_ref_window_is_open_binding*(window: SiwinWindowRef): bool {.raises: [], cdecl, exportc, dynlib.} = - windowIsOpenBinding(window) - -proc fig_draw_siwin_window_ref_siwin_display_server_name_binding*(window: SiwinWindowRef): cstring {.raises: [], cdecl, exportc, dynlib.} = - siwinDisplayServerNameBinding(window).cstring - -proc fig_draw_siwin_window_ref_backing_width_binding*(window: SiwinWindowRef): int32 {.raises: [], cdecl, exportc, dynlib.} = - backingWidthBinding(window) - -proc fig_draw_siwin_window_ref_backing_height_binding*(window: SiwinWindowRef): int32 {.raises: [], cdecl, exportc, dynlib.} = - backingHeightBinding(window) - -proc fig_draw_siwin_window_ref_logical_width_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = - logicalWidthBinding(window) - -proc fig_draw_siwin_window_ref_logical_height_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = - logicalHeightBinding(window) - -proc fig_draw_siwin_window_ref_content_scale_binding*(window: SiwinWindowRef): float32 {.raises: [], cdecl, exportc, dynlib.} = - contentScaleBinding(window) - -proc fig_draw_siwin_window_ref_configure_ui_scale_binding*(window: SiwinWindowRef, env_var: cstring): bool {.raises: [], cdecl, exportc, dynlib.} = - configureUiScaleBinding(window, env_var.`$`) - -proc fig_draw_siwin_window_ref_refresh_ui_scale_binding*(window: SiwinWindowRef, auto_scale: bool) {.raises: [], cdecl, exportc, dynlib.} = - refreshUiScaleBinding(window, auto_scale) - -proc fig_draw_siwin_window_ref_present_now_binding*(window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - presentNowBinding(window) - -proc fig_draw_siwin_renderer_ref_unref*(x: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_siwin_renderer_ref_siwin_backend_name_for_renderer_binding*(renderer: SiwinRendererRef): cstring {.raises: [], cdecl, exportc, dynlib.} = - siwinBackendNameForRendererBinding(renderer).cstring - -proc fig_draw_siwin_renderer_ref_siwin_window_title_for_renderer_binding*(renderer: SiwinRendererRef, window: SiwinWindowRef, suffix: cstring): cstring {.raises: [], cdecl, exportc, dynlib.} = - siwinWindowTitleForRendererBinding(renderer, window, suffix.`$`).cstring - -proc fig_draw_siwin_renderer_ref_setup_backend_binding*(renderer: SiwinRendererRef, window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - setupBackendBinding(renderer, window) - -proc fig_draw_siwin_renderer_ref_begin_frame_binding*(renderer: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = - beginFrameBinding(renderer) - -proc fig_draw_siwin_renderer_ref_end_frame_binding*(renderer: SiwinRendererRef) {.raises: [], cdecl, exportc, dynlib.} = - endFrameBinding(renderer) - -proc fig_draw_siwin_metal_layer_ref_unref*(x: SiwinMetalLayerRef) {.raises: [], cdecl, exportc, dynlib.} = - GC_unref(x) - -proc fig_draw_siwin_metal_layer_ref_update_metal_layer_binding*(layer: SiwinMetalLayerRef, window: SiwinWindowRef) {.raises: [], cdecl, exportc, dynlib.} = - updateMetalLayerBinding(layer, window) - -proc fig_draw_siwin_metal_layer_ref_set_opaque_binding*(layer: SiwinMetalLayerRef, opaque: bool) {.raises: [], cdecl, exportc, dynlib.} = - setOpaqueBinding(layer, opaque) - -proc fig_draw_siwin_backend_name_binding*(): cstring {.raises: [], cdecl, exportc, dynlib.} = - siwinBackendNameBinding().cstring - -proc fig_draw_siwin_window_title_binding*(suffix: cstring): cstring {.raises: [], cdecl, exportc, dynlib.} = - siwinWindowTitleBinding(suffix.`$`).cstring - -proc fig_draw_shared_siwin_globals_ptr_binding*(): uint64 {.raises: [], cdecl, exportc, dynlib.} = - sharedSiwinGlobalsPtrBinding() - -proc fig_draw_new_siwin_renderer_binding*(atlas_size: int, pixel_scale: float32): SiwinRendererRef {.raises: [], cdecl, exportc, dynlib.} = - newSiwinRendererBinding(atlas_size, pixel_scale) - -proc fig_draw_new_siwin_window_binding*(width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.raises: [], cdecl, exportc, dynlib.} = - newSiwinWindowBinding(width, height, fullscreen, title.`$`, vsync, msaa, resizable, frameless, transparent) - -proc fig_draw_new_siwin_window_for_renderer_binding*(renderer: SiwinRendererRef, width: int32, height: int32, fullscreen: bool, title: cstring, vsync: bool, msaa: int32, resizable: bool, frameless: bool, transparent: bool): SiwinWindowRef {.raises: [], cdecl, exportc, dynlib.} = - newSiwinWindowForRendererBinding(renderer, width, height, fullscreen, title.`$`, vsync, msaa, resizable, frameless, transparent) - -proc fig_draw_attach_metal_layer_binding*(window: SiwinWindowRef, device_ptr: uint64): SiwinMetalLayerRef {.raises: [], cdecl, exportc, dynlib.} = - attachMetalLayerBinding(window, device_ptr) - diff --git a/bindings/siwinshim_bindings.nim b/bindings/siwinshim_bindings.nim index f5d92c6..a9bf751 100644 --- a/bindings/siwinshim_bindings.nim +++ b/bindings/siwinshim_bindings.nim @@ -240,6 +240,16 @@ proc endFrameBinding(renderer: SiwinRendererRef) = except Exception: discard +proc renderFrameBinding( + renderer: SiwinRendererRef, renders: Renders, width, height: float32 +) = + if renderer.isNil or renderer.inner.isNil or renders.isNil: + return + try: + renderer.inner.renderFrame(renders.inner, vec2(width, height)) + except Exception: + discard + when defined(macosx) and UseMetalBackend: proc attachMetalLayerBinding( window: SiwinWindowRef, devicePtr: uint64 @@ -295,6 +305,7 @@ exportRefObject SiwinRendererRef: setupBackendBinding(SiwinRendererRef, SiwinWindowRef) beginFrameBinding(SiwinRendererRef) endFrameBinding(SiwinRendererRef) + renderFrameBinding(SiwinRendererRef, Renders, float32, float32) when defined(macosx) and UseMetalBackend: exportRefObject SiwinMetalLayerRef: From 9b1caed3ef974116bf2697638fe62a5cca879c1a Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:36:58 -0600 Subject: [PATCH 6/9] update bindings --- bindings/bindings.nim | 31 ++-- bindings/siwinshim_bindings.nim | 42 ++++- examples/python/.gitignore | 1 + examples/python/siwin_renderlist_100.py | 227 ++++++++++++++++++++++++ 4 files changed, 279 insertions(+), 22 deletions(-) create mode 100644 examples/python/.gitignore create mode 100644 examples/python/siwin_renderlist_100.py diff --git a/bindings/bindings.nim b/bindings/bindings.nim index adfb888..c6a90a0 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -10,7 +10,6 @@ const ExportSiwinShim* {.booldefine: "figdraw.bindings.siwinshim".} = false type FigKind* = fdn.FigKind - ZLevel* = int8 Fig* = ref object inner: fdn.Fig @@ -187,10 +186,10 @@ proc kind(fig: Fig): FigKind = proc setKind(fig: Fig, kind: FigKind) = fig.inner = figWithKind(fig.inner, kind) -proc zLevel(fig: Fig): ZLevel = +proc zLevel(fig: Fig): int8 = fig.inner.zlevel.int8 -proc setZLevel(fig: Fig, zLevel: ZLevel) = +proc setZLevel(fig: Fig, zLevel: int8) = fig.inner.zlevel = fdn.ZLevel(zLevel) proc x(fig: Fig): float32 = @@ -250,16 +249,16 @@ proc newRenders(): Renders = proc clear(renders: Renders) = renders.inner.layers.clear() -proc containsLayer(renders: Renders, zLevel: ZLevel): bool = +proc containsLayer(renders: Renders, zLevel: int8): bool = renders.inner.contains(fdn.ZLevel(zLevel)) -proc addRoot(renders: Renders, zLevel: ZLevel, root: Fig): int16 = +proc addRoot(renders: Renders, zLevel: int8, root: Fig): int16 = try: renders.inner.addRoot(fdn.ZLevel(zLevel), root.inner).int16 except CatchableError: -1'i16 -proc addChild(renders: Renders, zLevel: ZLevel, parentIdx: int16, child: Fig): int16 = +proc addChild(renders: Renders, zLevel: int8, parentIdx: int16, child: Fig): int16 = try: renders.inner.addChild( fdn.ZLevel(zLevel), @@ -269,7 +268,7 @@ proc addChild(renders: Renders, zLevel: ZLevel, parentIdx: int16, child: Fig): i except CatchableError: -1'i16 -proc layerNodeCount(renders: Renders, zLevel: ZLevel): int = +proc layerNodeCount(renders: Renders, zLevel: int8): int = try: if not renders.containsLayer(zLevel): return 0 @@ -277,7 +276,7 @@ proc layerNodeCount(renders: Renders, zLevel: ZLevel): int = except CatchableError: 0 -proc layerRootCount(renders: Renders, zLevel: ZLevel): int = +proc layerRootCount(renders: Renders, zLevel: int8): int = try: if not renders.containsLayer(zLevel): return 0 @@ -285,7 +284,7 @@ proc layerRootCount(renders: Renders, zLevel: ZLevel): int = except CatchableError: 0 -proc getLayerNode(renders: Renders, zLevel: ZLevel, nodeIdx: int16): Fig = +proc getLayerNode(renders: Renders, zLevel: int8, nodeIdx: int16): Fig = try: Fig(inner: renders.inner[fdn.ZLevel(zLevel)].nodes[nodeIdx.int]) except CatchableError: @@ -302,7 +301,7 @@ exportRefObject Fig: kind(Fig) setKind(Fig, FigKind) zLevel(Fig) - setZLevel(Fig, ZLevel) + setZLevel(Fig, int8) x(Fig) y(Fig) width(Fig) @@ -329,12 +328,12 @@ exportRefObject Renders: newRenders() procs: clear(Renders) - containsLayer(Renders, ZLevel) - addRoot(Renders, ZLevel, Fig) - addChild(Renders, ZLevel, int16, Fig) - layerNodeCount(Renders, ZLevel) - layerRootCount(Renders, ZLevel) - getLayerNode(Renders, ZLevel, int16) + containsLayer(Renders, int8) + addRoot(Renders, int8, Fig) + addChild(Renders, int8, int16, Fig) + layerNodeCount(Renders, int8) + layerRootCount(Renders, int8) + getLayerNode(Renders, int8, int16) exportRefObject TypefaceRef: discard diff --git a/bindings/siwinshim_bindings.nim b/bindings/siwinshim_bindings.nim index a9bf751..5f93cd3 100644 --- a/bindings/siwinshim_bindings.nim +++ b/bindings/siwinshim_bindings.nim @@ -15,15 +15,24 @@ when defined(macosx) and UseMetalBackend: SiwinMetalLayerRef* = ref object inner: MetalLayerHandle +var + siwinBackendNameStorage {.threadvar.}: string + siwinWindowTitleStorage {.threadvar.}: string + siwinDisplayNameStorage {.threadvar.}: string + siwinRendererBackendNameStorage {.threadvar.}: string + siwinRendererWindowTitleStorage {.threadvar.}: string + proc siwinBackendNameBinding(): string = try: - siwinBackendName() + siwinBackendNameStorage = siwinBackendName() + siwinBackendNameStorage except Exception: "" proc siwinWindowTitleBinding(suffix: string): string = try: - siwinWindowTitle(suffix = suffix) + siwinWindowTitleStorage = siwinWindowTitle(suffix = suffix) + siwinWindowTitleStorage except Exception: "" @@ -45,7 +54,8 @@ proc siwinBackendNameForRendererBinding(renderer: SiwinRendererRef): string = if renderer.isNil or renderer.inner.isNil: return "" try: - siwinBackendName(renderer.inner) + siwinRendererBackendNameStorage = siwinBackendName(renderer.inner) + siwinRendererBackendNameStorage except Exception: "" @@ -121,6 +131,22 @@ proc stepWindowBinding(window: SiwinWindowRef) = except Exception: discard +proc firstStepWindowBinding(window: SiwinWindowRef, makeVisible = true) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.firstStep(makeVisible) + except Exception: + discard + +proc redrawWindowBinding(window: SiwinWindowRef) = + if window.isNil or window.inner.isNil: + return + try: + window.inner.redraw() + except Exception: + discard + proc makeCurrentWindowBinding(window: SiwinWindowRef) = if window.isNil or window.inner.isNil: return @@ -138,7 +164,8 @@ proc siwinDisplayServerNameBinding(window: SiwinWindowRef): string = if window.isNil or window.inner.isNil: return "" try: - siwinDisplayServerName(window.inner) + siwinDisplayNameStorage = siwinDisplayServerName(window.inner) + siwinDisplayNameStorage except Exception: "" @@ -148,7 +175,9 @@ proc siwinWindowTitleForRendererBinding( if renderer.isNil or renderer.inner.isNil or window.isNil or window.inner.isNil: return "" try: - siwinWindowTitle(renderer.inner, window.inner, suffix = suffix) + siwinRendererWindowTitleStorage = + siwinWindowTitle(renderer.inner, window.inner, suffix = suffix) + siwinRendererWindowTitleStorage except Exception: "" @@ -285,7 +314,9 @@ when defined(macosx) and UseMetalBackend: exportRefObject SiwinWindowRef: procs: closeWindowBinding(SiwinWindowRef) + firstStepWindowBinding(SiwinWindowRef, bool) stepWindowBinding(SiwinWindowRef) + redrawWindowBinding(SiwinWindowRef) makeCurrentWindowBinding(SiwinWindowRef) windowIsOpenBinding(SiwinWindowRef) siwinDisplayServerNameBinding(SiwinWindowRef) @@ -301,7 +332,6 @@ exportRefObject SiwinWindowRef: exportRefObject SiwinRendererRef: procs: siwinBackendNameForRendererBinding(SiwinRendererRef) - siwinWindowTitleForRendererBinding(SiwinRendererRef, SiwinWindowRef, string) setupBackendBinding(SiwinRendererRef, SiwinWindowRef) beginFrameBinding(SiwinRendererRef) endFrameBinding(SiwinRendererRef) diff --git a/examples/python/.gitignore b/examples/python/.gitignore new file mode 100644 index 0000000..bee8a64 --- /dev/null +++ b/examples/python/.gitignore @@ -0,0 +1 @@ +__pycache__ diff --git a/examples/python/siwin_renderlist_100.py b/examples/python/siwin_renderlist_100.py new file mode 100644 index 0000000..9b080ae --- /dev/null +++ b/examples/python/siwin_renderlist_100.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python3 +import math +import os +import sys +import time +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +BINDINGS_DIR = ROOT / "bindings" / "generated" +sys.path.insert(0, str(BINDINGS_DIR)) + +# genny currently emits fig_draw.py expecting libfig_draw.*, while config.nims +# outputs libfigdraw.*. Create a local symlink/copy fallback before import. +if sys.platform == "darwin": + expected = BINDINGS_DIR / "libfig_draw.dylib" + actual = BINDINGS_DIR / "libfigdraw.dylib" + if (not expected.exists()) and actual.exists(): + try: + expected.symlink_to(actual.name) + except OSError: + expected.write_bytes(actual.read_bytes()) +elif sys.platform.startswith("linux"): + expected = BINDINGS_DIR / "libfig_draw.so" + actual = BINDINGS_DIR / "libfigdraw.so" + if (not expected.exists()) and actual.exists(): + try: + expected.symlink_to(actual.name) + except OSError: + expected.write_bytes(actual.read_bytes()) +elif sys.platform == "win32": + expected = BINDINGS_DIR / "fig_draw.dll" + actual = BINDINGS_DIR / "figdraw.dll" + if (not expected.exists()) and actual.exists(): + expected.write_bytes(actual.read_bytes()) + +import fig_draw as fd + + +COPIES = 100 +RUN_ONCE = os.getenv("FIGDRAW_RUN_ONCE", "").strip().lower() in {"1", "true", "yes"} +NO_SLEEP = os.getenv("FIGDRAW_NO_SLEEP", "1").strip().lower() in {"1", "true", "yes"} + + +def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: + renders = fd.Renders() + t = frame * 0.02 + + background = fd.new_rectangle_fig(0.0, 0.0, width, height) + background.set_fill_color(255, 255, 255, 155) + renders.add_root(0, background) + + red_start_x = 60.0 + red_start_y = 60.0 + green_start_x = 320.0 + green_start_y = 120.0 + blue_start_x = 180.0 + blue_start_y = 300.0 + max_w = 260.0 + max_h = 180.0 + max_x = max(0.0, width - (green_start_x + max_w)) + max_y = max(0.0, height - (blue_start_y + max_h)) + + for i in range(COPIES): + seed_x = math.sin(i * 78.233) * 43758.5453 + seed_y = math.sin((i + 19) * 37.719) * 24634.6345 + base_x = (seed_x - math.floor(seed_x)) * max_x if max_x > 0 else 0.0 + base_y = (seed_y - math.floor(seed_y)) * max_y if max_y > 0 else 0.0 + + jitter_x = math.sin(t + i * 0.15) * 20.0 + jitter_y = math.cos(t * 0.9 + i * 0.2) * 20.0 + offset_x = min(max(base_x + jitter_x, 0.0), max_x) + offset_y = min(max(base_y + jitter_y, 0.0), max_y) + + size_pulse_w = 0.5 + 0.5 * math.sin(t * 0.8 + i * 0.07) + size_pulse_h = 0.5 + 0.5 * math.cos(t * 0.65 + i * 0.09) + + red_w = 160.0 + 100.0 * size_pulse_w + red_h = 110.0 + 70.0 * size_pulse_h + green_w = 160.0 + 100.0 * size_pulse_h + green_h = 110.0 + 70.0 * size_pulse_w + blue_w = 160.0 + 100.0 * (1.0 - size_pulse_w) + blue_h = 110.0 + 70.0 * (1.0 - size_pulse_h) + + red_fig = fd.new_rectangle_fig(red_start_x + offset_x, red_start_y + offset_y, red_w, red_h) + red_fig.set_fill_color(220, 40, 40, 155) + renders.add_root(0, red_fig) + + green_fig = fd.new_rectangle_fig( + green_start_x + offset_x, green_start_y + offset_y, green_w, green_h + ) + green_fig.set_fill_color(40, 180, 90, 155) + renders.add_root(0, green_fig) + + blue_fig = fd.new_rectangle_fig(blue_start_x + offset_x, blue_start_y + offset_y, blue_w, blue_h) + blue_fig.set_fill_color(60, 90, 220, 155) + renders.add_root(0, blue_fig) + + return renders + + +def main() -> int: + fd.set_fig_data_dir(str(ROOT / "data")) + + typeface = fd.load_typeface_binding("Ubuntu.ttf") + if not typeface: + print("Failed to load typeface: Ubuntu.ttf") + return 1 + fps_font = fd.FigFontRef(typeface, 18.0) + fps_text = "0.0 FPS" + + renderer = fd.new_siwin_renderer_binding(512, 1.0) + if not renderer: + print("Failed to create Siwin renderer") + return 1 + + title = fd.siwin_window_title_binding("Siwin RenderList (Python)") + window = fd.new_siwin_window_binding(800, 600, False, title, True, 0, True, False, False) + if not window: + print("Failed to create Siwin window") + return 1 + + auto_scale = window.configure_ui_scale_binding("") + renderer.setup_backend_binding(window) + window.first_step_window_binding(True) + window.make_current_window_binding() + print("Backend:", renderer.siwin_backend_name_for_renderer_binding()) + + frames = 0 + fps_frames = 0 + frame = 0 + fps_start = time.time() + make_render_tree_ms_sum = 0.0 + render_frame_ms_sum = 0.0 + last_element_count = 0 + + try: + while window.window_is_open_binding(): + window.refresh_ui_scale_binding(auto_scale) + + frame += 1 + frames += 1 + fps_frames += 1 + + renderer.begin_frame_binding() + width = window.logical_width_binding() + height = window.logical_height_binding() + + t0 = time.perf_counter() + renders = make_render_tree(width, height, frame) + make_render_tree_ms_sum += (time.perf_counter() - t0) * 1000.0 + last_element_count = renders.layer_node_count(0) + + hud_margin = 12.0 + hud_w = 180.0 + hud_h = 34.0 + hud_x = width - hud_w - hud_margin + hud_y = hud_margin + hud_rect = fd.new_rectangle_fig(hud_x, hud_y, hud_w, hud_h) + hud_rect.set_fill_color(0, 0, 0, 155) + renders.add_root(0, hud_rect) + + hud_text_pad_x = 10.0 + hud_text_pad_y = 6.0 + hud_text_x = hud_x + hud_text_pad_x + hud_text_y = hud_y + hud_text_pad_y + hud_text_w = hud_w - hud_text_pad_x * 2.0 + hud_text_h = hud_h - hud_text_pad_y * 2.0 + + fps_layout = fd.typeset_text_binding( + hud_text_w, + hud_text_h, + fps_font, + fps_text, + h_align=2, # Right + v_align=1, # Middle + min_content=False, + wrap=False, + ) + if fps_layout: + hud_text = fd.new_text_fig(hud_text_x, hud_text_y, hud_text_w, hud_text_h) + hud_text.set_fill_color(0, 0, 0, 0) + fd.set_fig_text_layout_binding(hud_text, fps_layout) + renders.add_root(0, hud_text) + + t1 = time.perf_counter() + renderer.render_frame_binding(renders, width, height) + render_frame_ms_sum += (time.perf_counter() - t1) * 1000.0 + renderer.end_frame_binding() + window.present_now_binding() + + window.redraw_window_binding() + window.step_window_binding() + + now = time.time() + elapsed = now - fps_start + if elapsed >= 1.0: + fps = fps_frames / elapsed + fps_text = f"{fps:0.1f} FPS" + avg_make = make_render_tree_ms_sum / max(1, fps_frames) + avg_render = render_frame_ms_sum / max(1, fps_frames) + print( + "fps:", + f"{fps:.1f}", + "| elems:", + last_element_count, + "| makeRenderTree avg(ms):", + f"{avg_make:.3f}", + "| renderFrame avg(ms):", + f"{avg_render:.3f}", + ) + fps_frames = 0 + fps_start = now + make_render_tree_ms_sum = 0.0 + render_frame_ms_sum = 0.0 + + if RUN_ONCE and frames >= 1: + break + if (not NO_SLEEP) and window.window_is_open_binding(): + time.sleep(0.016) + finally: + window.close_window_binding() + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From b0ad3546b51b5e14e05afd74b9833020f4e99c20 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:39:19 -0600 Subject: [PATCH 7/9] update bindings - borders --- bindings/bindings.nim | 13 +++++++++++++ examples/python/siwin_renderlist_100.py | 19 +++++++++++++++++-- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/bindings/bindings.nim b/bindings/bindings.nim index c6a90a0..4267459 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -213,6 +213,17 @@ proc setFillColor(fig: Fig, r, g, b, a: uint8) = proc setRotation(fig: Fig, rotation: float32) = fig.inner.rotation = rotation +proc setCorners(fig: Fig, topLeft, topRight, bottomLeft, bottomRight: float32) = + fig.inner.corners = [topLeft, topRight, bottomLeft, bottomRight] + +proc setStroke(fig: Fig, weight: float32, r, g, b, a: uint8) = + if fig.inner.kind != fdn.nkRectangle: + fig.inner = figWithKind(fig.inner, fdn.nkRectangle) + fig.inner.stroke = RenderStroke( + weight: weight, + fill: fill(rgba(r, g, b, a)), + ) + proc newRenderList(): RenderList = RenderList(inner: fdn.RenderList()) @@ -309,6 +320,8 @@ exportRefObject Fig: setScreenBox(Fig, float32, float32, float32, float32) setFillColor(Fig, uint8, uint8, uint8, uint8) setRotation(Fig, float32) + setCorners(Fig, float32, float32, float32, float32) + setStroke(Fig, float32, uint8, uint8, uint8, uint8) exportRefObject RenderList: constructor: diff --git a/examples/python/siwin_renderlist_100.py b/examples/python/siwin_renderlist_100.py index 9b080ae..b5b2898 100644 --- a/examples/python/siwin_renderlist_100.py +++ b/examples/python/siwin_renderlist_100.py @@ -84,16 +84,30 @@ def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: red_fig = fd.new_rectangle_fig(red_start_x + offset_x, red_start_y + offset_y, red_w, red_h) red_fig.set_fill_color(220, 40, 40, 155) + corner_pulse = 0.5 + 0.5 * math.sin(t * 1.25 + i * 0.11) + c0 = 4.0 + 26.0 * corner_pulse + c1 = 6.0 + 22.0 * (1.0 - corner_pulse) + c2 = 8.0 + 18.0 * (0.5 + 0.5 * math.sin(t * 0.7 + i * 0.05)) + c3 = 10.0 + 16.0 * (0.5 + 0.5 * math.cos(t * 0.8 + i * 0.06)) + red_fig.set_corners(c0, c1, c2, c3) + red_fig.set_stroke(5.0, 0, 0, 0, 155) renders.add_root(0, red_fig) green_fig = fd.new_rectangle_fig( green_start_x + offset_x, green_start_y + offset_y, green_w, green_h ) green_fig.set_fill_color(40, 180, 90, 155) + green_corner_pulse = 0.5 + 0.5 * math.cos(t * 0.95 + i * 0.08) + g0 = 6.0 + 22.0 * green_corner_pulse + g1 = 8.0 + 18.0 * (1.0 - green_corner_pulse) + g2 = 10.0 + 16.0 * (0.5 + 0.5 * math.cos(t * 0.75 + i * 0.04)) + g3 = 12.0 + 14.0 * (0.5 + 0.5 * math.sin(t * 0.85 + i * 0.05)) + green_fig.set_corners(g0, g1, g2, g3) renders.add_root(0, green_fig) blue_fig = fd.new_rectangle_fig(blue_start_x + offset_x, blue_start_y + offset_y, blue_w, blue_h) blue_fig.set_fill_color(60, 90, 220, 155) + blue_fig.set_stroke(4.0, 255, 255, 255, 210) renders.add_root(0, blue_fig) return renders @@ -114,7 +128,7 @@ def main() -> int: print("Failed to create Siwin renderer") return 1 - title = fd.siwin_window_title_binding("Siwin RenderList (Python)") + title = "Siwin RenderList (Python)" window = fd.new_siwin_window_binding(800, 600, False, title, True, 0, True, False, False) if not window: print("Failed to create Siwin window") @@ -124,7 +138,7 @@ def main() -> int: renderer.setup_backend_binding(window) window.first_step_window_binding(True) window.make_current_window_binding() - print("Backend:", renderer.siwin_backend_name_for_renderer_binding()) + print("Backend initialized") frames = 0 fps_frames = 0 @@ -158,6 +172,7 @@ def main() -> int: hud_y = hud_margin hud_rect = fd.new_rectangle_fig(hud_x, hud_y, hud_w, hud_h) hud_rect.set_fill_color(0, 0, 0, 155) + hud_rect.set_corners(8.0, 8.0, 8.0, 8.0) renders.add_root(0, hud_rect) hud_text_pad_x = 10.0 From 4ff3cbbdd2bc55dde53e0054d13c02249e53e0aa Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:41:01 -0600 Subject: [PATCH 8/9] update bindings - shadows --- bindings/bindings.nim | 49 +++++++++++++++++++++++++ examples/python/siwin_renderlist_100.py | 36 ++++++++++++++++++ 2 files changed, 85 insertions(+) diff --git a/bindings/bindings.nim b/bindings/bindings.nim index 4267459..cd11549 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -224,6 +224,41 @@ proc setStroke(fig: Fig, weight: float32, r, g, b, a: uint8) = fill: fill(rgba(r, g, b, a)), ) +proc clearShadows(fig: Fig) = + if fig.inner.kind != fdn.nkRectangle: + fig.inner = figWithKind(fig.inner, fdn.nkRectangle) + fig.inner.shadows = [RenderShadow(), RenderShadow(), RenderShadow(), RenderShadow()] + +proc setShadow( + fig: Fig, + shadowIndex: int8, + style: int8, + blur, spread, x, y: float32, + r, g, b, a: uint8, +) = + if fig.inner.kind != fdn.nkRectangle: + fig.inner = figWithKind(fig.inner, fdn.nkRectangle) + if shadowIndex < 0'i8 or shadowIndex >= ShadowCount.int8: + return + + var shadowStyle = ShadowStyle.NoShadow + case style + of 1'i8: + shadowStyle = ShadowStyle.DropShadow + of 2'i8: + shadowStyle = ShadowStyle.InnerShadow + else: + discard + + fig.inner.shadows[shadowIndex.int] = RenderShadow( + style: shadowStyle, + blur: blur, + spread: spread, + x: x, + y: y, + fill: fill(rgba(r, g, b, a)), + ) + proc newRenderList(): RenderList = RenderList(inner: fdn.RenderList()) @@ -322,6 +357,20 @@ exportRefObject Fig: setRotation(Fig, float32) setCorners(Fig, float32, float32, float32, float32) setStroke(Fig, float32, uint8, uint8, uint8, uint8) + clearShadows(Fig) + setShadow( + Fig, + int8, + int8, + float32, + float32, + float32, + float32, + uint8, + uint8, + uint8, + uint8, + ) exportRefObject RenderList: constructor: diff --git a/examples/python/siwin_renderlist_100.py b/examples/python/siwin_renderlist_100.py index b5b2898..341a09e 100644 --- a/examples/python/siwin_renderlist_100.py +++ b/examples/python/siwin_renderlist_100.py @@ -103,11 +103,47 @@ def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: g2 = 10.0 + 16.0 * (0.5 + 0.5 * math.cos(t * 0.75 + i * 0.04)) g3 = 12.0 + 14.0 * (0.5 + 0.5 * math.sin(t * 0.85 + i * 0.05)) green_fig.set_corners(g0, g1, g2, g3) + shadow_pulse = 0.5 + 0.5 * math.sin(t * 1.1 + i * 0.05) + shadow_blur = max(0.0, 6.0 + 18.0 * shadow_pulse) + shadow_spread = max(0.0, 4.0 + 20.0 * (1.0 - shadow_pulse)) + shadow_x = 6.0 + 10.0 * math.sin(t * 0.9 + i * 0.03) + shadow_y = 6.0 + 10.0 * math.cos(t * 0.9 + i * 0.03) + green_fig.clear_shadows() + green_fig.set_shadow( + 0, # first shadow slot + 1, # DropShadow + shadow_blur, + shadow_spread, + shadow_x, + shadow_y, + 0, + 0, + 0, + 155, + ) renders.add_root(0, green_fig) blue_fig = fd.new_rectangle_fig(blue_start_x + offset_x, blue_start_y + offset_y, blue_w, blue_h) blue_fig.set_fill_color(60, 90, 220, 155) blue_fig.set_stroke(4.0, 255, 255, 255, 210) + inset_pulse = 0.5 + 0.5 * math.sin(t * 1.05 + i * 0.06) + inset_blur = max(0.0, 8.0 + 10.0 * inset_pulse) + inset_spread = max(0.0, 2.0 + 10.0 * (1.0 - inset_pulse)) + inset_x = 6.0 * math.sin(t * 0.85 + i * 0.04) + inset_y = 6.0 * math.cos(t * 0.8 + i * 0.04) + blue_fig.clear_shadows() + blue_fig.set_shadow( + 0, # first shadow slot + 2, # InnerShadow + inset_blur, + inset_spread, + inset_x, + inset_y, + 40, + 40, + 60, + 150, + ) renders.add_root(0, blue_fig) return renders From 8ea7d456df985e2997e930bfdb31ff1e0b31d61a Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Mon, 9 Mar 2026 22:45:01 -0600 Subject: [PATCH 9/9] update bindings - shadows --- bindings/bindings.nim | 152 ++++++++++++++++++++++++ examples/python/siwin_renderlist_100.py | 52 +++++--- 2 files changed, 189 insertions(+), 15 deletions(-) diff --git a/bindings/bindings.nim b/bindings/bindings.nim index cd11549..39e54e4 100644 --- a/bindings/bindings.nim +++ b/bindings/bindings.nim @@ -11,6 +11,12 @@ const ExportSiwinShim* {.booldefine: "figdraw.bindings.siwinshim".} = false type FigKind* = fdn.FigKind + RgbaColor* = object + r*: uint8 + g*: uint8 + b*: uint8 + a*: uint8 + Fig* = ref object inner: fdn.Fig @@ -32,6 +38,9 @@ type proc newFig(): Fig = Fig(inner: fdn.Fig(kind: fdn.nkFrame)) +proc newRgbaColor(r, g, b, a: uint8): RgbaColor = + RgbaColor(r: r, g: g, b: b, a: a) + proc newRectangleFig(x, y, w, h: float32): Fig = Fig( inner: fdn.Fig( @@ -210,6 +219,73 @@ proc setScreenBox(fig: Fig, x, y, w, h: float32) = proc setFillColor(fig: Fig, r, g, b, a: uint8) = fig.inner.fill = fill(rgba(r, g, b, a)) +proc setFillColorRgba(fig: Fig, color: RgbaColor) = + fig.inner.fill = fill(rgba(color.r, color.g, color.b, color.a)) + +proc parseFillAxis(axis: int8): FillGradientAxis = + case axis + of 1'i8: + fgaY + of 2'i8: + fgaDiagTLBR + of 3'i8: + fgaDiagBLTR + else: + fgaX + +proc setFillLinear2( + fig: Fig, + sr, sg, sb, sa: uint8, + er, eg, eb, ea: uint8, + axis: int8, +) = + fig.inner.fill = linear( + rgba(sr, sg, sb, sa), + rgba(er, eg, eb, ea), + axis = parseFillAxis(axis), + ) + +proc setFillLinear2Rgba( + fig: Fig, + startColor, endColor: RgbaColor, + axis: int8, +) = + fig.inner.fill = linear( + rgba(startColor.r, startColor.g, startColor.b, startColor.a), + rgba(endColor.r, endColor.g, endColor.b, endColor.a), + axis = parseFillAxis(axis), + ) + +proc setFillLinear3( + fig: Fig, + sr, sg, sb, sa: uint8, + mr, mg, mb, ma: uint8, + er, eg, eb, ea: uint8, + axis: int8, + midPos: uint8, +) = + fig.inner.fill = linear( + rgba(sr, sg, sb, sa), + rgba(mr, mg, mb, ma), + rgba(er, eg, eb, ea), + axis = parseFillAxis(axis), + midPos = midPos, + ) + +proc setFillLinear3Rgba( + fig: Fig, + startColor, midColor, endColor: RgbaColor, + axis: int8, + midPos: uint8, +) = + fig.inner.fill = linear( + rgba(startColor.r, startColor.g, startColor.b, startColor.a), + rgba(midColor.r, midColor.g, midColor.b, midColor.a), + rgba(endColor.r, endColor.g, endColor.b, endColor.a), + axis = parseFillAxis(axis), + midPos = midPos, + ) + proc setRotation(fig: Fig, rotation: float32) = fig.inner.rotation = rotation @@ -224,6 +300,14 @@ proc setStroke(fig: Fig, weight: float32, r, g, b, a: uint8) = fill: fill(rgba(r, g, b, a)), ) +proc setStrokeRgba(fig: Fig, weight: float32, color: RgbaColor) = + if fig.inner.kind != fdn.nkRectangle: + fig.inner = figWithKind(fig.inner, fdn.nkRectangle) + fig.inner.stroke = RenderStroke( + weight: weight, + fill: fill(rgba(color.r, color.g, color.b, color.a)), + ) + proc clearShadows(fig: Fig) = if fig.inner.kind != fdn.nkRectangle: fig.inner = figWithKind(fig.inner, fdn.nkRectangle) @@ -259,6 +343,36 @@ proc setShadow( fill: fill(rgba(r, g, b, a)), ) +proc setShadowRgba( + fig: Fig, + shadowIndex: int8, + style: int8, + blur, spread, x, y: float32, + color: RgbaColor, +) = + if fig.inner.kind != fdn.nkRectangle: + fig.inner = figWithKind(fig.inner, fdn.nkRectangle) + if shadowIndex < 0'i8 or shadowIndex >= ShadowCount.int8: + return + + var shadowStyle = ShadowStyle.NoShadow + case style + of 1'i8: + shadowStyle = ShadowStyle.DropShadow + of 2'i8: + shadowStyle = ShadowStyle.InnerShadow + else: + discard + + fig.inner.shadows[shadowIndex.int] = RenderShadow( + style: shadowStyle, + blur: blur, + spread: spread, + x: x, + y: y, + fill: fill(rgba(color.r, color.g, color.b, color.a)), + ) + proc newRenderList(): RenderList = RenderList(inner: fdn.RenderList()) @@ -339,6 +453,10 @@ proc getLayerNode(renders: Renders, zLevel: int8, nodeIdx: int16): Fig = exportEnums: FigKind +exportObject RgbaColor: + constructor: + newRgbaColor(uint8, uint8, uint8, uint8) + exportRefObject Fig: constructor: newFig() @@ -354,9 +472,42 @@ exportRefObject Fig: height(Fig) setScreenBox(Fig, float32, float32, float32, float32) setFillColor(Fig, uint8, uint8, uint8, uint8) + setFillColorRgba(Fig, RgbaColor) + setFillLinear2( + Fig, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + int8, + ) + setFillLinear2Rgba(Fig, RgbaColor, RgbaColor, int8) + setFillLinear3( + Fig, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + uint8, + int8, + uint8, + ) + setFillLinear3Rgba(Fig, RgbaColor, RgbaColor, RgbaColor, int8, uint8) setRotation(Fig, float32) setCorners(Fig, float32, float32, float32, float32) setStroke(Fig, float32, uint8, uint8, uint8, uint8) + setStrokeRgba(Fig, float32, RgbaColor) clearShadows(Fig) setShadow( Fig, @@ -371,6 +522,7 @@ exportRefObject Fig: uint8, uint8, ) + setShadowRgba(Fig, int8, int8, float32, float32, float32, float32, RgbaColor) exportRefObject RenderList: constructor: diff --git a/examples/python/siwin_renderlist_100.py b/examples/python/siwin_renderlist_100.py index 341a09e..e2697c4 100644 --- a/examples/python/siwin_renderlist_100.py +++ b/examples/python/siwin_renderlist_100.py @@ -41,6 +41,20 @@ RUN_ONCE = os.getenv("FIGDRAW_RUN_ONCE", "").strip().lower() in {"1", "true", "yes"} NO_SLEEP = os.getenv("FIGDRAW_NO_SLEEP", "1").strip().lower() in {"1", "true", "yes"} +RED_FILL = fd.RgbaColor(220, 40, 40, 155) +RED_STROKE = fd.RgbaColor(0, 0, 0, 155) +GREEN_SOLID = fd.RgbaColor(40, 180, 90, 155) +GREEN_GRAD_START = fd.RgbaColor(18, 112, 64, 255) +GREEN_GRAD_MID = fd.RgbaColor(40, 180, 90, 255) +GREEN_GRAD_STOP = fd.RgbaColor(78, 224, 188, 255) +BLUE_SOLID = fd.RgbaColor(60, 90, 220, 155) +BLUE_GRAD_START = fd.RgbaColor(44, 72, 186, 255) +BLUE_GRAD_MID = fd.RgbaColor(60, 90, 220, 255) +BLUE_GRAD_STOP = fd.RgbaColor(118, 168, 255, 255) +WHITE_STROKE = fd.RgbaColor(255, 255, 255, 210) +BLACK_SHADOW = fd.RgbaColor(0, 0, 0, 155) +BLUE_INNER_SHADOW = fd.RgbaColor(40, 40, 60, 150) + def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: renders = fd.Renders() @@ -83,20 +97,27 @@ def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: blue_h = 110.0 + 70.0 * (1.0 - size_pulse_h) red_fig = fd.new_rectangle_fig(red_start_x + offset_x, red_start_y + offset_y, red_w, red_h) - red_fig.set_fill_color(220, 40, 40, 155) + red_fig.set_fill_color_rgba(RED_FILL) corner_pulse = 0.5 + 0.5 * math.sin(t * 1.25 + i * 0.11) c0 = 4.0 + 26.0 * corner_pulse c1 = 6.0 + 22.0 * (1.0 - corner_pulse) c2 = 8.0 + 18.0 * (0.5 + 0.5 * math.sin(t * 0.7 + i * 0.05)) c3 = 10.0 + 16.0 * (0.5 + 0.5 * math.cos(t * 0.8 + i * 0.06)) red_fig.set_corners(c0, c1, c2, c3) - red_fig.set_stroke(5.0, 0, 0, 0, 155) + red_fig.set_stroke_rgba(5.0, RED_STROKE) renders.add_root(0, red_fig) green_fig = fd.new_rectangle_fig( green_start_x + offset_x, green_start_y + offset_y, green_w, green_h ) - green_fig.set_fill_color(40, 180, 90, 155) + use_green_gradient = (i % 2) == 0 + if use_green_gradient: + green_axis = 0 if (i % 4) < 2 else 2 # X or DiagTLBR + green_fig.set_fill_linear3_rgba( + GREEN_GRAD_START, GREEN_GRAD_MID, GREEN_GRAD_STOP, green_axis, 128 + ) + else: + green_fig.set_fill_color_rgba(GREEN_SOLID) green_corner_pulse = 0.5 + 0.5 * math.cos(t * 0.95 + i * 0.08) g0 = 6.0 + 22.0 * green_corner_pulse g1 = 8.0 + 18.0 * (1.0 - green_corner_pulse) @@ -109,40 +130,41 @@ def make_render_tree(width: float, height: float, frame: int) -> fd.Renders: shadow_x = 6.0 + 10.0 * math.sin(t * 0.9 + i * 0.03) shadow_y = 6.0 + 10.0 * math.cos(t * 0.9 + i * 0.03) green_fig.clear_shadows() - green_fig.set_shadow( + green_fig.set_shadow_rgba( 0, # first shadow slot 1, # DropShadow shadow_blur, shadow_spread, shadow_x, shadow_y, - 0, - 0, - 0, - 155, + BLACK_SHADOW, ) renders.add_root(0, green_fig) blue_fig = fd.new_rectangle_fig(blue_start_x + offset_x, blue_start_y + offset_y, blue_w, blue_h) - blue_fig.set_fill_color(60, 90, 220, 155) - blue_fig.set_stroke(4.0, 255, 255, 255, 210) + use_blue_gradient = (i % 3) == 0 + if use_blue_gradient: + blue_axis = 1 if (i % 2) == 0 else 3 # Y or DiagBLTR + blue_fig.set_fill_linear3_rgba( + BLUE_GRAD_START, BLUE_GRAD_MID, BLUE_GRAD_STOP, blue_axis, 132 + ) + else: + blue_fig.set_fill_color_rgba(BLUE_SOLID) + blue_fig.set_stroke_rgba(4.0, WHITE_STROKE) inset_pulse = 0.5 + 0.5 * math.sin(t * 1.05 + i * 0.06) inset_blur = max(0.0, 8.0 + 10.0 * inset_pulse) inset_spread = max(0.0, 2.0 + 10.0 * (1.0 - inset_pulse)) inset_x = 6.0 * math.sin(t * 0.85 + i * 0.04) inset_y = 6.0 * math.cos(t * 0.8 + i * 0.04) blue_fig.clear_shadows() - blue_fig.set_shadow( + blue_fig.set_shadow_rgba( 0, # first shadow slot 2, # InnerShadow inset_blur, inset_spread, inset_x, inset_y, - 40, - 40, - 60, - 150, + BLUE_INNER_SHADOW, ) renders.add_root(0, blue_fig)