@solidrt/flux-types 0.0.53 → 0.0.55

package/gui/gpu.d.ts

@@ -129,8 +129,19 @@ declare module "flux:gpu" {
    * shader sampling minifies through the chain; the `<texture>` display
    * draw samples the full-size level. Regeneration is one GPU pass per
    * upload or render, so a per-frame texture pays it per frame.
+   *
+   * `anisotropy` (default 1 = off) is the anisotropic filtering level, Three's
+   * `texture.anisotropy`: the most taps a shader sample may take along the
+   * axis a surface is foreshortened on, so a tiled ground plane seen at a
+   * grazing angle stays sharp to the horizon instead of smearing into the
+   * mip level its long axis picks. Any number >= 1; rounded down to a power
+   * of two, capped at 16 and then at the device's `limits.maxAnisotropy`
+   * (1 on a device without the extension - the texture then samples as
+   * today, no error). Only meaningful with `mipmap: true` (it filters
+   * through the chain), ignored by the `<texture>` display draw like the
+   * chain itself. Below 1 or non-finite throws.
    */
-  export type SamplerOptions = { filter?: FilterMode; wrap?: WrapMode; mipmap?: boolean }
+  export type SamplerOptions = { filter?: FilterMode; wrap?: WrapMode; mipmap?: boolean; anisotropy?: number }
   /**
    * One `textures` binding value: a texture id, sampled with the texture's
    * own declared state, or `{ id, filter?, wrap? }` to sample that id with a
@@ -186,6 +197,14 @@ declare module "flux:gpu" {
     maxTextureUnits: number
     /** Vertex attributes one pipeline may declare (>= 16). */
     maxVertexAttribs: number
+    /**
+     * Highest `anisotropy` level the device samples at (a power of two, 1
+     * when the device has no anisotropic filtering). A report, not a
+     * ceiling: a higher requested level is clamped to it silently, so
+     * `anisotropy: limits.maxAnisotropy` is the "as sharp as this device
+     * goes" spelling.
+     */
+    maxAnisotropy: number
   }
   /**
    * Create an immutable texture from a pixel buffer (exactly
@@ -277,7 +296,14 @@ declare module "flux:gpu" {
    * 300 es`, `precision highp float;`, `uniform vec2 iResolution;`, plus
    * `out vec4 fragColor;` for a fragment stage (the same text
    * {@link createPipelineTexture} injects). Do not combine `header` with your
-   * own `#version` line. Returns a shader (stage) id in its own id space;
+   * own `#version` line. The header declares those names rather than only
+   * filling them, so a source compiled with `header: true` must not declare
+   * them again: `uniform vec3 iResolution;` carried over from a ported shader
+   * is the usual mistake and fails as a redefinition (under the header
+   * iResolution is vec2; only a complete source may declare it vec3 and get
+   * `(w, h, 1.0)`). Everything else - samplers, app-driven uniforms,
+   * varyings (no `vUV` here) - is the source's own declaration.
+   * Returns a shader (stage) id in its own id space;
    * compile errors throw here, synchronously, at a call site the app chose.
    * Free with {@link destroyShader}.
    *

package/gui/rendertree.d.ts

@@ -15,7 +15,7 @@ declare module "flux:rendertree" {
     lineHeight?: number
     /** measureText only. */
     maxLines?: number
-    /** prepareText only: also report each unit's {@link TextUnit.carets}. */
+    /** prepareText only: also report each unit's {@link TextUnit.carets} (kerned per-glyph positions). */
     carets?: boolean
     /**
      * prepareText only: styled ranges over the text, in JS string offsets,
@@ -65,7 +65,11 @@ declare module "flux:rendertree" {
      * With `carets`: the caret positions inside the unit, one per grapheme
      * cluster boundary from its start (`offset` = start, x 0) to the end of
      * its shaped text (before any break characters), in order. `offset` is
-     * into the prepared text, `x` from the unit's pen position.
+     * into the prepared text, `x` from the unit's pen position. These are
+     * the per-glyph x positions of the shaping that is drawn, kerning
+     * included: for placing or animating single glyphs, use them rather
+     * than measuring characters one at a time with measureText, which sees
+     * no neighbors and drifts on every kerning pair.
      */
     carets?: { offset: number, x: number }[]
   }
@@ -165,8 +169,11 @@ declare module "flux:rendertree" {
   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.
+   * the shared word cache, so a text already drawn or prepared costs no
+   * shaping), for app-side line breaking - text into a shape, around an
+   * obstacle, across columns, fitted by size, per glyph; see layoutNextLine
+   * in @solidrt/core. `runs` restyle ranges, `carets` adds glyph positions;
+   * `maxLines` is ignored.
    */
   export function prepareText(text: string, options?: MeasureTextOptions): PreparedText
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",