@agent-native/toolkit 0.201.1 → 0.202.0-nightly-20261006033736

package/dist/app/shared/ocean/particles.wgsl

@@ -0,0 +1,139 @@
+struct ParticleUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewport: vec4f,
+  world: vec4f,
+  fade: vec4f,
+  oceanColor: vec4f,
+  neonColor: vec4f,
+  foamColor: vec4f,
+  cursor: vec4f,
+};
+
+struct VertexOut {
+  @builtin(position) position: vec4f,
+  @location(0) pointCoord: vec2f,
+  @location(1) foam: f32,
+  @location(2) normal: vec3f,
+  @location(3) viewDir: vec3f,
+  @location(4) height: f32,
+  @location(5) fade: f32,
+};
+
+@group(0) @binding(0) var<uniform> u: ParticleUniforms;
+@group(0) @binding(1) var u_displacement: texture_2d<f32>;
+@group(0) @binding(2) var u_normalFoam: texture_2d<f32>;
+
+fn particleHash(p: vec2u) -> f32 {
+  var n = p.x * 374761393u + p.y * 668265263u;
+  n = (n ^ (n >> 13u)) * 1274126177u;
+  n = n ^ (n >> 16u);
+  return f32(n) / 4294967295.0;
+}
+
+fn quadCorner(vertexIndex: u32) -> vec2f {
+  let cornerIndex = array<u32, 6>(0u, 1u, 2u, 2u, 1u, 3u)[vertexIndex % 6u];
+  switch (cornerIndex) {
+    case 0u: { return vec2f(-1.0, -1.0); }
+    case 1u: { return vec2f( 1.0, -1.0); }
+    case 2u: { return vec2f(-1.0,  1.0); }
+    default: { return vec2f( 1.0,  1.0); }
+  }
+}
+
+@vertex fn vs_main(
+  @builtin(vertex_index) vertexIndex: u32,
+  @builtin(instance_index) instanceIndex: u32,
+) -> VertexOut {
+  let resolution = max(1u, u32(u.viewport.w));
+  let i = instanceIndex % resolution;
+  let j = instanceIndex / resolution;
+  let particleRef = vec2f(f32(i), f32(j)) / f32(resolution);
+  let texCoord = vec2u(i, j);
+
+  let disp = textureLoad(u_displacement, texCoord, 0).xyz * u.world.y;
+  let nf = textureLoad(u_normalFoam, texCoord, 0);
+
+  let halfWorld = u.world.x * 0.5;
+  let base = vec3f(
+    particleRef.x * u.world.x - halfWorld,
+    0.0,
+    particleRef.y * u.world.x - halfWorld,
+  );
+  let pos = base + disp;
+
+  let mv = u.view * vec4f(pos, 1.0);
+  let viewDir = -mv.xyz;
+  let dist = -mv.z;
+  let f = 1.0 - smoothstep(u.fade.x, u.fade.y, dist);
+  let fade = pow(clamp(f, 0.0, 1.0), u.fade.z);
+
+  let projected = u.projection * mv;
+  var ndc = projected.xy / projected.w;
+
+  let aspect = u.viewport.x / max(u.viewport.y, 1.0);
+  if (u.cursor.z > 0.0) {
+    let cursorDelta = u.cursor.xy - ndc;
+    let fieldDelta = cursorDelta * vec2f(aspect, 1.0);
+    let cursorDistance = length(fieldDelta);
+    let rangeFalloff = 1.0 - smoothstep(0.0, 1.7, cursorDistance);
+    let particleId = vec2u(i, j);
+    let particleSeed = particleHash(particleId);
+    let detached = smoothstep(0.76, 0.998, particleSeed);
+    let phase = particleHash(particleId + vec2u(37u, 71u)) * 6.2831855;
+    let activity = 0.55 + 0.45 * (0.5 + 0.5 * sin(u.cursor.w * 0.45 + phase));
+    let trailProgress = clamp(cursorDistance / 1.7, 0.0, 1.0);
+    let trailWidth = mix(0.025, 0.28, trailProgress);
+    let jitter = vec2f(
+      particleHash(particleId + vec2u(17u, 53u)) - 0.5,
+      particleHash(particleId + vec2u(41u, 29u)) - 0.5,
+    ) * vec2f(trailWidth / aspect, trailWidth);
+    let nearFalloff = 1.0 - smoothstep(0.0, 1.0, cursorDistance);
+    let baselineResponse = mix(0.004, 0.014, nearFalloff) *
+      mix(0.6, 1.0, particleSeed);
+    let particleResponse = baselineResponse +
+      detached * activity * mix(0.11, 0.82, nearFalloff);
+    let attraction = rangeFalloff * particleResponse * u.cursor.z;
+    ndc += (u.cursor.xy + jitter - ndc) * attraction;
+  }
+
+  let corner = quadCorner(vertexIndex);
+  let pointSizePx = 2.0 * u.world.z * u.viewport.z;
+  let clipOffset = corner * (pointSizePx / u.viewport.xy) * projected.w;
+  let clip = vec4f(ndc * projected.w + clipOffset, projected.z, projected.w);
+
+  var out: VertexOut;
+  out.position = clip;
+  out.pointCoord = corner * 0.5 + vec2f(0.5);
+  out.foam = nf.w;
+  out.normal = nf.xyz;
+  out.viewDir = viewDir;
+  out.height = disp.y;
+  out.fade = fade;
+  return out;
+}
+
+@fragment fn fs_main(in: VertexOut) -> @location(0) vec4f {
+  let cc = in.pointCoord - vec2f(0.5);
+  let d2 = dot(cc, cc);
+  if (d2 > 0.25) {
+    discard;
+  }
+
+  let n = normalize(in.normal);
+  let v = normalize(in.viewDir);
+  let fresnel = pow(1.0 - clamp(dot(n, v), 0.0, 1.0), 5.0);
+
+  let foam = clamp(in.foam, 0.0, 1.0);
+  let crest = smoothstep(-0.5, 1.5, in.height);
+
+  var color = u.oceanColor.rgb * 0.5;
+  color += u.neonColor.rgb * crest * 0.5;
+  color += u.neonColor.rgb * fresnel * 0.15;
+  color = mix(color, u.foamColor.rgb, foam);
+  var alpha = 0.02 + crest * 0.06 + fresnel * 0.04;
+  alpha = mix(alpha, 1.0, foam);
+  color *= in.fade;
+  alpha *= in.fade;
+  return vec4f(color, clamp(alpha, 0.0, 1.0));
+}

