@solidrt/flux-types 0.0.49 → 0.0.50

package/gui/gpu.d.ts

@@ -397,9 +397,25 @@ declare module "flux:gpu" {
    * depth-tested additive pass usually pairs with `depthWrite: false`; with
    * writes on, unsorted geometry depth-rejects its own later fragments and
    * accumulation becomes draw-order-dependent. That pairing is the app's to
-   * state - neither option implies the other.
-   */
-  export type BlendMode = "none" | "add"
+   * state - neither option implies the other. "multiply" scales
+   * (glBlendFunc(DST_COLOR, ZERO)): each fragment multiplies what is already
+   * in the target, all four channels, so it darkens where "add" brightens -
+   * a projected shadow, a dust pass. Order-independent like "add", same
+   * `depthWrite: false` pairing. On the premultiplied target a uniform factor
+   * across rgb and alpha fades the existing pixels; alpha 1 with rgb below 1
+   * darkens color only - so a strength-weighted shadow is
+   * `vec4(mix(vec3(1.0), shadowColor, strength), 1.0)`, not alpha =
+   * strength (that fades instead). "alpha" composites OVER
+   * (glBlendFunc(ONE, ONE_MINUS_SRC_ALPHA)): classic translucency, with the
+   * fragment written premultiplied like every target pixel -
+   * `vec4(color * a, a)`, never straight rgb with a loose alpha. It is the
+   * one order-DEPENDENT mode: the result follows draw-list order, so
+   * translucent geometry must land back-to-front - by draw-list ordering
+   * (`before`, `setDrawOrder`) or a sorting layer above - and normally after
+   * the opaque draws with `depthWrite: false`, so it depth-tests against them
+   * without occluding what it only tints. Nothing sorts for you here.
+   */
+  export type BlendMode = "none" | "add" | "multiply" | "alpha"
   /**
    * Face culling for a pipeline's draws. "none" (default) rasters both faces
    * - the two-sided fallback open surfaces need. "back" discards faces wound

package/gui/rendertree.d.ts

@@ -5,15 +5,44 @@
 // module; requestFrame here only schedules a future frame.
 
 declare module "flux:rendertree" {
-  /** Font options for {@link measureText}. */
+  /** Font options for {@link measureText} and {@link prepareText}. */
   export interface MeasureTextOptions {
     fontFamily?: "sans" | "serif" | "mono" | (string & {})
     fontSize?: number
     fontStyle?: "normal" | "italic"
     fontWeight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+    lineHeight?: number
+    /** measureText only. */
     maxLines?: number
   }
 
+  /**
+   * One wrap unit (a word plus its trailing whitespace, or an empty unit at
+   * a blank line) of a {@link prepareText} result: everything the engine
+   * knows about it, for app-side line breaking.
+   */
+  export interface TextUnit {
+    /** The unit's text without its break characters. */
+    text: string
+    /** Offsets into the prepared text (JS string indexing), break characters included: the ranges tile the text. */
+    start: number
+    end: number
+    /** Horizontal extent including trailing whitespace: what the next unit's pen position advances by. */
+    advance: number
+    /** Ink extent without trailing whitespace: what the unit needs at the end of a line. */
+    width: number
+    ascent: number
+    descent: number
+    /** The unit ends at a hard line break (newline). */
+    hardBreak: boolean
+  }
+
+  /** The wrap units of a text in one font, shaped once. Plain data; layout is arithmetic over `units`. */
+  export interface PreparedText {
+    text: string
+    units: TextUnit[]
+  }
+
   /** Create the window root node with the given id. */
   export function createRoot(id: number): void
   /** Create a node of `kind` (the primitive element name) with the given id. */
@@ -73,6 +102,12 @@ declare module "flux:rendertree" {
    * adding it to the tree.
    */
   export function measureText(text: string, options?: MeasureTextOptions): { width: number, height: number }
+  /**
+   * Segment `text` into wrap units and shape each in the given font (through
+   * the shared word cache), for laying lines out in app code; see
+   * layoutNextLine in @solidrt/core. Single style; `maxLines` is ignored.
+   */
+  export function prepareText(text: string, options?: MeasureTextOptions): PreparedText
   /**
    * The node's bounding box from the most recent layout, relative to its
    * nearest positioning context (an ancestor with an explicit

package/modules/wasm.d.ts

@@ -1,5 +1,11 @@
 // There is no `WebAssembly` global in flux; this module is the entire wasm
-// surface. Imports must be scalar-signature functions only (no imported
+// surface. Modules run in a pure interpreter (wasmi, no JIT), so this is a
+// portability tool - one compiled module runs on every flux target with no
+// native binaries or dlopen - not a speed tool. Tight typed compute runs
+// somewhat faster than the same loop in JavaScript (a small constant
+// factor, nowhere near browser wasm speed), and every host call costs
+// extra marshalling, so call-heavy code can end up slower.
+// Imports must be scalar-signature functions only (no imported
 // memory, globals or tables), which constrains the toolchain on the other
 // side: default emscripten output imports its memory and is rejected, while
 // `emcc -sSTANDALONE_WASM=1 --no-entry` produces a module that fits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "license": "MIT",
   "author": "Antoine van Wel",
   "types": "index.d.ts",