include/rive/wasm/module_render.hpp

#ifndef _RIVE_WASM_MODULE_RENDER_HPP_
#define _RIVE_WASM_MODULE_RENDER_HPP_

#ifdef RIVE_WASM_MODULE

#include "rive/refcnt.hpp"

#include <memory>
#include <stdint.h>
#include <string>

namespace rive
{
class Factory;
class Renderer;
class RenderImage;
namespace ore
{
class Context;
}

/// The script module's handle-backed render factory; every object it makes
/// crosses to the host as a u32 handle through the rive_*_v1 imports.
Factory* wasmModuleFactory();

#if defined(RIVE_CANVAS) && defined(RIVE_ORE)
namespace ore
{
class ShaderModule;
struct ShaderModuleDesc;
class TextureView;
} // namespace ore
namespace gpu
{
class RenderCanvas;
}
/// The module's ore context; factories realize against rive_gpu_v1 handles.
ore::Context* wasmModuleOreContext();

/// The asset shader loads build from until the next call; the host makes
/// every module from it, the desc only feeds module-side reflection.
void wasmModuleShaderSource(uint32_t object, const std::string& name);
rcp<ore::ShaderModule> wasmModuleShaderModule(
    const ore::ShaderModuleDesc& desc,
    uint32_t entry);

/// Module-side canvas pair over a host canvas handle: a RenderCanvas whose
/// target owns the handle, and a color view carrying real attachment
/// metadata for pass validation.
struct WasmModuleCanvas
{
  rcp<gpu::RenderCanvas> canvas;
  rcp<ore::TextureView> colorView;
};
WasmModuleCanvas wasmModuleWrapCanvas(uint32_t canvasHandle);
/// Recreates the wrapped canvas at a new size through the host; empty on
/// failure. The canvas handle transfers to the returned wrap.
WasmModuleCanvas wasmModuleResizeCanvas(
    const rcp<gpu::RenderCanvas>& canvas,
    uint32_t width,
    uint32_t height);
/// Mints a fresh host image handle over the canvas's presentable image.
uint32_t wasmModuleCanvasImageHandle(const rcp<gpu::RenderCanvas>& canvas);
#endif

/// Wraps a host renderer handle for one draw call.
std::unique_ptr<Renderer> makeWasmModuleRenderer(uint32_t handle);

/// The host handle inside a module renderer.
uint32_t wasmModuleRendererHandle(Renderer* renderer);

/// Wraps a host image handle. Dimensions are fetched at wrap time; call
/// wasmModuleRefreshImageSize to pick up an image that decoded since.
rcp<RenderImage> makeWasmModuleRenderImage(uint32_t handle);

/// Re-reads a module render image's size from its host image.
void wasmModuleRefreshImageSize(RenderImage* image);

/// The host handle inside a module render image.
uint32_t wasmModuleImageHandle(RenderImage* image);
} // namespace rive

#endif
#endif