wzzc-dev/moui/render - mooncakes.io

wzzc-dev/moui/render does not have a README file

HostSurfaceCapability

pub(open) trait HostSurfaceCapability {
  fn surface_id(Self) -> String
  fn metrics(Self) -> @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics
  fn cpu_present(Self) -> PresentTarget?
  fn native_surface(Self) -> NativeSurface?
  fn image_source(Self) -> HostImageSource?
}

Object-safe capabilities supplied by one platform window.

NativeSurfaceCapability

source

pub(open) trait NativeSurfaceCapability {
  fn surface_handle(Self) -> UInt64
  fn display_handle(Self) -> UInt64?
  fn acquire(Self, @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> UInt64?
  fn present(Self, UInt64) -> Bool
  fn resize(Self, @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> Unit
  fn dispose(Self) -> Unit
}

Object-safe native-surface operations. Handles have no platform or graphics API tag in the root contract; the selected renderer interprets them using its composition-root platform policy.

FrameToken

source

pub struct FrameToken {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Identifies one frame submission for one native-surface generation.

FrameToken::equal

source

fn FrameToken::equal(FrameToken, FrameToken) -> Bool

FrameToken::new

source

fn FrameToken::new(surface_generation~ : Int, sequence~ : Int) -> FrameToken

FrameToken::not_equal

source

fn FrameToken::not_equal(x : FrameToken, y : FrameToken) -> Bool

FrameToken::sequence

source

fn FrameToken::sequence(self : FrameToken) -> Int

FrameToken::surface_generation

source

fn FrameToken::surface_generation(self : FrameToken) -> Int

FrameToken::to_json

source

fn FrameToken::to_json(FrameToken) -> Json

FrameToken::to_repr

source

fn FrameToken::to_repr(FrameToken) -> @moonbitlang/core/debug.Repr
Repr

HostImageSource

source

pub struct HostImageSource {
  read_fn : (String) -> Bytes?
}

Renderer-neutral image source supplied by a platform backend. Format detection and decoding stay in the selected renderer module.

HostImageSource::new

source

fn HostImageSource::new(read~ : (String) -> Bytes?) -> HostImageSource

HostImageSource::read

source

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

HostImageSource::unavailable

source

fn HostImageSource::unavailable() -> HostImageSource

HostSurface

source

pub struct HostSurface {
  capability : &HostSurfaceCapability
}

Opaque surface wrapper passed from a platform backend to renderer providers.

HostSurface::cpu_present

source

fn HostSurface::cpu_present(self : HostSurface) -> PresentTarget?

HostSurface::from_capability

source

fn HostSurface::from_capability(capability : &HostSurfaceCapability) -> HostSurface

HostSurface::image_source

source

fn HostSurface::image_source(self : HostSurface) -> HostImageSource?

HostSurface::metrics

source

fn HostSurface::metrics(self : HostSurface) -> @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics

HostSurface::native_surface

source

fn HostSurface::native_surface(self : HostSurface) -> NativeSurface?

HostSurface::new

source

fn HostSurface::new(surface_id? : String, metrics~ : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics, cpu_present? : PresentTarget?, native_surface? : NativeSurface?, image_source? : HostImageSource?) -> HostSurface

HostSurface::surface_id

source

fn HostSurface::surface_id(self : HostSurface) -> String

ImageResourceLoadCompletion

source

pub(all) struct ImageResourceLoadCompletion {
  source : String
  status : ImageResourceLoadCompletionStatus
  width : Int
  height : Int
  diagnostic : String
  background_io : Bool
  decoded_pixels : Bytes
  decoded_row_bytes : Int
  background_decode : Bool
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ImageResourceLoadCompletion::equal

source

fn ImageResourceLoadCompletion::equal(ImageResourceLoadCompletion, ImageResourceLoadCompletion) -> Bool

ImageResourceLoadCompletion::failed

source

fn ImageResourceLoadCompletion::failed(source : String, diagnostic~ : String, background_io? : Bool) -> ImageResourceLoadCompletion

ImageResourceLoadCompletion::has_decoded_rgba_payload

source

fn ImageResourceLoadCompletion::has_decoded_rgba_payload(self : ImageResourceLoadCompletion) -> Bool

ImageResourceLoadCompletion::not_equal

source

fn ImageResourceLoadCompletion::not_equal(x : ImageResourceLoadCompletion, y : ImageResourceLoadCompletion) -> Bool

ImageResourceLoadCompletion::ready

source

fn ImageResourceLoadCompletion::ready(source : String, width~ : Int, height~ : Int, background_io? : Bool) -> ImageResourceLoadCompletion

ImageResourceLoadCompletion::ready_decoded_rgba

source

fn ImageResourceLoadCompletion::ready_decoded_rgba(source : String, width~ : Int, height~ : Int, row_bytes~ : Int, pixels : Bytes, background_io? : Bool, background_decode? : Bool) -> ImageResourceLoadCompletion

ImageResourceLoadCompletion::to_json

source

fn ImageResourceLoadCompletion::to_json(ImageResourceLoadCompletion) -> Json

ImageResourceLoadCompletion::to_repr

source

fn ImageResourceLoadCompletion::to_repr(ImageResourceLoadCompletion) -> @moonbitlang/core/debug.Repr
Repr

ImageResourceLoadCompletionStatus

source

pub(all) enum ImageResourceLoadCompletionStatus {
  ImageLoadReady
  ImageLoadFailed
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ImageResourceLoadCompletionStatus::equal

source

fn ImageResourceLoadCompletionStatus::equal(ImageResourceLoadCompletionStatus, ImageResourceLoadCompletionStatus) -> Bool

ImageResourceLoadCompletionStatus::not_equal

source

fn ImageResourceLoadCompletionStatus::not_equal(x : ImageResourceLoadCompletionStatus, y : ImageResourceLoadCompletionStatus) -> Bool

ImageResourceLoadCompletionStatus::to_json

source

fn ImageResourceLoadCompletionStatus::to_json(ImageResourceLoadCompletionStatus) -> Json

ImageResourceLoadCompletionStatus::to_repr

source

fn ImageResourceLoadCompletionStatus::to_repr(ImageResourceLoadCompletionStatus) -> @moonbitlang/core/debug.Repr
Repr

ImageResourceRecord

source

pub(all) struct ImageResourceRecord {
  source : String
  status : ImageResourceStatus
  width : Int
  height : Int
  diagnostic : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ImageResourceRecord::disposed

source

fn ImageResourceRecord::disposed(source : String) -> ImageResourceRecord

ImageResourceRecord::equal

source

fn ImageResourceRecord::equal(ImageResourceRecord, ImageResourceRecord) -> Bool

ImageResourceRecord::failed

source

fn ImageResourceRecord::failed(source : String, diagnostic~ : String) -> ImageResourceRecord

ImageResourceRecord::loading

source

fn ImageResourceRecord::loading(source : String) -> ImageResourceRecord

ImageResourceRecord::not_equal

source

fn ImageResourceRecord::not_equal(x : ImageResourceRecord, y : ImageResourceRecord) -> Bool

ImageResourceRecord::ready

source

fn ImageResourceRecord::ready(source : String, width~ : Int, height~ : Int) -> ImageResourceRecord

ImageResourceRecord::to_json

source

fn ImageResourceRecord::to_json(ImageResourceRecord) -> Json

ImageResourceRecord::to_repr

source

fn ImageResourceRecord::to_repr(ImageResourceRecord) -> @moonbitlang/core/debug.Repr
Repr

ImageResourceStatus

source

pub(all) enum ImageResourceStatus {
  ImageLoading
  ImageReady
  ImageFailed
  ImageDisposed
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ImageResourceStatus::equal

source

fn ImageResourceStatus::equal(ImageResourceStatus, ImageResourceStatus) -> Bool

ImageResourceStatus::not_equal

source

fn ImageResourceStatus::not_equal(x : ImageResourceStatus, y : ImageResourceStatus) -> Bool

ImageResourceStatus::to_json

source

fn ImageResourceStatus::to_json(ImageResourceStatus) -> Json

ImageResourceStatus::to_repr

source

fn ImageResourceStatus::to_repr(ImageResourceStatus) -> @moonbitlang/core/debug.Repr
Repr

NativeSurface

source

pub struct NativeSurface {
  capability : &NativeSurfaceCapability
}

Opaque wrapper around native surface operations. Construction rejects zero surface handles and zero display handles.

NativeSurface::acquire

source

fn NativeSurface::acquire(self : NativeSurface, metrics : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> UInt64?

NativeSurface::display_handle

source

fn NativeSurface::display_handle(self : NativeSurface) -> UInt64?

NativeSurface::dispose

source

fn NativeSurface::dispose(self : NativeSurface) -> Unit

NativeSurface::new

source

fn NativeSurface::new(surface_handle~ : UInt64, display_handle? : UInt64?, acquire? : (@wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> UInt64?, present? : (UInt64) -> Bool, resize? : (@wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> Unit, dispose? : () -> Unit) -> NativeSurface?

NativeSurface::present

source

fn NativeSurface::present(self : NativeSurface, surface : UInt64) -> Bool

NativeSurface::resize

source

fn NativeSurface::resize(self : NativeSurface, metrics : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> Unit

NativeSurface::surface_handle

source

fn NativeSurface::surface_handle(self : NativeSurface) -> UInt64

PixelFrame

source

pub(all) struct PixelFrame {
  width : Int
  height : Int
  row_bytes : Int
  scale_factor : Double
  pixels : Bytes
}

A renderer-neutral pixel frame supplied to a host presenter.

PixelFrame::height

source

fn PixelFrame::height(self : PixelFrame) -> Int

PixelFrame::new

source

fn PixelFrame::new(width~ : Int, height~ : Int, row_bytes~ : Int, scale_factor~ : Double, pixels~ : Bytes) -> PixelFrame

PixelFrame::pixels

source

fn PixelFrame::pixels(self : PixelFrame) -> Bytes

PixelFrame::row_bytes

source

fn PixelFrame::row_bytes(self : PixelFrame) -> Int

PixelFrame::scale_factor

source

fn PixelFrame::scale_factor(self : PixelFrame) -> Double

PixelFrame::width

source

fn PixelFrame::width(self : PixelFrame) -> Int

PresentTarget

source

pub struct PresentTarget {
  description : String
  present_fn : (PixelFrame) -> Bool
}

A CPU presenter owned by a platform backend. The callback is expressed in neutral bytes and does not depend on a renderer module.

PresentTarget::description

source

fn PresentTarget::description(self : PresentTarget) -> String

PresentTarget::new

source

fn PresentTarget::new(description~ : String, present~ : (PixelFrame) -> Bool) -> PresentTarget

PresentTarget::present

source

fn PresentTarget::present(self : PresentTarget, frame : PixelFrame) -> Bool

RecoveryResult

source

pub(all) enum RecoveryResult {
  RecoverySucceeded
  RecoveryFailed(String)
  FallbackToCpu
}

Result of a renderer recovery attempt after a context or presentation failure.

RectBatch

source

pub struct RectBatch {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RectBatch::color

source

fn RectBatch::color(self : RectBatch) -> @wzzc-dev/moui/core.Color
Color

RectBatch::equal

source

fn RectBatch::equal(RectBatch, RectBatch) -> Bool

RectBatch::new

source

fn RectBatch::new(rect~ : @wzzc-dev/moui/core.Rect
Rect, color~ : @wzzc-dev/moui/core.Color
Color) -> RectBatch

RectBatch::not_equal

source

fn RectBatch::not_equal(x : RectBatch, y : RectBatch) -> Bool

RectBatch::rect

source

fn RectBatch::rect(self : RectBatch) -> @wzzc-dev/moui/core.Rect
Rect

RectBatch::to_json

source

fn RectBatch::to_json(RectBatch) -> Json

RectBatch::to_repr

source

fn RectBatch::to_repr(RectBatch) -> @moonbitlang/core/debug.Repr
Repr

RectVertex

source

pub struct RectVertex {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RectVertex::a

source

fn RectVertex::a(self : RectVertex) -> Double

RectVertex::b

source

fn RectVertex::b(self : RectVertex) -> Double

RectVertex::equal

source

fn RectVertex::equal(RectVertex, RectVertex) -> Bool

RectVertex::g

source

fn RectVertex::g(self : RectVertex) -> Double

RectVertex::not_equal

source

fn RectVertex::not_equal(x : RectVertex, y : RectVertex) -> Bool

RectVertex::r

source

fn RectVertex::r(self : RectVertex) -> Double

RectVertex::to_json

source

fn RectVertex::to_json(RectVertex) -> Json

RectVertex::to_repr

source

fn RectVertex::to_repr(RectVertex) -> @moonbitlang/core/debug.Repr
Repr

RectVertex::x

source

fn RectVertex::x(self : RectVertex) -> Double

RectVertex::y

source

fn RectVertex::y(self : RectVertex) -> Double

RenderFrameInput

source

pub(all) struct RenderFrameInput {
  metrics : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics
  commands : Array[@wzzc-dev/moui/core.DrawCommand
DrawCommand]
  damage : @wzzc-dev/moui/core.DamageRegion
DamageRegion
  clear_color : @wzzc-dev/moui/core.Color
Color?
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RenderFrameInput::equal

source

fn RenderFrameInput::equal(RenderFrameInput, RenderFrameInput) -> Bool

RenderFrameInput::new

source

fn RenderFrameInput::new(metrics~ : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics, commands~ : Array[@wzzc-dev/moui/core.DrawCommand
DrawCommand], damage? : @wzzc-dev/moui/core.DamageRegion
DamageRegion, clear_color? : @wzzc-dev/moui/core.Color
Color?) -> RenderFrameInput

RenderFrameInput::not_equal

source

fn RenderFrameInput::not_equal(x : RenderFrameInput, y : RenderFrameInput) -> Bool

RenderFrameInput::to_json

source

fn RenderFrameInput::to_json(RenderFrameInput) -> Json

RenderFrameInput::to_repr

source

fn RenderFrameInput::to_repr(RenderFrameInput) -> @moonbitlang/core/debug.Repr
Repr

RenderFrameResult

source

pub(all) struct RenderFrameResult {
  presented : Bool
  queued : Bool
  cache_hit_count : Int
  cache_miss_count : Int
  cache_update_count : Int
  cache_evict_count : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RenderFrameResult::equal

source

fn RenderFrameResult::equal(RenderFrameResult, RenderFrameResult) -> Bool

RenderFrameResult::new

source

fn RenderFrameResult::new(presented? : Bool, queued? : Bool, cache_hit_count? : Int, cache_miss_count? : Int, cache_update_count? : Int, cache_evict_count? : Int) -> RenderFrameResult

RenderFrameResult::not_equal

source

fn RenderFrameResult::not_equal(x : RenderFrameResult, y : RenderFrameResult) -> Bool

RenderFrameResult::to_json

source

fn RenderFrameResult::to_json(RenderFrameResult) -> Json

RenderFrameResult::to_repr

source

fn RenderFrameResult::to_repr(RenderFrameResult) -> @moonbitlang/core/debug.Repr
Repr

RenderFrameSubmission

source

pub struct RenderFrameSubmission {
  // private fields
}

A draw frame paired with the backend-owned submission identity.

RenderFrameSubmission::frame

source

fn RenderFrameSubmission::frame(self : RenderFrameSubmission) -> @wzzc-dev/moui/core.DrawFrame
DrawFrame

RenderFrameSubmission::new

source

fn RenderFrameSubmission::new(token~ : FrameToken, frame~ : @wzzc-dev/moui/core.DrawFrame
DrawFrame) -> RenderFrameSubmission

RenderFrameSubmission::token

source

fn RenderFrameSubmission::token(self : RenderFrameSubmission) -> FrameToken

RenderPresentCompletion

source

pub(all) struct RenderPresentCompletion {
  token : FrameToken
  submitted_at_ms : Double
  completed_at_ms : Double
  presented_at_ms : Double
  status : RenderPresentStatus
  gpu_context_generation : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Renderer-worker completion metadata. The frame token is the only identity used by backend frame owners to accept or reject an asynchronous result.

RenderPresentCompletion::completed_at_ms

source

fn RenderPresentCompletion::completed_at_ms(self : RenderPresentCompletion) -> Double

RenderPresentCompletion::equal

source

fn RenderPresentCompletion::equal(RenderPresentCompletion, RenderPresentCompletion) -> Bool

RenderPresentCompletion::gpu_context_generation

source

fn RenderPresentCompletion::gpu_context_generation(self : RenderPresentCompletion) -> Int

RenderPresentCompletion::new

source

fn RenderPresentCompletion::new(token~ : FrameToken, submitted_at_ms~ : Double, completed_at_ms~ : Double, presented_at_ms~ : Double, status~ : RenderPresentStatus, gpu_context_generation~ : Int) -> RenderPresentCompletion

RenderPresentCompletion::not_equal

source

fn RenderPresentCompletion::not_equal(x : RenderPresentCompletion, y : RenderPresentCompletion) -> Bool

RenderPresentCompletion::presented_at_ms

source

fn RenderPresentCompletion::presented_at_ms(self : RenderPresentCompletion) -> Double

RenderPresentCompletion::status

source

fn RenderPresentCompletion::status(self : RenderPresentCompletion) -> RenderPresentStatus

RenderPresentCompletion::submitted_at_ms

source

fn RenderPresentCompletion::submitted_at_ms(self : RenderPresentCompletion) -> Double

RenderPresentCompletion::to_json

source

fn RenderPresentCompletion::to_json(RenderPresentCompletion) -> Json

RenderPresentCompletion::to_repr

source

fn RenderPresentCompletion::to_repr(RenderPresentCompletion) -> @moonbitlang/core/debug.Repr
Repr

RenderPresentCompletion::token

source

fn RenderPresentCompletion::token(self : RenderPresentCompletion) -> FrameToken

RenderPresentStatus

source

pub(all) enum RenderPresentStatus {
  Recorded
  Presented
  Dropped
  FallbackToRaster
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Completion emitted by an asynchronous renderer worker. A queued frame is not considered presented until the host drains this record.

RenderPresentStatus::equal

source

fn RenderPresentStatus::equal(RenderPresentStatus, RenderPresentStatus) -> Bool

RenderPresentStatus::not_equal

source

fn RenderPresentStatus::not_equal(x : RenderPresentStatus, y : RenderPresentStatus) -> Bool

RenderPresentStatus::to_json

source

fn RenderPresentStatus::to_json(RenderPresentStatus) -> Json

RenderPresentStatus::to_repr

source

fn RenderPresentStatus::to_repr(RenderPresentStatus) -> @moonbitlang/core/debug.Repr
Repr

RenderWindowId

source

pub(all) struct RenderWindowId {
  value : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Renderer-level window identifier. Mirror of WindowId in the host package — the host converts between the two at the API boundary so that moui/render never imports moui/backend.

RenderWindowId::equal

source

fn RenderWindowId::equal(RenderWindowId, RenderWindowId) -> Bool

RenderWindowId::new

source

fn RenderWindowId::new(value : Int) -> RenderWindowId

RenderWindowId::not_equal

source

fn RenderWindowId::not_equal(x : RenderWindowId, y : RenderWindowId) -> Bool

RenderWindowId::to_json

source

fn RenderWindowId::to_json(RenderWindowId) -> Json

RenderWindowId::to_repr

source

fn RenderWindowId::to_repr(RenderWindowId) -> @moonbitlang/core/debug.Repr
Repr

RendererBackendFeatureCapability

source

pub(all) struct RendererBackendFeatureCapability {
  provider_id : String
  feature : RendererFeature
  backend : RendererBackendKind
  status : RendererFeatureStatus
  note : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererBackendFeatureCapability::equal

source

fn RendererBackendFeatureCapability::equal(RendererBackendFeatureCapability, RendererBackendFeatureCapability) -> Bool

RendererBackendFeatureCapability::new

source

fn RendererBackendFeatureCapability::new(provider_id~ : String, feature~ : RendererFeature, backend~ : RendererBackendKind, status~ : RendererFeatureStatus, note? : String) -> RendererBackendFeatureCapability

RendererBackendFeatureCapability::not_equal

source

fn RendererBackendFeatureCapability::not_equal(x : RendererBackendFeatureCapability, y : RendererBackendFeatureCapability) -> Bool

RendererBackendFeatureCapability::to_json

source

fn RendererBackendFeatureCapability::to_json(RendererBackendFeatureCapability) -> Json

RendererBackendFeatureCapability::to_repr

source

fn RendererBackendFeatureCapability::to_repr(RendererBackendFeatureCapability) -> @moonbitlang/core/debug.Repr
Repr

RendererBackendInfo

source

pub(all) struct RendererBackendInfo {
  backend : RendererBackendKind
  status : RendererCapabilityStatus
  can_render : Bool
  can_resize : Bool
  owns_surface : Bool
  description : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererBackendInfo::equal

source

fn RendererBackendInfo::equal(RendererBackendInfo, RendererBackendInfo) -> Bool

RendererBackendInfo::new

source

fn RendererBackendInfo::new(backend~ : RendererBackendKind, status~ : RendererCapabilityStatus, can_render~ : Bool, can_resize~ : Bool, owns_surface~ : Bool, description? : String) -> RendererBackendInfo

RendererBackendInfo::not_equal

source

fn RendererBackendInfo::not_equal(x : RendererBackendInfo, y : RendererBackendInfo) -> Bool

RendererBackendInfo::to_json

source

fn RendererBackendInfo::to_json(RendererBackendInfo) -> Json

RendererBackendInfo::to_repr

source

fn RendererBackendInfo::to_repr(RendererBackendInfo) -> @moonbitlang/core/debug.Repr
Repr

RendererBackendKind

source

pub(all) enum RendererBackendKind {
  NativeWgpu
  WebGpuWasm
  SkiaRasterNative
  SkiaGpuNative
  SunRasterNative
  Canvas2DWasm
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

MoUI renderer facade. Core value types (RendererBackendKind, @core.SurfaceMetrics, RenderFrameResult, …) are defined in this file. The package also owns opaque host-surface capabilities, image/frame DTOs, capability reporting, and the provider/session plugin system (ADR 0027) in provider_contract.mbt and renderer_session.mbt.

RendererProvider plugin system

See provider_contract.mbt for:

RendererProvider — static registration and delayed surface binding
RendererSession — complete per-window live renderer lifecycle
HostSurface — opaque platform capability wrapper

Provider selection and registries live in moui/render/common. Concrete providers live in sub-packages:

moui_skia_renderer
moui_wgpu_renderer
moui_sun_renderer
moui_web_renderer and moui_web_renderer/canvas2d

RendererBackendKind::equal

source

fn RendererBackendKind::equal(RendererBackendKind, RendererBackendKind) -> Bool

RendererBackendKind::family

source

fn RendererBackendKind::family(self : RendererBackendKind) -> RendererFamily

RendererBackendKind::label

source

fn RendererBackendKind::label(self : RendererBackendKind) -> String

RendererBackendKind::not_equal

source

fn RendererBackendKind::not_equal(x : RendererBackendKind, y : RendererBackendKind) -> Bool

RendererBackendKind::short_label

source

fn RendererBackendKind::short_label(self : RendererBackendKind) -> String

RendererBackendKind::to_json

source

fn RendererBackendKind::to_json(RendererBackendKind) -> Json

RendererBackendKind::to_repr

source

fn RendererBackendKind::to_repr(RendererBackendKind) -> @moonbitlang/core/debug.Repr
Repr

RendererBindResult

source

pub(all) enum RendererBindResult {
  Bound(RendererSession)
  Rejected(String)
}

Result of asking one provider to bind a host surface. Rejection must be inspection-only: a provider may not retain renderer or native-surface resources unless it returns Bound.

RendererCapabilityStatus

source

pub(all) enum RendererCapabilityStatus {
  Supported
  Unavailable
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererCapabilityStatus::equal

source

fn RendererCapabilityStatus::equal(RendererCapabilityStatus, RendererCapabilityStatus) -> Bool

RendererCapabilityStatus::not_equal

source

fn RendererCapabilityStatus::not_equal(x : RendererCapabilityStatus, y : RendererCapabilityStatus) -> Bool

RendererCapabilityStatus::to_json

source

fn RendererCapabilityStatus::to_json(RendererCapabilityStatus) -> Json

RendererCapabilityStatus::to_repr

source

fn RendererCapabilityStatus::to_repr(RendererCapabilityStatus) -> @moonbitlang/core/debug.Repr
Repr

RendererCommandFallback

source

pub struct RendererCommandFallback {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererCommandFallback::command

source

fn RendererCommandFallback::command(self : RendererCommandFallback) -> String

RendererCommandFallback::equal

source

fn RendererCommandFallback::equal(RendererCommandFallback, RendererCommandFallback) -> Bool

RendererCommandFallback::feature

source

fn RendererCommandFallback::feature(self : RendererCommandFallback) -> RendererFeature

RendererCommandFallback::index

source

fn RendererCommandFallback::index(self : RendererCommandFallback) -> Int

RendererCommandFallback::kind

source

fn RendererCommandFallback::kind(self : RendererCommandFallback) -> RendererCommandFallbackKind

RendererCommandFallback::new

source

fn RendererCommandFallback::new(index~ : Int, feature~ : RendererFeature, command~ : String, kind? : RendererCommandFallbackKind, reason~ : String) -> RendererCommandFallback

RendererCommandFallback::not_equal

source

fn RendererCommandFallback::not_equal(x : RendererCommandFallback, y : RendererCommandFallback) -> Bool

RendererCommandFallback::reason

source

fn RendererCommandFallback::reason(self : RendererCommandFallback) -> String

RendererCommandFallback::to_json

source

fn RendererCommandFallback::to_json(RendererCommandFallback) -> Json

RendererCommandFallback::to_repr

source

fn RendererCommandFallback::to_repr(RendererCommandFallback) -> @moonbitlang/core/debug.Repr
Repr

RendererCommandFallbackKind

source

pub(all) enum RendererCommandFallbackKind {
  PlannedFallback
  UnbalancedPop
  UnclosedScope
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererCommandFallbackKind::equal

source

fn RendererCommandFallbackKind::equal(RendererCommandFallbackKind, RendererCommandFallbackKind) -> Bool

RendererCommandFallbackKind::not_equal

source

fn RendererCommandFallbackKind::not_equal(x : RendererCommandFallbackKind, y : RendererCommandFallbackKind) -> Bool

RendererCommandFallbackKind::to_json

source

fn RendererCommandFallbackKind::to_json(RendererCommandFallbackKind) -> Json

RendererCommandFallbackKind::to_repr

source

fn RendererCommandFallbackKind::to_repr(RendererCommandFallbackKind) -> @moonbitlang/core/debug.Repr
Repr

RendererCommandPlan

source

pub struct RendererCommandPlan {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererCommandPlan::equal

source

fn RendererCommandPlan::equal(RendererCommandPlan, RendererCommandPlan) -> Bool

RendererCommandPlan::fallback_count

source

fn RendererCommandPlan::fallback_count(self : RendererCommandPlan) -> Int

RendererCommandPlan::fallbacks

source

fn RendererCommandPlan::fallbacks(self : RendererCommandPlan) -> Array[RendererCommandFallback]

RendererCommandPlan::final_filter_depth

source

fn RendererCommandPlan::final_filter_depth(self : RendererCommandPlan) -> Int

RendererCommandPlan::final_layer_depth

source

fn RendererCommandPlan::final_layer_depth(self : RendererCommandPlan) -> Int

RendererCommandPlan::new

source

fn RendererCommandPlan::new(total_commands~ : Int, fallback_count~ : Int, final_layer_depth~ : Int, final_filter_depth~ : Int, fallbacks~ : Array[RendererCommandFallback]) -> RendererCommandPlan

RendererCommandPlan::not_equal

source

fn RendererCommandPlan::not_equal(x : RendererCommandPlan, y : RendererCommandPlan) -> Bool

RendererCommandPlan::to_json

source

fn RendererCommandPlan::to_json(RendererCommandPlan) -> Json

RendererCommandPlan::to_repr

source

fn RendererCommandPlan::to_repr(RendererCommandPlan) -> @moonbitlang/core/debug.Repr
Repr

RendererCommandPlan::total_commands

source

fn RendererCommandPlan::total_commands(self : RendererCommandPlan) -> Int

RendererControlMessage

source

pub(all) enum RendererControlMessage {
  Resize(@wzzc-dev/moui/core.Size
Size)
  Detach
  ContextLoss(String)
  Shutdown
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Ordered control messages shared by the renderer facade and the common mailbox implementation. Frame submission policy remains in render/common.

RendererControlMessage::equal

source

fn RendererControlMessage::equal(RendererControlMessage, RendererControlMessage) -> Bool

RendererControlMessage::not_equal

source

fn RendererControlMessage::not_equal(x : RendererControlMessage, y : RendererControlMessage) -> Bool

RendererControlMessage::to_json

source

fn RendererControlMessage::to_json(RendererControlMessage) -> Json

RendererControlMessage::to_repr

source

fn RendererControlMessage::to_repr(RendererControlMessage) -> @moonbitlang/core/debug.Repr
Repr

RendererDescriptor

source

pub(all) struct RendererDescriptor {
  backend : RendererBackendKind
  family : RendererFamily
  presentation : RendererPresentationModel
  supported_targets : Array[RendererTarget]
  capabilities : Array[RendererBackendFeatureCapability]
  description : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererDescriptor::equal

source

fn RendererDescriptor::equal(RendererDescriptor, RendererDescriptor) -> Bool

RendererDescriptor::new

source

fn RendererDescriptor::new(backend~ : RendererBackendKind, family~ : RendererFamily, presentation~ : RendererPresentationModel, supported_targets~ : Array[RendererTarget], capabilities~ : Array[RendererBackendFeatureCapability], description? : String) -> RendererDescriptor

RendererDescriptor::not_equal

source

fn RendererDescriptor::not_equal(x : RendererDescriptor, y : RendererDescriptor) -> Bool

RendererDescriptor::to_json

source

fn RendererDescriptor::to_json(RendererDescriptor) -> Json

RendererDescriptor::to_repr

source

fn RendererDescriptor::to_repr(RendererDescriptor) -> @moonbitlang/core/debug.Repr
Repr

RendererEvent

source

pub(all) enum RendererEvent {
  PresentCompleted(RenderPresentCompletion)
  ImageLoadRequested(RendererImageLoadRequest)
}

RendererFamily

source

pub(all) enum RendererFamily {
  Wgpu
  WebGpu
  Skia
  Sun
  Canvas2D
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererFamily::equal

source

fn RendererFamily::equal(RendererFamily, RendererFamily) -> Bool

RendererFamily::label

source

fn RendererFamily::label(self : RendererFamily) -> String

RendererFamily::not_equal

source

fn RendererFamily::not_equal(x : RendererFamily, y : RendererFamily) -> Bool

RendererFamily::to_json

source

fn RendererFamily::to_json(RendererFamily) -> Json

RendererFamily::to_repr

source

fn RendererFamily::to_repr(RendererFamily) -> @moonbitlang/core/debug.Repr
Repr

RendererFeature

source

pub(all) enum RendererFeature {
  Rect
  RoundedRect
  Gradient
  Shadow
  Text
  Image
  Clip
  Transform
  Opacity
  LayerCompositing
  BlendMode
  FilterEffect
  PathVector
  ShaderEffect
  TextShaping
  EmojiText
  AsyncImage
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererFeature::equal

source

fn RendererFeature::equal(RendererFeature, RendererFeature) -> Bool

RendererFeature::label

source

fn RendererFeature::label(self : RendererFeature) -> String

RendererFeature::not_equal

source

fn RendererFeature::not_equal(x : RendererFeature, y : RendererFeature) -> Bool

RendererFeature::to_json

source

fn RendererFeature::to_json(RendererFeature) -> Json

RendererFeature::to_repr

source

fn RendererFeature::to_repr(RendererFeature) -> @moonbitlang/core/debug.Repr
Repr

RendererFeatureCapability

source

pub(all) struct RendererFeatureCapability {
  feature : RendererFeature
  providers : Array[RendererBackendFeatureCapability]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererFeatureCapability::equal

source

fn RendererFeatureCapability::equal(RendererFeatureCapability, RendererFeatureCapability) -> Bool

RendererFeatureCapability::needs_follow_up

source

fn RendererFeatureCapability::needs_follow_up(self : RendererFeatureCapability) -> Bool

RendererFeatureCapability::new

source

fn RendererFeatureCapability::new(feature~ : RendererFeature, providers~ : Array[RendererBackendFeatureCapability]) -> RendererFeatureCapability

RendererFeatureCapability::not_equal

source

fn RendererFeatureCapability::not_equal(x : RendererFeatureCapability, y : RendererFeatureCapability) -> Bool

RendererFeatureCapability::note_for_provider

source

fn RendererFeatureCapability::note_for_provider(self : RendererFeatureCapability, provider_id : String) -> String

RendererFeatureCapability::provider_capability

source

fn RendererFeatureCapability::provider_capability(self : RendererFeatureCapability, provider_id : String) -> RendererBackendFeatureCapability?

RendererFeatureCapability::status_for_provider

source

fn RendererFeatureCapability::status_for_provider(self : RendererFeatureCapability, provider_id : String) -> RendererFeatureStatus

RendererFeatureCapability::to_json

source

fn RendererFeatureCapability::to_json(RendererFeatureCapability) -> Json

RendererFeatureCapability::to_repr

source

fn RendererFeatureCapability::to_repr(RendererFeatureCapability) -> @moonbitlang/core/debug.Repr
Repr

RendererFeatureStatus

source

pub(all) enum RendererFeatureStatus {
  Supported
  Partial
  Gap
  HostForwarded
  Unavailable
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererFeatureStatus::equal

source

fn RendererFeatureStatus::equal(RendererFeatureStatus, RendererFeatureStatus) -> Bool

RendererFeatureStatus::label

source

fn RendererFeatureStatus::label(self : RendererFeatureStatus) -> String

RendererFeatureStatus::needs_follow_up

source

fn RendererFeatureStatus::needs_follow_up(self : RendererFeatureStatus) -> Bool

RendererFeatureStatus::not_equal

source

fn RendererFeatureStatus::not_equal(x : RendererFeatureStatus, y : RendererFeatureStatus) -> Bool

RendererFeatureStatus::to_json

source

fn RendererFeatureStatus::to_json(RendererFeatureStatus) -> Json

RendererFeatureStatus::to_repr

source

fn RendererFeatureStatus::to_repr(RendererFeatureStatus) -> @moonbitlang/core/debug.Repr
Repr

RendererGpuRecoveryCapability

source

pub struct RendererGpuRecoveryCapability {
  // private fields
}

RendererGpuRecoveryCapability::new

source

fn RendererGpuRecoveryCapability::new(inject_context_loss? : () -> Unit, gpu_recovery_count? : () -> Int, gpu_fallback_active? : () -> Bool) -> RendererGpuRecoveryCapability

RendererImageCompletionResult

source

pub(all) enum RendererImageCompletionResult {
  Applied(Bool)
  Stale
  Disposed
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererImageCompletionResult::equal

source

fn RendererImageCompletionResult::equal(RendererImageCompletionResult, RendererImageCompletionResult) -> Bool

RendererImageCompletionResult::not_equal

source

fn RendererImageCompletionResult::not_equal(x : RendererImageCompletionResult, y : RendererImageCompletionResult) -> Bool

RendererImageCompletionResult::to_json

source

fn RendererImageCompletionResult::to_json(RendererImageCompletionResult) -> Json

RendererImageCompletionResult::to_repr

source

fn RendererImageCompletionResult::to_repr(RendererImageCompletionResult) -> @moonbitlang/core/debug.Repr
Repr

RendererImageDecoder

source

pub struct RendererImageDecoder {
  decode_fn : (String, Bytes?) -> ImageResourceLoadCompletion
}

Renderer-owned byte decoder used to build a host async image loader.

RendererImageDecoder::decode

source

fn RendererImageDecoder::decode(self : RendererImageDecoder, source : String, bytes : Bytes?) -> ImageResourceLoadCompletion

RendererImageDecoder::new

source

fn RendererImageDecoder::new(decode~ : (String, Bytes?) -> ImageResourceLoadCompletion) -> RendererImageDecoder

RendererImageDiagnostics

source

pub struct RendererImageDiagnostics {
  // private fields
}

RendererImageDiagnostics::pending_request_count

source

fn RendererImageDiagnostics::pending_request_count(self : RendererImageDiagnostics) -> Int

RendererImageDiagnostics::records

source

fn RendererImageDiagnostics::records(self : RendererImageDiagnostics) -> Array[ImageResourceRecord]

RendererImageLoadCompletion

source

pub struct RendererImageLoadCompletion {
  // private fields
}

RendererImageLoadCompletion::new

source

fn RendererImageLoadCompletion::new(token~ : RendererImageLoadToken, result~ : ImageResourceLoadCompletion) -> RendererImageLoadCompletion

RendererImageLoadCompletion::result

source

fn RendererImageLoadCompletion::result(self : RendererImageLoadCompletion) -> ImageResourceLoadCompletion

RendererImageLoadCompletion::token

source

fn RendererImageLoadCompletion::token(self : RendererImageLoadCompletion) -> RendererImageLoadToken

RendererImageLoadRequest

source

pub struct RendererImageLoadRequest {
  // private fields
}

RendererImageLoadRequest::load

source

fn RendererImageLoadRequest::load(self : RendererImageLoadRequest) -> RendererImageLoadCompletion

Decode this request, reading the source through the host's synchronous HostImageSource.

RendererImageLoadRequest::load_bytes

source

fn RendererImageLoadRequest::load_bytes(self : RendererImageLoadRequest, bytes : Bytes) -> RendererImageLoadCompletion

Decode this request from bytes the host already obtained out-of-band.

A host that fetches asynchronously — remote sources on a worker, for example — must not re-read through the synchronous HostImageSource, which would either block the caller or return nothing. It hands the fetched payload here instead, and decoding stays in the renderer-owned decoder.

RendererImageLoadRequest::source

source

fn RendererImageLoadRequest::source(self : RendererImageLoadRequest) -> String

RendererImageLoadRequest::token

source

fn RendererImageLoadRequest::token(self : RendererImageLoadRequest) -> RendererImageLoadToken

RendererImageLoadToken

source

pub struct RendererImageLoadToken {
  // private fields
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Opaque renderer-owned identity for one image I/O request.

RendererImageLoadToken::equal

source

fn RendererImageLoadToken::equal(RendererImageLoadToken, RendererImageLoadToken) -> Bool

RendererImageLoadToken::not_equal

source

fn RendererImageLoadToken::not_equal(x : RendererImageLoadToken, y : RendererImageLoadToken) -> Bool

RendererImageLoadToken::to_json

source

fn RendererImageLoadToken::to_json(RendererImageLoadToken) -> Json

RendererImageLoadToken::to_repr

source

fn RendererImageLoadToken::to_repr(RendererImageLoadToken) -> @moonbitlang/core/debug.Repr
Repr

RendererPlatformViewCapability

source

pub struct RendererPlatformViewCapability {
  // private fields
}

RendererPlatformViewCapability::new

source

fn RendererPlatformViewCapability::new(draw_platform_view_pixels? : (Bytes, Int, Int, Int, Double, Double, Double, Double) -> Unit, set_platform_view_draw_fn? : (() -> Unit?) -> Unit) -> RendererPlatformViewCapability

RendererPresentationModel

source

pub(all) enum RendererPresentationModel {
  HostGpuSurface
  WebCanvas
  CpuPixelFrame
  ExternalSurface
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererPresentationModel::equal

source

fn RendererPresentationModel::equal(RendererPresentationModel, RendererPresentationModel) -> Bool

RendererPresentationModel::label

source

fn RendererPresentationModel::label(self : RendererPresentationModel) -> String

RendererPresentationModel::not_equal

source

fn RendererPresentationModel::not_equal(x : RendererPresentationModel, y : RendererPresentationModel) -> Bool

RendererPresentationModel::to_json

source

fn RendererPresentationModel::to_json(RendererPresentationModel) -> Json

RendererPresentationModel::to_repr

source

fn RendererPresentationModel::to_repr(RendererPresentationModel) -> @moonbitlang/core/debug.Repr
Repr

RendererProvider

source

pub(all) struct RendererProvider {
  id : String
  descriptor : RendererDescriptor
  capabilities : () -> Array[RendererBackendFeatureCapability]
  bind : (HostSurface) -> RendererBindResult
}

Static renderer registration. The composition root registers providers in preference order; moui/render/common invokes bind after the platform window has produced an opaque HostSurface.

RendererProvider::bind_surface

source

fn RendererProvider::bind_surface(self : RendererProvider, surface : HostSurface) -> RendererBindResult

RendererProvider::capability_report

source

fn RendererProvider::capability_report(self : RendererProvider) -> Array[RendererBackendFeatureCapability]

RendererProvider::descriptor

source

fn RendererProvider::descriptor(self : RendererProvider) -> RendererDescriptor

RendererProvider::id

source

fn RendererProvider::id(self : RendererProvider) -> String

RendererProvider::new

source

fn RendererProvider::new(id~ : String, descriptor~ : RendererDescriptor, capabilities~ : () -> Array[RendererBackendFeatureCapability], bind~ : (HostSurface) -> RendererBindResult) -> RendererProvider

RendererSelection

source

pub(all) enum RendererSelection {
  Default
  Backend(RendererBackendKind)
  Family(RendererFamily)
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererSelection::equal

source

fn RendererSelection::equal(RendererSelection, RendererSelection) -> Bool

RendererSelection::matches_backend

source

fn RendererSelection::matches_backend(self : RendererSelection, backend : RendererBackendKind) -> Bool

RendererSelection::native_default

source

fn RendererSelection::native_default() -> RendererSelection

RendererSelection::not_equal

source

fn RendererSelection::not_equal(x : RendererSelection, y : RendererSelection) -> Bool

RendererSelection::to_json

source

fn RendererSelection::to_json(RendererSelection) -> Json

RendererSelection::to_repr

source

fn RendererSelection::to_repr(RendererSelection) -> @moonbitlang/core/debug.Repr
Repr

RendererSelection::web_default

source

fn RendererSelection::web_default() -> RendererSelection

RendererSession

source

pub struct RendererSession {
  // private fields
}

Complete live renderer lifecycle for one host surface.

RendererSession::apply_image_load_completion

source

fn RendererSession::apply_image_load_completion(self : RendererSession, completion : RendererImageLoadCompletion) -> RendererImageCompletionResult

RendererSession::dispose

source

fn RendererSession::dispose(self : RendererSession) -> Unit

RendererSession::drain_events

source

fn RendererSession::drain_events(self : RendererSession) -> Array[RendererEvent]

RendererSession::draw_platform_view_pixels

source

fn RendererSession::draw_platform_view_pixels(self : RendererSession, pixels : Bytes, src_width : Int, src_height : Int, src_stride : Int, dst_x : Double, dst_y : Double, dst_width : Double, dst_height : Double) -> Unit

RendererSession::gpu_fallback_active

source

fn RendererSession::gpu_fallback_active(self : RendererSession) -> Bool

RendererSession::gpu_recovery_count

source

fn RendererSession::gpu_recovery_count(self : RendererSession) -> Int

RendererSession::image_diagnostics

source

fn RendererSession::image_diagnostics(self : RendererSession) -> RendererImageDiagnostics

RendererSession::inject_context_loss

source

fn RendererSession::inject_context_loss(self : RendererSession) -> Unit

RendererSession::new

source

fn RendererSession::new(resize~ : (@wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> Unit, render_frame~ : (RenderFrameSubmission) -> RenderFrameResult, drain_events? : () -> Array[RendererEvent]?, text_system~ : () -> @wzzc-dev/moui/core.TextSystem
TextSystem, present_count? : () -> Int, recover? : (String) -> RecoveryResult, dispose? : () -> Unit, image_records? : () -> Array[ImageResourceRecord], apply_image_load_completion? : (ImageResourceLoadCompletion) -> Bool, image_source? : HostImageSource, image_decoder? : RendererImageDecoder?, native_surface? : NativeSurface?, platform_view? : RendererPlatformViewCapability, gpu_recovery? : RendererGpuRecoveryCapability) -> RendererSession

RendererSession::present_count

source

fn RendererSession::present_count(self : RendererSession) -> Int

RendererSession::recover

source

fn RendererSession::recover(self : RendererSession, reason : String) -> RecoveryResult

RendererSession::render_frame

source

fn RendererSession::render_frame(self : RendererSession, submission : RenderFrameSubmission) -> RenderFrameResult

RendererSession::resize

source

fn RendererSession::resize(self : RendererSession, metrics : @wzzc-dev/moui/core.SurfaceMetrics
SurfaceMetrics) -> Unit

RendererSession::set_platform_view_draw_fn

source

fn RendererSession::set_platform_view_draw_fn(self : RendererSession, draw_fn : () -> Unit?) -> Unit

RendererSession::text_system

source

fn RendererSession::text_system(self : RendererSession) -> @wzzc-dev/moui/core.TextSystem
TextSystem

RendererTarget

source

pub(all) enum RendererTarget {
  Native
  WasmGc
  Web
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RendererTarget::equal

source

fn RendererTarget::equal(RendererTarget, RendererTarget) -> Bool

RendererTarget::not_equal

source

fn RendererTarget::not_equal(x : RendererTarget, y : RendererTarget) -> Bool

RendererTarget::to_json

source

fn RendererTarget::to_json(RendererTarget) -> Json

RendererTarget::to_repr

source

fn RendererTarget::to_repr(RendererTarget) -> @moonbitlang/core/debug.Repr
Repr

WgpuSurfaceContract

source

pub(all) struct WgpuSurfaceContract {
  source : WgpuSurfaceSourceKind
  backend : RendererBackendKind
  ready : Bool
  description : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

WgpuSurfaceContract::equal

source

fn WgpuSurfaceContract::equal(WgpuSurfaceContract, WgpuSurfaceContract) -> Bool

WgpuSurfaceContract::new

source

fn WgpuSurfaceContract::new(source~ : WgpuSurfaceSourceKind, backend~ : RendererBackendKind, ready~ : Bool, description? : String) -> WgpuSurfaceContract

WgpuSurfaceContract::not_equal

source

fn WgpuSurfaceContract::not_equal(x : WgpuSurfaceContract, y : WgpuSurfaceContract) -> Bool

WgpuSurfaceContract::to_json

source

fn WgpuSurfaceContract::to_json(WgpuSurfaceContract) -> Json

WgpuSurfaceContract::to_repr

source

fn WgpuSurfaceContract::to_repr(WgpuSurfaceContract) -> @moonbitlang/core/debug.Repr
Repr

WgpuSurfaceSourceKind

source

pub(all) enum WgpuSurfaceSourceKind {
  NativeHostSurface
  WebCanvasSurface
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

WgpuSurfaceSourceKind::equal

source

fn WgpuSurfaceSourceKind::equal(WgpuSurfaceSourceKind, WgpuSurfaceSourceKind) -> Bool

WgpuSurfaceSourceKind::not_equal

source

fn WgpuSurfaceSourceKind::not_equal(x : WgpuSurfaceSourceKind, y : WgpuSurfaceSourceKind) -> Bool

WgpuSurfaceSourceKind::to_json

source

fn WgpuSurfaceSourceKind::to_json(WgpuSurfaceSourceKind) -> Json

WgpuSurfaceSourceKind::to_repr

source

fn WgpuSurfaceSourceKind::to_repr(WgpuSurfaceSourceKind) -> @moonbitlang/core/debug.Repr
Repr

collect_rect_batches

source

fn collect_rect_batches(commands : Array[@wzzc-dev/moui/core.DrawCommand
DrawCommand]) -> Array[RectBatch]

first_clear_color

source

fn first_clear_color(commands : Array[@wzzc-dev/moui/core.DrawCommand
DrawCommand]) -> @wzzc-dev/moui/core.Color
Color

grow_capacity

source

fn grow_capacity(required : UInt64) -> UInt64

rect_batches_to_vertices

source

fn rect_batches_to_vertices(batches : Array[RectBatch], size : @wzzc-dev/moui/core.Size
Size) -> Array[RectVertex]

rect_vertices_to_bytes

source

fn rect_vertices_to_bytes(vertices : Array[RectVertex]) -> Bytes

render_present_completion_is_presented

source

fn render_present_completion_is_presented(completion : RenderPresentCompletion) -> Bool

render_present_completions_have_presented

source

fn render_present_completions_have_presented(completions : Array[RenderPresentCompletion]) -> Bool

render_present_completions_have_terminal

source

fn render_present_completions_have_terminal(completions : Array[RenderPresentCompletion]) -> Bool

size_dim_to_uint

source

fn size_dim_to_uint(value : Double) -> UInt

Source Files

Site source Report issue Packages Build queue Skills Statistics

#HostSurfaceCapability

#NativeSurfaceCapability

#FrameToken

#FrameToken::equal

#FrameToken::new

#FrameToken::not_equal

#FrameToken::sequence

#FrameToken::surface_generation

#FrameToken::to_json

#FrameToken::to_repr

#HostImageSource

#HostImageSource::new

#HostImageSource::read

#HostImageSource::unavailable

#HostSurface

#HostSurface::cpu_present

#HostSurface::from_capability

#HostSurface::image_source

#HostSurface::metrics

#HostSurface::native_surface

#HostSurface::new

#HostSurface::surface_id

#ImageResourceLoadCompletion

#ImageResourceLoadCompletion::equal

#ImageResourceLoadCompletion::failed

#ImageResourceLoadCompletion::has_decoded_rgba_payload

#ImageResourceLoadCompletion::not_equal

#ImageResourceLoadCompletion::ready

#ImageResourceLoadCompletion::ready_decoded_rgba

#ImageResourceLoadCompletion::to_json

#ImageResourceLoadCompletion::to_repr

#ImageResourceLoadCompletionStatus

#ImageResourceLoadCompletionStatus::equal

#ImageResourceLoadCompletionStatus::not_equal

#ImageResourceLoadCompletionStatus::to_json

#ImageResourceLoadCompletionStatus::to_repr

#ImageResourceRecord

#ImageResourceRecord::disposed

#ImageResourceRecord::equal

#ImageResourceRecord::failed

#ImageResourceRecord::loading

#ImageResourceRecord::not_equal

#ImageResourceRecord::ready

#ImageResourceRecord::to_json

#ImageResourceRecord::to_repr

#ImageResourceStatus

#ImageResourceStatus::equal

#ImageResourceStatus::not_equal

#ImageResourceStatus::to_json

#ImageResourceStatus::to_repr

#NativeSurface

#NativeSurface::acquire

#NativeSurface::display_handle

#NativeSurface::dispose

#NativeSurface::new

#NativeSurface::present

#NativeSurface::resize

#NativeSurface::surface_handle

#PixelFrame

#PixelFrame::height

#PixelFrame::new

#PixelFrame::pixels

#PixelFrame::row_bytes

#PixelFrame::scale_factor

#PixelFrame::width

#PresentTarget

#PresentTarget::description

#PresentTarget::new

#PresentTarget::present

#RecoveryResult

#RectBatch

#RectBatch::color

#RectBatch::equal

#RectBatch::new

#RectBatch::not_equal

#RectBatch::rect

#RectBatch::to_json

#RectBatch::to_repr

#RectVertex

#RectVertex::a

HostSurfaceCapability

NativeSurfaceCapability

FrameToken

FrameToken::equal

FrameToken::new

FrameToken::not_equal

FrameToken::sequence

FrameToken::surface_generation

FrameToken::to_json

FrameToken::to_repr

HostImageSource

HostImageSource::new

HostImageSource::read

HostImageSource::unavailable

HostSurface

HostSurface::cpu_present

HostSurface::from_capability

HostSurface::image_source

HostSurface::metrics

HostSurface::native_surface

HostSurface::new

HostSurface::surface_id

ImageResourceLoadCompletion

ImageResourceLoadCompletion::equal

ImageResourceLoadCompletion::failed

ImageResourceLoadCompletion::has_decoded_rgba_payload

ImageResourceLoadCompletion::not_equal

ImageResourceLoadCompletion::ready

ImageResourceLoadCompletion::ready_decoded_rgba

ImageResourceLoadCompletion::to_json

ImageResourceLoadCompletion::to_repr

ImageResourceLoadCompletionStatus

ImageResourceLoadCompletionStatus::equal

ImageResourceLoadCompletionStatus::not_equal

ImageResourceLoadCompletionStatus::to_json

ImageResourceLoadCompletionStatus::to_repr

ImageResourceRecord

ImageResourceRecord::disposed

ImageResourceRecord::equal

ImageResourceRecord::failed

ImageResourceRecord::loading

ImageResourceRecord::not_equal

ImageResourceRecord::ready

ImageResourceRecord::to_json

ImageResourceRecord::to_repr

ImageResourceStatus

ImageResourceStatus::equal

ImageResourceStatus::not_equal

ImageResourceStatus::to_json

ImageResourceStatus::to_repr

NativeSurface

NativeSurface::acquire

NativeSurface::display_handle

NativeSurface::dispose

NativeSurface::new

NativeSurface::present

NativeSurface::resize

NativeSurface::surface_handle

PixelFrame

PixelFrame::height

PixelFrame::new

PixelFrame::pixels

PixelFrame::row_bytes

PixelFrame::scale_factor

PixelFrame::width

PresentTarget

PresentTarget::description

PresentTarget::new

PresentTarget::present

RecoveryResult

RectBatch

RectBatch::color

RectBatch::equal

RectBatch::new

RectBatch::not_equal

RectBatch::rect

RectBatch::to_json

RectBatch::to_repr

RectVertex

RectVertex::a