package/dist/app/shared/ocean/particles.wgsl.js

@@ -0,0 +1 @@
+export default "struct ParticleUniforms {\n  view: mat4x4f,\n  projection: mat4x4f,\n  viewport: vec4f,\n  world: vec4f,\n  fade: vec4f,\n  oceanColor: vec4f,\n  neonColor: vec4f,\n  foamColor: vec4f,\n  cursor: vec4f,\n};\n\nstruct VertexOut {\n  @builtin(position) position: vec4f,\n  @location(0) pointCoord: vec2f,\n  @location(1) foam: f32,\n  @location(2) normal: vec3f,\n  @location(3) viewDir: vec3f,\n  @location(4) height: f32,\n  @location(5) fade: f32,\n};\n\n@group(0) @binding(0) var<uniform> u: ParticleUniforms;\n@group(0) @binding(1) var u_displacement: texture_2d<f32>;\n@group(0) @binding(2) var u_normalFoam: texture_2d<f32>;\n\nfn particleHash(p: vec2u) -> f32 {\n  var n = p.x * 374761393u + p.y * 668265263u;\n  n = (n ^ (n >> 13u)) * 1274126177u;\n  n = n ^ (n >> 16u);\n  return f32(n) / 4294967295.0;\n}\n\nfn quadCorner(vertexIndex: u32) -> vec2f {\n  let cornerIndex = array<u32, 6>(0u, 1u, 2u, 2u, 1u, 3u)[vertexIndex % 6u];\n  switch (cornerIndex) {\n    case 0u: { return vec2f(-1.0, -1.0); }\n    case 1u: { return vec2f( 1.0, -1.0); }\n    case 2u: { return vec2f(-1.0,  1.0); }\n    default: { return vec2f( 1.0,  1.0); }\n  }\n}\n\n@vertex fn vs_main(\n  @builtin(vertex_index) vertexIndex: u32,\n  @builtin(instance_index) instanceIndex: u32,\n) -> VertexOut {\n  let resolution = max(1u, u32(u.viewport.w));\n  let i = instanceIndex % resolution;\n  let j = instanceIndex / resolution;\n  let particleRef = vec2f(f32(i), f32(j)) / f32(resolution);\n  let texCoord = vec2u(i, j);\n\n  let disp = textureLoad(u_displacement, texCoord, 0).xyz * u.world.y;\n  let nf = textureLoad(u_normalFoam, texCoord, 0);\n\n  let halfWorld = u.world.x * 0.5;\n  let base = vec3f(\n    particleRef.x * u.world.x - halfWorld,\n    0.0,\n    particleRef.y * u.world.x - halfWorld,\n  );\n  let pos = base + disp;\n\n  let mv = u.view * vec4f(pos, 1.0);\n  let viewDir = -mv.xyz;\n  let dist = -mv.z;\n  let f = 1.0 - smoothstep(u.fade.x, u.fade.y, dist);\n  let fade = pow(clamp(f, 0.0, 1.0), u.fade.z);\n\n  let projected = u.projection * mv;\n  var ndc = projected.xy / projected.w;\n\n  let aspect = u.viewport.x / max(u.viewport.y, 1.0);\n  if (u.cursor.z > 0.0) {\n    let cursorDelta = u.cursor.xy - ndc;\n    let fieldDelta = cursorDelta * vec2f(aspect, 1.0);\n    let cursorDistance = length(fieldDelta);\n    let rangeFalloff = 1.0 - smoothstep(0.0, 1.7, cursorDistance);\n    let particleId = vec2u(i, j);\n    let particleSeed = particleHash(particleId);\n    let detached = smoothstep(0.76, 0.998, particleSeed);\n    let phase = particleHash(particleId + vec2u(37u, 71u)) * 6.2831855;\n    let activity = 0.55 + 0.45 * (0.5 + 0.5 * sin(u.cursor.w * 0.45 + phase));\n    let trailProgress = clamp(cursorDistance / 1.7, 0.0, 1.0);\n    let trailWidth = mix(0.025, 0.28, trailProgress);\n    let jitter = vec2f(\n      particleHash(particleId + vec2u(17u, 53u)) - 0.5,\n      particleHash(particleId + vec2u(41u, 29u)) - 0.5,\n    ) * vec2f(trailWidth / aspect, trailWidth);\n    let nearFalloff = 1.0 - smoothstep(0.0, 1.0, cursorDistance);\n    let baselineResponse = mix(0.004, 0.014, nearFalloff) *\n      mix(0.6, 1.0, particleSeed);\n    let particleResponse = baselineResponse +\n      detached * activity * mix(0.11, 0.82, nearFalloff);\n    let attraction = rangeFalloff * particleResponse * u.cursor.z;\n    ndc += (u.cursor.xy + jitter - ndc) * attraction;\n  }\n\n  let corner = quadCorner(vertexIndex);\n  let pointSizePx = 2.0 * u.world.z * u.viewport.z;\n  let clipOffset = corner * (pointSizePx / u.viewport.xy) * projected.w;\n  let clip = vec4f(ndc * projected.w + clipOffset, projected.z, projected.w);\n\n  var out: VertexOut;\n  out.position = clip;\n  out.pointCoord = corner * 0.5 + vec2f(0.5);\n  out.foam = nf.w;\n  out.normal = nf.xyz;\n  out.viewDir = viewDir;\n  out.height = disp.y;\n  out.fade = fade;\n  return out;\n}\n\n@fragment fn fs_main(in: VertexOut) -> @location(0) vec4f {\n  let cc = in.pointCoord - vec2f(0.5);\n  let d2 = dot(cc, cc);\n  if (d2 > 0.25) {\n    discard;\n  }\n\n  let n = normalize(in.normal);\n  let v = normalize(in.viewDir);\n  let fresnel = pow(1.0 - clamp(dot(n, v), 0.0, 1.0), 5.0);\n\n  let foam = clamp(in.foam, 0.0, 1.0);\n  let crest = smoothstep(-0.5, 1.5, in.height);\n\n  var color = u.oceanColor.rgb * 0.5;\n  color += u.neonColor.rgb * crest * 0.5;\n  color += u.neonColor.rgb * fresnel * 0.15;\n  color = mix(color, u.foamColor.rgb, foam);\n  var alpha = 0.02 + crest * 0.06 + fresnel * 0.04;\n  alpha = mix(alpha, 1.0, foam);\n  color *= in.fade;\n  alpha *= in.fade;\n  return vec4f(color, clamp(alpha, 0.0, 1.0));\n}\n";

