@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/perf-benchmark.mjs

@@ -217,6 +217,399 @@ export const DEFAULT_PERF_SCENES = [
       };
     `,
   },
+  {
+    id: 'native_2d_flagship_stress',
+    lane: 'stage183-native-2d',
+    surfaceTags: [
+      'tilemap-mutation',
+      'tilemap-query',
+      'render-targets',
+      'draw2d-compositor',
+      'particles',
+      'runtime-inspector',
+    ],
+    frames: 360,
+    source: `
+      let image = null;
+      let mapId = 0;
+      let worldTarget = null;
+      let lightTarget = null;
+      let finalTarget = null;
+      let elapsed = 0;
+      let frameIndex = 0;
+      let canUseParticles = false;
+      let lastStats = null;
+      const agents = [];
+      const coverCells = [];
+      const fallbackParticles = [];
+      const brokenCover = new Set();
+
+      function keyForCell(x, y) {
+        return x + ':' + y;
+      }
+
+      function buildMap() {
+        const width = 48;
+        const height = 32;
+        const tileCount = width * height;
+        const ground = Array.from({ length: tileCount }, () => 1);
+        const cover = Array.from({ length: tileCount }, () => 0);
+        const hazards = Array.from({ length: tileCount }, () => 0);
+
+        for (let y = 4; y < height - 4; y += 4) {
+          for (let x = 6; x < width - 6; x += 6) {
+            const coverIndex = (y * width) + x;
+            cover[coverIndex] = 1;
+            coverCells.push({ x, y });
+
+            const neighborX = Math.min(width - 1, x + 1);
+            const neighborIndex = (y * width) + neighborX;
+            cover[neighborIndex] = 1;
+            coverCells.push({ x: neighborX, y });
+          }
+        }
+
+        for (let x = 3; x < width - 3; x += 5) {
+          const y = 14 + ((Math.floor(x / 5)) % 5);
+          const index = (y * width) + x;
+          hazards[index] = 1;
+        }
+
+        return aura.tilemap.import({
+          width,
+          height,
+          tilewidth: 16,
+          tileheight: 16,
+          solidLayerNames: ['cover', 'hazards'],
+          layers: [
+            { name: 'ground', type: 'tilelayer', width, height, data: ground },
+            { name: 'cover', type: 'tilelayer', width, height, data: cover, properties: { solid: true } },
+            { name: 'hazards', type: 'tilelayer', width, height, data: hazards, properties: { solid: true } },
+          ],
+          tilesets: [
+            { firstgid: 1, image: 'player.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 },
+          ],
+        });
+      }
+
+      function seedAgents() {
+        for (let i = 0; i < 96; i += 1) {
+          agents.push({
+            x: 72 + ((i % 16) * 34),
+            y: 56 + (Math.floor(i / 16) * 28),
+            heading: (i * 0.37) % (Math.PI * 2),
+            speed: 26 + ((i % 7) * 4),
+            phase: i * 0.21,
+            radius: 6 + (i % 4),
+            hue: (i % 5) / 5,
+          });
+        }
+      }
+
+      function seedParticles() {
+        canUseParticles = !!(
+          aura.particles
+          && typeof aura.particles.emit === 'function'
+          && typeof aura.particles.update === 'function'
+          && typeof aura.particles.draw === 'function'
+        );
+
+        if (canUseParticles) {
+          for (let i = 0; i < 6; i += 1) {
+            const emitter = aura.particles.emit({
+              x: 92 + (i * 96),
+              y: 86 + ((i % 3) * 54),
+              count: 18,
+              life: 0.9,
+              size: 2,
+              speedMin: 16,
+              speedMax: 28,
+              direction: i * 0.31,
+              spread: 0.9,
+              loop: true,
+              rate: 24,
+            });
+            if (emitter?.emitterId && typeof aura.particles.setLayer === 'function') {
+              aura.particles.setLayer(emitter.emitterId, 2);
+            }
+            if (emitter?.emitterId && typeof aura.particles.setBlend === 'function') {
+              aura.particles.setBlend(emitter.emitterId, 'add');
+            }
+          }
+          return;
+        }
+
+        for (let i = 0; i < 96; i += 1) {
+          fallbackParticles.push({
+            originX: 84 + ((i % 12) * 44),
+            originY: 80 + (Math.floor(i / 12) * 22),
+            phase: i * 0.17,
+            radius: 4 + ((i % 5) * 2),
+            speed: 0.8 + ((i % 7) * 0.12),
+          });
+        }
+      }
+
+      function mutateTilemap() {
+        if (!mapId || !aura.tilemap || typeof aura.tilemap.setTile !== 'function') {
+          return;
+        }
+
+        const baseIndex = (frameIndex * 5) % coverCells.length;
+        for (let i = 0; i < 4; i += 1) {
+          const cell = coverCells[(baseIndex + (i * 11)) % coverCells.length];
+          const cellKey = keyForCell(cell.x, cell.y);
+          const shouldBreak = ((Math.floor(frameIndex / 18) + i) % 2) === 0;
+          if (shouldBreak && !brokenCover.has(cellKey)) {
+            aura.tilemap.setTile(mapId, 'cover', { x: cell.x, y: cell.y }, 0);
+            if (typeof aura.tilemap.setTileCollision === 'function') {
+              aura.tilemap.setTileCollision(mapId, 'cover', { x: cell.x, y: cell.y }, false);
+            }
+            brokenCover.add(cellKey);
+            continue;
+          }
+          if (!shouldBreak && brokenCover.has(cellKey)) {
+            aura.tilemap.setTile(mapId, 'cover', { x: cell.x, y: cell.y }, 1);
+            if (typeof aura.tilemap.setTileCollision === 'function') {
+              aura.tilemap.setTileCollision(mapId, 'cover', { x: cell.x, y: cell.y }, true);
+            }
+            brokenCover.delete(cellKey);
+          }
+        }
+
+        if ((frameIndex % 72) === 0 && typeof aura.tilemap.removeRegion === 'function') {
+          const column = 8 + (Math.floor(frameIndex / 72) % 8) * 4;
+          aura.tilemap.removeRegion(mapId, 'hazards', {
+            x: column,
+            y: 14,
+            w: 2,
+            h: 2,
+          });
+        }
+      }
+
+      function worldCamera() {
+        return {
+          x: 72 + ((Math.sin(elapsed * 0.6) + 1) * 76),
+          y: 42 + ((Math.cos(elapsed * 0.4) + 1) * 54),
+          width: 320,
+          height: 208,
+        };
+      }
+
+      function drawAgent(agent, options = {}) {
+        const width = 12 + (agent.radius * 2);
+        const height = 12 + (agent.radius * 2);
+        const tint = options.tint || aura.rgba(
+          0.35 + (agent.hue * 0.45),
+          0.75,
+          1,
+          options.alpha ?? 0.92,
+        );
+
+        if (image) {
+          aura.draw2d.image(image, agent.x, agent.y, {
+            width,
+            height,
+            originX: 0.5,
+            originY: 0.5,
+            rotation: agent.heading,
+            tint,
+            alpha: options.alpha ?? 0.92,
+          });
+          return;
+        }
+
+        aura.draw2d.circle(agent.x, agent.y, agent.radius, tint);
+      }
+
+      function drawFallbackParticles() {
+        for (let i = 0; i < fallbackParticles.length; i += 1) {
+          const particle = fallbackParticles[i];
+          const theta = (elapsed * particle.speed * 2.2) + particle.phase;
+          aura.draw2d.circle(
+            particle.originX + Math.cos(theta) * particle.radius,
+            particle.originY + Math.sin(theta * 1.4) * particle.radius,
+            2,
+            aura.rgba(0.78, 0.9, 1, 0.72),
+          );
+        }
+      }
+
+      function drawWorldStage() {
+        aura.draw2d.clear(2, 4, 8, 1);
+        aura.tilemap.draw(mapId, { camera: worldCamera() });
+
+        for (let i = 0; i < agents.length; i += 1) {
+          drawAgent(agents[i]);
+        }
+
+        if (canUseParticles) {
+          aura.particles.draw({ maxParticles: 768 });
+        } else {
+          drawFallbackParticles();
+        }
+      }
+
+      function drawLightStage(source) {
+        aura.draw2d.clear(0, 0, 0, 0);
+        aura.draw2d.sprite(source, 0, 0, { width: 384, height: 256 });
+        for (let i = 0; i < agents.length; i += 8) {
+          const agent = agents[i];
+          aura.draw2d.circleFill(
+            agent.x,
+            agent.y,
+            18 + (Math.sin(elapsed * 3 + agent.phase) * 3),
+            aura.rgba(0.2, 0.85, 1, 0.12),
+          );
+        }
+        aura.draw2d.tileSprite(source, 0, 0, 384, 256, {
+          tileScaleX: 1.2,
+          tileScaleY: 1.2,
+          tileOffsetX: elapsed * 38,
+          tileOffsetY: elapsed * 22,
+          tint: aura.rgba(0.06, 0.12, 0.18, 0.24),
+        });
+      }
+
+      function drawFinalStage(worldSource, lightSource) {
+        aura.draw2d.clear(0, 0, 0, 0);
+        aura.draw2d.sprite(worldSource, 0, 0, { width: 384, height: 256 });
+        aura.draw2d.sprite(lightSource, 0, 0, { width: 384, height: 256, alpha: 0.94 });
+        aura.draw2d.rectFill(10, 10, 196, 28, aura.rgba(0.04, 0.07, 0.12, 0.84));
+        const particles = Number(lastStats?.phase2?.particles?.active || 0);
+        const tilemaps = Number(lastStats?.phase2?.tilemap?.active || 0);
+        const compositor = Number(lastStats?.draw2dRuntime?.compositor?.knownGraphCount || 0);
+        aura.draw2d.text(
+          '2D FLAGSHIP ' + particles + 'P ' + tilemaps + 'T ' + compositor + 'G',
+          18,
+          20,
+          { size: 12, color: aura.colors.white },
+        );
+        aura.draw2d.text(
+          'frame ' + frameIndex + ' cover ' + brokenCover.size,
+          18,
+          34,
+          { size: 10, color: aura.colors.white },
+        );
+      }
+
+      aura.setup = function () {
+        image = aura.assets.image('player.png');
+        mapId = buildMap();
+        worldTarget = aura.draw2d.createRenderTarget(384, 256);
+        lightTarget = aura.draw2d.createRenderTarget(384, 256);
+        finalTarget = aura.draw2d.createRenderTarget(384, 256);
+        seedAgents();
+        seedParticles();
+      };
+
+      aura.update = function (dt) {
+        elapsed += dt;
+        frameIndex += 1;
+        mutateTilemap();
+        if (canUseParticles) {
+          aura.particles.update(dt);
+        }
+        lastStats = typeof aura.debug?.inspectorStats === 'function'
+          ? aura.debug.inspectorStats()
+          : null;
+
+        for (let i = 0; i < agents.length; i += 1) {
+          const agent = agents[i];
+          const theta = (elapsed * (0.9 + ((i % 5) * 0.14))) + agent.phase;
+          const dx = Math.cos(theta) * agent.speed * dt;
+          const dy = Math.sin(theta * 1.2) * agent.speed * dt;
+          const nextX = agent.x + dx;
+          const nextY = agent.y + dy;
+          const ahead = aura.tilemap.queryPoint(mapId, { x: nextX, y: nextY });
+          const sweep = aura.tilemap.queryAABB(mapId, {
+            x: nextX - agent.radius,
+            y: nextY - agent.radius,
+            w: agent.radius * 2,
+            h: agent.radius * 2,
+          });
+          const ray = aura.tilemap.queryRay(mapId, {
+            x: agent.x,
+            y: agent.y,
+            dx: Math.cos(agent.heading),
+            dy: Math.sin(agent.heading),
+            maxDistance: 22,
+          });
+
+          if (ahead?.hit || sweep?.hit || ray?.hit) {
+            agent.heading += 1.2 + ((i % 3) * 0.3);
+          } else {
+            agent.x = nextX;
+            agent.y = nextY;
+            agent.heading = theta;
+          }
+
+          if (agent.x < 24) agent.x = 24;
+          if (agent.y < 24) agent.y = 24;
+          if (agent.x > 740) agent.x = 740;
+          if (agent.y > 500) agent.y = 500;
+        }
+      };
+
+      aura.draw = function () {
+        aura.draw2d.clear(3, 5, 9);
+
+        let composed = finalTarget;
+
+        if (typeof aura.draw2d.runCompositorGraph === 'function') {
+          const graph = aura.draw2d.runCompositorGraph('perf-native-2d-flagship', [
+            { id: 'world', target: worldTarget, draw: drawWorldStage },
+            {
+              id: 'light',
+              target: lightTarget,
+              draw: () => drawLightStage({
+                type: 'compositorStage',
+                graph: 'perf-native-2d-flagship',
+                stage: 'world',
+              }),
+            },
+            {
+              id: 'final',
+              target: finalTarget,
+              draw: () => drawFinalStage(
+                {
+                  type: 'compositorStage',
+                  graph: 'perf-native-2d-flagship',
+                  stage: 'world',
+                },
+                {
+                  type: 'compositorStage',
+                  graph: 'perf-native-2d-flagship',
+                  stage: 'light',
+                },
+              ),
+            },
+          ]);
+          if (graph?.ok === true && Array.isArray(graph.stages) && graph.stages.length === 3) {
+            composed = graph.stages[2];
+          }
+        } else {
+          drawWorldStage();
+          return;
+        }
+
+        aura.draw2d.sprite(composed, 16, 16, {
+          width: 704,
+          height: 440,
+        });
+        aura.draw2d.sprite(composed, 744, 56, {
+          width: 256,
+          height: 160,
+          alpha: 0.88,
+        });
+        aura.draw2d.text('native_2d_flagship_stress', 748, 228, {
+          size: 11,
+          color: aura.colors.white,
+        });
+      };
+    `,
+  },
   {
     id: 'ui_composition_surface_stress',
     frames: 360,
@@ -910,16 +1303,24 @@ export async function runPerfBenchmarks(options = {}) {
   const sceneReports = [];
 
   for (const scene of scenes) {
-    const entryRelative = `src/${scene.id}.js`;
-    const entryAbsolute = resolve(workspaceRoot, entryRelative);
-    writeFileSync(entryAbsolute, scene.source.trimStart(), 'utf8');
+    const hasInlineSource = typeof scene.source === 'string' && scene.source.trim().length > 0;
+    const entryRelative = typeof scene.entryFile === 'string' && scene.entryFile.trim().length > 0
+      ? scene.entryFile.trim()
+      : `src/${scene.id}.js`;
+    const sceneProjectRoot = hasInlineSource
+      ? workspaceRoot
+      : resolve(scene.projectRoot || projectRoot);
+    if (hasInlineSource) {
+      const entryAbsolute = resolve(workspaceRoot, entryRelative);
+      writeFileSync(entryAbsolute, scene.source.trimStart(), 'utf8');
+    }
 
     const samplesMs = [];
 
     for (let run = 0; run < repeats; run += 1) {
       const started = process.hrtime.bigint();
       await runHeadlessTest({
-        projectRoot: workspaceRoot,
+        projectRoot: sceneProjectRoot,
         file: entryRelative,
         frames: scene.frames,
         width: scene.width ?? 1280,
@@ -945,6 +1346,9 @@ export async function runPerfBenchmarks(options = {}) {
       id: scene.id,
       scenario: scene.id,
       assetMode,
+      lane: typeof scene.lane === 'string' && scene.lane.trim().length > 0 ? scene.lane.trim() : null,
+      surfaceTags: Array.isArray(scene.surfaceTags) ? [...scene.surfaceTags] : [],
+      sourceMode: hasInlineSource ? 'synthetic-source' : 'authored-entry',
       frames: scene.frames,
       repeats,
       frameTimeSamplesMs: frameTimes,