src/wasm/wasm_natives_gen.hpp

// Generated by src/wasm/idl/generate.py from bindings.py. Do not edit.
//
// Included inside wasm_scripting_vm.cpp's anonymous namespace before
// the native implementations; the declarations pin each hand-written
// impl core to the contract signature (a mismatch makes the table
// cast ambiguous). The WAMR wrappers adapt exec_env to the VM the
// cores share with the browser lane's generated C shims.
// clang-format off

typedef struct rive_gpu_texture_desc_v1
{
    uint32_t width;
    uint32_t height;
    uint32_t depthOrArrayLayers;
    uint32_t format;
    uint32_t textureType;
    uint32_t renderTarget;
    uint32_t numMipmaps;
    uint32_t sampleCount;
} rive_gpu_texture_desc_v1;

typedef struct rive_gpu_texture_upload_v1
{
    uint32_t bytesPerRow;
    uint32_t rowsPerImage;
    uint32_t mipLevel;
    uint32_t layer;
    uint32_t x;
    uint32_t y;
    uint32_t z;
    uint32_t width;
    uint32_t height;
    uint32_t depth;
} rive_gpu_texture_upload_v1;

typedef struct rive_gpu_sampler_desc_v1
{
    uint32_t minFilter;
    uint32_t magFilter;
    uint32_t mipmapFilter;
    uint32_t wrapU;
    uint32_t wrapV;
    uint32_t wrapW;
    uint32_t compare;
    float minLod;
    float maxLod;
    uint32_t maxAnisotropy;
} rive_gpu_sampler_desc_v1;

typedef struct rive_gpu_texture_view_desc_v1
{
    uint32_t dimension;
    uint32_t aspect;
    uint32_t baseMipLevel;
    uint32_t mipCount;
    uint32_t baseLayer;
    uint32_t layerCount;
} rive_gpu_texture_view_desc_v1;

typedef struct rive_gpu_shader_module_desc_v1
{
    uint32_t language;
    uint32_t stage;
    uint32_t codeSize;
    uint32_t hlslSourceSize;
    uint32_t hlslEntryPointSize;
    uint32_t bindingMapSize;
    uint32_t glFixupSize;
    uint32_t shaderAssetId;
} rive_gpu_shader_module_desc_v1;

typedef struct rive_gpu_bind_group_layout_entry_v1
{
    uint32_t binding;
    uint32_t kind;
    uint32_t visibility;
    uint32_t hasDynamicOffset;
    uint32_t textureViewDim;
    uint32_t textureSampleType;
    uint32_t textureMultisampled;
    uint32_t minBindingSize;
    uint32_t nativeSlotVS;
    uint32_t nativeSlotFS;
    uint32_t nativeSlotCS;
} rive_gpu_bind_group_layout_entry_v1;

typedef struct rive_gpu_bind_group_ubo_v1
{
    uint32_t slot;
    uint32_t buffer;
    uint32_t offset;
    uint32_t size;
} rive_gpu_bind_group_ubo_v1;

typedef struct rive_gpu_bind_group_texture_v1
{
    uint32_t slot;
    uint32_t view;
} rive_gpu_bind_group_texture_v1;

typedef struct rive_gpu_bind_group_sampler_v1
{
    uint32_t slot;
    uint32_t sampler;
} rive_gpu_bind_group_sampler_v1;

typedef struct rive_gpu_color_target_v1
{
    uint32_t format;
    uint32_t blendEnabled;
    uint32_t srcColor;
    uint32_t dstColor;
    uint32_t colorOp;
    uint32_t srcAlpha;
    uint32_t dstAlpha;
    uint32_t alphaOp;
    uint32_t writeMask;
} rive_gpu_color_target_v1;

typedef struct rive_gpu_vertex_buffer_layout_v1
{
    uint32_t stride;
    uint32_t stepMode;
    uint32_t attributeCount;
} rive_gpu_vertex_buffer_layout_v1;

typedef struct rive_gpu_vertex_attribute_v1
{
    uint32_t format;
    uint32_t offset;
    uint32_t shaderSlot;
} rive_gpu_vertex_attribute_v1;

typedef struct rive_gpu_pass_color_attachment_v1
{
    uint32_t view;
    uint32_t resolveTarget;
    uint32_t loadOp;
    uint32_t storeOp;
    float clearR;
    float clearG;
    float clearB;
    float clearA;
} rive_gpu_pass_color_attachment_v1;

typedef struct rive_gpu_pass_desc_v1
{
    uint32_t colorCount;
    uint32_t depthView;
    uint32_t depthLoadOp;
    uint32_t depthStoreOp;
    float depthClearValue;
    uint32_t stencilLoadOp;
    uint32_t stencilStoreOp;
    uint32_t stencilClearValue;
} rive_gpu_pass_desc_v1;

typedef struct rive_gpu_pipeline_desc_v1
{
    uint32_t vertexModule;
    uint32_t fragmentModule;
    uint32_t vertexEntrySize;
    uint32_t fragmentEntrySize;
    uint32_t colorCount;
    uint32_t vertexBufferCount;
    uint32_t attributeCount;
    uint32_t bindGroupLayoutCount;
    uint32_t topology;
    uint32_t indexFormat;
    uint32_t cullMode;
    uint32_t winding;
    uint32_t depthFormat;
    uint32_t depthCompare;
    uint32_t depthWriteEnabled;
    uint32_t depthBias;
    float depthBiasSlopeScale;
    float depthBiasClamp;
    uint32_t stencilFrontCompare;
    uint32_t stencilFrontFailOp;
    uint32_t stencilFrontDepthFailOp;
    uint32_t stencilFrontPassOp;
    uint32_t stencilBackCompare;
    uint32_t stencilBackFailOp;
    uint32_t stencilBackDepthFailOp;
    uint32_t stencilBackPassOp;
    uint32_t stencilReadMask;
    uint32_t stencilWriteMask;
    uint32_t sampleCount;
} rive_gpu_pipeline_desc_v1;

