@moku-labs/game 0.1.0 → 0.2.0

package/bin/moku-game-assets.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { compileStrings, runCli } from "../dist/assets.mjs";
+
+process.exitCode = await runCli(process.argv.slice(2), compileStrings);

package/dist/index.d.mts

@@ -1148,7 +1148,9 @@ declare function music(key: string | null, options?: MusicOptions): Descriptor;
  * wide, that follows the shape: rounded corners stay rounded. Its alpha is
  * `strength × alpha ×` the share of the disc of radius `distance` around the pixel the view
  * covers, so `strength: 2` is full next to a straight edge and fades to nothing at `distance`.
- * The view is padded by its live `distance`. One render pass per apply.
+ * It takes 64 to 256 probes, by radius in physical pixels: about 3.5 physical pixels apart up to
+ * a radius of 32 physical pixels. The view is padded by its live `distance`. One render pass per
+ * apply.
  *
  * @example
  * ```ts

package/dist/index.mjs

@@ -18103,27 +18103,33 @@ function defineFilter(id, spec) {
 //#region src/plugins/effects/filters/glow-glsl.ts
 /**
 * @file effects/filters — the GLSL twin of the `Glow` fragment, the same math as `glow-wgsl.ts`
-* for the WebGL fallback: 64 probes on a golden-angle spiral over the disc of radius `distance`,
-* each weighted by `(1 − r / distance)²`, every probe clamped to the input frame, and the source
-* drawn over the premultiplied halo `color × coverage × strength × alpha`.
+* for the WebGL fallback: 64 to 256 probes, by radius in physical pixels, on a golden-angle
+* spiral over the disc of radius `distance`, each weighted by `(1 − r / distance)²`, every probe
+* clamped to the input frame, and the source drawn over the premultiplied halo
+* `color × coverage × strength × alpha`. The loop bound stays the constant 256, as GLSL ES
+* wants, and a `break` leaves at the count.
 */
 /**
 * The GLSL ES 3.0 fragment body of `Glow`. Reads the uniforms `strength`, `distance`, `color` and
 * `alpha` under their bare names.
 */
-const GLOW_GLSL = `const int GLOW_PROBES = 64;
+const GLOW_GLSL = `const int GLOW_MAX_PROBES = 256;
 const float GLOW_TURN_COS = -0.7373688780783197;
 const float GLOW_TURN_SIN = 0.6754902942615238;
 
 void main() {
   vec4 source = texture(uTexture, vTextureCoord);
   vec2 reach = uInputSize.zw * distance;
+  float radiusPx = distance * uInputPixel.x * uInputSize.z;
+  int probes = clamp(int(ceil(radiusPx * radiusPx * 0.25)), 64, GLOW_MAX_PROBES);
   vec2 turn = vec2(1.0, 0.0);
   float coverage = 0.0;
   float weights = 0.0;
 
-  for (int probeIndex = 0; probeIndex < GLOW_PROBES; probeIndex++) {
-    float along = sqrt((float(probeIndex) + 0.5) / float(GLOW_PROBES));
+  for (int probeIndex = 0; probeIndex < GLOW_MAX_PROBES; probeIndex++) {
+    if (probeIndex >= probes) break;
+
+    float along = sqrt((float(probeIndex) + 0.5) / float(probes));
     float weight = (1.0 - along) * (1.0 - along);
     vec2 probe = clamp(vTextureCoord + turn * reach * along, uInputClamp.xy, uInputClamp.zw);
 
@@ -18145,8 +18151,8 @@ void main() {
 //#endregion
 //#region src/plugins/effects/filters/glow-wgsl.ts
 /**
-* @file effects/filters — the fragment body of `Glow`: a soft halo that follows the shape. 64
-* probes spread evenly over the disc of radius `distance` around the pixel (a golden-angle
+* @file effects/filters — the fragment body of `Glow`: a soft halo that follows the shape.
+* Probes spread evenly over the disc of radius `distance` around the pixel (a golden-angle
 * spiral, so no rings and no spokes show) measure how much of the disc the shape covers, each
 * probe weighted by `(1 − r / distance)²`: the near probes count most and the rim counts nothing.
 * Next to a straight edge that is about ½, and it falls off fast and then slowly to 0 at
@@ -18154,11 +18160,16 @@ void main() {
 * unweighted mean falls almost linearly and reads as an outline). The halo is
 * `color × coverage × strength × alpha`, premultiplied, under the source pixel, the source drawn
 * over it. Every probe stays in the input frame, so the padding around the view stays clear.
+*
+* 64 to 256 probes, by radius in physical pixels: `clamp(ceil((distance × resolution)² × 0.25),
+* 64, 256)`, about 3.5 physical pixels apart up to a radius of 32 physical pixels, so a glow on a
+* dense screen does not band; past it the 256 spread wider. The count comes from uniforms only,
+* so the loop leaves at it in uniform control flow, under the constant bound 256.
 */
 /**
 * The WGSL fragment body of `Glow`. Reads `fu.strength`, `fu.distance`, `fu.color`, `fu.alpha`.
 */
-const GLOW_WGSL = `const GLOW_PROBES: i32 = 64;
+const GLOW_WGSL = `const GLOW_MAX_PROBES: i32 = 256;
 const GLOW_TURN_COS: f32 = -0.7373688780783197;
 const GLOW_TURN_SIN: f32 = 0.6754902942615238;
 
@@ -18166,12 +18177,16 @@ const GLOW_TURN_SIN: f32 = 0.6754902942615238;
 fn mainFragment(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
   let source = textureSample(uTexture, uSampler, uv);
   let reach = gfu.uInputSize.zw * fu.distance;
+  let radiusPx = fu.distance * gfu.uInputPixel.x * gfu.uInputSize.z;
+  let probes = clamp(i32(ceil(radiusPx * radiusPx * 0.25)), 64, GLOW_MAX_PROBES);
   var turn = vec2<f32>(1.0, 0.0);
   var coverage = 0.0;
   var weights = 0.0;
 
-  for (var probeIndex = 0; probeIndex < GLOW_PROBES; probeIndex++) {
-    let along = sqrt((f32(probeIndex) + 0.5) / f32(GLOW_PROBES));
+  for (var probeIndex = 0; probeIndex < GLOW_MAX_PROBES; probeIndex++) {
+    if (probeIndex >= probes) { break; }
+
+    let along = sqrt((f32(probeIndex) + 0.5) / f32(probes));
     let weight = (1.0 - along) * (1.0 - along);
     let probe = clamp(uv + turn * reach * along, gfu.uInputClamp.xy, gfu.uInputClamp.zw);
 
@@ -18308,7 +18323,9 @@ const alphaDefaults = {
 * wide, that follows the shape: rounded corners stay rounded. Its alpha is
 * `strength × alpha ×` the share of the disc of radius `distance` around the pixel the view
 * covers, so `strength: 2` is full next to a straight edge and fades to nothing at `distance`.
-* The view is padded by its live `distance`. One render pass per apply.
+* It takes 64 to 256 probes, by radius in physical pixels: about 3.5 physical pixels apart up to
+* a radius of 32 physical pixels. The view is padded by its live `distance`. One render pass per
+* apply.
 *
 * @example
 * ```ts
