Skip to content

Releases

Strata 0.9.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 05:57
04c6cce

The grid relay: a ready-made web-kit scene (web/kit/grid-relay) that draws
a grid scene described by page messages in a versioned binary wire format,
so Python games running under pygbag can show the same 3D grid view they
draw on the desktop. It ships in the release's wasm32-emscripten tarball
under kit/grid-relay, both as sources and prebuilt (kit/grid-relay/dist/:
the scene's .js and .wasm, the kit scripts and the page), so a host needs
no Emscripten of its own to serve it. The web kit moves to 1.3 (screen panels and text, a
flat clear colour). The engine and its C ABI are unchanged from 0.8.0 (ABI
1.17).

  • The grid relay (web/kit/grid-relay, kit 1.3): a ready-made web-kit
    scene for games whose code runs in the page but cannot call Strata, such
    as Python under pygbag. The page hands it a grid scene as versioned binary
    messages (wire format 1.0, documented in its WIRE.md): the board once,
    pieces once per game tick as anchors plus shapes measured from them, the
    HUD's screen panels and labels when they change, and the view (camera,
    clear colour, sun). The relay slides pieces between ticks (not under
    reduced motion), refuses another major version of the format with a
    console error, and draws what desktop Strata draws for the same scene:
    four 2048 cascades, shadows to 40 units, no fog, no MSAA, a flat clear
    colour. grid-relay.js loads it only on request and under a size gate,
    and forwards keys (desktop Strata's scancodes and SDL3 modifier bits),
    text, mouse buttons, motion, the wheel, touch and pen (as mouse events and
    FINGER_* events) and resizes as StrataEvent-shaped records. The kit
    gains screen panels and text (Host::rect, Host::text) and a
    configurable clear (Host::clearFlags, Host::clearColor; the sky stays
    the default). tests/unit checks the reader natively, the ABI-floor target
    compiles the relay against the 0.7.0 strata.h, and CI draws two recorded
    scenes in Chromium and compares them with desktop stills of the same scene
    (tests/web/run_grid_relay.cjs). No ABI change, and no golden changes.

Strata 0.8.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 04:15
5ea7e14

Wide lines, world-anchored labels, RGBA mesh colours, ambient and sun
levels, and window fullscreen: STRATA_ABI_MINOR moves from 12 to 17, and
every addition is compatible (STRATA_ABI_VERSION stays 1). The web kit
moves to 1.2 (Host::wideLine, Host::label, the light levels, a loader
that can cover one section of a page). The Python binding knows the v0.7.0
and v0.8.0 libraries' SHA-256s and gains Engine.set_fullscreen() and
Engine.fullscreen().

  • ABI 1.17: window fullscreen. strata_set_fullscreen(engine, enabled) makes
    the window cover its display, borderless at the desktop's resolution (no
    video mode change), or puts it back as a window at its earlier size;
    strata_is_fullscreen(engine) reports the state. The switch is synced
    before the call returns, so strata_get_drawable_size is already right,
    and a STRATA_EVENT_RESIZED follows as for any resize. Window surface
    only: headless and host-context engines return STRATA_ERROR_UNSUPPORTED
    and change nothing. In a browser it's the Fullscreen API, granted only from
    a user gesture. Python: Engine.set_fullscreen(), Engine.fullscreen();
    C#: StrataNative.strata_set_fullscreen, strata_is_fullscreen. No
    golden changes.

  • ARCHITECTURE.md, STRATA_LIGHTING_SUN (#99): why a sun a few degrees above
    the horizon draws a dark frame with the default levels. A table gives the
    key light, n·l, ambient and the fraction of a flat surface's colour
    received at 2°, 5° and 30°, evaluated from src/render/sun.cpp and the sun
    shader. The section also covers how to raise and then reset the ABI 1.16
    light levels for low-sun stills. Docs only: no ABI change, and no golden
    changes.

  • docs/LARGE_SCENES.md (#102): a guide to map-sized scenes. It covers
    choosing the near and far planes (depth precision, and fog, which runs from
    0.35 × the far plane to the far plane), camera height compared with terrain
    relief, exaggerating heights in the terrain tile rather than the camera,
    shadow_distance and marker size. Docs only: no ABI change, and no golden
    changes.

  • Value noise and fractal Brownian motion in modules/sim
    (strata/sim/noise.hpp). valueNoise(x, y, seed) is smoothstep-blended
    lattice value noise from an integer hash; fbm(x, y, FbmParams) sums
    octaves layers (each with its own seed and lattice offset) with gain
    and lacunarity, normalised to [-1, 1]. No global state; the same seed
    gives the same values on every compiler. Games built on Strata that drew
    terrain or patches from one or two octaves got smooth, round edges: the
    header carries a table, measured on this implementation with the new
    strata-sim-fbm-dimension tool, of the box-counting dimension of a level
    set's edge (about 1.0 for 1-4 octaves; 1.01 to 1.31 for gain 0.5 to 0.75
    at 9 octaves; natural coastlines are about 1.1-1.3). Unit tests pin the
    values for fixed seeds and check that more gain gives a rougher edge. C++
    only: no ABI change, and no golden changes.

  • Wide lines (ABI 1.13, #46). strata_submit_lines draws GL_LINES, which
    are one pixel wide, and WebGL 2 draws no wider, so at DPR 2 or 3 a road,
    river or route nearly vanished. strata_submit_wide_lines(engine, vertices, count, flags) takes pairs of the new StrataWideLineVertex (36
    bytes: position, colour, width_pixels, world_width;
    STRATA_STRUCT_WIDE_LINE_VERTEX = 17) and draws each segment as a
    camera-facing quad with a one-pixel antialiased edge, in the browser as on
    the desktop. The width at each end is the larger of width_pixels and
    world_width as projected there, and varies along the segment, so a
    ribbon can taper; the colour varies too. Flags: STRATA_LINES_ON_TOP (as
    for strata_submit_lines_ex) and the new STRATA_LINES_ROUND_CAPS, round
    ends so a polyline's segments join without notches
    (strata_submit_lines_ex still rejects it). A segment that crosses behind
    the eye is cut there. StrataLineVertex, strata_submit_lines and
    strata_submit_lines_ex are unchanged and draw exactly what they drew:
    every existing golden passes as it was. STRATA_ABI_MINOR is 13. The C#
    (StrataWideLineVertex, strata_submit_wide_lines, LinesRoundCaps)
    and Python (WideLineVertex, Engine.submit_wide_lines,
    LINES_ROUND_CAPS) bindings have it, and the web kit's host has
    Host::wideLine(...) (round caps by default), submitted with the frame
    and counted in sk_stats line segments; the kit's version stays 1.1, as
    its page/wasm contract did not change. The scene format has wide_line;
    new golden w1_wide_lines, unit tests for validation and the layout,
    layout tests in C# and Python, and a Python test that a 10-pixel line
    covers 10 pixels.

  • ABI 1.14, world-anchored labels (#47). Both additions are compatible;
    every ABI 1.x host keeps working and no existing image changes.

    • strata_project_point projects a world point with the camera last set
      onto the drawable as it is now: pixels from the top-left (the
      coordinates StrataText and StrataRect use), the distance along the
      view axis (as strata_read_depth_f32 measures it) and whether the
      point is in front of the camera. Hosts in C, C++, C# and Python no
      longer re-derive the engine's view-projection to place a label.
    • strata_submit_world_text takes StrataTexts plus one world anchor
      each; a text's x and y become a pixel offset from where its anchor
      lands. Anchors are projected at end_frame with the frame's camera and
      size, labels behind the camera are skipped, and labels are drawn after
      the frame's rectangles and before its screen text. They are not
      depth-tested. GL-free projectPoint in src/render/overlay.cpp, with
      unit tests; Engine::projectPoint, Engine::submitWorldText.
    • Python: Engine.project_point ((x, y, depth) or None behind the
      camera) and Engine.submit_world_text. C#: the two P/Invokes.
    • Web kit 1.2: Host::label(x, y, z, text) centres an engine-drawn label
      just above a world point, so it shows in stills rendered with
      sk_save_png as well as in the page. It compiles out against an older
      strata.h, so a vendored kit still links with the 0.7.0 library. The
      example scene labels its lamp.
    • New golden o3_world_labels and a label scene directive.
    • Text is still Strata's 8 x 8 printable-ASCII font: a non-ASCII
      character (an accented place name) shows as one ?. A wider glyph set
      is left for a separate change.
  • ABI 1.16: ambient and sun levels (#49). In STRATA_LIGHTING_SUN the ambient
    and the sun's strength were fixed functions of time of day, so a host could
    not lift a scene's shadow side or dim the sun for weather without moving
    it. strata_set_ambient(engine, tint, lift) makes the hemisphere ambient
    (and SPACE's flat legacy_ambient) ambient * tint + lift;
    strata_set_sun_intensity(engine, intensity, tint) scales the key light
    (the sun, or the moon at night) and keeps its direction, shadows and the
    sky. Both stay across strata_set_lighting, are ignored by LEGACY, and
    are validated (tint and intensity 0..16, lift 0..1; NULL is the default).
    New functions only: StrataLighting is unchanged, STRATA_ABI_VERSION
    stays 1 and STRATA_ABI_MINOR is 16. The defaults draw exactly what 1.15
    drew (x * 1 + 0 is x): every existing golden passes unchanged, a unit
    test checks the sky bit for bit over a whole day, and the Python test
    draws the same bytes with and without explicit default calls. In the C#
    and Python bindings (set_ambient, set_sun_intensity). Scene files gain
    ambient and sun_intensity; new golden sun_levels_overcast
    (before and after: docs/media/light-levels.png).

  • Web kit 1.2 (the same unreleased kit minor as Host::label, #47):
    Host::ambientTint, ambientLift, sunIntensity and
    sunTint (applied every frame; the defaults draw what 1.1 drew), and
    Host::fill(light, lift, priority): a fill light whose lift is added to
    the ambient when the tier's light budget drops it, so a scene that stands
    in fill lights for ambient no longer goes dark at tier 0 (4 lights). The
    tiers' budgets are unchanged, and a light added with light() adds
    nothing when dropped, so no tier changes for an existing host. Unit tests
    in test_kit_lights.cpp.

  • Web kit: a vendored kit builds against the 0.7.0 library again (#68).
    Host::wideLine (ABI 1.13) and the light levels (ABI 1.16) called the
    newer functions with no STRATA_ABI_MINOR guard, so docs/WEB.md's
    promise that the newer parts compile out held only for Host::label.
    They are now guarded like it; against an older strata.h they are absent
    and a dropped fill light adds no ambient. A new compile-only target,
    strata-kit-abi-floor, builds the kit's example scene with
    STRATA_ABI_MINOR lowered to 12 and every newer name poisoned (GCC and
    Clang), so an unguarded call fails the build. No ABI or pixel change.

  • Web kit: the slow bar (StrataLoader.slow()) wraps its buttons under its
    text when the row is too narrow, and its width is no longer capped at half
    the viewport (an auto width beside left:50%). On a 390 px phone it used
    to squeeze the text and the button onto several lines each, side by side.
    The smoke test's loader checks now include the bar at 390 px. The kit
    version stays 1.1.

  • Web kit: a canvas with no CSS size no longer grows on every frame at a
    device pixel ratio over 1 (#89). Such a canvas is shown at its width and
    height attributes, which the kit sets to its displayed size times the
    DPR, so it doubled until the browser's canvas limit; docs/WEB.md's page
    example had one. StrataKit.create now finds a canvas sized only by its
    attributes, pins its CSS size once at what it showed (kit.cssPinned)
    and warns in the console; a canvas with a CSS width or height is left as
    it is. The WEB.md example gives its canvas a CSS size, and the smoke...

Read more

Strata 0.7.0

Choose a tag to compare

@github-actions github-actions released this 29 Oct 03:30
20827c3

The web kit: the shell around a Strata scene embedded in a web page, shipped
in the release's strata-0.7.0-wasm32-emscripten.tar.gz as kit/, so hosts
stop copying it from one another. The engine and its C ABI are unchanged:
STRATA_ABI_VERSION stays 1 and STRATA_ABI_MINOR stays 12, and the
libraries draw what 0.6.0 drew. The kit carries its own version (1.1). The
Python binding knows the v0.6.0 libraries' SHA-256s and, for the first time,
this release's own (strata.load_release("0.7.0") needs no hash).

  • A release's Python binding can load_release its own version with no
    hash. Until now KNOWN_RELEASES gained a version's SHA-256s only after
    that release was published, so the binding at tag v0.6.0 stopped at 0.5.0.
    The libraries are now reproducible on every platform (MSVC builds with
    /Brepro; the Linux build already was), so the release-prep pull request
    pins its own hashes with the new tools/known_releases.py pin, and the
    package job checks them: on a tag, a missing or different entry fails
    the workflow before the release job; on other runs of an untagged version
    it warns with the lines to pin. Tests in tests/python/test_known_releases.py
    cover the tool, check that every earlier release (0.4.0 on) is pinned and
    that the binding's version is the project's. CONTRIBUTING.md has the
    release steps. No ABI or pixel change.
  • strata_set_lighting errors now include the rejected value for
    legacy_ambient (legacy and space modes), time_of_day and
    latitude_degrees, shadow_distance and split_lambda, the same way the
    cascade, shadow-map-size, camera, point-light and terrain checks already
    do. No ABI or pixel change.
  • The headless surface no longer crashes on WSL2 with a GPU. There, Mesa
    picks its d3d12 driver, and with Mesa 21.2 and the NVIDIA WSL driver
    eglInitialize segfaulted inside it, so strata_create killed the host
    instead of returning an error. Where /dev/dxg exists and none of
    GALLIUM_DRIVER, LIBGL_ALWAYS_SOFTWARE or MESA_LOADER_DRIVER_OVERRIDE
    is set, the headless surface now sets GALLIUM_DRIVER=llvmpipe before
    loading EGL and logs that it did; GALLIUM_DRIVER=d3d12 opts back in.
    Elsewhere nothing changes. No ABI or pixel change. A unit test covers the
    choice (test_headless_driver.cpp).
  • Web kit 1.1 (web/kit/; docs/WEB.md, "The web kit"). No ABI or pixel
    change.
    • StrataLoader.show(options) and StrataLoader.progress(fraction, label): a host whose own loader knows its progress (a .NET
      browser-wasm or Unity-style boot) shows the loading shell and drives
      its bar without load()'s fetch. The fraction is clamped to 0..1 and
      the bar never moves back; the label, or the percentage, replaces the size
      line.
    • StrataLoader.slow() is idempotent: a second call while its bar is
      showing no longer adds another.
    • sk_stats / kit.stats() count meshes (meshes, as the host sets
      Host::meshes), and ?fps=1 shows them. A 1.0 wasm reports 0.
    • The gate's reduced-motion message now reads "This device asks for
      reduced motion. The live view is a 3.4 MB download and is animated."
    • testing/smoke.cjs checks the loading shell on a blank page first:
      progress() clamps, stays monotonic and shows its label, and slow()
      twice shows one bar.
  • The web kit no longer downloads the scene's .wasm twice.
    strata-loader.js streams the file for its progress bar and hands the
    bytes over as Module.wasmBinary, but emsdk 6.0.11's default
    INCOMING_MODULE_JS_API leaves wasmBinary out, so the glue that
    build-kit.sh built ignored them and fetched the file again.
    build-kit.sh now passes that list with wasmBinary added (the example's
    .wasm is unchanged; its .js reads Module.wasmBinary), and
    testing/smoke.cjs fails when any .wasm is requested more than once.
  • The web kit (web/kit/, shipped in the wasm32-emscripten tarball as
    kit/; docs/WEB.md, "The web kit"): the shell around a Strata scene
    embedded in a page's own WebGL 2 context, so hosts stop copying it. No ABI
    change; the kit uses only the C ABI and carries its own version (1.0).
    • strata_kit.h: header-only host shell. Context and engine creation
      (preserveDrawingBuffer on), resize, three quality tiers, an orbit
      camera and its view-projection export, the sun, per-frame batches with
      the point-alpha clamp and prioritised point lights, frame stats, and
      rebuilding the engine after a lost context (sk_restore). Natively the
      same header opens a headless engine and saves PNGs.
    • strata-kit.js: dependency-free page shell. DPR-capped sizing, adaptive
      quality (pixel density first, then shadows; reset on a hidden tab),
      orbit/pan/pinch/keyboard camera, project and pick in CSS pixels,
      webglcontextlost/restored, ?quality=, ?fps=1, ?drive=1 with
      drive(t), and label placement with hysteresis.
    • strata-loader.js: the loading shell. Poster backdrop, byte-accurate
      progress with the size, and a fallback to the trailer or poster when
      WebGL 2 is missing, the engine fails, the context is gone or the device
      is too slow.
    • build-kit.sh (parameterised, SHA-checked, byte-reproducible),
      ci-snippet.yml, and testing/ (smoke.cjs: tap == pick at DPR 1/2/3,
      context loss; capture.cjs: frames from drive(t)).
    • CI builds web/kit/example with the kit against its own libstrata.a,
      runs the smoke test on it in Chromium, and checks the tarball carries
      the kit.
  • Python binding: KNOWN_RELEASES gains v0.6.0 (linux-x64 and win-x64),
    so strata.load_release("0.6.0") needs no hash.

Strata 0.6.0

Choose a tag to compare

@github-actions github-actions released this 24 Oct 14:51
c2d7ee4

What a playtesting harness needs to play a Strata game without a person at
the window: injected events, a shared frame clock and the drive channel
(STRATA_DRIVE, with STRATA_DRIVE_SURFACE, STRATA_DRIVE_CLOCK and
STRATA_DRIVE_STEP). The ABI addition is compatible: STRATA_ABI_VERSION
stays 1 and STRATA_ABI_MINOR is 12. The Python binding also knows the
v0.5.0 libraries' SHA-256s.

  • ABI 1.12, for playtesting harnesses (Preponderous RFC 0027): a Strata game
    can be played by something other than a person at a window. All compatible
    additions; every ABI 1.x host keeps working. See docs/DRIVE.md.
    • strata_push_event / Engine::pushEvent: queue an event that
      strata_poll_event returns after the platform's own, on any surface
      (bounded at 4096).
    • strata_frame_seconds / Engine::frameSeconds: the seconds to advance
      this frame, from a monotonic clock, or the step a stepped driver granted.
    • strata_is_driven / Engine::driven: whether a harness drove this
      engine, so a game can keep a driven run away from the player's saves.
    • The drive channel: with STRATA_DRIVE naming a Unix socket, the engine
      connects (it never listens) and takes JSON lines that inject events, step
      a stepped clock (STRATA_DRIVE_CLOCK, STRATA_DRIVE_STEP) and take
      screenshots. STRATA_DRIVE_SURFACE=headless turns a driven game's window
      into a headless surface. A failed or dropped connection runs undriven.
    • strata_set_relative_mouse_mode returns STRATA_OK on a headless or
      host-context surface when the engine is driven; injected motion is then
      relative. Undriven, nothing changes.
    • Tests: test_drive.cpp (the protocol over a socket pair, no GL) and
      strata-drive-e2e (a real headless engine, two stepped runs drawing
      identical frames; skipped where there is no EGL). C# P/Invokes and Python
      declarations (Engine.push_event, frame_seconds, driven), with tests.
  • Python binding: KNOWN_RELEASES gains v0.5.0 (linux-x64 and win-x64),
    so strata.load_release("0.5.0") needs no hash.

Strata 0.5.0

Choose a tag to compare

@github-actions github-actions released this 24 Oct 06:33
2f997ac

What the Strata-adoption RFCs asked for: depth readback, nearest filtering,
translucency and on-top overlays, a Python binding, machine-readable image
comparison, and executable tools in the release tarball. Every ABI addition
is compatible: STRATA_ABI_VERSION stays 1 and STRATA_ABI_MINOR is 11.

  • ABI 1.11: translucency and on-top overlays, asked for by a faction-map
    viewer proposal (translucent border fences; relation arcs that show through
    hills) and RFC 0031 (a backing panel for text). All are compatible
    additions.
    • STRATA_MESH_TRANSLUCENT (StrataTexturedMesh.flags): alpha blended
      with alpha color[3] times the texel's alpha, drawn in a new
      translucent pass after the sky, back to front by bounding-box centre,
      depth-tested without writing depth, both faces drawn, casting no shadows.
      Lit or unlit (with STRATA_MESH_UNLIT).
    • strata_submit_lines_ex(engine, vertices, count, flags) with
      STRATA_LINES_ON_TOP, and STRATA_POINT_ON_TOP for points: drawn after
      the depth-tested overlays with no depth test.
    • StrataRect (STRATA_STRUCT_RECT, 32 bytes) and strata_submit_rects:
      filled, alpha-blended screen rectangles, drawn before the frame's text.
    • C# and Python declarations, with layout tests. New golden
      o2_translucent_on_top; the scene format gains mesh_translucent <alpha>, rect, and an on_top option for line and point.
  • strata-imgcmp --json prints the comparison as one JSON object (pass,
    sizes, pixel counts, fraction over, max and mean ΔE, threshold, limit, diff
    path, or an error member on an I/O error) with the same exit status, and
    --always-diff writes the --diff image on a pass too. Asked for by
    RFC 0028 (visual diffs for
    usd-asset-gate,
    ask A2). A diff image that cannot be written is now exit 2 instead of being
    ignored. A CTest test, strata-imgcmp-cli, checks the exit codes and both
    flags.
  • A Python binding, bindings/python/strata (pip install from the
    repository's bindings/python): ctypes declarations of the whole C ABI,
    with no compiled code. Every struct is checked against the library's layout
    tables at load time, and a library whose layouts differ is refused. It has
    a small Engine wrapper, lib.raw.strata_* for direct calls, and
    per-function ABI minors, so a call newer than the loaded library raises
    StrataError naming the minor it needs. The library is loaded from a path,
    STRATA_LIBRARY, STRATA_NATIVE_DIR, or a release fetched by
    strata.load_release(version, sha256), which is verified against a pinned
    SHA-256 and deleted on a mismatch. Desktop Linux and Windows only; Pyodide
    is out of scope. tests/python (unittest) checks the layouts, the release
    fetch (offline) and headless drawing, including bn_primitives_legacy
    drawn from Python against its golden. CI runs it on llvmpipe, and the
    layout tests also run against the Windows DLL. Shared by RFCs 0022, 0026,
    0028 and 0031, and by a plugin-tooling RFC (headless previews).
  • ABI 1.9: strata_read_depth_f32 reads the last frame's depth as float32,
    top row first: the planar distance along the view axis in world units, or
    +infinity where nothing was drawn. Headless surfaces only; a window, a host
    context, and a headless request that fell back to a hidden window return
    STRATA_ERROR_UNSUPPORTED. Asked for by RFC 0026 (headless rendering for
    usd-synth-data).
    A depth_pack draw copies the depth attachment's float bits into RGBA8,
    so it is exact on the GL 4.5 and GLES 3.0 devices alike, and
    src/render/depth_readback.cpp linearises it with the frame's projection
    (either depth convention, or orthographic), with unit tests.
    Engine::readDepth; C# P/Invoke. New golden depth_readback_planes and a
    scene directive, expect_depth <x> <y> <distance|inf>, that checks the
    readback after the captured frame (skipped where unsupported).
  • ABI 1.10: STRATA_TEXTURE_NEAREST (0x8), a strata_create_texture_rgba8
    flag for nearest-texel filtering, so a magnified texture keeps hard texel
    edges (cell fields, pixel art). Both devices already supported it
    internally for the overlay font; the flag exposes it. Asked for by RFC 0025
    (a shared replay player, ask S1), whose fields are hard-edged cells. C#
    StrataAbi.TextureNearest. New golden tex_nearest_field (the same
    checker linear and nearest side by side) and a nearest texture option in
    the scene format.
  • The Linux release tarball keeps the executable bit on bin/strata-golden
    and bin/strata-imgcmp. In 0.4.0 they were mode 0644 (artifact uploads drop
    Unix file modes), so they ran only after a chmod +x. A new CI job,
    Package release assets, builds every release asset on every run, not
    only on tags, sets the modes, and fails unless the tarball's tools are
    executable and strata-imgcmp runs straight from it. The Release job
    publishes that job's assets.
  • strata.h comments for StrataPointLight, StrataTerrainTile and
    StrataMesh now cover STRATA_LIGHTING_SPACE (ABI 1.5): point lights shade
    it, and the terrain and meshes are drawn under every lighting mode and take
    point-light shadows in it. The mesh comment no longer says meshes share the
    terrain's vertex format, which gained a uv in ABI 1.7. Comments only; no
    layout or signature changes.

Strata 0.4.0

Choose a tag to compare

@github-actions github-actions released this 22 Oct 12:46
2e03be8

The browser (WebGL 2 through Emscripten), a seasonal sun, textures, picking
and texture updates. Every ABI addition is compatible: STRATA_ABI_VERSION
stays 1 and STRATA_ABI_MINOR is 8.

  • ABI 1.8, for Kindling
    (a first-person cozy restoration game): grime cleaned patch by patch,
    knowing what is under the crosshair, and mouse-look. All three are
    compatible additions; every ABI 1.x host keeps working.

    • strata_update_texture_rgba8 replaces a rectangle of an existing
      texture (same texel conventions as creation; the mip chain is rebuilt for
      STRATA_TEXTURE_MIPMAPS textures). New GpuDevice::updateTexture in the
      GL 4.5 and GLES 3.0 / WebGL 2 devices; Engine::updateTextureRgba8.
    • StrataRayHit (STRATA_STRUCT_RAY_HIT, 36 bytes) and
      strata_raycast_meshes: the nearest static-mesh triangle along a ray,
      through each mesh's model matrix, both faces counting. Meshes now keep a
      CPU copy of their positions and indices for this (12 bytes per vertex
      plus 4 per index). GL-free maths in src/render/ray_pick.cpp, with unit
      tests; Engine::raycastMeshes.
    • strata_set_relative_mouse_mode: on the SDL3 window, hides and captures
      the cursor and reports motion as dx/dy only (pointer lock in a
      browser); STRATA_ERROR_UNSUPPORTED on headless and host-context
      surfaces. Engine::setRelativeMouseMode.
    • C# mirror and P/Invokes in Strata.Interop, with layout tests.
    • New golden tex_update_grime, and two scene directives:
      texture_update (applied between the two frames strata-golden draws)
      and expect_ray (fails the scene unless the raycast hits the named mesh).
  • The WebGL 2 / GLES device starts on contexts with fewer than 16 fragment
    texture units. Its scratch unit (where textures are bound while created)
    was fixed at 15, so a phone browser reporting 13 failed with "the GLES
    device needs 16 fragment texture units". The scratch unit is now the
    device's last unit, and 9 units (Strata's 8 plus scratch) are required.

  • The USD and save modules build and pass their tests on Windows (MSVC).
    modules/save gains fs_win32.cpp (MoveFileExW with write-through,
    FlushFileBuffers, LockFileEx; UTF-8 paths converted to UTF-16), selected
    instead of fs_posix.cpp on Windows. The --crash suite (fork, setrlimit,
    SIGKILL) stays POSIX-only and reports itself skipped on Windows. CI builds a
    Windows OpenUSD prebuilt once (key.sh windows,
    build-openusd-windows.sh) and publishes it as a release asset beside the
    Linux one.

  • Strata runs in the browser (WebGL 2). A second GpuDevice backend,
    OpenGL ES 3.0 (src/rhi/gles3_device.cpp), draws every pass: the GL 4.5
    shaders are rewritten to GLSL ES 3.00 when pipelines are created, cube map
    arrays become one cube map per shadowed light, base vertex/instance fold
    into attribute offsets, and depth clamp uses EXT_depth_clamp or a shader
    fallback. The C ABI is unchanged (no new functions; ABI stays 1.7). Desktop
    builds still default to OpenGL 4.5 and its goldens are unchanged.

  • Emscripten builds (emcmake cmake ..., emsdk 6.0.11 in CI): SDL3's
    Emscripten driver for the canvas and input, libstrata.a (engine + SDL3 in
    one archive), C++ exceptions compiled as -fwasm-exceptions by default
    (STRATA_WASM_EXCEPTIONS), and strata-golden as a web page. See
    docs/WEB.md, including notes for .NET browser-wasm hosts.

  • examples/village-day: the L2 village through a day, from the C ABI only;
    an SDL3 window natively, a canvas in the browser. README animation of it
    running in headless Chromium (tools/make_web_media.py).

  • The desktop library can run the GLES device too: STRATA_GL_API=gles3
    selects it on an OpenGL ES 3.0 context (EGL or SDL3), and
    STRATA_GLES_NO_DEPTH_CLAMP=1 forces the depth clamp fallback. CI draws
    the desktop goldens through it on llvmpipe (0 pixels over ΔE 4 on all 22).

  • CI job build-web: builds with Emscripten, runs the unit tests under Node,
    checks libstrata.a defines the C ABI, and draws every golden scene in
    headless Chromium (Playwright 1.61.1, SwiftShader) against new
    web-swiftshader.png goldens, with and without EXT_depth_clamp, and
    against the desktop goldens at the default tolerance. Releases gain a
    strata-<version>-wasm32-emscripten.tar.gz asset.

  • glad is regenerated with OpenGL ES 3.0 merged into glad/gl.h.
    GpuDevice gains createIndexBuffer (WebGL fixes a buffer's kind at its
    first binding).

  • Seasonal sun (ABI 1.6): StrataSolarPosition, strata_solar_position
    (the sun's direction, elevation, azimuth, declination, hour angle and
    equation of time for a UTC moment, latitude and longitude, from NOAA's solar
    position equations) and strata_set_sun_direction, which places the
    STRATA_LIGHTING_SUN sun directly instead of by time_of_day and latitude.
    The existing time-of-day sun is unchanged and stays the default.

  • Scene files take sun date <YYYY-MM-DD> <HH:MM> <utc_offset> <lat> <lon>.
    New goldens sun_june_noon, sun_december_noon and
    sun_december_afternoon.

  • Textures and textured, transformable meshes (ABI 1.7):
    strata_create_texture_rgba8 (RGBA8, optional mip chain with trilinear
    filtering, wrap or clamp per axis) and strata_destroy_texture;
    StrataTexturedMesh and strata_add_textured_mesh (a static mesh with
    uvs, a texture that multiplies its colour, and STRATA_MESH_UNLIT for
    emissive surfaces that ignore lights and fog and cast no shadow); and
    strata_set_mesh_transform, a per-mesh model matrix (normals through its
    inverse transpose) applied in the opaque and shadow passes, so a planet
    spins about a tilted axis with one call a frame and no re-upload.

  • GpuDevice textures gain mip chains and repeat wrapping. Static meshes
    now have their own pipelines (a uv per vertex, a model matrix in uniform
    binding 3, the texture on unit 4); untextured meshes sample a white texel
    and draw exactly as before.

  • Scene files take texture, sphere_mesh, uvs, mesh_texture,
    mesh_unlit and mesh_transform. New goldens tex_globe_sun and
    tex_space_planets.

openusd-v26.08-windows2022-msvc143-51c7751f88df

Choose a tag to compare

Prebuilt OpenUSD install (Windows x64, MSVC) for Strata CI and Windows builds of Strata games (modules/usd/openusd/openusd.lock). Put lib and bin on PATH at run time. Not an engine release. Licences are in share/licenses/.

Repacked from openusd-v26.08-windows2022-msvc143-31fc9d97b5f3 (same lock and build script; that key was computed over a CRLF checkout before .gitattributes pinned them to LF).

openusd-v26.08-windows2022-msvc143-31fc9d97b5f3

Choose a tag to compare

@github-actions github-actions released this 19 Oct 01:40
b7ff1a7

Prebuilt OpenUSD install (Windows x64, MSVC) for Strata CI and Windows builds of Strata games (modules/usd/openusd/openusd.lock). Put lib and bin on PATH at run time. Not an engine release. Licences are in share/licenses/.

Strata 0.3.0

Choose a tag to compare

@github-actions github-actions released this 18 Oct 23:08
a0d2897

Static meshes, overlays and space lighting, and the simulation module. Every
ABI addition is compatible: STRATA_ABI_VERSION stays 1 and
STRATA_ABI_MINOR is 5.

  • Static meshes (ABI 1.4): StrataMesh, strata_add_mesh,
    strata_remove_mesh and strata_clear_meshes. Up to 256 indexed triangle
    meshes, already in world space, with a linear RGB colour per vertex or per
    mesh and host or engine-computed (area-weighted) normals. They share the
    terrain's vertex format and pipelines, so they are drawn under both lighting
    modes and cast and receive sun and point-light shadows. For geometry the
    primitives and the terrain tile cannot express, such as extruded footprints
    and ribbons; a narrow precursor to RFC 0020 §9's cooked meshes and
    materials, not milestone M1.
  • Scene files take mesh, vertices, vcolors and triangles lines.
    tools/gen_mesh_scene.py writes the static-mesh goldens' world.
  • Overlays (ABI 1.5): StrataLineVertex, StrataPoint and StrataText
    with strata_submit_lines, strata_submit_points and
    strata_submit_text. Unlit, alpha-blended lines and round points
    (fixed pixel size, true world size, or both; solid or a soft additive
    glow), depth-tested against the scene, and screen-space text in the
    public-domain font8x8 bitmap font, drawn in new overlay and text
    passes after the sky.
  • STRATA_LIGHTING_SPACE (ABI 1.5): point lights over a flat ambient, with
    no sun, moon, fog or sky, for scenes lit by a light inside them.
  • GpuDevice: line topology, alpha and additive blending, drawArrays, and
    R8 textures with initial data.
  • Scene files take lighting space, line, circle, point and text
    lines. New goldens o1_space_system and o1_overlays_sun.
  • modules/sim (strata::sim, C++ only, STRATA_WITH_SIM, on by default;
    not in the C ABI and no GL): a seeded PCG32 Rng, a Registry with a fixed
    iteration order, Field2D/Mask2D with mass-conserving diffusion and
    decay, a FixedStep clock, a StateHasher fingerprint and colormaps.
  • Optional OpenUSD modules behind STRATA_WITH_USD (off by default):
    modules/usd (the flat world and USD sync points) and modules/save
    (content-addressed, integrity-checked saves). CI fetches a prebuilt OpenUSD
    keyed by its pin.
  • A simulation module, modules/sim (strata::sim, C++ only, on by default
    with STRATA_WITH_SIM): a seeded PCG32 Rng, a Registry<Components...>
    with a deterministic iteration order, Field2D/Mask2D scalar fields with
    mass-conserving diffusion and decay, a FixedStep clock, a StateHasher
    fingerprint and field colormaps for terrain-tile heatmaps. No GL, no new
    dependencies, no C ABI change. Tested by strata-sim-tests.

Strata 0.2.0

Choose a tag to compare

@github-actions github-actions released this 18 Oct 16:18
dd68a1c

Lighting milestones L3–L4 and terrain milestone T1 from RFC 0020. Every ABI
addition is compatible: STRATA_ABI_VERSION stays 1 and the new
STRATA_ABI_MINOR is 3.

  • Point lights (milestone L3, ABI 1.1): StrataPointLight and
    strata_set_point_lights, up to 32 unshadowed lights with a range-windowed
    falloff in sun lighting. strata_abi_minor() and STRATA_ABI_MINOR
    report compatible additions; STRATA_ABI_VERSION stays 1.
  • Shadowed point lights (milestone L4, ABI 1.2):
    STRATA_POINT_LIGHT_CAST_SHADOWS gives up to four point lights cube shadow
    maps (one cube-map array, 512² faces, distance/range depth, nine-tap
    filtering), drawn in a new point_shadow pass.
  • A terrain tile (milestone T1, ABI 1.3): StrataTerrainTile and
    strata_set_terrain, one static heightmapped tile with per-sample colour,
    drawn under both lighting modes and casting and receiving sun and
    point-light shadows.
  • Scene files take light point lines, with an optional shadow, and
    terrain, heights and colors lines. tools/gen_terrain_scene.py
    writes the terrain goldens' world.