package/dist/app/shared/ocean/present.wgsl

@@ -0,0 +1,40 @@
+struct PresentUniforms {
+  fgColor: vec4f,
+  bgColor: vec4f,
+
+  brightness: f32,
+  _pad: vec3f,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: PresentUniforms;
+@group(0) @binding(1) var sceneHDR: texture_2d<f32>;
+@group(0) @binding(2) var bloomTexture: texture_2d<f32>;
+@group(0) @binding(3) var linearSampler: sampler;
+
+fn LinearTosRGB(value: vec4f) -> vec4f {
+  let lt = value.rgb * 12.92;
+  let gt = 1.055 * pow(value.rgb, vec3f(0.41666)) - vec3f(0.055);
+  let rgb = select(gt, lt, value.rgb <= vec3f(0.0031308));
+  return vec4f(rgb, value.a);
+}
+
+@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let scene = textureSample(sceneHDR, linearSampler, uv);
+  let bloom = textureSample(bloomTexture, linearSampler, uv);
+  let hdr = scene.rgb + bloom.rgb;
+
+
+
+
+  let tone = clamp(dot(hdr, vec3f(0.2126, 0.7152, 0.0722)), 0.0, 1.0);
+
+
+
+
+
+  var color = mix(uniforms.bgColor.rgb, uniforms.fgColor.rgb, tone);
+  color += (uniforms.fgColor.rgb - uniforms.bgColor.rgb) * tone * tone
+    * (uniforms.brightness - 1.0);
+
+  return LinearTosRGB(vec4f(clamp(color, vec3f(0.0), vec3f(1.0)), 1.0));
+}