void rtLogImpl(WasmScriptingVM* vm, int32_t level, const char* message, uint32_t length);
void rtMarkNeedsUpdateImpl(WasmScriptingVM* vm, uint32_t object);
void rtBudgetExceededImpl(WasmScriptingVM* vm, uint32_t ms);
uint32_t dataViewModelImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataRootViewModelImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataGlobalViewModelImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength);
uint32_t dataGlobalViewModelNamesImpl(WasmScriptingVM* vm, uint32_t object, char* buffer, uint32_t capacity);
uint32_t dataContextImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataContextParentImpl(WasmScriptingVM* vm, uint32_t dataContext);
uint32_t dataContextViewModelImpl(WasmScriptingVM* vm, uint32_t dataContext);
void dataContextReleaseImpl(WasmScriptingVM* vm, uint32_t dataContext);
uint32_t dataHasViewModelImpl(WasmScriptingVM* vm, const char* name, uint32_t nameLength);
uint32_t dataNewViewModelImpl(WasmScriptingVM* vm, const char* name, uint32_t nameLength, const char* templateName, uint32_t templateLength);
void dataVmiReleaseImpl(WasmScriptingVM* vm, uint32_t vmi);
uint32_t dataVmiNumberImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiBooleanImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiStringImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiTriggerImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiColorImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiViewModelImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiPropertyImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length, uint32_t* kindOut, uint32_t kindCount);
uint32_t dataVmiInstanceImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t nameLength);
uint32_t dataVmiSymbolIndexImpl(WasmScriptingVM* vm, uint32_t vmi);
uint32_t dataVmiEqualImpl(WasmScriptingVM* vm, uint32_t a, uint32_t b);
uint32_t dataViewModelGetImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataVmiListImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiEnumImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiImageImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiFontImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiBlobImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataImageGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataImageSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t image);
uint32_t dataFontGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataFontSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t font);
void dataFontReleaseImpl(WasmScriptingVM* vm, uint32_t font);
uint32_t dataBlobPresentImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataBlobGetImpl(WasmScriptingVM* vm, uint32_t property, uint8_t* buffer, uint32_t capacity);
uint32_t dataBlobNameImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataBlobSetImpl(WasmScriptingVM* vm, uint32_t property, const uint8_t* bytes, uint32_t byteCount);
void dataBlobClearImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataEnumGetImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataEnumSetImpl(WasmScriptingVM* vm, uint32_t property, const char* value, uint32_t length);
uint32_t dataEnumValuesImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataPropReleaseImpl(WasmScriptingVM* vm, uint32_t property);
void dataTriggerFireImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataListLengthImpl(WasmScriptingVM* vm, uint32_t property);
void dataListPushImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataListPopImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataListShiftImpl(WasmScriptingVM* vm, uint32_t property);
void dataListClearImpl(WasmScriptingVM* vm, uint32_t property);
void dataListSwapImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index1, uint32_t index2);
void dataListInsertImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi, uint32_t index);
void dataListRemoveImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
void dataListRemoveAtImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index);
void dataListRemoveAllOfImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataListGetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index);
void dataViewModelSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataColorGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataColorSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t value);
float dataNumberGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataNumberSetImpl(WasmScriptingVM* vm, uint32_t property, float value);
uint32_t dataBooleanGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataBooleanSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t value);
uint32_t dataStringGetImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataStringSetImpl(WasmScriptingVM* vm, uint32_t property, const char* value, uint32_t length);
void dataWatchImpl(WasmScriptingVM* vm, uint32_t property, uint32_t token);
void dataUnwatchImpl(WasmScriptingVM* vm, uint32_t property);
void dataConvertResultImpl(WasmScriptingVM* vm, uint32_t kind, float number, uint32_t booleanValue, uint32_t color, const char* value, uint32_t length);
void artboardReleaseImpl(WasmScriptingVM* vm, uint32_t artboard);
uint32_t artboardAdvanceImpl(WasmScriptingVM* vm, uint32_t artboard, float seconds);
void artboardDrawImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t renderer);
uint32_t artboardInstanceImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t vmi);
uint32_t artboardDataImpl(WasmScriptingVM* vm, uint32_t artboard);
float artboardWidthImpl(WasmScriptingVM* vm, uint32_t artboard);
float artboardHeightImpl(WasmScriptingVM* vm, uint32_t artboard);
void artboardSetWidthImpl(WasmScriptingVM* vm, uint32_t artboard, float value);
void artboardSetHeightImpl(WasmScriptingVM* vm, uint32_t artboard, float value);
uint32_t artboardFrameOriginImpl(WasmScriptingVM* vm, uint32_t artboard);
void artboardSetFrameOriginImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t value);
void artboardBoundsImpl(WasmScriptingVM* vm, uint32_t artboard, float* out, uint32_t outCount);
uint32_t artboardPointerEventImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t kind, uint32_t pointerId, float x, float y);
uint32_t artboardAnimationImpl(WasmScriptingVM* vm, uint32_t artboard, const char* name, uint32_t length);
void artboardAnimationReleaseImpl(WasmScriptingVM* vm, uint32_t animation);
float artboardAnimationDurationImpl(WasmScriptingVM* vm, uint32_t animation);
uint32_t artboardAnimationAdvanceImpl(WasmScriptingVM* vm, uint32_t animation, float seconds);
void artboardAnimationSetTimeImpl(WasmScriptingVM* vm, uint32_t animation, float value, uint32_t mode);
uint32_t artboardNodeImpl(WasmScriptingVM* vm, uint32_t artboard, const char* name, uint32_t length);
void artboardNodeReleaseImpl(WasmScriptingVM* vm, uint32_t node);
void artboardNodeTransformImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
void artboardNodeSetImpl(WasmScriptingVM* vm, uint32_t node, uint32_t field, float v0, float v1);
void artboardNodeWorldTransformImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
void artboardNodeSetWorldTransformImpl(WasmScriptingVM* vm, uint32_t node, const float* values, uint32_t floatCount);
void artboardNodeDecomposeImpl(WasmScriptingVM* vm, uint32_t node, const float* values, uint32_t floatCount);
uint32_t artboardNodePathVerbsImpl(WasmScriptingVM* vm, uint32_t node, uint8_t* out, uint32_t outCount);
uint32_t artboardNodePathPointsImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
uint32_t artboardNodePaintImpl(WasmScriptingVM* vm, uint32_t node, uint32_t* out, uint32_t outCount);
uint32_t pathNewImpl(WasmScriptingVM* vm);
void pathUpdateImpl(WasmScriptingVM* vm, uint32_t path, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount, uint32_t fillRule);
void pathReleaseImpl(WasmScriptingVM* vm, uint32_t path);
void pathEffectResultImpl(WasmScriptingVM* vm, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount);
uint32_t paintNewImpl(WasmScriptingVM* vm);
void paintReleaseImpl(WasmScriptingVM* vm, uint32_t paint);
void paintStyleImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintColorImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintThicknessImpl(WasmScriptingVM* vm, uint32_t paint, float value);
void paintJoinImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintCapImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintBlendModeImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintFeatherImpl(WasmScriptingVM* vm, uint32_t paint, float value);
void paintShaderImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t shader);
uint32_t gpuFeaturesImpl(WasmScriptingVM* vm, uint32_t* out, uint32_t outCount);
uint32_t gpuCanvasNewImpl(WasmScriptingVM* vm, uint32_t width, uint32_t height);
void gpuCanvasReleaseImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t gpuCanvasColorViewImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t* props, uint32_t propCount);
uint32_t gpuCanvasImageImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t gpuCanvasResizeImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t width, uint32_t height, uint32_t* props, uint32_t propCount);
uint32_t gpuPassBeginImpl(WasmScriptingVM* vm, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const rive_gpu_pass_color_attachment_v1* colors, uint32_t colorByteCount);
void gpuPassSetPipelineImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t pipeline);
void gpuPassSetVertexBufferImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t slot, uint32_t buffer, uint32_t offset);
void gpuPassSetIndexBufferImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t buffer, uint32_t indexFormat, uint32_t offset);
void gpuPassSetBindGroupImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t groupIndex, uint32_t bindGroup, const uint32_t* dynamicOffsets, uint32_t dynamicOffsetByteCount);
void gpuPassSetViewportImpl(WasmScriptingVM* vm, uint32_t pass, float x, float y, float width, float height, float minDepth, float maxDepth);
void gpuPassSetScissorImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t x, uint32_t y, uint32_t width, uint32_t height);
void gpuPassSetStencilReferenceImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t ref);
void gpuPassSetBlendColorImpl(WasmScriptingVM* vm, uint32_t pass, float r, float g, float b, float a);
void gpuPassDrawImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
void gpuPassDrawIndexedImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance);
void gpuPassFinishImpl(WasmScriptingVM* vm, uint32_t pass);
void gpuPassReleaseImpl(WasmScriptingVM* vm, uint32_t pass);
uint32_t gpuImageViewImpl(WasmScriptingVM* vm, uint32_t image, uint32_t width, uint32_t height);
uint32_t gpuBufferNewImpl(WasmScriptingVM* vm, uint32_t usage, uint32_t sizeInBytes, uint32_t immutable, const uint8_t* data, uint32_t dataCount);
void gpuBufferUpdateImpl(WasmScriptingVM* vm, uint32_t buffer, uint32_t dstOffset, const uint8_t* data, uint32_t dataCount);
void gpuBufferReleaseImpl(WasmScriptingVM* vm, uint32_t buffer);
uint32_t gpuTextureNewImpl(WasmScriptingVM* vm, const rive_gpu_texture_desc_v1* desc, uint32_t descByteCount);
void gpuTextureUploadImpl(WasmScriptingVM* vm, uint32_t texture, const rive_gpu_texture_upload_v1* region, uint32_t regionByteCount, const uint8_t* data, uint32_t dataCount);
void gpuTextureReleaseImpl(WasmScriptingVM* vm, uint32_t texture);
uint32_t gpuSamplerNewImpl(WasmScriptingVM* vm, const rive_gpu_sampler_desc_v1* desc, uint32_t descByteCount);
void gpuSamplerReleaseImpl(WasmScriptingVM* vm, uint32_t sampler);
uint32_t gpuTextureViewNewImpl(WasmScriptingVM* vm, uint32_t texture, const rive_gpu_texture_view_desc_v1* desc, uint32_t descByteCount);
void gpuTextureViewReleaseImpl(WasmScriptingVM* vm, uint32_t view);
uint32_t gpuShaderTargetImpl(WasmScriptingVM* vm);
uint32_t gpuShaderAssetBytesImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount);
uint32_t gpuShaderAssetIdImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength);
uint32_t gpuShaderModuleNewImpl(WasmScriptingVM* vm, const rive_gpu_shader_module_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount);
void gpuShaderModuleReleaseImpl(WasmScriptingVM* vm, uint32_t shaderModule);
uint32_t gpuBindGroupLayoutNewImpl(WasmScriptingVM* vm, uint32_t groupIndex, const rive_gpu_bind_group_layout_entry_v1* entries, uint32_t entryByteCount);
void gpuBindGroupLayoutReleaseImpl(WasmScriptingVM* vm, uint32_t layout);
uint32_t gpuBindGroupLayoutFromShaderImpl(WasmScriptingVM* vm, uint32_t shaderModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount);
uint32_t gpuBindGroupNewImpl(WasmScriptingVM* vm, uint32_t layout, const rive_gpu_bind_group_ubo_v1* ubos, uint32_t uboByteCount, const rive_gpu_bind_group_texture_v1* textures, uint32_t textureByteCount, const rive_gpu_bind_group_sampler_v1* samplers, uint32_t samplerByteCount);
void gpuBindGroupReleaseImpl(WasmScriptingVM* vm, uint32_t bindGroup);
uint32_t gpuPipelineNewImpl(WasmScriptingVM* vm, const rive_gpu_pipeline_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount);
void gpuPipelineReleaseImpl(WasmScriptingVM* vm, uint32_t pipeline);
uint32_t bufferNewImpl(WasmScriptingVM* vm, uint32_t bufferType, uint32_t flags, uint32_t sizeInBytes);
void bufferUpdateImpl(WasmScriptingVM* vm, uint32_t buffer, const uint8_t* bytes, uint32_t byteCount);
void bufferReleaseImpl(WasmScriptingVM* vm, uint32_t buffer);
uint32_t blobAssetBytesImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount);
uint32_t imageFromAssetImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t length);
uint32_t imageWidthImpl(WasmScriptingVM* vm, uint32_t image);
uint32_t imageHeightImpl(WasmScriptingVM* vm, uint32_t image);
void imageReleaseImpl(WasmScriptingVM* vm, uint32_t image);
uint32_t imageDecodeImpl(WasmScriptingVM* vm, const uint8_t* bytes, uint32_t byteCount, uint32_t token);
void imageDecodeCancelImpl(WasmScriptingVM* vm, uint32_t token);
uint32_t shaderLinearImpl(WasmScriptingVM* vm, float sx, float sy, float ex, float ey, uint32_t colors, uint32_t stops, uint32_t count);
uint32_t shaderRadialImpl(WasmScriptingVM* vm, float cx, float cy, float radius, uint32_t colors, uint32_t stops, uint32_t count);
void shaderReleaseImpl(WasmScriptingVM* vm, uint32_t shader);
void rendererSaveImpl(WasmScriptingVM* vm, uint32_t renderer);
void rendererRestoreImpl(WasmScriptingVM* vm, uint32_t renderer);
void rendererTransformImpl(WasmScriptingVM* vm, uint32_t renderer, float xx, float xy, float yx, float yy, float tx, float ty);
void rendererDrawPathImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t path, uint32_t paint);
void rendererClipPathImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t path);
void rendererDrawImageImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t blend, float opacity);
void rendererDrawImageMeshImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t blend, float opacity);

