first pass

2026-07-03 22:04:34 -04:00
parent 2b1dd273b4
commit 2fa76da8bc
10973 changed files with 128242 additions and 0 deletions
--- a/index.html
+++ b/index.html
@@ -0,0 +1,156 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Pipeline Test</title>
+    <style>
+        body {
+            background: #222;
+            color: #eee;
+            font-family: monospace;
+            padding: 20px;
+        }
+
+        #canvas-container {
+            display: flex;
+            gap: 20px;
+            margin-top: 20px;
+        }
+
+        canvas {
+            border: 1px solid #444;
+        }
+
+        #webgl-canvas {
+            width: 512px;
+            height: 512px;
+        }
+    </style>
+</head>
+<body>
+<h2>Renderer Data Pipeline Prototype</h2>
+<div id="output">Loading and building geometry...</div>
+
+<div id="canvas-container">
+    <canvas id="webgl-canvas" width="1024" height="1024"></canvas>
+    <div id="atlas-container"></div>
+</div>
+
+<script type="module">
+    import {loadBlockstate, loadModel, TextureAtlas} from './assets.js';
+    import {resolveTexture, buildGeometry} from './geometry.js';
+    import {Renderer} from './renderer.js';
+    import {
+        mat4Identity,
+        mat4Ortho,
+        mat4LookAt,
+        mat4Multiply,
+        mat4Translate,
+        mat4RotateY
+    } from './math.js';
+
+    // Matches block properties against vanilla variant strings
+    function resolveVariant(blockstate, properties) {
+        const propStr = Object.keys(properties).sort().map(k => `${k}=${properties[k]}`).join(',');
+        let variantDef = blockstate.variants[propStr] || blockstate.variants[""];
+        return Array.isArray(variantDef) ? variantDef[0] : variantDef;
+    }
+
+    async function testPipeline() {
+        try {
+            const atlas = new TextureAtlas(512);
+            document.getElementById('atlas-container').appendChild(atlas.canvas);
+
+            const stateId = 'minecraft:repeater';
+            const state = await loadBlockstate(stateId);
+
+            const directions = ['north', 'east', 'south', 'west'];
+            const instancesToDraw = [];
+
+            // Generate a 4x4 grid covering all repeater states
+            for (let x = 0; x < 4; x++) {
+                for (let z = 0; z < 4; z++) {
+                    const props = {
+                        facing: directions[x],
+                        delay: (z + 1).toString(),
+                        locked: (x % 2 === 0).toString(),
+                        powered: (z % 2 === 0).toString()
+                    };
+
+                    const variant = resolveVariant(state, props);
+                    const model = await loadModel(variant.model);
+
+                    // Load textures
+                    for (const el of model.elements || []) {
+                        for (const face of Object.values(el.faces || {})) {
+                            const texPath = resolveTexture(model, face.texture);
+                            if (texPath) await atlas.load(texPath);
+                        }
+                    }
+
+                    // For now, we rebuild geometry per block.
+                    // Later, we will cache buffers by model ID.
+                    const geometry = buildGeometry(model, atlas);
+
+                    // Calculate instance matrix
+                    const matrix = mat4Identity(new Float32Array(16));
+
+                    // 1. Move to grid slot
+                    mat4Translate(matrix, matrix, [x * 1.5, 0, z * 1.5]);
+
+                    // 2. Minecraft rotates around block center (0.5, 0.5, 0.5)
+                    mat4Translate(matrix, matrix, [0.5, 0.5, 0.5]);
+                    if (variant.y) mat4RotateY(matrix, matrix, -variant.y * Math.PI / 180);
+                    mat4Translate(matrix, matrix, [-0.5, -0.5, -0.5]);
+
+                    instancesToDraw.push({geometry, matrix});
+                }
+            }
+
+            const webglCanvas = document.getElementById('webgl-canvas');
+            const renderer = new Renderer(webglCanvas);
+            renderer.updateAtlas(atlas.canvas);
+
+            // Convert raw geometries into WebGL VAOs
+            const buffers = instancesToDraw.map(inst => renderer.createModelBuffer(inst.geometry));
+
+            // Camera setup to fit the grid
+            const proj = new Float32Array(16);
+            const view = new Float32Array(16);
+            const viewProj = new Float32Array(16);
+
+            mat4Ortho(proj, -4, 4, -4, 4, -20, 20);
+            mat4LookAt(view,
+                8, 6, 8,         // Eye
+                2.25, 0, 2.25,   // Look at center of grid
+                0, 1, 0
+            );
+            mat4Multiply(viewProj, proj, view);
+
+            function render() {
+                const gl = renderer.gl;
+                gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
+                gl.clearColor(0.1, 0.1, 0.12, 1.0);
+                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+
+                for (let i = 0; i < instancesToDraw.length; i++) {
+                    renderer.drawSingleInstance(buffers[i], viewProj, instancesToDraw[i].matrix);
+                }
+
+                requestAnimationFrame(render);
+            }
+
+            render();
+
+            document.getElementById('output').innerHTML = `<strong>Repeater Stress Test Active</strong>`;
+
+        } catch (err) {
+            console.error(err);
+            document.getElementById('output').textContent = 'Error: ' + err.message;
+        }
+    }
+
+    testPipeline();
+</script>
+</body>
+</html>