package/dist/app/shared/ocean/present.wgsl.js

@@ -0,0 +1 @@
+export default "struct PresentUniforms {\n  fgColor: vec4f,\n  bgColor: vec4f,\n\n  brightness: f32,\n  _pad: vec3f,\n};\n\n@group(0) @binding(0) var<uniform> uniforms: PresentUniforms;\n@group(0) @binding(1) var sceneHDR: texture_2d<f32>;\n@group(0) @binding(2) var bloomTexture: texture_2d<f32>;\n@group(0) @binding(3) var linearSampler: sampler;\n\nfn LinearTosRGB(value: vec4f) -> vec4f {\n  let lt = value.rgb * 12.92;\n  let gt = 1.055 * pow(value.rgb, vec3f(0.41666)) - vec3f(0.055);\n  let rgb = select(gt, lt, value.rgb <= vec3f(0.0031308));\n  return vec4f(rgb, value.a);\n}\n\n@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let scene = textureSample(sceneHDR, linearSampler, uv);\n  let bloom = textureSample(bloomTexture, linearSampler, uv);\n  let hdr = scene.rgb + bloom.rgb;\n\n\n\n\n  let tone = clamp(dot(hdr, vec3f(0.2126, 0.7152, 0.0722)), 0.0, 1.0);\n\n\n\n\n\n  var color = mix(uniforms.bgColor.rgb, uniforms.fgColor.rgb, tone);\n  color += (uniforms.fgColor.rgb - uniforms.bgColor.rgb) * tone * tone\n    * (uniforms.brightness - 1.0);\n\n  return LinearTosRGB(vec4f(clamp(color, vec3f(0.0), vec3f(1.0)), 1.0));\n}\n";