@@ -30942,6 +30959,9 @@ function defineMotion(spec) {
 * | `@moku-labs/game/assets` | the build-time asset key scanner and the production packer (`packAssets`, `--pack <dir>`), node and bun only |
 * | `@moku-labs/game/inspect` | the editor's read door: `read`, `watch`, `defineSource`, the `sources` catalogue |
 * | `@moku-labs/game/control` | the editor's write door, dev builds only: `run`, `defineCommand`, the `commands` catalogue |
+* | `@moku-labs/game/jsx-runtime`, `/jsx-dev-runtime` | the JSX runtimes `jsxImportSource: "@moku-labs/game"` names |
+* | `@moku-labs/game/fonts/*` | the MSDF body font `font-body.fnt` + `.png` and its OFL licence; a game copies them into `features/ui/assets/` |
+* | bin `moku-game-assets` | the asset scanner CLI, bun only |
 *
 * @file The package root: the composed framework and its public exports.
 * @example

package/fonts/LICENSE.txt

@@ -0,0 +1,105 @@
+The MSDF body font of this folder is built from a Google Font released under the SIL Open Font
+License 1.1. The licence text follows.
+
+- font-body.fnt, font-body.png: Pangolin Regular (Pangolin-Regular.ttf).
+
+================================================================================
+
+Pangolin
+
+================================================================================
+
+
+Copyright 2016 The Pangolin Project Authors (https://github.com/googlefonts/pangolin)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.