🥮 mooncakes.io
    Sign in

    moui_3d

    Experimental 3D scene and glTF viewer addon for MoUI

    moui
    3d
    gltf
    viewer
    Download zip
    Author
    Version
    0.2.1
    License
    Apache-2.0
    Repository
    Last updated
    5 days ago
    Downloads
    13

    Dependencies

    #moui_3d

    Experimental, renderer-neutral 3D scene and glTF viewer primitives for MoUI.

    The first slice intentionally owns CPU scene data, camera controls, picking, and the external-surface binding contract. It does not add 3D variants to MoUI's 2D DrawCommand protocol.

    GltfResourceResolver

    source
    type GltfResourceResolver = (String) -> Bytes?

    Resolves a URI referenced by a JSON .gltf document.

    GltfError

    source
    pub(all) suberror GltfError {
      EmptyInput
      InvalidMagic
      UnsupportedVersion(Int)
      InvalidDeclaredLength
      TruncatedChunk
      MissingJsonChunk
      InvalidJson(String)
      UnsupportedAssetVersion(String)
      MissingBuffer(Int)
      MissingBufferView(Int)
      MissingAccessor(Int)
      MissingAttribute(String)
      InvalidAccessor(Int)
      UnsupportedComponentType(Int)
      UnsupportedAccessorType(String)
      UnsupportedPrimitiveMode(Int)
      UnsupportedExtension(String)
      UnsupportedRequiredExtension(String)
      ExternalResourceUnavailable(String)
      InvalidTexture(Int)
      InvalidSampler(Int)
      InvalidCamera(Int)
      InvalidScene(Int)
      InvalidSkin(Int)
      InvalidAnimation(Int)
      UnsupportedAnimationPath(String)
      InvalidNode(Int)
      InvalidNodeCycle(Int)
    } derive(Eq, ToJson, 
    Debug    )

    GltfError::equal

    source
    fn GltfError::equal(GltfError, GltfError) -> Bool

    GltfError::not_equal

    source
    fn GltfError::not_equal(x : GltfError, y : GltfError) -> Bool

    GltfError::to_json

    source
    fn GltfError::to_json(GltfError) -> Json

    GltfError::to_repr

    source

    Aabb

    source
    pub(all) struct Aabb {
      min : Vec3
      max : Vec3
      valid : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Aabb::center

    source
    fn Aabb::center(self : Aabb) -> Vec3

    Aabb::empty

    source
    fn Aabb::empty() -> Aabb

    Aabb::equal

    source
    fn Aabb::equal(Aabb, Aabb) -> Bool

    Aabb::extent

    source
    fn Aabb::extent(self : Aabb) -> Vec3

    Aabb::from_points

    source
    fn Aabb::from_points(points : Array[Vec3]) -> Aabb

    Aabb::include_point

    source
    fn Aabb::include_point(self : Aabb, point : Vec3) -> Aabb

    Aabb::is_valid

    source
    fn Aabb::is_valid(self : Aabb) -> Bool

    Aabb::max

    source
    fn Aabb::max(self : Aabb) -> Vec3

    Aabb::min

    source
    fn Aabb::min(self : Aabb) -> Vec3

    Aabb::not_equal

    source
    fn Aabb::not_equal(x : Aabb, y : Aabb) -> Bool

    Aabb::radius

    source
    fn Aabb::radius(self : Aabb) -> Double

    Aabb::to_json

    source
    fn Aabb::to_json(Aabb) -> Json

    Aabb::to_repr

    source

    Aabb::transformed

    source
    fn Aabb::transformed(self : Aabb, matrix : Mat4) -> Aabb

    Aabb::union

    source
    fn Aabb::union(self : Aabb, other : Aabb) -> Aabb

    AlphaMode

    source
    pub(all) enum AlphaMode {
      Opaque
      Mask
      Blend
    } derive(Eq, ToJson, 
    Debug    )

    AlphaMode::equal

    source
    fn AlphaMode::equal(AlphaMode, AlphaMode) -> Bool

    AlphaMode::not_equal

    source
    fn AlphaMode::not_equal(x : AlphaMode, y : AlphaMode) -> Bool

    AlphaMode::to_json

    source
    fn AlphaMode::to_json(AlphaMode) -> Json

    AlphaMode::to_repr

    source

    AnimationChannel

    source
    pub(all) struct AnimationChannel {
      node : NodeId
      path : AnimationPath
      interpolation : AnimationInterpolation
      keyframes : Array[AnimationKeyframe]
    } derive(
    Debug    )

    AnimationChannel::interpolation

    source

    AnimationChannel::keyframes

    source

    AnimationChannel::new

    source
    fn AnimationChannel::new(node~ : NodeId, path~ : AnimationPath, interpolation~ : AnimationInterpolation, keyframes~ : Array[AnimationKeyframe]) -> AnimationChannel

    AnimationChannel::node

    source

    AnimationChannel::path

    source

    AnimationChannel::to_repr

    source

    AnimationClip

    source
    pub(all) struct AnimationClip {
      name : String
      channels : Array[AnimationChannel]
      duration : Double
    } derive(
    Debug    )

    A named glTF animation clip. Channels are evaluated independently and can be blended or selected by the application without coupling the scene to a playback clock.

    AnimationClip::channels

    source

    AnimationClip::duration

    source
    fn AnimationClip::duration(self : AnimationClip) -> Double

    AnimationClip::name

    source
    fn AnimationClip::name(self : AnimationClip) -> String

    AnimationClip::new

    source
    fn AnimationClip::new(name? : String, channels~ : Array[AnimationChannel]) -> AnimationClip

    AnimationClip::to_repr

    source

    AnimationInterpolation

    source
    pub(all) enum AnimationInterpolation {
      Step
      Linear
      CubicSpline
    } derive(Eq, ToJson, 
    Debug    )

    glTF animation interpolation modes supported by the CPU evaluator.

    AnimationInterpolation::equal

    source

    AnimationInterpolation::not_equal

    source

    AnimationInterpolation::to_json

    source

    AnimationInterpolation::to_repr

    source

    AnimationKeyframe

    source
    pub(all) struct AnimationKeyframe {
      time : Double
      value : Array[Double]
      in_tangent : Array[Double]
      out_tangent : Array[Double]
    } derive(
    Debug    )

    AnimationKeyframe::in_tangent

    source
    fn AnimationKeyframe::in_tangent(self : AnimationKeyframe) -> Array[Double]

    AnimationKeyframe::new

    source
    fn AnimationKeyframe::new(time~ : Double, value~ : Array[Double], in_tangent? : Array[Double], out_tangent? : Array[Double]) -> AnimationKeyframe

    AnimationKeyframe::out_tangent

    source
    fn AnimationKeyframe::out_tangent(self : AnimationKeyframe) -> Array[Double]

    AnimationKeyframe::time

    source
    fn AnimationKeyframe::time(self : AnimationKeyframe) -> Double

    AnimationKeyframe::to_repr

    source

    AnimationKeyframe::value

    source
    fn AnimationKeyframe::value(self : AnimationKeyframe) -> Array[Double]

    AnimationPath

    source
    pub(all) enum AnimationPath {
      Translation
      Rotation
      Scale
      Weights
    } derive(Eq, ToJson, 
    Debug    )

    AnimationPath::equal

    source

    AnimationPath::not_equal

    source
    fn AnimationPath::not_equal(x : AnimationPath, y : AnimationPath) -> Bool

    AnimationPath::to_json

    source

    AnimationPath::to_repr

    source

    AnimationPlayer

    source
    pub struct AnimationPlayer {
      clip : AnimationClip?
      time : Double
      playing : Bool
    }

    CPU playback state for a selected clip. Applying samples to node TRS is intentionally left to the scene owner so renderers never own animation clocks or mutable scene state.

    AnimationPlayer::advance

    source
    fn AnimationPlayer::advance(self : AnimationPlayer, delta_seconds : Double) -> Unit

    AnimationPlayer::clear_clip

    source
    fn AnimationPlayer::clear_clip(self : AnimationPlayer) -> Unit

    AnimationPlayer::new

    source

    AnimationPlayer::pause

    source
    fn AnimationPlayer::pause(self : AnimationPlayer) -> Unit

    AnimationPlayer::play

    source
    fn AnimationPlayer::play(self : AnimationPlayer) -> Unit

    AnimationPlayer::playing

    source
    fn AnimationPlayer::playing(self : AnimationPlayer) -> Bool

    AnimationPlayer::sample

    source

    AnimationPlayer::seek

    source
    fn AnimationPlayer::seek(self : AnimationPlayer, time : Double) -> Unit

    AnimationPlayer::set_clip

    source
    fn AnimationPlayer::set_clip(self : AnimationPlayer, clip : AnimationClip) -> Unit

    AnimationPlayer::time

    source
    fn AnimationPlayer::time(self : AnimationPlayer) -> Double

    AnimationSample

    source
    pub(all) struct AnimationSample {
      node : NodeId
      path : AnimationPath
      value : Array[Double]
    } derive(
    Debug    )

    AnimationSample::new

    source
    fn AnimationSample::new(node~ : NodeId, path~ : AnimationPath, value~ : Array[Double]) -> AnimationSample

    AnimationSample::node

    source

    AnimationSample::path

    source

    AnimationSample::to_repr

    source

    AnimationSample::value

    source
    fn AnimationSample::value(self : AnimationSample) -> Array[Double]

    AssetByteSource

    source
    pub(all) struct AssetByteSource {
      read_fn : (String) -> Bytes?
    }

    Platform-neutral byte source injected by an application or service layer. moui_3d never performs filesystem or network I/O itself.

    AssetByteSource::new

    source
    fn AssetByteSource::new(read : (String) -> Bytes?) -> AssetByteSource

    AssetByteSource::read

    source
    fn AssetByteSource::read(self : AssetByteSource, uri : String) -> Bytes?

    AssetLoadResult

    source
    pub(all) enum AssetLoadResult {
      Bytes(Bytes)
      Missing(String)
      Invalid(String)
    } derive(
    Debug    )

    Camera

    source
    pub(all) struct Camera {
      name : String
      projection : CameraProjection
    } derive(Eq, ToJson, 
    Debug    )

    Camera::equal

    source
    fn Camera::equal(Camera, Camera) -> Bool

    Camera::name

    source
    fn Camera::name(self : Camera) -> String

    Camera::new

    source
    fn Camera::new(name? : String, projection~ : CameraProjection) -> Camera

    Camera::not_equal

    source
    fn Camera::not_equal(x : Camera, y : Camera) -> Bool

    Camera::projection

    source
    fn Camera::projection(self : Camera) -> CameraProjection

    Camera::to_json

    source
    fn Camera::to_json(Camera) -> Json

    Camera::to_repr

    source

    CameraProjection

    source
    pub(all) enum CameraProjection {
      Perspective(Double, Double, Double, Double)
      Orthographic(Double, Double, Double, Double)
    } derive(Eq, ToJson, 
    Debug    )

    CameraProjection::equal

    source

    CameraProjection::not_equal

    source
    fn CameraProjection::not_equal(x : CameraProjection, y : CameraProjection) -> Bool

    CameraProjection::to_json

    source

    CameraProjection::to_repr

    source

    GltfDocument

    source
    pub(all) struct GltfDocument {
      json : String
      binary : Bytes?
      mesh_count : Int
      node_count : Int
      material_count : Int
      texture_count : Int
      sampler_count : Int
      camera_count : Int
      scene_count : Int
    } derive(
    Debug    )

    GltfDocument::binary

    source
    fn GltfDocument::binary(self : GltfDocument) -> Bytes?

    GltfDocument::camera_count

    source
    fn GltfDocument::camera_count(self : GltfDocument) -> Int

    GltfDocument::json

    source
    fn GltfDocument::json(self : GltfDocument) -> String

    GltfDocument::material_count

    source
    fn GltfDocument::material_count(self : GltfDocument) -> Int

    GltfDocument::mesh_count

    source
    fn GltfDocument::mesh_count(self : GltfDocument) -> Int

    GltfDocument::node_count

    source
    fn GltfDocument::node_count(self : GltfDocument) -> Int

    GltfDocument::sampler_count

    source
    fn GltfDocument::sampler_count(self : GltfDocument) -> Int

    GltfDocument::scene_count

    source
    fn GltfDocument::scene_count(self : GltfDocument) -> Int

    GltfDocument::texture_count

    source
    fn GltfDocument::texture_count(self : GltfDocument) -> Int

    GltfDocument::to_repr

    source

    Mat4

    source
    pub(all) struct Mat4 {
      values : Array[Double]
    } derive(
    Debug    )

    Row-major 4x4 matrix. Translation occupies indices 3, 7 and 11.

    Mat4::at

    source
    fn Mat4::at(self : Mat4, row : Int, column : Int) -> Double

    Mat4::from_values

    source
    fn Mat4::from_values(values : Array[Double]) -> Mat4

    Mat4::identity

    source
    fn Mat4::identity() -> Mat4

    Mat4::look_at

    source
    fn Mat4::look_at(eye~ : Vec3, target~ : Vec3, up~ : Vec3) -> Mat4

    Mat4::mul

    source
    fn Mat4::mul(self : Mat4, other : Mat4) -> Mat4

    Mat4::perspective

    source
    fn Mat4::perspective(fov_y_radians~ : Double, aspect~ : Double, near~ : Double, far~ : Double) -> Mat4

    Mat4::scale_uniform

    source
    fn Mat4::scale_uniform(amount : Double) -> Mat4

    Mat4::to_repr

    source

    Mat4::transform_homogeneous

    source
    fn Mat4::transform_homogeneous(self : Mat4, point : Vec3) -> Vec4

    Transform a point without performing the perspective divide. Renderers must use this form so clip-space w survives until the GPU vertex shader.

    Mat4::transform_point

    source
    fn Mat4::transform_point(self : Mat4, point : Vec3) -> Vec3

    Mat4::transform_vec4

    source
    fn Mat4::transform_vec4(self : Mat4, vector : Vec4) -> Vec4

    Transform an arbitrary homogeneous vector without a perspective divide.

    Mat4::translation

    source
    fn Mat4::translation(offset : Vec3) -> Mat4

    Mat4::values

    source
    fn Mat4::values(self : Mat4) -> Array[Double]

    Material

    source
    pub(all) struct Material {
      base_color : Vec4
      metallic : Double
      roughness : Double
      base_color_texture : TextureId?
      normal_texture : TextureId?
      occlusion_texture : TextureId?
      emissive_texture : TextureId?
      emissive_factor : Vec3
      alpha_mode : AlphaMode
      alpha_cutoff : Double
      double_sided : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Material::alpha_cutoff

    source
    fn Material::alpha_cutoff(self : Material) -> Double

    Material::alpha_mode

    source
    fn Material::alpha_mode(self : Material) -> AlphaMode

    Material::base_color

    source
    fn Material::base_color(self : Material) -> Vec4

    Material::base_color_texture

    source
    fn Material::base_color_texture(self : Material) -> TextureId?

    Material::double_sided

    source
    fn Material::double_sided(self : Material) -> Bool

    Material::emissive_factor

    source
    fn Material::emissive_factor(self : Material) -> Vec3

    Material::emissive_texture

    source
    fn Material::emissive_texture(self : Material) -> TextureId?

    Material::equal

    source
    fn Material::equal(Material, Material) -> Bool

    Material::metallic

    source
    fn Material::metallic(self : Material) -> Double

    Material::normal_texture

    source
    fn Material::normal_texture(self : Material) -> TextureId?

    Material::not_equal

    source
    fn Material::not_equal(x : Material, y : Material) -> Bool

    Material::occlusion_texture

    source
    fn Material::occlusion_texture(self : Material) -> TextureId?

    Material::pbr

    source
    fn Material::pbr(base_color? : Vec4, metallic? : Double, roughness? : Double, base_color_texture? : TextureId?, normal_texture? : TextureId?, occlusion_texture? : TextureId?, emissive_texture? : TextureId?, emissive_factor? : Vec3, alpha_mode? : AlphaMode, alpha_cutoff? : Double, double_sided? : Bool) -> Material

    Material::roughness

    source
    fn Material::roughness(self : Material) -> Double

    Material::to_json

    source
    fn Material::to_json(Material) -> Json

    Material::to_repr

    source

    MaterialId

    source
    pub(all) struct MaterialId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    MaterialId::equal

    source
    fn MaterialId::equal(MaterialId, MaterialId) -> Bool

    MaterialId::new

    source
    fn MaterialId::new(value : Int) -> MaterialId

    MaterialId::not_equal

    source
    fn MaterialId::not_equal(x : MaterialId, y : MaterialId) -> Bool

    MaterialId::to_json

    source
    fn MaterialId::to_json(MaterialId) -> Json

    MaterialId::to_repr

    source

    MaterialId::value

    source
    fn MaterialId::value(self : MaterialId) -> Int

    Mesh

    source
    pub(all) struct Mesh {
      name : String
      primitives : Array[Primitive]
      weights : Array[Double]
      bounds : Aabb
    } derive(
    Debug    )

    Mesh::bounds

    source
    fn Mesh::bounds(self : Mesh) -> Aabb

    Mesh::name

    source
    fn Mesh::name(self : Mesh) -> String

    Mesh::new

    source
    fn Mesh::new(name? : String, primitives~ : Array[Primitive], weights? : Array[Double]) -> Mesh

    Mesh::primitives

    source
    fn Mesh::primitives(self : Mesh) -> Array[Primitive]

    Mesh::to_repr

    source

    Mesh::weights

    source
    fn Mesh::weights(self : Mesh) -> Array[Double]

    MeshId

    source
    pub(all) struct MeshId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    MeshId::equal

    source
    fn MeshId::equal(MeshId, MeshId) -> Bool

    MeshId::new

    source
    fn MeshId::new(value : Int) -> MeshId

    MeshId::not_equal

    source
    fn MeshId::not_equal(x : MeshId, y : MeshId) -> Bool

    MeshId::to_json

    source
    fn MeshId::to_json(MeshId) -> Json

    MeshId::to_repr

    source

    MeshId::value

    source
    fn MeshId::value(self : MeshId) -> Int

    Node

    source
    pub(all) struct Node {
      name : String
      parent : NodeId?
      children : Array[NodeId]
      local_transform : Mat4
      mesh : MeshId?
      camera : Int?
      skin : Int?
      weights : Array[Double]?
    } derive(
    Debug    )

    Node::camera

    source
    fn Node::camera(self : Node) -> Int?

    Node::children

    source
    fn Node::children(self : Node) -> Array[NodeId]

    Node::local_transform

    source
    fn Node::local_transform(self : Node) -> Mat4

    Node::mesh

    source
    fn Node::mesh(self : Node) -> MeshId?

    Node::name

    source
    fn Node::name(self : Node) -> String

    Node::new

    source
    fn Node::new(name? : String, parent? : NodeId?, local_transform? : Mat4, mesh? : MeshId?, camera? : Int?, skin? : Int?, weights? : Array[Double]?) -> Node

    Node::parent

    source
    fn Node::parent(self : Node) -> NodeId?

    Node::skin

    source
    fn Node::skin(self : Node) -> Int?

    Node::to_repr

    source

    Node::weights

    source
    fn Node::weights(self : Node) -> Array[Double]?

    Node::with_child

    source
    fn Node::with_child(self : Node, child : NodeId) -> Node

    Node::with_local_transform

    source
    fn Node::with_local_transform(self : Node, local_transform : Mat4) -> Node

    Return a node with a replaced local transform. Scene animation applies poses to a copied scene so the authored/rest transform remains reusable.

    NodeId

    source
    pub(all) struct NodeId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    NodeId::equal

    source
    fn NodeId::equal(NodeId, NodeId) -> Bool

    NodeId::new

    source
    fn NodeId::new(value : Int) -> NodeId

    NodeId::not_equal

    source
    fn NodeId::not_equal(x : NodeId, y : NodeId) -> Bool

    NodeId::to_json

    source
    fn NodeId::to_json(NodeId) -> Json

    NodeId::to_repr

    source

    NodeId::value

    source
    fn NodeId::value(self : NodeId) -> Int

    OrbitCamera

    source
    pub(all) struct OrbitCamera {
      target : Vec3
      radius : Double
      azimuth : Double
      polar : Double
      perspective : PerspectiveCamera
    } derive(Eq, ToJson, 
    Debug    )

    Orbit camera state. polar is measured from the positive Y axis and is clamped away from the poles so orbiting cannot flip the view upside down.

    OrbitCamera::azimuth

    source
    fn OrbitCamera::azimuth(self : OrbitCamera) -> Double

    OrbitCamera::equal

    source
    fn OrbitCamera::equal(OrbitCamera, OrbitCamera) -> Bool

    OrbitCamera::fit

    source
    fn OrbitCamera::fit(self : OrbitCamera, bounds : Aabb, padding? : Double) -> OrbitCamera

    OrbitCamera::new

    source
    fn OrbitCamera::new(target? : Vec3, radius? : Double, azimuth? : Double, polar? : Double, perspective? : PerspectiveCamera) -> OrbitCamera

    OrbitCamera::not_equal

    source
    fn OrbitCamera::not_equal(x : OrbitCamera, y : OrbitCamera) -> Bool

    OrbitCamera::orbit

    source
    fn OrbitCamera::orbit(self : OrbitCamera, delta_azimuth : Double, delta_polar : Double) -> OrbitCamera

    OrbitCamera::pan

    source
    fn OrbitCamera::pan(self : OrbitCamera, delta : Vec2) -> OrbitCamera

    OrbitCamera::perspective

    source
    fn OrbitCamera::perspective(self : OrbitCamera) -> PerspectiveCamera

    OrbitCamera::polar

    source
    fn OrbitCamera::polar(self : OrbitCamera) -> Double

    OrbitCamera::position

    source
    fn OrbitCamera::position(self : OrbitCamera) -> Vec3

    OrbitCamera::projection

    source
    fn OrbitCamera::projection(self : OrbitCamera) -> Mat4

    OrbitCamera::radius

    source
    fn OrbitCamera::radius(self : OrbitCamera) -> Double

    OrbitCamera::ray_for_viewport

    source
    fn OrbitCamera::ray_for_viewport(self : OrbitCamera, point : Vec2, viewport : Vec2) -> Ray

    Construct a world-space ray through a logical viewport point.

    OrbitCamera::target

    source
    fn OrbitCamera::target(self : OrbitCamera) -> Vec3

    OrbitCamera::to_json

    source
    fn OrbitCamera::to_json(OrbitCamera) -> Json

    OrbitCamera::to_repr

    source

    OrbitCamera::view

    source
    fn OrbitCamera::view(self : OrbitCamera) -> Mat4

    OrbitCamera::with_aspect

    source
    fn OrbitCamera::with_aspect(self : OrbitCamera, aspect : Double) -> OrbitCamera

    OrbitCamera::zoom

    source
    fn OrbitCamera::zoom(self : OrbitCamera, amount : Double) -> OrbitCamera

    PerspectiveCamera

    source
    pub(all) struct PerspectiveCamera {
      fov_y_radians : Double
      aspect : Double
      near : Double
      far : Double
    } derive(Eq, ToJson, 
    Debug    )

    Perspective camera with the glTF-compatible Y-up, right-handed convention.

    PerspectiveCamera::equal

    source

    PerspectiveCamera::far

    source
    fn PerspectiveCamera::far(self : PerspectiveCamera) -> Double

    PerspectiveCamera::fov_y_radians

    source
    fn PerspectiveCamera::fov_y_radians(self : PerspectiveCamera) -> Double

    PerspectiveCamera::near

    source
    fn PerspectiveCamera::near(self : PerspectiveCamera) -> Double

    PerspectiveCamera::new

    source
    fn PerspectiveCamera::new(fov_y_radians? : Double, aspect? : Double, near? : Double, far? : Double) -> PerspectiveCamera

    PerspectiveCamera::not_equal

    source
    fn PerspectiveCamera::not_equal(x : PerspectiveCamera, y : PerspectiveCamera) -> Bool

    PerspectiveCamera::projection

    source
    fn PerspectiveCamera::projection(self : PerspectiveCamera) -> Mat4

    PerspectiveCamera::to_json

    source

    PerspectiveCamera::to_repr

    source

    PerspectiveCamera::with_aspect

    source
    fn PerspectiveCamera::with_aspect(self : PerspectiveCamera, aspect : Double) -> PerspectiveCamera

    PickHit

    source
    pub(all) struct PickHit {
      node : NodeId
      primitive_index : Int
      distance : Double
      position : Vec3
    } derive(Eq, ToJson, 
    Debug    )

    PickHit::distance

    source
    fn PickHit::distance(self : PickHit) -> Double

    PickHit::equal

    source
    fn PickHit::equal(PickHit, PickHit) -> Bool

    PickHit::node

    source
    fn PickHit::node(self : PickHit) -> NodeId

    PickHit::not_equal

    source
    fn PickHit::not_equal(x : PickHit, y : PickHit) -> Bool

    PickHit::position

    source
    fn PickHit::position(self : PickHit) -> Vec3

    PickHit::primitive_index

    source
    fn PickHit::primitive_index(self : PickHit) -> Int

    PickHit::to_json

    source
    fn PickHit::to_json(PickHit) -> Json

    PickHit::to_repr

    source

    Primitive

    source
    pub(all) struct Primitive {
      vertices : Array[Vertex]
      indices : Array[Int]
      material : MaterialId?
      bounds : Aabb
      morph_targets : Array[Array[VertexDelta]]
    } derive(
    Debug    )

    Primitive::bounds

    source
    fn Primitive::bounds(self : Primitive) -> Aabb

    Primitive::indices

    source
    fn Primitive::indices(self : Primitive) -> Array[Int]

    Primitive::material

    source
    fn Primitive::material(self : Primitive) -> MaterialId?

    Primitive::morph_targets

    source
    fn Primitive::morph_targets(self : Primitive) -> Array[Array[VertexDelta]]

    Primitive::new

    source
    fn Primitive::new(vertices~ : Array[Vertex], indices~ : Array[Int], material? : MaterialId?, morph_targets? : Array[Array[VertexDelta]]) -> Primitive

    Primitive::to_repr

    source

    Primitive::vertices

    source
    fn Primitive::vertices(self : Primitive) -> Array[Vertex]

    Quat

    source
    pub(all) struct Quat {
      x : Double
      y : Double
      z : Double
      w : Double
    } derive(Eq, ToJson, 
    Debug    )

    Quat::equal

    source
    fn Quat::equal(Quat, Quat) -> Bool

    Quat::from_axis_angle

    source
    fn Quat::from_axis_angle(axis~ : Vec3, angle~ : Double) -> Quat

    Quat::identity

    source
    fn Quat::identity() -> Quat

    Quat::mul

    source
    fn Quat::mul(self : Quat, other : Quat) -> Quat

    Quat::new

    source
    fn Quat::new(x~ : Double, y~ : Double, z~ : Double, w~ : Double) -> Quat

    Quat::not_equal

    source
    fn Quat::not_equal(x : Quat, y : Quat) -> Bool

    Quat::rotate

    source
    fn Quat::rotate(self : Quat, vector : Vec3) -> Vec3

    Quat::to_json

    source
    fn Quat::to_json(Quat) -> Json

    Quat::to_mat4

    source
    fn Quat::to_mat4(self : Quat) -> Mat4

    Quat::to_repr

    source

    Quat::w

    source
    fn Quat::w(self : Quat) -> Double

    Quat::x

    source
    fn Quat::x(self : Quat) -> Double

    Quat::y

    source
    fn Quat::y(self : Quat) -> Double

    Quat::z

    source
    fn Quat::z(self : Quat) -> Double

    Ray

    source
    pub(all) struct Ray {
      origin : Vec3
      direction : Vec3
    } derive(Eq, ToJson, 
    Debug    )

    Ray::at

    source
    fn Ray::at(self : Ray, distance : Double) -> Vec3

    Ray::direction

    source
    fn Ray::direction(self : Ray) -> Vec3

    Ray::equal

    source
    fn Ray::equal(Ray, Ray) -> Bool

    Ray::intersect_aabb

    source
    fn Ray::intersect_aabb(self : Ray, bounds : Aabb) -> Bool

    Ray::intersect_triangle

    source
    fn Ray::intersect_triangle(self : Ray, a : Vec3, b : Vec3, c : Vec3) -> Double?

    Moller-Trumbore ray/triangle intersection. Returns the positive distance.

    Ray::new

    source
    fn Ray::new(origin~ : Vec3, direction~ : Vec3) -> Ray

    Ray::not_equal

    source
    fn Ray::not_equal(x : Ray, y : Ray) -> Bool

    Ray::origin

    source
    fn Ray::origin(self : Ray) -> Vec3

    Ray::to_json

    source
    fn Ray::to_json(Ray) -> Json

    Ray::to_repr

    source

    Sampler

    source
    pub(all) struct Sampler {
      mag_filter : SamplerFilter
      min_filter : SamplerFilter
      wrap_s : SamplerWrap
      wrap_t : SamplerWrap
    } derive(Eq, ToJson, 
    Debug    )

    Sampler::equal

    source
    fn Sampler::equal(Sampler, Sampler) -> Bool

    Sampler::mag_filter

    source
    fn Sampler::mag_filter(self : Sampler) -> SamplerFilter

    Sampler::min_filter

    source
    fn Sampler::min_filter(self : Sampler) -> SamplerFilter

    Sampler::new

    source
    fn Sampler::new(mag_filter? : SamplerFilter, min_filter? : SamplerFilter, wrap_s? : SamplerWrap, wrap_t? : SamplerWrap) -> Sampler

    Sampler::not_equal

    source
    fn Sampler::not_equal(x : Sampler, y : Sampler) -> Bool

    Sampler::to_json

    source
    fn Sampler::to_json(Sampler) -> Json

    Sampler::to_repr

    source

    Sampler::wrap_s

    source
    fn Sampler::wrap_s(self : Sampler) -> SamplerWrap

    Sampler::wrap_t

    source
    fn Sampler::wrap_t(self : Sampler) -> SamplerWrap

    SamplerFilter

    source
    pub(all) enum SamplerFilter {
      Nearest
      Linear
      NearestMipmapNearest
      LinearMipmapNearest
      NearestMipmapLinear
      LinearMipmapLinear
    } derive(Eq, ToJson, 
    Debug    )

    SamplerFilter::equal

    source

    SamplerFilter::not_equal

    source
    fn SamplerFilter::not_equal(x : SamplerFilter, y : SamplerFilter) -> Bool

    SamplerFilter::to_json

    source

    SamplerFilter::to_repr

    source

    SamplerId

    source
    pub(all) struct SamplerId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    SamplerId::equal

    source
    fn SamplerId::equal(SamplerId, SamplerId) -> Bool

    SamplerId::new

    source
    fn SamplerId::new(value : Int) -> SamplerId

    SamplerId::not_equal

    source
    fn SamplerId::not_equal(x : SamplerId, y : SamplerId) -> Bool

    SamplerId::to_json

    source
    fn SamplerId::to_json(SamplerId) -> Json

    SamplerId::to_repr

    source

    SamplerId::value

    source
    fn SamplerId::value(self : SamplerId) -> Int

    SamplerWrap

    source
    pub(all) enum SamplerWrap {
      Repeat
      MirroredRepeat
      ClampToEdge
    } derive(Eq, ToJson, 
    Debug    )

    SamplerWrap::equal

    source
    fn SamplerWrap::equal(SamplerWrap, SamplerWrap) -> Bool

    SamplerWrap::not_equal

    source
    fn SamplerWrap::not_equal(x : SamplerWrap, y : SamplerWrap) -> Bool

    SamplerWrap::to_json

    source
    fn SamplerWrap::to_json(SamplerWrap) -> Json

    SamplerWrap::to_repr

    source

    Scene

    source
    pub(all) struct Scene {
      meshes : Array[Mesh]
      materials : Array[Material]
      textures : Array[Texture]
      samplers : Array[Sampler]
      cameras : Array[Camera]
      definitions : Array[SceneDefinition]
      skins : Array[Skin]
      default_scene : Int?
      nodes : Array[Node]
      animations : Array[AnimationClip]
    } derive(
    Debug    )

    Scene::add_animation

    source
    fn Scene::add_animation(self : Scene, animation : AnimationClip) -> Int

    Scene::add_camera

    source
    fn Scene::add_camera(self : Scene, camera : Camera) -> Int

    Scene::add_material

    source
    fn Scene::add_material(self : Scene, material : Material) -> MaterialId

    Scene::add_mesh

    source
    fn Scene::add_mesh(self : Scene, mesh : Mesh) -> MeshId

    Scene::add_node

    source
    fn Scene::add_node(self : Scene, node : Node) -> NodeId

    Scene::add_sampler

    source
    fn Scene::add_sampler(self : Scene, sampler : Sampler) -> SamplerId

    Scene::add_scene_definition

    source
    fn Scene::add_scene_definition(self : Scene, definition : SceneDefinition) -> Int

    Scene::add_skin

    source
    fn Scene::add_skin(self : Scene, skin : Skin) -> Int

    Scene::add_texture

    source
    fn Scene::add_texture(self : Scene, texture : Texture) -> TextureId

    Scene::animations

    source
    fn Scene::animations(self : Scene) -> Array[AnimationClip]

    Scene::apply_animation_samples

    source
    fn Scene::apply_animation_samples(self : Scene, samples : Array[AnimationSample]) -> Scene

    Apply sampled animation channels to a copied scene. Unknown node ids and unsupported/empty samples are ignored so malformed optional channels do not invalidate an otherwise renderable scene.

    Scene::bounds

    source
    fn Scene::bounds(self : Scene) -> Aabb

    Scene::cameras

    source
    fn Scene::cameras(self : Scene) -> Array[Camera]

    Scene::copy

    source
    fn Scene::copy(self : Scene) -> Scene

    Copy the scene containers before applying a transient animation pose. Mesh/material/animation values are immutable, while nodes are replaced in the returned scene and never mutated in the authored scene.

    Scene::default_scene

    source
    fn Scene::default_scene(self : Scene) -> Int?

    Scene::empty

    source
    fn Scene::empty() -> Scene

    Scene::materials

    source
    fn Scene::materials(self : Scene) -> Array[Material]

    Scene::mesh

    source
    fn Scene::mesh(self : Scene, id : MeshId) -> Mesh?

    Scene::meshes

    source
    fn Scene::meshes(self : Scene) -> Array[Mesh]

    Scene::node

    source
    fn Scene::node(self : Scene, id : NodeId) -> Node?

    Scene::nodes

    source
    fn Scene::nodes(self : Scene) -> Array[Node]

    Scene::pick

    source
    fn Scene::pick(self : Scene, ray : Ray) -> PickHit?

    Scene::samplers

    source
    fn Scene::samplers(self : Scene) -> Array[Sampler]

    Scene::scene_definitions

    source
    fn Scene::scene_definitions(self : Scene) -> Array[SceneDefinition]

    Scene::set_default_scene

    source
    fn Scene::set_default_scene(self : Scene, index : Int?) -> Unit

    Scene::skins

    source
    fn Scene::skins(self : Scene) -> Array[Skin]

    Scene::textures

    source
    fn Scene::textures(self : Scene) -> Array[Texture]

    Scene::to_repr

    source

    Scene::world_transform

    source
    fn Scene::world_transform(self : Scene, id : NodeId) -> Mat4

    SceneDefinition

    source
    pub(all) struct SceneDefinition {
      name : String
      roots : Array[NodeId]
    } derive(Eq, ToJson, 
    Debug    )

    SceneDefinition::equal

    source

    SceneDefinition::name

    source
    fn SceneDefinition::name(self : SceneDefinition) -> String

    SceneDefinition::new

    source
    fn SceneDefinition::new(name? : String, roots~ : Array[NodeId]) -> SceneDefinition

    SceneDefinition::not_equal

    source
    fn SceneDefinition::not_equal(x : SceneDefinition, y : SceneDefinition) -> Bool

    SceneDefinition::roots

    source

    SceneDefinition::to_json

    source

    SceneDefinition::to_repr

    source

    Skin

    source
    pub(all) struct Skin {
      name : String
      joints : Array[NodeId]
      inverse_bind_matrices : Array[Mat4]
      skeleton : NodeId?
    } derive(
    Debug    )

    Skin::inverse_bind_matrices

    source
    fn Skin::inverse_bind_matrices(self : Skin) -> Array[Mat4]

    Skin::joints

    source
    fn Skin::joints(self : Skin) -> Array[NodeId]

    Skin::name

    source
    fn Skin::name(self : Skin) -> String

    Skin::new

    source
    fn Skin::new(name? : String, joints~ : Array[NodeId], inverse_bind_matrices? : Array[Mat4], skeleton? : NodeId?) -> Skin

    Skin::skeleton

    source
    fn Skin::skeleton(self : Skin) -> NodeId?

    Skin::to_repr

    source

    Texture

    source
    pub(all) struct Texture {
      source : TextureSource
      mime_type : String?
      sampler : SamplerId?
    } derive(
    Debug    )

    Texture::embedded

    source
    fn Texture::embedded(bytes : Bytes, mime_type? : String?, sampler? : SamplerId?) -> Texture

    Texture::mime_type

    source
    fn Texture::mime_type(self : Texture) -> String?

    Texture::sampler

    source
    fn Texture::sampler(self : Texture) -> SamplerId?

    Texture::source

    source
    fn Texture::source(self : Texture) -> TextureSource

    Texture::to_repr

    source

    Texture::uri

    source
    fn Texture::uri(uri : String, mime_type? : String?, sampler? : SamplerId?) -> Texture

    TextureId

    source
    pub(all) struct TextureId {
      value : Int
    } derive(Eq, ToJson, 
    Debug    )

    TextureId::equal

    source
    fn TextureId::equal(TextureId, TextureId) -> Bool

    TextureId::new

    source
    fn TextureId::new(value : Int) -> TextureId

    TextureId::not_equal

    source
    fn TextureId::not_equal(x : TextureId, y : TextureId) -> Bool

    TextureId::to_json

    source
    fn TextureId::to_json(TextureId) -> Json

    TextureId::to_repr

    source

    TextureId::value

    source
    fn TextureId::value(self : TextureId) -> Int

    TextureSource

    source
    pub(all) enum TextureSource {
      Uri(String)
      Embedded(Bytes)
    } derive(
    Debug    )

    ThreeDViewportBinding

    source
    pub struct ThreeDViewportBinding {
      latest : 
    Ref    [ViewportSnapshot?]
      status : 
    Ref    [ViewportStatus]
    }

    Latest-wins CPU bridge between a MoUI view and an external 3D surface. Renderer residency and GPU cache state never cross this boundary.

    ThreeDViewportBinding::new

    source

    ThreeDViewportBinding::publish

    source
    fn ThreeDViewportBinding::publish(self : ThreeDViewportBinding, snapshot : ViewportSnapshot) -> Bool

    ThreeDViewportBinding::set_status

    source
    fn ThreeDViewportBinding::set_status(self : ThreeDViewportBinding, status : ViewportStatus) -> Unit

    ThreeDViewportBinding::snapshot

    source

    ThreeDViewportBinding::status

    source

    ThreeDViewportHost

    source
    pub struct ThreeDViewportHost {
      binding : ThreeDViewportBinding
      surface_handler : 
    Ref    [(UInt64, Int, Int, Double) -> Unit]
      frame_handler : 
    Ref    [(ViewportSnapshot, Int, Int, Double) -> Unit]
      dispose_handler : 
    Ref    [(UInt64) -> Unit]
      invalidate_handler : 
    Ref    [() -> Unit]
    }

    Addon-owned bridge between a platform-view plugin and a concrete 3D renderer. The bridge carries only CPU snapshots and surface geometry; renderer resources never cross into the MoUI frame contract.

    ThreeDViewportHost::binding

    source

    ThreeDViewportHost::dispose_platform_views

    source
    fn ThreeDViewportHost::dispose_platform_views(self : ThreeDViewportHost, window_handle : UInt64) -> Unit

    ThreeDViewportHost::invalidate

    source
    fn ThreeDViewportHost::invalidate(self : ThreeDViewportHost) -> Unit

    ThreeDViewportHost::new

    source

    ThreeDViewportHost::set_dispose_handler

    source
    fn ThreeDViewportHost::set_dispose_handler(self : ThreeDViewportHost, handler : (UInt64) -> Unit) -> Unit

    ThreeDViewportHost::set_frame_handler

    source
    fn ThreeDViewportHost::set_frame_handler(self : ThreeDViewportHost, handler : (ViewportSnapshot, Int, Int, Double) -> Unit) -> Unit

    ThreeDViewportHost::set_invalidate_handler

    source
    fn ThreeDViewportHost::set_invalidate_handler(self : ThreeDViewportHost, handler : () -> Unit) -> Unit

    Install the platform redraw hook used when renderer availability changes outside the ordinary MoUI model update path.

    ThreeDViewportHost::set_surface_handler

    source
    fn ThreeDViewportHost::set_surface_handler(self : ThreeDViewportHost, handler : (UInt64, Int, Int, Double) -> Unit) -> Unit

    Called by a concrete renderer composition root once it is ready to interpret the platform surface handle.

    ThreeDViewportHost::sync_platform_view

    source
    fn ThreeDViewportHost::sync_platform_view(self : ThreeDViewportHost, window_handle : UInt64, placement : 
    PlatformViewPlacement    , surface_handle : UInt64, frame : 
    DrawFrame    , content_offset_y : Double, scale_factor? : Double) -> Unit

    Sync one placement after a platform plugin has created or resolved its concrete child surface handle.

    ThreeDViewportHost::sync_platform_views

    source
    fn ThreeDViewportHost::sync_platform_views(self : ThreeDViewportHost, window_handle : UInt64, frame : 
    DrawFrame    , content_offset_y : Double) -> Unit

    Synchronize all placements owned by the 3D addon. The plugin passes the host window handle; a native backend may replace it with a child surface handle before invoking the frame handler.

    Vec2

    source
    pub(all) struct Vec2 {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    A two-dimensional vector used by the 3D addon for texture coordinates and screen-space input.

    Vec2::equal

    source
    fn Vec2::equal(Vec2, Vec2) -> Bool

    Vec2::new

    source
    fn Vec2::new(x~ : Double, y~ : Double) -> Vec2

    Vec2::not_equal

    source
    fn Vec2::not_equal(x : Vec2, y : Vec2) -> Bool

    Vec2::to_json

    source
    fn Vec2::to_json(Vec2) -> Json

    Vec2::to_repr

    source

    Vec2::x

    source
    fn Vec2::x(self : Vec2) -> Double

    Vec2::y

    source
    fn Vec2::y(self : Vec2) -> Double

    Vec2::zero

    source
    fn Vec2::zero() -> Vec2

    Vec3

    source
    pub(all) struct Vec3 {
      x : Double
      y : Double
      z : Double
    } derive(Eq, ToJson, 
    Debug    )

    A three-dimensional vector. Public scene coordinates use Double so camera and picking calculations stay deterministic before GPU packing.

    Vec3::add

    source
    fn Vec3::add(self : Vec3, other : Vec3) -> Vec3

    Vec3::cross

    source
    fn Vec3::cross(self : Vec3, other : Vec3) -> Vec3

    Vec3::dot

    source
    fn Vec3::dot(self : Vec3, other : Vec3) -> Double

    Vec3::equal

    source
    fn Vec3::equal(Vec3, Vec3) -> Bool

    Vec3::length

    source
    fn Vec3::length(self : Vec3) -> Double

    Vec3::length_squared

    source
    fn Vec3::length_squared(self : Vec3) -> Double

    Vec3::lerp

    source
    fn Vec3::lerp(self : Vec3, other : Vec3, progress : Double) -> Vec3

    Vec3::new

    source
    fn Vec3::new(x~ : Double, y~ : Double, z~ : Double) -> Vec3

    Vec3::normalized

    source
    fn Vec3::normalized(self : Vec3) -> Vec3

    Vec3::not_equal

    source
    fn Vec3::not_equal(x : Vec3, y : Vec3) -> Bool

    Vec3::scale

    source
    fn Vec3::scale(self : Vec3, amount : Double) -> Vec3

    Vec3::sub

    source
    fn Vec3::sub(self : Vec3, other : Vec3) -> Vec3

    Vec3::to_json

    source
    fn Vec3::to_json(Vec3) -> Json

    Vec3::to_repr

    source

    Vec3::x

    source
    fn Vec3::x(self : Vec3) -> Double

    Vec3::y

    source
    fn Vec3::y(self : Vec3) -> Double

    Vec3::z

    source
    fn Vec3::z(self : Vec3) -> Double

    Vec3::zero

    source
    fn Vec3::zero() -> Vec3

    Vec4

    source
    pub(all) struct Vec4 {
      x : Double
      y : Double
      z : Double
      w : Double
    } derive(Eq, ToJson, 
    Debug    )

    A four-dimensional vector used for colors and homogeneous coordinates.

    Vec4::equal

    source
    fn Vec4::equal(Vec4, Vec4) -> Bool

    Vec4::new

    source
    fn Vec4::new(x~ : Double, y~ : Double, z~ : Double, w~ : Double) -> Vec4

    Vec4::not_equal

    source
    fn Vec4::not_equal(x : Vec4, y : Vec4) -> Bool

    Vec4::scale

    source
    fn Vec4::scale(self : Vec4, amount : Double) -> Vec4

    Vec4::to_json

    source
    fn Vec4::to_json(Vec4) -> Json

    Vec4::to_repr

    source

    Vec4::w

    source
    fn Vec4::w(self : Vec4) -> Double

    Vec4::x

    source
    fn Vec4::x(self : Vec4) -> Double

    Vec4::y

    source
    fn Vec4::y(self : Vec4) -> Double

    Vec4::z

    source
    fn Vec4::z(self : Vec4) -> Double

    Vec4::zero

    source
    fn Vec4::zero() -> Vec4

    Vertex

    source
    pub(all) struct Vertex {
      position : Vec3
      normal : Vec3
      texcoord : Vec2
      joints : (Int, Int, Int, Int)
      weights : Vec4
    } derive(Eq, ToJson, 
    Debug    )

    Vertex::equal

    source
    fn Vertex::equal(Vertex, Vertex) -> Bool

    Vertex::joints

    source
    fn Vertex::joints(self : Vertex) -> (Int, Int, Int, Int)

    Vertex::new

    source
    fn Vertex::new(position~ : Vec3, normal? : Vec3, texcoord? : Vec2, joints? : (Int, Int, Int, Int), weights? : Vec4) -> Vertex

    Vertex::normal

    source
    fn Vertex::normal(self : Vertex) -> Vec3

    Vertex::not_equal

    source
    fn Vertex::not_equal(x : Vertex, y : Vertex) -> Bool

    Vertex::position

    source
    fn Vertex::position(self : Vertex) -> Vec3

    Vertex::texcoord

    source
    fn Vertex::texcoord(self : Vertex) -> Vec2

    Vertex::to_json

    source
    fn Vertex::to_json(Vertex) -> Json

    Vertex::to_repr

    source

    Vertex::weights

    source
    fn Vertex::weights(self : Vertex) -> Vec4

    VertexDelta

    source
    pub(all) struct VertexDelta {
      position : Vec3
      normal : Vec3
      tangent : Vec3
    } derive(Eq, ToJson, 
    Debug    )

    VertexDelta::equal

    source
    fn VertexDelta::equal(VertexDelta, VertexDelta) -> Bool

    VertexDelta::new

    source
    fn VertexDelta::new(position? : Vec3, normal? : Vec3, tangent? : Vec3) -> VertexDelta

    VertexDelta::normal

    source
    fn VertexDelta::normal(self : VertexDelta) -> Vec3

    VertexDelta::not_equal

    source
    fn VertexDelta::not_equal(x : VertexDelta, y : VertexDelta) -> Bool

    VertexDelta::position

    source
    fn VertexDelta::position(self : VertexDelta) -> Vec3

    VertexDelta::tangent

    source
    fn VertexDelta::tangent(self : VertexDelta) -> Vec3

    VertexDelta::to_json

    source
    fn VertexDelta::to_json(VertexDelta) -> Json

    VertexDelta::to_repr

    source

    ViewportEvent

    source
    pub(all) enum ViewportEvent {
      PointerDown(
    Point    )
      PointerMove(
    Point    )
      PointerUp(
    Point    )
      Wheel(Double)
      Resize(
    Size    )
      Focus(Bool)
      Pick(NodeId)
      RendererStatus
    } derive(Eq, 
    Debug    )

    ViewportEvent::equal

    source

    ViewportEvent::not_equal

    source
    fn ViewportEvent::not_equal(x : ViewportEvent, y : ViewportEvent) -> Bool

    ViewportEvent::to_repr

    source

    ViewportSnapshot

    source
    pub(all) struct ViewportSnapshot {
      scene_revision : Int64
      scene : Scene
      camera : OrbitCamera
      bounds : Aabb
    } derive(
    Debug    )

    ViewportSnapshot::bounds

    source
    fn ViewportSnapshot::bounds(self : ViewportSnapshot) -> Aabb

    ViewportSnapshot::camera

    source

    ViewportSnapshot::new

    source
    fn ViewportSnapshot::new(scene_revision~ : Int64, scene~ : Scene, camera~ : OrbitCamera) -> ViewportSnapshot

    ViewportSnapshot::scene

    source

    ViewportSnapshot::scene_revision

    source
    fn ViewportSnapshot::scene_revision(self : ViewportSnapshot) -> Int64

    ViewportSnapshot::to_repr

    source

    ViewportStatus

    source
    pub(all) enum ViewportStatus {
      Loading
      Ready
      Unavailable(String)
      Failed(String)
    } derive(Eq, ToJson, 
    Debug    )

    ViewportStatus::equal

    source

    ViewportStatus::not_equal

    source
    fn ViewportStatus::not_equal(x : ViewportStatus, y : ViewportStatus) -> Bool

    ViewportStatus::to_json

    source

    ViewportStatus::to_repr

    source

    decode_viewport_event

    source

    Decode the stable, human-readable platform event names used by the addon plugin. Pointer payloads are x,y; wheel payload is a signed scalar.

    load_asset

    source
    fn load_asset(source : AssetByteSource, asset : TextureSource) -> AssetLoadResult

    Resolve an embedded asset directly or delegate URI lookup to the injected source. This small helper is deterministic and easy to test.

    load_gltf_scene

    source
    fn load_gltf_scene(json : String, binary? : Bytes?, resolve? : (String) -> Bytes??) -> Scene raise GltfError

    Decode the supported glTF subset into the addon scene model.

    This function accepts already-loaded bytes only. binary is the GLB BIN chunk (or the single buffer supplied by an app); external JSON resources are obtained through resolve.

    parse_glb

    source
    fn parse_glb(bytes : Bytes) -> GltfDocument raise GltfError

    parse_gltf_json

    source
    fn parse_gltf_json(json : String, binary? : Bytes?) -> GltfDocument raise GltfError

    sample_animation_channel

    source
    fn sample_animation_channel(channel : AnimationChannel, time : Double) -> Array[Double]

    three_d_viewport

    source
    fn[Msg] three_d_viewport(binding~ : ThreeDViewportBinding, snapshot~ : ViewportSnapshot, semantics_label? : String, on_event? : (ViewportEvent) -> Msg?) -> 
    View    [Msg]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io