hypercube-compute 2.0.0

package/src/addons/ocean-simulation/OceanWebGLRenderer.ts

@@ -0,0 +1,258 @@
+import { TriadeGrid } from '../../core/TriadeGrid';
+
+export class OceanWebGLRenderer {
+    private gl: WebGL2RenderingContext;
+    private program: WebGLProgram;
+    private indexCount: number = 0;
+
+    private texRho: WebGLTexture;
+    private texUx: WebGLTexture;
+    private texUy: WebGLTexture;
+    private texObst: WebGLTexture;
+
+    private globalW: number;
+    private globalH: number;
+    private chunkSize: number;
+
+    constructor(canvas: HTMLCanvasElement, cols: number, rows: number, chunkSize: number) {
+        this.chunkSize = chunkSize;
+        this.globalW = cols * chunkSize;
+        this.globalH = rows * chunkSize;
+
+        const gl = canvas.getContext('webgl2');
+        if (!gl) throw new Error("WebGL2 non supporté.");
+        this.gl = gl;
+
+        // Extensions pour Float32 Textures
+        this.gl.getExtension("EXT_color_buffer_float");
+        this.gl.getExtension("OES_texture_float_linear");
+
+        const vsSource = `#version 300 es
+        in vec2 a_position;
+        out vec2 v_uv;
+        out vec3 v_worldPos;
+        uniform sampler2D u_rho; // We sample density in Vertex Shader!
+        uniform sampler2D u_obst; // Also sample obstacles in Vertex Shader!
+        
+        void main() {
+            v_uv = a_position * 0.5 + 0.5;
+            v_uv.y = 1.0 - v_uv.y;
+            
+            // VTF: Vertex Texture Fetch (Real 3D heights from LBM Density)
+            float rho = texture(u_rho, v_uv).r;
+            float obst = texture(u_obst, v_uv).r;
+            float h = 0.0;
+            if (obst > 0.5) {
+                h = 5.0; // Island elevated plateau
+            } else {
+                h = (rho - 1.0) * 8.0; // Wave extrusion amplitude (softened)
+            }
+            
+            vec3 p = vec3(a_position.x, a_position.y, h);
+            v_worldPos = p;
+
+            // 3D Camera / Perspective Math
+            float angleX = -1.1; // Look down tilt
+            float cosX = cos(angleX);
+            float sinX = sin(angleX);
+            
+            // Apply Pitch rotation
+            float yRot = p.y * cosX - p.z * sinX;
+            float zRot = p.y * sinX + p.z * cosX;
+            
+            // Move camera back
+            zRot -= 2.2; 
+            
+            // Perspective projection
+            float fov = 1.7; 
+            gl_Position = vec4(p.x * fov, (yRot - 0.2) * fov, zRot, -zRot);
+        }`;
+
+        const fsSource = `#version 300 es
+        precision highp float;
+        precision highp sampler2D;
+        
+        in vec2 v_uv;
+        in vec3 v_worldPos;
+        uniform sampler2D u_rho; // LBM Density -> Heights
+        uniform sampler2D u_ux;
+        uniform sampler2D u_uy;
+        uniform sampler2D u_obst;
+
+        out vec4 outColor;
+        
+        void main() {
+            float obst = texture(u_obst, v_uv).r;
+            if (obst > 0.5) {
+                // Island material
+                vec3 islandTop = vec3(0.5, 0.6, 0.3); // Grass / Forest
+                vec3 islandSide = vec3(0.7, 0.6, 0.4); // Sand / Rock
+                
+                // Read local normals to detect cliffs
+                float oL = textureOffset(u_obst, v_uv, ivec2(-1, 0)).r;
+                float oR = textureOffset(u_obst, v_uv, ivec2(1, 0)).r;
+                float oB = textureOffset(u_obst, v_uv, ivec2(0, -1)).r;
+                float oT = textureOffset(u_obst, v_uv, ivec2(0, 1)).r;
+                float sumO = oL + oR + oB + oT;
+                
+                if (sumO < 3.5) {
+                    outColor = vec4(islandSide, 1.0); // Cliff / Beach
+                } else {
+                    outColor = vec4(islandTop, 1.0); // Plateau core
+                }
+                return;
+            }
+
+            // Sample density around the pixel to compute normal vector
+            float rL = textureOffset(u_rho, v_uv, ivec2(-1, 0)).r;
+            float rR = textureOffset(u_rho, v_uv, ivec2(1, 0)).r;
+            float rB = textureOffset(u_rho, v_uv, ivec2(0, -1)).r; // Inverted Y due to texture flip
+            float rT = textureOffset(u_rho, v_uv, ivec2(0, 1)).r;
+
+            // Generate Normal from heightmap (Density is height proxy)
+            float strength = 25.0; // Softened normals
+            vec3 normal = normalize(vec3((rL - rR) * strength, (rB - rT) * strength, 1.0));
+
+            // Lighting setup
+            vec3 lightDir = normalize(vec3(0.5, 0.8, 0.5)); // Sun angle
+            vec3 viewDir  = normalize(vec3(0.0, -0.6, 1.0)); // Looking at the water
+            
+            float ux = texture(u_ux, v_uv).r;
+            float uy = texture(u_uy, v_uv).r;
+            float speed = sqrt(ux*ux + uy*uy);
+
+            // Water Base Color based on speed (currents)
+            vec3 waterDeep = vec3(0.02, 0.2, 0.5);
+            vec3 waterShallow = vec3(0.0, 0.6, 0.9);
+            vec3 waterColor = mix(waterDeep, waterShallow, clamp(speed * 80.0, 0.0, 1.0));
+
+            // Diffuse Lighting (Lambert)
+            float diff = max(dot(normal, lightDir), 0.0);
+            vec3 diffuse = waterColor * (diff * 0.7 + 0.3); // + ambient
+
+            // Specular Lighting (Phong)
+            vec3 reflectDir = reflect(-lightDir, normal);
+            float spec = pow(max(dot(viewDir, reflectDir), 0.0), 48.0);
+            vec3 specular = vec3(1.0, 1.0, 1.0) * spec * 0.8;
+
+            // Foam based on density peaks (breaking waves)
+            float rho_center = texture(u_rho, v_uv).r;
+            float foam = (rho_center > 1.015) ? clamp((rho_center - 1.015) * 15.0, 0.0, 1.0) : 0.0;
+            
+            outColor = vec4(diffuse + specular + foam, 1.0);
+        }`;
+
+        this.program = this.createProgram(vsSource, fsSource);
+
+        // Generate 256x256 High-Res Grid Mesh for 3D displacement
+        const segments = 256;
+        const vertices = new Float32Array((segments + 1) * (segments + 1) * 2);
+        let ptr = 0;
+        for (let y = 0; y <= segments; y++) {
+            for (let x = 0; x <= segments; x++) {
+                vertices[ptr++] = (x / segments) * 2.0 - 1.0;
+                vertices[ptr++] = 1.0 - (y / segments) * 2.0;
+            }
+        }
+
+        const indices = new Uint32Array(segments * segments * 6);
+        let iPtr = 0;
+        for (let y = 0; y < segments; y++) {
+            for (let x = 0; x < segments; x++) {
+                const i = x + y * (segments + 1);
+                indices[iPtr++] = i;
+                indices[iPtr++] = i + 1;
+                indices[iPtr++] = i + segments + 1;
+                indices[iPtr++] = i + segments + 1;
+                indices[iPtr++] = i + 1;
+                indices[iPtr++] = i + segments + 2;
+            }
+        }
+        this.indexCount = indices.length;
+
+        const posBuf = this.gl.createBuffer();
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, posBuf);
+        this.gl.bufferData(this.gl.ARRAY_BUFFER, vertices, this.gl.STATIC_DRAW);
+
+        const indexBuf = this.gl.createBuffer()!;
+        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, indexBuf);
+        this.gl.bufferData(this.gl.ELEMENT_ARRAY_BUFFER, indices, this.gl.STATIC_DRAW);
+
+        this.texRho = this.createTexture();
+        this.texUx = this.createTexture();
+        this.texUy = this.createTexture();
+        this.texObst = this.createTexture();
+
+        this.gl.useProgram(this.program);
+        this.bindTextureUniform("u_rho", 0);
+        this.bindTextureUniform("u_ux", 1);
+        this.bindTextureUniform("u_uy", 2);
+        this.bindTextureUniform("u_obst", 3);
+
+        const posLoc = this.gl.getAttribLocation(this.program, "a_position");
+        this.gl.enableVertexAttribArray(posLoc);
+        this.gl.vertexAttribPointer(posLoc, 2, this.gl.FLOAT, false, 0, 0);
+    }
+
+    private createTexture() {
+        const tex = this.gl.createTexture()!;
+        this.gl.bindTexture(this.gl.TEXTURE_2D, tex);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR); // Linear for smoother visual
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+
+        // Allocate full global Toric map texture
+        this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.R32F, this.globalW, this.globalH, 0, this.gl.RED, this.gl.FLOAT, null);
+        return tex;
+    }
+
+    private bindTextureUniform(name: string, unit: number) {
+        const loc = this.gl.getUniformLocation(this.program, name);
+        this.gl.uniform1i(loc, unit);
+    }
+
+    private updateSubTexture(tex: WebGLTexture, unit: number, xOff: number, yOff: number, data: Float32Array) {
+        this.gl.activeTexture(this.gl.TEXTURE0 + unit);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, tex);
+        this.gl.texSubImage2D(this.gl.TEXTURE_2D, 0, xOff, yOff, this.chunkSize, this.chunkSize, this.gl.RED, this.gl.FLOAT, data);
+    }
+
+    public render(grid: TriadeGrid) {
+        this.gl.useProgram(this.program);
+
+        // Upload each chunk into the master textures using O(1) subset uploads
+        for (let y = 0; y < grid.rows; y++) {
+            for (let x = 0; x < grid.cols; x++) {
+                const cube = grid.cubes[y][x];
+                if (!cube) continue;
+
+                const xOff = x * this.chunkSize;
+                const yOff = y * this.chunkSize;
+
+                // Face mapping for OceanEngine (Rho = Face 20)
+                this.updateSubTexture(this.texRho, 0, xOff, yOff, cube.faces[20]);
+                this.updateSubTexture(this.texUx, 1, xOff, yOff, cube.faces[18]);
+                this.updateSubTexture(this.texUy, 2, xOff, yOff, cube.faces[19]);
+                this.updateSubTexture(this.texObst, 3, xOff, yOff, cube.faces[22]);
+            }
+        }
+
+        // Draw 3D Surface
+        this.gl.drawElements(this.gl.TRIANGLES, this.indexCount, this.gl.UNSIGNED_INT, 0);
+    }
+
+    private createProgram(vsSource: string, fsSource: string) {
+        const vs = this.gl.createShader(this.gl.VERTEX_SHADER)!;
+        this.gl.shaderSource(vs, vsSource);
+        this.gl.compileShader(vs);
+        const fs = this.gl.createShader(this.gl.FRAGMENT_SHADER)!;
+        this.gl.shaderSource(fs, fsSource);
+        this.gl.compileShader(fs);
+        const prog = this.gl.createProgram()!;
+        this.gl.attachShader(prog, vs);
+        this.gl.attachShader(prog, fs);
+        this.gl.linkProgram(prog);
+        return prog;
+    }
+}