package/dist/app/shared/ocean/renderer.d.ts

@@ -0,0 +1,66 @@
+import { type Draw, type Effect, type Frame, type Gpu, type Surface, type Target } from "vgpu";
+import { type OceanColors } from "./ocean-colors.js";
+import { type IfftStage } from "./ocean-graph.js";
+type Output = Surface | Target;
+interface RendererOptions {
+    readonly canvas: HTMLCanvasElement;
+    readonly colors?: OceanColors;
+    readonly fps?: number;
+    readonly onError?: (error: unknown) => void;
+}
+type PointerTarget = readonly [number, number, number];
+export declare function createRenderer({ canvas, colors, fps, onError, }: RendererOptions): {
+    ready: Promise<void>;
+    firstFrame: Promise<void>;
+    dispose: () => void;
+    setColors: (next: OceanColors) => void;
+    setPaused: (next: boolean) => void;
+    setPointer: (next: PointerTarget) => void;
+};
+export type OceanRenderer = ReturnType<typeof createRenderer>;
+export declare function createGraph(gpu: Gpu, output: Output, label: string, colors?: OceanColors): Promise<OceanGraph>;
+declare function buildGraph(gpu: Gpu, output: Output, label: string, colors: OceanColors, own: (value: Target) => Target): {
+    simulation: {
+        noise: Target;
+        h0: Target;
+        spectrum: Target;
+        ping: Target;
+        pong: Target;
+        normalFoam: Target;
+    };
+    scene: Target;
+    bloom: {
+        bright: Target;
+        composite: Target;
+        levels: {
+            horizontal: Target;
+            vertical: Target;
+            horizontalEffect: Effect;
+            verticalEffect: Effect;
+        }[];
+    };
+    effects: {
+        noise: Effect;
+        initialSpectrum: Effect;
+        evolveSpectrum: Effect;
+        normals: Effect;
+        bright: Effect;
+        composite: Effect;
+        present: Effect;
+    };
+    ifft: {
+        spec: IfftStage;
+        effect: Effect;
+        output: Target;
+    }[];
+    particles: Draw;
+    needsInitialSpectrum: boolean;
+};
+export type OceanGraph = ReturnType<typeof buildGraph>;
+export declare function setPresentColors(graph: OceanGraph, colors: OceanColors): void;
+export declare function renderAt(gpu: Gpu, graph: OceanGraph, output: Target, time: number): void;
+export declare function renderGraph(currentFrame: Frame, graph: OceanGraph, output: Output): void;
+export declare function bloomSizes(size: readonly [number, number]): [number, number][];
+export declare function destroyGraph(graph: OceanGraph): void;
+export {};
+//# sourceMappingURL=renderer.d.ts.map

package/dist/app/shared/ocean/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../../src/app/shared/ocean/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,KAAK,EAEV,KAAK,GAAG,EAER,KAAK,OAAO,EACZ,KAAK,MAAM,EACZ,MAAM,MAAM,CAAC;AAUd,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE3E,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAW1B,KAAK,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE/B,UAAU,eAAe;IACvB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,KAAK,aAAa,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AASvD,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,MAAM,EACN,GAAG,EACH,OAAO,GACR,EAAE,eAAe;;;mBA2BI,IAAI;sBAkKC,WAAW,KAAG,IAAI;sBApBlB,OAAO,KAAG,IAAI;uBAeb,aAAa,KAAG,IAAI;EAY/C;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAE9D,wBAAsB,WAAW,CAC/B,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,WAAkC,GACzC,OAAO,CAAC,UAAU,CAAC,CAiBrB;AAED,iBAAS,UAAU,CACjB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiM/B;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAuEvD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAE7E;AAoCD,wBAAgB,QAAQ,CACtB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,IAAI,CAGN;AAED,wBAAgB,WAAW,CACzB,YAAY,EAAE,KAAK,EACnB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,GACb,IAAI,CAuBN;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CASpB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAWpD"}