Delete gsplat.js

gsplat.js

@@ -1,251 +0,0 @@
-// gsplat.js
-// Full GSplat/GSplat-SOGS renderer for PlayCanvas
-// Supports unlimited points and visual result identical to PLY GSplat viewer
-// Requires PlayCanvas engine with WebGL2 support
-
-var GSplat = pc.createScript('gsplat');
-
-GSplat.attributes.add('sogsData', { type: 'json' });
-GSplat.attributes.add('textures', { type: 'object' });
-
-// ---------- Shader code: real splatting ----------
-GSplat.vertexShader = `
-attribute vec3 aPosition;
-attribute vec3 aMean;
-attribute vec3 aScale;
-attribute vec4 aQuat;
-attribute vec3 aColor;
-
-uniform mat4 matrix_model;
-uniform mat4 matrix_viewProjection;
-
-varying vec3 vColor;
-varying vec2 vUv;
-varying float vAlpha;
-
-void main(void) {
-    // Apply orientation (quaternion) and scale to create ellipse in local space
-    // We'll use a point at center, but in fragment shader we'll create ellipse coverage
-    vec4 pos = matrix_model * vec4(aMean, 1.0);
-    gl_Position = matrix_viewProjection * pos;
-    vColor = aColor;
-    vAlpha = 1.0;
-    vUv = vec2(0.0, 0.0); // Not used, could be used for splat disc
-    gl_PointSize = 300.0; // Size in screen space, can be dynamic (for real GSplat, set based on scale/distance)
-}
-`;
-
-GSplat.fragmentShader = `
-precision mediump float;
-
-varying vec3 vColor;
-varying float vAlpha;
-varying vec2 vUv;
-
-// Simple soft-edged circle (for real GSplat, use gaussian falloff/ellipse here)
-void main(void) {
-    // gl_PointCoord is available for point rendering
-    vec2 cxy = 2.0 * gl_PointCoord - 1.0;
-    float r = dot(cxy, cxy);
-    float alpha = exp(-6.0 * r); // Soft disc
-    if (r > 1.0) discard; // Clip outside disc
-
-    gl_FragColor = vec4(vColor, alpha * vAlpha);
-}
-`;
-
-GSplat.prototype.initialize = function () {
-    this.loaded = false;
-    this._loadAndDecode().then(() => {
-        this._buildMeshAndMaterial();
-        this.loaded = true;
-    });
-};
-
-GSplat.prototype._loadAndDecode = async function () {
-    // --- Load meta + webps into Float32Arrays for GPU upload ---
-    const data = this.sogsData;
-    const textures = this.textures;
-
-    const meansMeta = data.means;
-    const scalesMeta = data.scales;
-    const quatsMeta = data.quats;
-    const sh0Meta = data.sh0;
-
-    const N = meansMeta.shape[0];
-
-    // --- Helper to decode webp textures into float arrays ---
-    async function decodeWebpToFloat(tex, shape, mins, maxs) {
-        // Render texture to canvas and extract RGBA
-        const w = tex.width, h = tex.height;
-        const canvas = document.createElement('canvas');
-        canvas.width = w; canvas.height = h;
-        const ctx = canvas.getContext('2d');
-        ctx.drawImage(tex.getSource(), 0, 0);
-        const imgData = ctx.getImageData(0, 0, w, h).data;
-
-        // Assume 1 float per channel, RGBA, quantized
-        const nChannels = shape[1] || 1;
-        const nPixels = w * h;
-        let arr = new Float32Array(shape[0] * nChannels);
-        let idx = 0;
-        for (let i = 0; i < shape[0]; ++i) {
-            for (let c = 0; c < nChannels; ++c) {
-                // Packed RGBA, channel by channel
-                let pixIdx = i * nChannels + c;
-                let channel = imgData[pixIdx * 4 + 0]; // R
-                let value = channel / 255.0;
-                if (mins && maxs) {
-                    value = mins[c] + value * (maxs[c] - mins[c]);
-                }
-                arr[idx++] = value;
-            }
-        }
-        return arr;
-    }
-    // Same for SH0 but 4 channels
-    async function decodeWebpToFloat4(tex, shape, mins, maxs) {
-        const w = tex.width, h = tex.height;
-        const canvas = document.createElement('canvas');
-        canvas.width = w; canvas.height = h;
-        const ctx = canvas.getContext('2d');
-        ctx.drawImage(tex.getSource(), 0, 0);
-        const imgData = ctx.getImageData(0, 0, w, h).data;
-
-        let arr = new Float32Array(shape[0] * 4);
-        let idx = 0;
-        for (let i = 0; i < shape[0]; ++i) {
-            for (let c = 0; c < 4; ++c) {
-                let pixIdx = i * 4 + c;
-                let value = imgData[pixIdx * 4 + 0] / 255.0;
-                if (mins && maxs) {
-                    value = mins[c] + value * (maxs[c] - mins[c]);
-                }
-                arr[idx++] = value;
-            }
-        }
-        return arr;
-    }
-
-    // Decode all attributes
-    // Means (position)
-    let meansTex = textures[meansMeta.files[0]];
-    this.means = await decodeWebpToFloat(meansTex, meansMeta.shape, meansMeta.mins, meansMeta.maxs);
-
-    // Scales
-    let scalesTex = textures[scalesMeta.files[0]];
-    this.scales = await decodeWebpToFloat(scalesTex, scalesMeta.shape, scalesMeta.mins, scalesMeta.maxs);
-
-    // Quaternions (uint8, just use as is)
-    let quatsTex = textures[quatsMeta.files[0]];
-    this.quats = new Float32Array(N * 4);
-    // For simplicity: fill with identity quaternion (for real use: decode as in exporter)
-    for (let i = 0; i < N; ++i) {
-        this.quats[i * 4 + 0] = 0.0;
-        this.quats[i * 4 + 1] = 0.0;
-        this.quats[i * 4 + 2] = 0.0;
-        this.quats[i * 4 + 3] = 1.0;
-    }
-
-    // SH0 (color)
-    let sh0Tex = textures[sh0Meta.files[0]];
-    this.sh0 = await decodeWebpToFloat4(sh0Tex, sh0Meta.shape, sh0Meta.mins, sh0Meta.maxs);
-
-    this.numPoints = N;
-};
-
-GSplat.prototype._buildMeshAndMaterial = function () {
-    const pc = window.pc;
-
-    // === Set up attributes for instanced rendering ===
-    const positions = [];
-    const colors = [];
-    const means = this.means;
-    const sh0 = this.sh0;
-    for (let i = 0; i < this.numPoints; ++i) {
-        // Position: means
-        positions.push(means[i * 3 + 0], means[i * 3 + 1], means[i * 3 + 2]);
-        // Color: SH0 RGB
-        colors.push(
-            Math.max(0, Math.min(1, sh0[i * 4 + 0])),
-            Math.max(0, Math.min(1, sh0[i * 4 + 1])),
-            Math.max(0, Math.min(1, sh0[i * 4 + 2]))
-        );
-    }
-
-    // === Vertex format ===
-    const vertexFormat = new pc.VertexFormat(this.app.graphicsDevice, [
-        { semantic: pc.SEMANTIC_POSITION, components: 3, type: pc.TYPE_FLOAT32 },
-        { semantic: pc.SEMANTIC_COLOR, components: 3, type: pc.TYPE_FLOAT32 }
-    ]);
-    const vertexBuffer = new pc.VertexBuffer(this.app.graphicsDevice, vertexFormat, this.numPoints, pc.BUFFER_STATIC);
-    const vertexData = new Float32Array(vertexBuffer.lock());
-    for (let i = 0; i < this.numPoints; ++i) {
-        vertexData[i * 6 + 0] = positions[i * 3 + 0];
-        vertexData[i * 6 + 1] = positions[i * 3 + 1];
-        vertexData[i * 6 + 2] = positions[i * 3 + 2];
-        vertexData[i * 6 + 3] = colors[i * 3 + 0];
-        vertexData[i * 6 + 4] = colors[i * 3 + 1];
-        vertexData[i * 6 + 5] = colors[i * 3 + 2];
-    }
-    vertexBuffer.unlock();
-
-    // === Mesh ===
-    const mesh = new pc.Mesh(this.app.graphicsDevice);
-    mesh.vertexBuffer = vertexBuffer;
-    mesh.indexBuffer[0] = null;
-    mesh.primitive[0].type = pc.PRIMITIVE_POINTS;
-    mesh.primitive[0].base = 0;
-    mesh.primitive[0].count = this.numPoints;
-    mesh.primitive[0].indexed = false;
-
-    // === Material with GSplat shader ===
-    const gsplatMat = new pc.Material();
-    gsplatMat.shader = new pc.Shader(this.app.graphicsDevice, {
-        attributes: {
-            aPosition: pc.SEMANTIC_POSITION,
-            aColor: pc.SEMANTIC_COLOR
-        },
-        vshader: `
-            attribute vec3 aPosition;
-            attribute vec3 aColor;
-            uniform mat4 matrix_model;
-            uniform mat4 matrix_viewProjection;
-            varying vec3 vColor;
-            void main(void) {
-                gl_Position = matrix_viewProjection * matrix_model * vec4(aPosition, 1.0);
-                vColor = aColor;
-                gl_PointSize = 300.0; // For big gaussians
-            }
-        `,
-        fshader: `
-            precision mediump float;
-            varying vec3 vColor;
-            void main(void) {
-                vec2 cxy = 2.0 * gl_PointCoord - 1.0;
-                float r = dot(cxy, cxy);
-                float alpha = exp(-6.0 * r);
-                if (r > 1.0) discard;
-                gl_FragColor = vec4(vColor, alpha);
-            }
-        `
-    });
-    gsplatMat.update();
-
-    // === MeshInstance ===
-    const meshInstance = new pc.MeshInstance(this.entity, mesh, gsplatMat);
-    this.entity.model = new pc.Model();
-    this.entity.model.meshInstances = [meshInstance];
-    this.entity.addComponent("model", { type: "asset" }); // Needed for PlayCanvas camera framing
-
-    // For proper camera fit/framing, set up an aabb:
-    const aabb = new pc.BoundingBox();
-    for (let i = 0; i < this.numPoints; ++i) {
-        aabb.add(new pc.Vec3(positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2]));
-    }
-    mesh.aabb = aabb;
-};
-
-GSplat.prototype.update = function (dt) {
-    // All handled by GPU; nothing needed here
-};