package/src/addons/ocean-simulation/OceanWorld.ts

@@ -0,0 +1,280 @@
+import { TriadeMasterBuffer } from '../../core/TriadeMasterBuffer';
+import { TriadeGrid } from '../../core/TriadeGrid';
+import { OceanEngine } from './OceanEngine';
+
+export interface Boat {
+    x: number; // Global coordinates
+    y: number;
+    vx: number;
+    vy: number;
+    length: number;
+    angle: number;
+}
+
+export class OceanWorld {
+    public readonly cols: number;
+    public readonly rows: number;
+    public readonly chunkSize: number;
+    public readonly globalSizeW: number;
+    public readonly globalSizeH: number;
+
+    public grid: TriadeGrid;
+    public boats: Boat[] = [];
+    public keys = { up: false, down: false, left: false, right: false };
+
+    constructor(
+        masterBuffer: TriadeMasterBuffer,
+        cols: number = 2,
+        rows: number = 2,
+        chunkSize: number = 64
+    ) {
+        this.cols = cols;
+        this.rows = rows;
+        this.chunkSize = chunkSize;
+        this.globalSizeW = cols * chunkSize;
+        this.globalSizeH = rows * chunkSize;
+
+        // Create the TriadeGrid with continuous periodic boundaries
+        // 24 faces are required by OceanEngine (LBM D2Q9 + Macro + Bio)
+        this.grid = new TriadeGrid(cols, rows, chunkSize, masterBuffer, () => new OceanEngine(), 24, true);
+
+        this.reset();
+    }
+
+    public reset() {
+        const w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+
+        // Reset distributions and macros
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const cube = this.grid.cubes[y][x]!;
+                cube.faces[20].fill(1.0);     // rho = 1.0
+                cube.faces[18].fill(0.0);     // ux = 0
+                cube.faces[19].fill(0.0);     // uy = 0
+                for (let k = 0; k < 9; k++) {
+                    cube.faces[k].fill(w[k]); // w_k * rho (1.0)
+                    cube.faces[k + 9].fill(w[k]); // Init swap buffer too!
+                }
+            }
+        }
+
+        // Initialize Global Obstacles (Central Island)
+        const cx = this.globalSizeW / 2;
+        const cy = this.globalSizeH / 2;
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const cube = this.grid.cubes[y][x]!;
+                const obst = cube.faces[22];
+                obst.fill(0.0); // Reset all to water
+                for (let ly = 0; ly < this.chunkSize; ly++) {
+                    for (let lx = 0; lx < this.chunkSize; lx++) {
+                        const globalX = (x * this.chunkSize + lx);
+                        const globalY = (y * this.chunkSize + ly);
+                        const dx = globalX - cx;
+                        const dy = globalY - cy;
+                        // Island of radius 20
+                        if (dx * dx + dy * dy < 400) {
+                            obst[ly * this.chunkSize + lx] = 1.0;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Reset boats
+        for (let b of this.boats) {
+            b.x = 20; b.y = 20;
+            b.vx = 0; b.vy = 0;
+            b.angle = 0;
+        }
+
+        // Force sync once
+        this.grid.compute([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22]);
+    }
+
+    public addBoat(globalX: number, globalY: number, length: number = 20) {
+        this.boats.push({ x: globalX, y: globalY, vx: 0, vy: 0, length, angle: 0 });
+    }
+
+    public step() {
+        // 1. Math Step for all chunks + Boundary Exchange
+        // Synchronize LBM distributions [0..8], Bio data [21], AND Macros [18, 19, 20]
+        // Syncing Macros ensures the Boat doesn't read 0 velocity exactly on the boundary cell!
+        this.grid.compute([0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 19, 20, 21]);
+
+        // 2. Global Boat Physics
+        for (const boat of this.boats) {
+            // Find which chunk the boat is currently in
+            const gx = Math.floor(boat.x);
+            const gy = Math.floor(boat.y);
+
+            // Toric world wrap around
+            const safeGx = (gx + this.globalSizeW) % this.globalSizeW;
+            const safeGy = (gy + this.globalSizeH) % this.globalSizeH;
+
+            const chunkX = Math.floor(safeGx / this.chunkSize);
+            const chunkY = Math.floor(safeGy / this.chunkSize);
+            const localX = safeGx % this.chunkSize;
+            const localY = safeGy % this.chunkSize;
+
+            const cube = this.grid.cubes[chunkY][chunkX];
+            if (cube) {
+                // Read macro velocities from the localized chunk
+                const uxFace = cube.faces[18];
+                const uyFace = cube.faces[19];
+
+                const localIdx = localY * this.chunkSize + localX;
+                const fux = uxFace[localIdx];
+                const fuy = uyFace[localIdx];
+
+                // --- Player Controls (WASD / ZQSD) ---
+                const engineForce = 0.15;
+                const turnForce = 0.05;
+
+                if (this.keys.up) {
+                    boat.vx += Math.cos(boat.angle) * engineForce;
+                    boat.vy += Math.sin(boat.angle) * engineForce;
+                }
+                if (this.keys.down) {
+                    boat.vx -= Math.cos(boat.angle) * engineForce * 0.5;
+                    boat.vy -= Math.sin(boat.angle) * engineForce * 0.5;
+                }
+                if (this.keys.left) boat.angle -= turnForce;
+                if (this.keys.right) boat.angle += turnForce;
+
+                // Si le joueur ne contrôle pas, le moteur tourne au ralenti tout droit
+                if (!this.keys.up && !this.keys.down && !this.keys.left && !this.keys.right) {
+                    boat.vx += Math.cos(boat.angle) * 0.01;
+                    boat.vy += Math.sin(boat.angle) * 0.01;
+                }
+
+                // Advection: Boat is carried by ocean currents
+                boat.vx += fux * 0.25 - boat.vx * 0.05; // Force de l'eau + Friction hydrodynamique
+                boat.vy += fuy * 0.25 - boat.vy * 0.05;
+
+                // Move boat
+                boat.x += boat.vx;
+                boat.y += boat.vy;
+
+                // --- HARD LIMIT ON ISLAND COLLISION ---
+                // Island radius is approx 20. We stop the boat from entering.
+                let cDx = boat.x - this.globalSizeW / 2;
+                if (Math.abs(cDx) > this.globalSizeW / 2) cDx = cDx > 0 ? cDx - this.globalSizeW : cDx + this.globalSizeW;
+                let cDy = boat.y - this.globalSizeH / 2;
+                if (Math.abs(cDy) > this.globalSizeH / 2) cDy = cDy > 0 ? cDy - this.globalSizeH : cDy + this.globalSizeH;
+
+                const newDist = Math.sqrt(cDx * cDx + cDy * cDy);
+                const islandR = 24; // Buffer radius
+                if (newDist < islandR) {
+                    const angleFromIsland = Math.atan2(cDy, cDx);
+
+                    // Repulse strictly to the border of the island
+                    boat.x += Math.cos(angleFromIsland) * (islandR - newDist);
+                    boat.y += Math.sin(angleFromIsland) * (islandR - newDist);
+
+                    // Kill velocity
+                    boat.vx *= 0.1;
+                    boat.vy *= 0.1;
+                }
+
+                // Toric world wrap for exact coordinates
+                boat.x = (boat.x + this.globalSizeW) % this.globalSizeW;
+                boat.y = (boat.y + this.globalSizeH) % this.globalSizeH;
+
+                // Update orientation
+                if (Math.abs(boat.vx) > 0.01 || Math.abs(boat.vy) > 0.01) {
+                    boat.angle = Math.atan2(boat.vy, boat.vx);
+                }
+            }
+        }
+    }
+
+    // Paramètres Globaux du "Touilleur" (Tempête/Vortex)
+    public setVortexParams(strength: number, radius: number) {
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const engine = this.grid.cubes[y][x]?.engine as OceanEngine;
+                if (engine) {
+                    engine.params.vortexStrength = strength;
+                    engine.params.vortexRadius = radius;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper to render a specific chunk to an isolated Canvas Context
+     */
+    public renderChunk(chunkX: number, chunkY: number, ctx: CanvasRenderingContext2D, imageData: ImageData) {
+        const cube = this.grid.cubes[chunkY][chunkX];
+        if (!cube) return;
+
+        const size = this.chunkSize;
+        const bio = cube.faces[21];
+        const ux = cube.faces[18];
+        const uy = cube.faces[19];
+        const obst = cube.faces[22];
+        const data = imageData.data;
+
+        for (let i = 0; i < size * size; i++) {
+            const j = i * 4;
+            if (obst[i] > 0.5) {
+                data[j] = 20; data[j + 1] = 20; data[j + 2] = 40; data[j + 3] = 255;
+            } else {
+                const speed = Math.sqrt(ux[i] * ux[i] + uy[i] * uy[i]);
+                const intensity = speed * 1200;
+                data[j] = Math.min(255, bio[i] * 40 + intensity * 0.1);
+                data[j + 1] = Math.min(255, bio[i] * 120 + intensity * 0.4);
+                data[j + 2] = Math.min(255, intensity * 2.5 + 20);
+                data[j + 3] = 255;
+            }
+        }
+        ctx.putImageData(imageData, 0, 0);
+
+        // Draw boats that belong to THIS chunk
+        ctx.fillStyle = "#fff";
+        for (const boat of this.boats) {
+            // Check if boat is in this chunk visually
+            // (We convert global boat coords to local chunk coords to draw them relative to this Canvas)
+            const localBoatX = boat.x - chunkX * size;
+            const localBoatY = boat.y - chunkY * size;
+
+            // Simple culling (draw if it's within chunk bounds or slightly outside to handle edges)
+            if (localBoatX >= -boat.length && localBoatX <= size + boat.length &&
+                localBoatY >= -boat.length && localBoatY <= size + boat.length) {
+                ctx.save();
+                ctx.translate(localBoatX, localBoatY);
+                ctx.rotate(boat.angle);
+                ctx.fillRect(-boat.length / 2, -2, boat.length, 4);
+                ctx.restore();
+            }
+        }
+    }
+
+    // Interaction globally mapped
+    public setInteraction(globalX: number, globalY: number, active: boolean) {
+        const safeGx = (globalX + this.globalSizeW) % this.globalSizeW;
+        const safeGy = (globalY + this.globalSizeH) % this.globalSizeH;
+
+        const chunkX = Math.floor(safeGx / this.chunkSize);
+        const chunkY = Math.floor(safeGy / this.chunkSize);
+        const localX = safeGx % this.chunkSize;
+        const localY = safeGy % this.chunkSize;
+
+        // Reset all chunks interactions first to avoid "sticky" mouse
+        for (let y = 0; y < this.rows; y++) {
+            for (let x = 0; x < this.cols; x++) {
+                const engine = this.grid.cubes[y][x]?.engine as OceanEngine;
+                if (engine) engine.interaction.active = false;
+            }
+        }
+
+        const cube = this.grid.cubes[chunkY][chunkX];
+        if (cube) {
+            const engine = cube.engine as OceanEngine;
+            engine.interaction.mouseX = localX;
+            engine.interaction.mouseY = localY;
+            engine.interaction.active = active;
+        }
+    }
+}

package/src/core/TriadeCubeV2.ts

@@ -0,0 +1,58 @@
+import { TriadeMasterBuffer } from './TriadeMasterBuffer';
+import type { ITriadeEngine } from '../engines/ITriadeEngine';
+
+export class TriadeCubeV2 {
+    public readonly mapSize: number;
+    public readonly faces: Float32Array[] = [];
+    public readonly offset: number; // Added this property
+    public engine: ITriadeEngine | null = null;
+
+    /**
+     * @param mapSize La résolution (N x N)
+     * @param masterBuffer L'allocateur de RAM central de l'Orchestrateur
+     */
+    constructor(mapSize: number, masterBuffer: TriadeMasterBuffer, numFaces: number = 6) {
+        this.mapSize = mapSize;
+
+        // 1. Demander la réservation de l'espace sur la bande mémoire (O(1) Memory Layout)
+        this.offset = masterBuffer.allocateCube(mapSize, numFaces);
+
+        // 2. Création des Vues 
+        const floatCount = mapSize * mapSize;
+        const bytesPerFace = floatCount * Float32Array.BYTES_PER_ELEMENT;
+
+        // Génération des N "Views" mathématiques
+        for (let i = 0; i < numFaces; i++) {
+            this.faces.push(
+                new Float32Array(
+                    masterBuffer.buffer,
+                    this.offset + (i * bytesPerFace),
+                    floatCount
+                )
+            );
+        }
+    }
+
+    /**
+     * Injecte le cerveau mathématique dans ce paquet mémoire.
+     */
+    setEngine(engine: ITriadeEngine) {
+        this.engine = engine;
+    }
+
+    /**
+     * Exécute le calcul de la Frame (O1, Wavefront, Automates)
+     */
+    compute() {
+        if (!this.engine) {
+            console.warn("[TriadeCubeV2] Aucun Engine (Cerveau) n'a été assigné à ce cube.");
+            return;
+        }
+        this.engine.compute(this.faces, this.mapSize);
+    }
+
+    /** Helper pour vider une face spécifique */
+    clearFace(faceIndex: number) {
+        this.faces[faceIndex].fill(0);
+    }
+}