void rtLog(wasm_exec_env_t env, int32_t level, const char* message, uint32_t length)
{
    rtLogImpl(vmFromEnv(env), level, message, length);
}
void rtMarkNeedsUpdate(wasm_exec_env_t env, uint32_t object)
{
    rtMarkNeedsUpdateImpl(vmFromEnv(env), object);
}
void rtBudgetExceeded(wasm_exec_env_t env, uint32_t ms)
{
    rtBudgetExceededImpl(vmFromEnv(env), ms);
}
uint32_t dataViewModel(wasm_exec_env_t env, uint32_t object)
{
    return dataViewModelImpl(vmFromEnv(env), object);
}
uint32_t dataRootViewModel(wasm_exec_env_t env, uint32_t object)
{
    return dataRootViewModelImpl(vmFromEnv(env), object);
}
uint32_t dataGlobalViewModel(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength)
{
    return dataGlobalViewModelImpl(vmFromEnv(env), object, name, nameLength);
}
uint32_t dataGlobalViewModelNames(wasm_exec_env_t env, uint32_t object, char* buffer, uint32_t capacity)
{
    return dataGlobalViewModelNamesImpl(vmFromEnv(env), object, buffer, capacity);
}
uint32_t dataContext(wasm_exec_env_t env, uint32_t object)
{
    return dataContextImpl(vmFromEnv(env), object);
}
uint32_t dataContextParent(wasm_exec_env_t env, uint32_t dataContext)
{
    return dataContextParentImpl(vmFromEnv(env), dataContext);
}
uint32_t dataContextViewModel(wasm_exec_env_t env, uint32_t dataContext)
{
    return dataContextViewModelImpl(vmFromEnv(env), dataContext);
}
void dataContextRelease(wasm_exec_env_t env, uint32_t dataContext)
{
    dataContextReleaseImpl(vmFromEnv(env), dataContext);
}
uint32_t dataHasViewModel(wasm_exec_env_t env, const char* name, uint32_t nameLength)
{
    return dataHasViewModelImpl(vmFromEnv(env), name, nameLength);
}
uint32_t dataNewViewModel(wasm_exec_env_t env, const char* name, uint32_t nameLength, const char* templateName, uint32_t templateLength)
{
    return dataNewViewModelImpl(vmFromEnv(env), name, nameLength, templateName, templateLength);
}
void dataVmiRelease(wasm_exec_env_t env, uint32_t vmi)
{
    dataVmiReleaseImpl(vmFromEnv(env), vmi);
}
uint32_t dataVmiNumber(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiNumberImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiBoolean(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiBooleanImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiString(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiStringImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiTrigger(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiTriggerImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiColor(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiColorImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiViewModel(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiViewModelImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiProperty(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length, uint32_t* kindOut, uint32_t kindCount)
{
    return dataVmiPropertyImpl(vmFromEnv(env), vmi, name, length, kindOut, kindCount);
}
uint32_t dataVmiInstance(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t nameLength)
{
    return dataVmiInstanceImpl(vmFromEnv(env), vmi, name, nameLength);
}
uint32_t dataVmiSymbolIndex(wasm_exec_env_t env, uint32_t vmi)
{
    return dataVmiSymbolIndexImpl(vmFromEnv(env), vmi);
}
uint32_t dataVmiEqual(wasm_exec_env_t env, uint32_t a, uint32_t b)
{
    return dataVmiEqualImpl(vmFromEnv(env), a, b);
}
uint32_t dataViewModelGet(wasm_exec_env_t env, uint32_t property)
{
    return dataViewModelGetImpl(vmFromEnv(env), property);
}
uint32_t dataVmiList(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiListImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiEnum(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiEnumImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiImage(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiImageImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiFont(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiFontImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataVmiBlob(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    return dataVmiBlobImpl(vmFromEnv(env), vmi, name, length);
}
uint32_t dataImageGet(wasm_exec_env_t env, uint32_t property)
{
    return dataImageGetImpl(vmFromEnv(env), property);
}
void dataImageSet(wasm_exec_env_t env, uint32_t property, uint32_t image)
{
    dataImageSetImpl(vmFromEnv(env), property, image);
}
uint32_t dataFontGet(wasm_exec_env_t env, uint32_t property)
{
    return dataFontGetImpl(vmFromEnv(env), property);
}
void dataFontSet(wasm_exec_env_t env, uint32_t property, uint32_t font)
{
    dataFontSetImpl(vmFromEnv(env), property, font);
}
void dataFontRelease(wasm_exec_env_t env, uint32_t font)
{
    dataFontReleaseImpl(vmFromEnv(env), font);
}
uint32_t dataBlobPresent(wasm_exec_env_t env, uint32_t property)
{
    return dataBlobPresentImpl(vmFromEnv(env), property);
}
uint32_t dataBlobGet(wasm_exec_env_t env, uint32_t property, uint8_t* buffer, uint32_t capacity)
{
    return dataBlobGetImpl(vmFromEnv(env), property, buffer, capacity);
}
uint32_t dataBlobName(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    return dataBlobNameImpl(vmFromEnv(env), property, buffer, capacity);
}
void dataBlobSet(wasm_exec_env_t env, uint32_t property, const uint8_t* bytes, uint32_t byteCount)
{
    dataBlobSetImpl(vmFromEnv(env), property, bytes, byteCount);
}
void dataBlobClear(wasm_exec_env_t env, uint32_t property)
{
    dataBlobClearImpl(vmFromEnv(env), property);
}
uint32_t dataEnumGet(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    return dataEnumGetImpl(vmFromEnv(env), property, buffer, capacity);
}
void dataEnumSet(wasm_exec_env_t env, uint32_t property, const char* value, uint32_t length)
{
    dataEnumSetImpl(vmFromEnv(env), property, value, length);
}
uint32_t dataEnumValues(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    return dataEnumValuesImpl(vmFromEnv(env), property, buffer, capacity);
}
void dataPropRelease(wasm_exec_env_t env, uint32_t property)
{
    dataPropReleaseImpl(vmFromEnv(env), property);
}
void dataTriggerFire(wasm_exec_env_t env, uint32_t property)
{
    dataTriggerFireImpl(vmFromEnv(env), property);
}
uint32_t dataListLength(wasm_exec_env_t env, uint32_t property)
{
    return dataListLengthImpl(vmFromEnv(env), property);
}
void dataListPush(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    dataListPushImpl(vmFromEnv(env), property, vmi);
}
uint32_t dataListPop(wasm_exec_env_t env, uint32_t property)
{
    return dataListPopImpl(vmFromEnv(env), property);
}
uint32_t dataListShift(wasm_exec_env_t env, uint32_t property)
{
    return dataListShiftImpl(vmFromEnv(env), property);
}
void dataListClear(wasm_exec_env_t env, uint32_t property)
{
    dataListClearImpl(vmFromEnv(env), property);
}
void dataListSwap(wasm_exec_env_t env, uint32_t property, uint32_t index1, uint32_t index2)
{
    dataListSwapImpl(vmFromEnv(env), property, index1, index2);
}
void dataListInsert(wasm_exec_env_t env, uint32_t property, uint32_t vmi, uint32_t index)
{
    dataListInsertImpl(vmFromEnv(env), property, vmi, index);
}
void dataListRemove(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    dataListRemoveImpl(vmFromEnv(env), property, vmi);
}
void dataListRemoveAt(wasm_exec_env_t env, uint32_t property, uint32_t index)
{
    dataListRemoveAtImpl(vmFromEnv(env), property, index);
}
void dataListRemoveAllOf(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    dataListRemoveAllOfImpl(vmFromEnv(env), property, vmi);
}
uint32_t dataListGet(wasm_exec_env_t env, uint32_t property, uint32_t index)
{
    return dataListGetImpl(vmFromEnv(env), property, index);
}
void dataViewModelSet(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    dataViewModelSetImpl(vmFromEnv(env), property, vmi);
}
uint32_t dataColorGet(wasm_exec_env_t env, uint32_t property)
{
    return dataColorGetImpl(vmFromEnv(env), property);
}
void dataColorSet(wasm_exec_env_t env, uint32_t property, uint32_t value)
{
    dataColorSetImpl(vmFromEnv(env), property, value);
}
float dataNumberGet(wasm_exec_env_t env, uint32_t property)
{
    return dataNumberGetImpl(vmFromEnv(env), property);
}
void dataNumberSet(wasm_exec_env_t env, uint32_t property, float value)
{
    dataNumberSetImpl(vmFromEnv(env), property, value);
}
uint32_t dataBooleanGet(wasm_exec_env_t env, uint32_t property)
{
    return dataBooleanGetImpl(vmFromEnv(env), property);
}
void dataBooleanSet(wasm_exec_env_t env, uint32_t property, uint32_t value)
{
    dataBooleanSetImpl(vmFromEnv(env), property, value);
}
uint32_t dataStringGet(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    return dataStringGetImpl(vmFromEnv(env), property, buffer, capacity);
}
void dataStringSet(wasm_exec_env_t env, uint32_t property, const char* value, uint32_t length)
{
    dataStringSetImpl(vmFromEnv(env), property, value, length);
}
void dataWatch(wasm_exec_env_t env, uint32_t property, uint32_t token)
{
    dataWatchImpl(vmFromEnv(env), property, token);
}
void dataUnwatch(wasm_exec_env_t env, uint32_t property)
{
    dataUnwatchImpl(vmFromEnv(env), property);
}
void dataConvertResult(wasm_exec_env_t env, uint32_t kind, float number, uint32_t booleanValue, uint32_t color, const char* value, uint32_t length)
{
    dataConvertResultImpl(vmFromEnv(env), kind, number, booleanValue, color, value, length);
}
void artboardRelease(wasm_exec_env_t env, uint32_t artboard)
{
    artboardReleaseImpl(vmFromEnv(env), artboard);
}
uint32_t artboardAdvance(wasm_exec_env_t env, uint32_t artboard, float seconds)
{
    return artboardAdvanceImpl(vmFromEnv(env), artboard, seconds);
}
void artboardDraw(wasm_exec_env_t env, uint32_t artboard, uint32_t renderer)
{
    artboardDrawImpl(vmFromEnv(env), artboard, renderer);
}
uint32_t artboardInstance(wasm_exec_env_t env, uint32_t artboard, uint32_t vmi)
{
    return artboardInstanceImpl(vmFromEnv(env), artboard, vmi);
}
uint32_t artboardData(wasm_exec_env_t env, uint32_t artboard)
{
    return artboardDataImpl(vmFromEnv(env), artboard);
}
float artboardWidth(wasm_exec_env_t env, uint32_t artboard)
{
    return artboardWidthImpl(vmFromEnv(env), artboard);
}
float artboardHeight(wasm_exec_env_t env, uint32_t artboard)
{
    return artboardHeightImpl(vmFromEnv(env), artboard);
}
void artboardSetWidth(wasm_exec_env_t env, uint32_t artboard, float value)
{
    artboardSetWidthImpl(vmFromEnv(env), artboard, value);
}
void artboardSetHeight(wasm_exec_env_t env, uint32_t artboard, float value)
{
    artboardSetHeightImpl(vmFromEnv(env), artboard, value);
}
uint32_t artboardFrameOrigin(wasm_exec_env_t env, uint32_t artboard)
{
    return artboardFrameOriginImpl(vmFromEnv(env), artboard);
}
void artboardSetFrameOrigin(wasm_exec_env_t env, uint32_t artboard, uint32_t value)
{
    artboardSetFrameOriginImpl(vmFromEnv(env), artboard, value);
}
void artboardBounds(wasm_exec_env_t env, uint32_t artboard, float* out, uint32_t outCount)
{
    artboardBoundsImpl(vmFromEnv(env), artboard, out, outCount);
}
uint32_t artboardPointerEvent(wasm_exec_env_t env, uint32_t artboard, uint32_t kind, uint32_t pointerId, float x, float y)
{
    return artboardPointerEventImpl(vmFromEnv(env), artboard, kind, pointerId, x, y);
}
uint32_t artboardAnimation(wasm_exec_env_t env, uint32_t artboard, const char* name, uint32_t length)
{
    return artboardAnimationImpl(vmFromEnv(env), artboard, name, length);
}
void artboardAnimationRelease(wasm_exec_env_t env, uint32_t animation)
{
    artboardAnimationReleaseImpl(vmFromEnv(env), animation);
}
float artboardAnimationDuration(wasm_exec_env_t env, uint32_t animation)
{
    return artboardAnimationDurationImpl(vmFromEnv(env), animation);
}
uint32_t artboardAnimationAdvance(wasm_exec_env_t env, uint32_t animation, float seconds)
{
    return artboardAnimationAdvanceImpl(vmFromEnv(env), animation, seconds);
}
void artboardAnimationSetTime(wasm_exec_env_t env, uint32_t animation, float value, uint32_t mode)
{
    artboardAnimationSetTimeImpl(vmFromEnv(env), animation, value, mode);
}
uint32_t artboardNode(wasm_exec_env_t env, uint32_t artboard, const char* name, uint32_t length)
{
    return artboardNodeImpl(vmFromEnv(env), artboard, name, length);
}
void artboardNodeRelease(wasm_exec_env_t env, uint32_t node)
{
    artboardNodeReleaseImpl(vmFromEnv(env), node);
}
void artboardNodeTransform(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    artboardNodeTransformImpl(vmFromEnv(env), node, out, outCount);
}
void artboardNodeSet(wasm_exec_env_t env, uint32_t node, uint32_t field, float v0, float v1)
{
    artboardNodeSetImpl(vmFromEnv(env), node, field, v0, v1);
}
void artboardNodeWorldTransform(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    artboardNodeWorldTransformImpl(vmFromEnv(env), node, out, outCount);
}
void artboardNodeSetWorldTransform(wasm_exec_env_t env, uint32_t node, const float* values, uint32_t floatCount)
{
    artboardNodeSetWorldTransformImpl(vmFromEnv(env), node, values, floatCount);
}
void artboardNodeDecompose(wasm_exec_env_t env, uint32_t node, const float* values, uint32_t floatCount)
{
    artboardNodeDecomposeImpl(vmFromEnv(env), node, values, floatCount);
}
uint32_t artboardNodePathVerbs(wasm_exec_env_t env, uint32_t node, uint8_t* out, uint32_t outCount)
{
    return artboardNodePathVerbsImpl(vmFromEnv(env), node, out, outCount);
}
uint32_t artboardNodePathPoints(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    return artboardNodePathPointsImpl(vmFromEnv(env), node, out, outCount);
}
uint32_t artboardNodePaint(wasm_exec_env_t env, uint32_t node, uint32_t* out, uint32_t outCount)
{
    return artboardNodePaintImpl(vmFromEnv(env), node, out, outCount);
}
uint32_t pathNew(wasm_exec_env_t env)
{
    return pathNewImpl(vmFromEnv(env));
}
void pathUpdate(wasm_exec_env_t env, uint32_t path, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount, uint32_t fillRule)
{
    pathUpdateImpl(vmFromEnv(env), path, verbs, verbCount, points, floatCount, fillRule);
}
void pathRelease(wasm_exec_env_t env, uint32_t path)
{
    pathReleaseImpl(vmFromEnv(env), path);
}
void pathEffectResult(wasm_exec_env_t env, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    pathEffectResultImpl(vmFromEnv(env), verbs, verbCount, points, floatCount);
}
uint32_t paintNew(wasm_exec_env_t env)
{
    return paintNewImpl(vmFromEnv(env));
}
void paintRelease(wasm_exec_env_t env, uint32_t paint)
{
    paintReleaseImpl(vmFromEnv(env), paint);
}
void paintStyle(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    paintStyleImpl(vmFromEnv(env), paint, value);
}
void paintColor(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    paintColorImpl(vmFromEnv(env), paint, value);
}
void paintThickness(wasm_exec_env_t env, uint32_t paint, float value)
{
    paintThicknessImpl(vmFromEnv(env), paint, value);
}
void paintJoin(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    paintJoinImpl(vmFromEnv(env), paint, value);
}
void paintCap(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    paintCapImpl(vmFromEnv(env), paint, value);
}
void paintBlendMode(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    paintBlendModeImpl(vmFromEnv(env), paint, value);
}
void paintFeather(wasm_exec_env_t env, uint32_t paint, float value)
{
    paintFeatherImpl(vmFromEnv(env), paint, value);
}
void paintShader(wasm_exec_env_t env, uint32_t paint, uint32_t shader)
{
    paintShaderImpl(vmFromEnv(env), paint, shader);
}
uint32_t gpuFeatures(wasm_exec_env_t env, uint32_t* out, uint32_t outCount)
{
    return gpuFeaturesImpl(vmFromEnv(env), out, outCount);
}
uint32_t gpuCanvasNew(wasm_exec_env_t env, uint32_t width, uint32_t height)
{
    return gpuCanvasNewImpl(vmFromEnv(env), width, height);
}
void gpuCanvasRelease(wasm_exec_env_t env, uint32_t canvas)
{
    gpuCanvasReleaseImpl(vmFromEnv(env), canvas);
}
uint32_t gpuCanvasColorView(wasm_exec_env_t env, uint32_t canvas, uint32_t* props, uint32_t propCount)
{
    return gpuCanvasColorViewImpl(vmFromEnv(env), canvas, props, propCount);
}
uint32_t gpuCanvasImage(wasm_exec_env_t env, uint32_t canvas)
{
    return gpuCanvasImageImpl(vmFromEnv(env), canvas);
}
uint32_t gpuCanvasResize(wasm_exec_env_t env, uint32_t canvas, uint32_t width, uint32_t height, uint32_t* props, uint32_t propCount)
{
    return gpuCanvasResizeImpl(vmFromEnv(env), canvas, width, height, props, propCount);
}
uint32_t gpuPassBegin(wasm_exec_env_t env, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const rive_gpu_pass_color_attachment_v1* colors, uint32_t colorByteCount)
{
    return gpuPassBeginImpl(vmFromEnv(env), desc, descByteCount, colors, colorByteCount);
}
void gpuPassSetPipeline(wasm_exec_env_t env, uint32_t pass, uint32_t pipeline)
{
    gpuPassSetPipelineImpl(vmFromEnv(env), pass, pipeline);
}
void gpuPassSetVertexBuffer(wasm_exec_env_t env, uint32_t pass, uint32_t slot, uint32_t buffer, uint32_t offset)
{
    gpuPassSetVertexBufferImpl(vmFromEnv(env), pass, slot, buffer, offset);
}
void gpuPassSetIndexBuffer(wasm_exec_env_t env, uint32_t pass, uint32_t buffer, uint32_t indexFormat, uint32_t offset)
{
    gpuPassSetIndexBufferImpl(vmFromEnv(env), pass, buffer, indexFormat, offset);
}
void gpuPassSetBindGroup(wasm_exec_env_t env, uint32_t pass, uint32_t groupIndex, uint32_t bindGroup, const uint32_t* dynamicOffsets, uint32_t dynamicOffsetByteCount)
{
    gpuPassSetBindGroupImpl(vmFromEnv(env), pass, groupIndex, bindGroup, dynamicOffsets, dynamicOffsetByteCount);
}
void gpuPassSetViewport(wasm_exec_env_t env, uint32_t pass, float x, float y, float width, float height, float minDepth, float maxDepth)
{
    gpuPassSetViewportImpl(vmFromEnv(env), pass, x, y, width, height, minDepth, maxDepth);
}
void gpuPassSetScissor(wasm_exec_env_t env, uint32_t pass, uint32_t x, uint32_t y, uint32_t width, uint32_t height)
{
    gpuPassSetScissorImpl(vmFromEnv(env), pass, x, y, width, height);
}
void gpuPassSetStencilReference(wasm_exec_env_t env, uint32_t pass, uint32_t ref)
{
    gpuPassSetStencilReferenceImpl(vmFromEnv(env), pass, ref);
}
void gpuPassSetBlendColor(wasm_exec_env_t env, uint32_t pass, float r, float g, float b, float a)
{
    gpuPassSetBlendColorImpl(vmFromEnv(env), pass, r, g, b, a);
}
void gpuPassDraw(wasm_exec_env_t env, uint32_t pass, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
    gpuPassDrawImpl(vmFromEnv(env), pass, vertexCount, instanceCount, firstVertex, firstInstance);
}
void gpuPassDrawIndexed(wasm_exec_env_t env, uint32_t pass, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance)
{
    gpuPassDrawIndexedImpl(vmFromEnv(env), pass, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
}
void gpuPassFinish(wasm_exec_env_t env, uint32_t pass)
{
    gpuPassFinishImpl(vmFromEnv(env), pass);
}
void gpuPassRelease(wasm_exec_env_t env, uint32_t pass)
{
    gpuPassReleaseImpl(vmFromEnv(env), pass);
}
uint32_t gpuImageView(wasm_exec_env_t env, uint32_t image, uint32_t width, uint32_t height)
{
    return gpuImageViewImpl(vmFromEnv(env), image, width, height);
}
uint32_t gpuBufferNew(wasm_exec_env_t env, uint32_t usage, uint32_t sizeInBytes, uint32_t immutable, const uint8_t* data, uint32_t dataCount)
{
    return gpuBufferNewImpl(vmFromEnv(env), usage, sizeInBytes, immutable, data, dataCount);
}
void gpuBufferUpdate(wasm_exec_env_t env, uint32_t buffer, uint32_t dstOffset, const uint8_t* data, uint32_t dataCount)
{
    gpuBufferUpdateImpl(vmFromEnv(env), buffer, dstOffset, data, dataCount);
}
void gpuBufferRelease(wasm_exec_env_t env, uint32_t buffer)
{
    gpuBufferReleaseImpl(vmFromEnv(env), buffer);
}
uint32_t gpuTextureNew(wasm_exec_env_t env, const rive_gpu_texture_desc_v1* desc, uint32_t descByteCount)
{
    return gpuTextureNewImpl(vmFromEnv(env), desc, descByteCount);
}
void gpuTextureUpload(wasm_exec_env_t env, uint32_t texture, const rive_gpu_texture_upload_v1* region, uint32_t regionByteCount, const uint8_t* data, uint32_t dataCount)
{
    gpuTextureUploadImpl(vmFromEnv(env), texture, region, regionByteCount, data, dataCount);
}
void gpuTextureRelease(wasm_exec_env_t env, uint32_t texture)
{
    gpuTextureReleaseImpl(vmFromEnv(env), texture);
}
uint32_t gpuSamplerNew(wasm_exec_env_t env, const rive_gpu_sampler_desc_v1* desc, uint32_t descByteCount)
{
    return gpuSamplerNewImpl(vmFromEnv(env), desc, descByteCount);
}
void gpuSamplerRelease(wasm_exec_env_t env, uint32_t sampler)
{
    gpuSamplerReleaseImpl(vmFromEnv(env), sampler);
}
uint32_t gpuTextureViewNew(wasm_exec_env_t env, uint32_t texture, const rive_gpu_texture_view_desc_v1* desc, uint32_t descByteCount)
{
    return gpuTextureViewNewImpl(vmFromEnv(env), texture, desc, descByteCount);
}
void gpuTextureViewRelease(wasm_exec_env_t env, uint32_t view)
{
    gpuTextureViewReleaseImpl(vmFromEnv(env), view);
}
uint32_t gpuShaderTarget(wasm_exec_env_t env)
{
    return gpuShaderTargetImpl(vmFromEnv(env));
}
uint32_t gpuShaderAssetBytes(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    return gpuShaderAssetBytesImpl(vmFromEnv(env), object, name, nameLength, out, outCount);
}
uint32_t gpuShaderAssetId(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength)
{
    return gpuShaderAssetIdImpl(vmFromEnv(env), object, name, nameLength);
}
uint32_t gpuShaderModuleNew(wasm_exec_env_t env, const rive_gpu_shader_module_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    return gpuShaderModuleNewImpl(vmFromEnv(env), desc, descByteCount, blob, blobCount);
}
void gpuShaderModuleRelease(wasm_exec_env_t env, uint32_t shaderModule)
{
    gpuShaderModuleReleaseImpl(vmFromEnv(env), shaderModule);
}
uint32_t gpuBindGroupLayoutNew(wasm_exec_env_t env, uint32_t groupIndex, const rive_gpu_bind_group_layout_entry_v1* entries, uint32_t entryByteCount)
{
    return gpuBindGroupLayoutNewImpl(vmFromEnv(env), groupIndex, entries, entryByteCount);
}
void gpuBindGroupLayoutRelease(wasm_exec_env_t env, uint32_t layout)
{
    gpuBindGroupLayoutReleaseImpl(vmFromEnv(env), layout);
}
uint32_t gpuBindGroupLayoutFromShader(wasm_exec_env_t env, uint32_t shaderModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount)
{
    return gpuBindGroupLayoutFromShaderImpl(vmFromEnv(env), shaderModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
uint32_t gpuBindGroupNew(wasm_exec_env_t env, uint32_t layout, const rive_gpu_bind_group_ubo_v1* ubos, uint32_t uboByteCount, const rive_gpu_bind_group_texture_v1* textures, uint32_t textureByteCount, const rive_gpu_bind_group_sampler_v1* samplers, uint32_t samplerByteCount)
{
    return gpuBindGroupNewImpl(vmFromEnv(env), layout, ubos, uboByteCount, textures, textureByteCount, samplers, samplerByteCount);
}
void gpuBindGroupRelease(wasm_exec_env_t env, uint32_t bindGroup)
{
    gpuBindGroupReleaseImpl(vmFromEnv(env), bindGroup);
}
uint32_t gpuPipelineNew(wasm_exec_env_t env, const rive_gpu_pipeline_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    return gpuPipelineNewImpl(vmFromEnv(env), desc, descByteCount, blob, blobCount);
}
void gpuPipelineRelease(wasm_exec_env_t env, uint32_t pipeline)
{
    gpuPipelineReleaseImpl(vmFromEnv(env), pipeline);
}
uint32_t bufferNew(wasm_exec_env_t env, uint32_t bufferType, uint32_t flags, uint32_t sizeInBytes)
{
    return bufferNewImpl(vmFromEnv(env), bufferType, flags, sizeInBytes);
}
void bufferUpdate(wasm_exec_env_t env, uint32_t buffer, const uint8_t* bytes, uint32_t byteCount)
{
    bufferUpdateImpl(vmFromEnv(env), buffer, bytes, byteCount);
}
void bufferRelease(wasm_exec_env_t env, uint32_t buffer)
{
    bufferReleaseImpl(vmFromEnv(env), buffer);
}
uint32_t blobAssetBytes(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    return blobAssetBytesImpl(vmFromEnv(env), object, name, nameLength, out, outCount);
}
uint32_t imageFromAsset(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t length)
{
    return imageFromAssetImpl(vmFromEnv(env), object, name, length);
}
uint32_t imageWidth(wasm_exec_env_t env, uint32_t image)
{
    return imageWidthImpl(vmFromEnv(env), image);
}
uint32_t imageHeight(wasm_exec_env_t env, uint32_t image)
{
    return imageHeightImpl(vmFromEnv(env), image);
}
void imageRelease(wasm_exec_env_t env, uint32_t image)
{
    imageReleaseImpl(vmFromEnv(env), image);
}
uint32_t imageDecode(wasm_exec_env_t env, const uint8_t* bytes, uint32_t byteCount, uint32_t token)
{
    return imageDecodeImpl(vmFromEnv(env), bytes, byteCount, token);
}
void imageDecodeCancel(wasm_exec_env_t env, uint32_t token)
{
    imageDecodeCancelImpl(vmFromEnv(env), token);
}
uint32_t shaderLinear(wasm_exec_env_t env, float sx, float sy, float ex, float ey, uint32_t colors, uint32_t stops, uint32_t count)
{
    return shaderLinearImpl(vmFromEnv(env), sx, sy, ex, ey, colors, stops, count);
}
uint32_t shaderRadial(wasm_exec_env_t env, float cx, float cy, float radius, uint32_t colors, uint32_t stops, uint32_t count)
{
    return shaderRadialImpl(vmFromEnv(env), cx, cy, radius, colors, stops, count);
}
void shaderRelease(wasm_exec_env_t env, uint32_t shader)
{
    shaderReleaseImpl(vmFromEnv(env), shader);
}
void rendererSave(wasm_exec_env_t env, uint32_t renderer)
{
    rendererSaveImpl(vmFromEnv(env), renderer);
}
void rendererRestore(wasm_exec_env_t env, uint32_t renderer)
{
    rendererRestoreImpl(vmFromEnv(env), renderer);
}
void rendererTransform(wasm_exec_env_t env, uint32_t renderer, float xx, float xy, float yx, float yy, float tx, float ty)
{
    rendererTransformImpl(vmFromEnv(env), renderer, xx, xy, yx, yy, tx, ty);
}
void rendererDrawPath(wasm_exec_env_t env, uint32_t renderer, uint32_t path, uint32_t paint)
{
    rendererDrawPathImpl(vmFromEnv(env), renderer, path, paint);
}
void rendererClipPath(wasm_exec_env_t env, uint32_t renderer, uint32_t path)
{
    rendererClipPathImpl(vmFromEnv(env), renderer, path);
}
void rendererDrawImage(wasm_exec_env_t env, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t blend, float opacity)
{
    rendererDrawImageImpl(vmFromEnv(env), renderer, image, sampler, blend, opacity);
}
void rendererDrawImageMesh(wasm_exec_env_t env, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t blend, float opacity)
{
    rendererDrawImageMeshImpl(vmFromEnv(env), renderer, image, sampler, vertexBuffer, uvBuffer, indexBuffer, blend, opacity);
}

NativeSymbol kRtNatives[] = {
    {"log", (void*)rtLog, "(i*~)", nullptr},
    {"mark_needs_update", (void*)rtMarkNeedsUpdate, "(i)", nullptr},
    {"budget_exceeded", (void*)rtBudgetExceeded, "(i)", nullptr},
};

NativeSymbol kDataNatives[] = {
    {"view_model", (void*)dataViewModel, "(i)i", nullptr},
    {"root_view_model", (void*)dataRootViewModel, "(i)i", nullptr},
    {"global_view_model", (void*)dataGlobalViewModel, "(i*~)i", nullptr},
    {"global_view_model_names", (void*)dataGlobalViewModelNames, "(i*~)i", nullptr},
    {"context", (void*)dataContext, "(i)i", nullptr},
    {"context_parent", (void*)dataContextParent, "(i)i", nullptr},
    {"context_view_model", (void*)dataContextViewModel, "(i)i", nullptr},
    {"context_release", (void*)dataContextRelease, "(i)", nullptr},
    {"has_view_model", (void*)dataHasViewModel, "(*~)i", nullptr},
    {"new_view_model", (void*)dataNewViewModel, "(*~*~)i", nullptr},
    {"vmi_release", (void*)dataVmiRelease, "(i)", nullptr},
    {"vmi_number", (void*)dataVmiNumber, "(i*~)i", nullptr},
    {"vmi_boolean", (void*)dataVmiBoolean, "(i*~)i", nullptr},
    {"vmi_string", (void*)dataVmiString, "(i*~)i", nullptr},
    {"vmi_trigger", (void*)dataVmiTrigger, "(i*~)i", nullptr},
    {"vmi_color", (void*)dataVmiColor, "(i*~)i", nullptr},
    {"vmi_view_model", (void*)dataVmiViewModel, "(i*~)i", nullptr},
    {"vmi_property", (void*)dataVmiProperty, "(i*~*~)i", nullptr},
    {"vmi_instance", (void*)dataVmiInstance, "(i*~)i", nullptr},
    {"vmi_symbol_index", (void*)dataVmiSymbolIndex, "(i)i", nullptr},
    {"vmi_equal", (void*)dataVmiEqual, "(ii)i", nullptr},
    {"view_model_get", (void*)dataViewModelGet, "(i)i", nullptr},
    {"vmi_list", (void*)dataVmiList, "(i*~)i", nullptr},
    {"vmi_enum", (void*)dataVmiEnum, "(i*~)i", nullptr},
    {"vmi_image", (void*)dataVmiImage, "(i*~)i", nullptr},
    {"vmi_font", (void*)dataVmiFont, "(i*~)i", nullptr},
    {"vmi_blob", (void*)dataVmiBlob, "(i*~)i", nullptr},
    {"image_get", (void*)dataImageGet, "(i)i", nullptr},
    {"image_set", (void*)dataImageSet, "(ii)", nullptr},
    {"font_get", (void*)dataFontGet, "(i)i", nullptr},
    {"font_set", (void*)dataFontSet, "(ii)", nullptr},
    {"font_release", (void*)dataFontRelease, "(i)", nullptr},
    {"blob_present", (void*)dataBlobPresent, "(i)i", nullptr},
    {"blob_get", (void*)dataBlobGet, "(i*~)i", nullptr},
    {"blob_name", (void*)dataBlobName, "(i*~)i", nullptr},
    {"blob_set", (void*)dataBlobSet, "(i*~)", nullptr},
    {"blob_clear", (void*)dataBlobClear, "(i)", nullptr},
    {"enum_get", (void*)dataEnumGet, "(i*~)i", nullptr},
    {"enum_set", (void*)dataEnumSet, "(i*~)", nullptr},
    {"enum_values", (void*)dataEnumValues, "(i*~)i", nullptr},
    {"prop_release", (void*)dataPropRelease, "(i)", nullptr},
    {"trigger_fire", (void*)dataTriggerFire, "(i)", nullptr},
    {"list_length", (void*)dataListLength, "(i)i", nullptr},
    {"list_push", (void*)dataListPush, "(ii)", nullptr},
    {"list_pop", (void*)dataListPop, "(i)i", nullptr},
    {"list_shift", (void*)dataListShift, "(i)i", nullptr},
    {"list_clear", (void*)dataListClear, "(i)", nullptr},
    {"list_swap", (void*)dataListSwap, "(iii)", nullptr},
    {"list_insert", (void*)dataListInsert, "(iii)", nullptr},
    {"list_remove", (void*)dataListRemove, "(ii)", nullptr},
    {"list_remove_at", (void*)dataListRemoveAt, "(ii)", nullptr},
    {"list_remove_all_of", (void*)dataListRemoveAllOf, "(ii)", nullptr},
    {"list_get", (void*)dataListGet, "(ii)i", nullptr},
    {"view_model_set", (void*)dataViewModelSet, "(ii)", nullptr},
    {"color_get", (void*)dataColorGet, "(i)i", nullptr},
    {"color_set", (void*)dataColorSet, "(ii)", nullptr},
    {"number_get", (void*)dataNumberGet, "(i)f", nullptr},
    {"number_set", (void*)dataNumberSet, "(if)", nullptr},
    {"boolean_get", (void*)dataBooleanGet, "(i)i", nullptr},
    {"boolean_set", (void*)dataBooleanSet, "(ii)", nullptr},
    {"string_get", (void*)dataStringGet, "(i*~)i", nullptr},
    {"string_set", (void*)dataStringSet, "(i*~)", nullptr},
    {"watch", (void*)dataWatch, "(ii)", nullptr},
    {"unwatch", (void*)dataUnwatch, "(i)", nullptr},
    {"convert_result", (void*)dataConvertResult, "(ifii*~)", nullptr},
};

NativeSymbol kArtboardNatives[] = {
    {"release", (void*)artboardRelease, "(i)", nullptr},
    {"advance", (void*)artboardAdvance, "(if)i", nullptr},
    {"draw", (void*)artboardDraw, "(ii)", nullptr},
    {"instance", (void*)artboardInstance, "(ii)i", nullptr},
    {"data", (void*)artboardData, "(i)i", nullptr},
    {"width", (void*)artboardWidth, "(i)f", nullptr},
    {"height", (void*)artboardHeight, "(i)f", nullptr},
    {"set_width", (void*)artboardSetWidth, "(if)", nullptr},
    {"set_height", (void*)artboardSetHeight, "(if)", nullptr},
    {"frame_origin", (void*)artboardFrameOrigin, "(i)i", nullptr},
    {"set_frame_origin", (void*)artboardSetFrameOrigin, "(ii)", nullptr},
    {"bounds", (void*)artboardBounds, "(i*~)", nullptr},
    {"pointer_event", (void*)artboardPointerEvent, "(iiiff)i", nullptr},
    {"animation", (void*)artboardAnimation, "(i*~)i", nullptr},
    {"animation_release", (void*)artboardAnimationRelease, "(i)", nullptr},
    {"animation_duration", (void*)artboardAnimationDuration, "(i)f", nullptr},
    {"animation_advance", (void*)artboardAnimationAdvance, "(if)i", nullptr},
    {"animation_set_time", (void*)artboardAnimationSetTime, "(ifi)", nullptr},
    {"node", (void*)artboardNode, "(i*~)i", nullptr},
    {"node_release", (void*)artboardNodeRelease, "(i)", nullptr},
    {"node_transform", (void*)artboardNodeTransform, "(i*~)", nullptr},
    {"node_set", (void*)artboardNodeSet, "(iiff)", nullptr},
    {"node_world_transform", (void*)artboardNodeWorldTransform, "(i*~)", nullptr},
    {"node_set_world_transform", (void*)artboardNodeSetWorldTransform, "(i*~)", nullptr},
    {"node_decompose", (void*)artboardNodeDecompose, "(i*~)", nullptr},
    {"node_path_verbs", (void*)artboardNodePathVerbs, "(i*~)i", nullptr},
    {"node_path_points", (void*)artboardNodePathPoints, "(i*~)i", nullptr},
    {"node_paint", (void*)artboardNodePaint, "(i*~)i", nullptr},
};

NativeSymbol kPathNatives[] = {
    {"new", (void*)pathNew, "()i", nullptr},
    {"update", (void*)pathUpdate, "(i*~*~i)", nullptr},
    {"release", (void*)pathRelease, "(i)", nullptr},
    {"effect_result", (void*)pathEffectResult, "(*~*~)", nullptr},
};

NativeSymbol kPaintNatives[] = {
    {"new", (void*)paintNew, "()i", nullptr},
    {"release", (void*)paintRelease, "(i)", nullptr},
    {"style", (void*)paintStyle, "(ii)", nullptr},
    {"color", (void*)paintColor, "(ii)", nullptr},
    {"thickness", (void*)paintThickness, "(if)", nullptr},
    {"join", (void*)paintJoin, "(ii)", nullptr},
    {"cap", (void*)paintCap, "(ii)", nullptr},
    {"blend_mode", (void*)paintBlendMode, "(ii)", nullptr},
    {"feather", (void*)paintFeather, "(if)", nullptr},
    {"shader", (void*)paintShader, "(ii)", nullptr},
};

NativeSymbol kGpuNatives[] = {
    {"features", (void*)gpuFeatures, "(*~)i", nullptr},
    {"canvas_new", (void*)gpuCanvasNew, "(ii)i", nullptr},
    {"canvas_release", (void*)gpuCanvasRelease, "(i)", nullptr},
    {"canvas_color_view", (void*)gpuCanvasColorView, "(i*~)i", nullptr},
    {"canvas_image", (void*)gpuCanvasImage, "(i)i", nullptr},
    {"canvas_resize", (void*)gpuCanvasResize, "(iii*~)i", nullptr},
    {"pass_begin", (void*)gpuPassBegin, "(*~*~)i", nullptr},
    {"pass_set_pipeline", (void*)gpuPassSetPipeline, "(ii)", nullptr},
    {"pass_set_vertex_buffer", (void*)gpuPassSetVertexBuffer, "(iiii)", nullptr},
    {"pass_set_index_buffer", (void*)gpuPassSetIndexBuffer, "(iiii)", nullptr},
    {"pass_set_bind_group", (void*)gpuPassSetBindGroup, "(iii*~)", nullptr},
    {"pass_set_viewport", (void*)gpuPassSetViewport, "(iffffff)", nullptr},
    {"pass_set_scissor", (void*)gpuPassSetScissor, "(iiiii)", nullptr},
    {"pass_set_stencil_reference", (void*)gpuPassSetStencilReference, "(ii)", nullptr},
    {"pass_set_blend_color", (void*)gpuPassSetBlendColor, "(iffff)", nullptr},
    {"pass_draw", (void*)gpuPassDraw, "(iiiii)", nullptr},
    {"pass_draw_indexed", (void*)gpuPassDrawIndexed, "(iiiiii)", nullptr},
    {"pass_finish", (void*)gpuPassFinish, "(i)", nullptr},
    {"pass_release", (void*)gpuPassRelease, "(i)", nullptr},
    {"image_view", (void*)gpuImageView, "(iii)i", nullptr},
    {"buffer_new", (void*)gpuBufferNew, "(iii*~)i", nullptr},
    {"buffer_update", (void*)gpuBufferUpdate, "(ii*~)", nullptr},
    {"buffer_release", (void*)gpuBufferRelease, "(i)", nullptr},
    {"texture_new", (void*)gpuTextureNew, "(*~)i", nullptr},
    {"texture_upload", (void*)gpuTextureUpload, "(i*~*~)", nullptr},
    {"texture_release", (void*)gpuTextureRelease, "(i)", nullptr},
    {"sampler_new", (void*)gpuSamplerNew, "(*~)i", nullptr},
    {"sampler_release", (void*)gpuSamplerRelease, "(i)", nullptr},
    {"texture_view_new", (void*)gpuTextureViewNew, "(i*~)i", nullptr},
    {"texture_view_release", (void*)gpuTextureViewRelease, "(i)", nullptr},
    {"shader_target", (void*)gpuShaderTarget, "()i", nullptr},
    {"shader_asset_bytes", (void*)gpuShaderAssetBytes, "(i*~*~)i", nullptr},
    {"shader_asset_id", (void*)gpuShaderAssetId, "(i*~)i", nullptr},
    {"shader_module_new", (void*)gpuShaderModuleNew, "(*~*~)i", nullptr},
    {"shader_module_release", (void*)gpuShaderModuleRelease, "(i)", nullptr},
    {"bind_group_layout_new", (void*)gpuBindGroupLayoutNew, "(i*~)i", nullptr},
    {"bind_group_layout_release", (void*)gpuBindGroupLayoutRelease, "(i)", nullptr},
    {"bind_group_layout_from_shader", (void*)gpuBindGroupLayoutFromShader, "(ii*~)i", nullptr},
    {"bind_group_new", (void*)gpuBindGroupNew, "(i*~*~*~)i", nullptr},
    {"bind_group_release", (void*)gpuBindGroupRelease, "(i)", nullptr},
    {"pipeline_new", (void*)gpuPipelineNew, "(*~*~)i", nullptr},
    {"pipeline_release", (void*)gpuPipelineRelease, "(i)", nullptr},
};

NativeSymbol kBufferNatives[] = {
    {"new", (void*)bufferNew, "(iii)i", nullptr},
    {"update", (void*)bufferUpdate, "(i*~)", nullptr},
    {"release", (void*)bufferRelease, "(i)", nullptr},
};

NativeSymbol kBlobNatives[] = {
    {"asset_bytes", (void*)blobAssetBytes, "(i*~*~)i", nullptr},
};

NativeSymbol kImageNatives[] = {
    {"from_asset", (void*)imageFromAsset, "(i*~)i", nullptr},
    {"width", (void*)imageWidth, "(i)i", nullptr},
    {"height", (void*)imageHeight, "(i)i", nullptr},
    {"release", (void*)imageRelease, "(i)", nullptr},
    {"decode", (void*)imageDecode, "(*~i)i", nullptr},
    {"decode_cancel", (void*)imageDecodeCancel, "(i)", nullptr},
};

NativeSymbol kShaderNatives[] = {
    {"linear", (void*)shaderLinear, "(ffffiii)i", nullptr},
    {"radial", (void*)shaderRadial, "(fffiii)i", nullptr},
    {"release", (void*)shaderRelease, "(i)", nullptr},
};

NativeSymbol kRendererNatives[] = {
    {"save", (void*)rendererSave, "(i)", nullptr},
    {"restore", (void*)rendererRestore, "(i)", nullptr},
    {"transform", (void*)rendererTransform, "(iffffff)", nullptr},
    {"draw_path", (void*)rendererDrawPath, "(iii)", nullptr},
    {"clip_path", (void*)rendererClipPath, "(ii)", nullptr},
    {"draw_image", (void*)rendererDrawImage, "(iiiif)", nullptr},
    {"draw_image_mesh", (void*)rendererDrawImageMesh, "(iiiiiiif)", nullptr},
};

inline bool registerRiveBindingNatives()
{
    return wasm_runtime_register_natives(
               "rive_rt_v1",
               kRtNatives,
               sizeof(kRtNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_data_v1",
               kDataNatives,
               sizeof(kDataNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_artboard_v1",
               kArtboardNatives,
               sizeof(kArtboardNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_path_v1",
               kPathNatives,
               sizeof(kPathNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_paint_v1",
               kPaintNatives,
               sizeof(kPaintNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_gpu_v1",
               kGpuNatives,
               sizeof(kGpuNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_buffer_v1",
               kBufferNatives,
               sizeof(kBufferNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_blob_v1",
               kBlobNatives,
               sizeof(kBlobNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_image_v1",
               kImageNatives,
               sizeof(kImageNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_shader_v1",
               kShaderNatives,
               sizeof(kShaderNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_renderer_v1",
               kRendererNatives,
               sizeof(kRendererNatives) / sizeof(NativeSymbol));
}