first pass

renderer.js

@@ -0,0 +1,155 @@
+// renderer.js
+import {mat4Identity, mat4Multiply, mat4Ortho, mat4LookAt} from './math.js';
+
+const VS_SRC = `#version 300 es
+layout(location=0) in vec3 a_position;
+layout(location=1) in vec3 a_normal;
+layout(location=2) in vec2 a_uv;
+layout(location=3) in float a_tint;
+
+// Instanced attributes
+layout(location=4) in mat4 i_matrix;
+layout(location=8) in vec3 i_color;
+
+uniform mat4 u_viewProj;
+uniform vec3 u_lightDir;
+
+out vec2 v_uv;
+out float v_light;
+out vec3 v_color;
+
+void main() {
+    gl_Position = u_viewProj * i_matrix * vec4(a_position, 1.0);
+    v_uv = a_uv;
+
+    // Apply geometry transform to normals for accurate lighting
+    vec3 normal = normalize(mat3(i_matrix) * a_normal);
+    
+    // Simple Lambertian lighting with ambient base
+    v_light = max(dot(normal, normalize(u_lightDir)), 0.0) * 0.6 + 0.4;
+    v_color = mix(vec3(1.0), i_color, a_tint); // Blend tint if face is tintable
+}
+`;
+
+const FS_SRC = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+in float v_light;
+in vec3 v_color;
+
+uniform sampler2D u_texture;
+
+out vec4 fragColor;
+
+void main() {
+    vec4 texColor = texture(u_texture, v_uv);
+    if (texColor.a < 0.1) discard; // Alpha test for foliage/glass
+    
+    fragColor = vec4(texColor.rgb * v_color * v_light, texColor.a);
+}
+`;
+
+function compileShader(gl, type, src) {
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        throw new Error(gl.getShaderInfoLog(shader));
+    }
+    return shader;
+}
+
+export class Renderer {
+    constructor(canvas) {
+        this.gl = canvas.getContext('webgl2', {antialias: true});
+        if (!this.gl) throw new Error("WebGL2 not supported");
+
+        const gl = this.gl;
+        gl.enable(gl.DEPTH_TEST);
+        gl.enable(gl.CULL_FACE); // Minecraft culls inside faces
+
+        // Compile Program
+        const vs = compileShader(gl, gl.VERTEX_SHADER, VS_SRC);
+        const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_SRC);
+        this.program = gl.createProgram();
+        gl.attachShader(this.program, vs);
+        gl.attachShader(this.program, fs);
+        gl.linkProgram(this.program);
+        if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+            throw new Error(gl.getProgramInfoLog(this.program));
+        }
+
+        this.uniforms = {
+            viewProj: gl.getUniformLocation(this.program, "u_viewProj"),
+            lightDir: gl.getUniformLocation(this.program, "u_lightDir"),
+            texture: gl.getUniformLocation(this.program, "u_texture")
+        };
+
+        this.atlasTexture = gl.createTexture();
+    }
+
+    updateAtlas(canvasAtlas) {
+        const gl = this.gl;
+        gl.bindTexture(gl.TEXTURE_2D, this.atlasTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, canvasAtlas);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    }
+
+    createModelBuffer(geometry) {
+        const gl = this.gl;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+
+        const bindAttr = (loc, data, size) => {
+            const buffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+            gl.enableVertexAttribArray(loc);
+            gl.vertexAttribPointer(loc, size, gl.FLOAT, false, 0, 0);
+        };
+
+        bindAttr(0, geometry.positions, 3);
+        bindAttr(1, geometry.normals, 3);
+        bindAttr(2, geometry.uvs, 2);
+        bindAttr(3, geometry.tints, 1);
+
+        const ebo = gl.createBuffer();
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, geometry.indices, gl.STATIC_DRAW);
+
+        gl.bindVertexArray(null);
+        return {vao, indexCount: geometry.indices.length};
+    }
+
+    drawSingleInstance(modelBuffer, viewProjMatrix, modelMatrix) {
+        const gl = this.gl;
+        gl.useProgram(this.program);
+
+        gl.uniformMatrix4fv(this.uniforms.viewProj, false, viewProjMatrix);
+        gl.uniform3f(this.uniforms.lightDir, 1.0, 2.0, 0.5);
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.atlasTexture);
+        gl.uniform1i(this.uniforms.texture, 0);
+
+        gl.bindVertexArray(modelBuffer.vao);
+
+        gl.disableVertexAttribArray(4);
+        gl.disableVertexAttribArray(5);
+        gl.disableVertexAttribArray(6);
+        gl.disableVertexAttribArray(7);
+        gl.disableVertexAttribArray(8);
+
+        // Push the calculated model matrix into the instanced attributes manually
+        gl.vertexAttrib4f(4, modelMatrix[0], modelMatrix[1], modelMatrix[2], modelMatrix[3]);
+        gl.vertexAttrib4f(5, modelMatrix[4], modelMatrix[5], modelMatrix[6], modelMatrix[7]);
+        gl.vertexAttrib4f(6, modelMatrix[8], modelMatrix[9], modelMatrix[10], modelMatrix[11]);
+        gl.vertexAttrib4f(7, modelMatrix[12], modelMatrix[13], modelMatrix[14], modelMatrix[15]);
+
+        gl.vertexAttrib3f(8, 1, 1, 1); // White tint
+
+        gl.drawElements(gl.TRIANGLES, modelBuffer.indexCount, gl.UNSIGNED_SHORT, 0);
+    }
+}