Datasets:

rcwang
/

for_elise

Tags:

License:

Dataset card Files Files and versions

xet

Community

for_elise / visualizer /static /js /vis.js

Relento

first commit.

ecd3201 about 2 years ago

Raw History Blame

23.2 kB

import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.153.0/build/three.module.js';
import {OrbitControls} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/controls/OrbitControls.js';
import {TrackballControls} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/controls/TrackballControls.js';
import {OBJLoader} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/loaders/OBJLoader.js';
import {MTLLoader} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/loaders/MTLLoader.js';
import {RGBELoader} from 'three/addons/loaders/RGBELoader.js';
import {GUI} from 'three/addons/libs/lil-gui.module.min.js';

// Get the audio element
const audioElement = document.getElementById("audio");
// Set the src of the audio element

const urlParams = new URLSearchParams(window.location.search);
let pieceId = parseInt(urlParams.get('id'));
if (!pieceId) {
    pieceId = 0;
}
console.log("Piece ID:", pieceId);
audioElement.src = `/audio/${pieceId}`;
let totalFrames = 0;
let totalDuration = -1;
let loadedFrames = 0;
let keyObjs = {};


document.getElementById('volumeControl').addEventListener('input', () => {
    audio.volume = volumeControl.value;
    if (audio.volume === 0) {
        volumeIcon.className = 'fas fa-volume-mute';  // Mute icon
    } else if (audio.volume <= 0.5) {
        volumeIcon.className = 'fas fa-volume-down';  // Lower volume icon
    } else {
        volumeIcon.className = 'fas fa-volume-up';  // Full volume icon
    }
});

async function fetchMetaData() {
    const url = `/metadata/${pieceId}`;
    // read the data from
    const response = await fetch(url);
    const jsonData = await response.json();  // Parse JSON response
    return jsonData;
}

async function fetchFacesData() {
    const url = `/mano_faces_data`;
    const response = await fetch(url);
    const jsonData = await response.json();
    return jsonData;
}

// Define IndexedDB setup
const dbName = "MeshFramesDB";
let db;

// Define an array of 2000 frames
let frames = new Array(2000);
// define preloadFrames
let preloadedFrames = {};
const preloadedWindowSize = 600;

// Function to preload a window of frames
async function preloadFramesAround(currentFrameIndex) {
    const startFrame = currentFrameIndex
    const endFrame = Math.min(totalFrames, currentFrameIndex + preloadedWindowSize);

    // Loop through the frames in the window and preload them
    for (let i = startFrame; i < endFrame; i++) {
        if (!preloadedFrames[i]) {  // If frame is not already loaded
            try {
                const frameData = await getFrameFromDB(i);
                preloadedFrames[i] = frameData;
            } catch (error) {
                console.error(`Error preloading frame ${i}:`, error);
            }
        }
    }

    // Remove frames that are too old from the object
    Object.keys(preloadedFrames).forEach(frameIndex => {
        if (frameIndex < startFrame || frameIndex > endFrame) {
            delete preloadedFrames[frameIndex];
        }
    });
}

function getPreloadedFrame(frameIndex) {
    return preloadedFrames[frameIndex];
}

// Open or create IndexedDB database
async function openDB() {
    await deleteDatabase();
    return new Promise((resolve, reject) => {
        const request = indexedDB.open(dbName, 1);

        request.onupgradeneeded = (event) => {
            db = event.target.result;
            // Create an object store for frames with the frame index as the key
            const objectStore = db.createObjectStore("frames", {keyPath: "index"});
        };

        request.onsuccess = (event) => {
            db = event.target.result;
            console.log("IndexedDB opened successfully");
            resolve();
        };

        request.onerror = (event) => {
            console.error("Error opening IndexedDB:", event.target);
            reject();
        };
    });
}

function deleteDatabase() {
    return new Promise((resolve, reject) => {
        const deleteRequest = indexedDB.deleteDatabase(dbName);

        deleteRequest.onsuccess = () => {
            console.log("Database deleted successfully.");
            resolve();
        };

        deleteRequest.onerror = (event) => {
            console.error("Error deleting database:", event.target.errorCode);
            reject();
        };

        deleteRequest.onblocked = () => {
            console.warn("Database deletion blocked. Close other tabs using this database.");
        };
    });
}

function printAllFramesInDB() {
    return new Promise((resolve, reject) => {
        const transaction = db.transaction(["frames"], "readonly");
        const objectStore = transaction.objectStore("frames");

        const allFrames = [];
        const request = objectStore.openCursor();  // Open a cursor to iterate over all entries

        request.onsuccess = (event) => {
            const cursor = event.target.result;
            if (cursor) {
                // Add frame data to array and print it
                allFrames.push(cursor.value);
                cursor.continue();  // Move to the next entry
            } else {
                console.log("All frames in the database:", allFrames);  // Print entire array after iteration
                resolve(allFrames);  // Resolve the promise with all the frame data
            }
        };

        request.onerror = (event) => {
            console.error("Error reading from IndexedDB:", event.target.errorCode);
            reject(event.target.errorCode);
        };
    });
}

function storeFrameInDB_(frameIndex, frameData) {
    frames[frameIndex] = frameData;
    return Promise.resolve();
}

// Store frame in IndexedDB
function storeFrameInDB(frameIndex, frameData) {
    // console.log("Storing frame:", frameIndex);
    return new Promise((resolve, reject) => {
        const transaction = db.transaction(["frames"], "readwrite");
        const objectStore = transaction.objectStore("frames");
        const request = objectStore.add({index: frameIndex, data: frameData});

        request.onsuccess = () => {
            resolve();
        };

        request.onerror = (event) => {
            console.error("Error storing frame:", event.target, event);
            reject();
        };
    });
}

function getFrameFromDB_(frameIndex) {
    const frameData = frames[frameIndex];
    if (frameData) {
        return Promise.resolve(frameData);
    } else {
        // throw an error
        return Promise.reject("Frame not found in IndexedDB");
    }
}

// Retrieve frame from IndexedDB
function getFrameFromDB(frameIndex) {
    return new Promise((resolve, reject) => {
        const transaction = db.transaction(["frames"], "readonly");
        const objectStore = transaction.objectStore("frames");
        const request = objectStore.get(frameIndex);

        request.onsuccess = (event) => {
            if (event.target.result) {
                resolve(event.target.result.data);
            } else {
                reject("Frame not found in IndexedDB");
            }
        };

        request.onerror = (event) => {
            console.error("Error retrieving frame:", event.target, "Frame index:", frameIndex);
            reject();
        };
    });
}

// Fetch mesh data and store in IndexedDB
async function fetchMeshData() {
    const url = `/mano_vertices_data/${pieceId}`;
    const response = await fetch(url);

    if (!response.ok) {
        throw new Error(`HTTP error! Status: ${response.status}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder("utf-8");
    let buffer = "";  // Buffer to hold incoming data

    const loadingText = document.getElementById('loadingText');

    let startTime = Date.now();  // Record the start time

    while (true) {
        const {done, value} = await reader.read();

        if (done) {
            break;
        }

        const chunkText = decoder.decode(value, {stream: true});
        buffer += chunkText;

        let parts = buffer.split('\n');
        buffer = parts.pop();  // Keep incomplete part in buffer

        // Sequential processing using for...of
        for (const frameJson of parts) {
            try {
                const frameData = JSON.parse(frameJson);
                // console.log("Processing frame:", loadedFrames);  // Debugging line

                // Store frame in IndexedDB sequentially
                await storeFrameInDB(loadedFrames, frameData);
                loadedFrames++;  // Increment after storing the frame

                const percentage = (loadedFrames / totalFrames) * 100;
                document.getElementById('bufferedBar').style.width = percentage + '%';


                const elapsedTime = (Date.now() - startTime) / 1000;
                const loadRate = loadedFrames / elapsedTime;
                const framesRemaining = totalFrames - loadedFrames;
                const timeRemaining = framesRemaining / loadRate;
                const minutes = Math.floor(timeRemaining / 60);
                const seconds = Math.floor(timeRemaining % 60);

                const elapsedTimeMinutes = Math.floor(elapsedTime / 60);
                const elapsedTimeSeconds = Math.floor(elapsedTime % 60);

                let text = `Loading... ${Math.floor(percentage)}% <br />`
                text += `ETA: ${minutes}m ${seconds}s <br />`
                text += `Elapsed time: ${elapsedTimeMinutes}m ${elapsedTimeSeconds}s`;
                loadingText.innerHTML = text;
            } catch (e) {
                console.error("Error parsing/storing frame:", e);
            }
        }
    }

    loadingText.innerHTML = 'Loading... 100% <br /> Elapsed time: ' + Math.floor((Date.now() - startTime) / 1000) + 's';
}

// Fetch frame from IndexedDB for rendering
async function fetchFrameForRendering(frameIndex) {
    try {
        const frameData = await getFrameFromDB(frameIndex);
        return frameData;
    } catch (error) {
        console.error("Error fetching frame for rendering:", error, "Frame index:", frameIndex);
        return null;
    }
}


async function main() {
    console.log("Starting application");
    // Setup the scene, camera, and renderer
    const scene = new THREE.Scene();
    const gui = new GUI();
    const camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 0.1, 1000);
    const renderer = new THREE.WebGLRenderer({canvas: document.getElementById('threeCanvas'), antialias: true});
    renderer.setSize(window.innerWidth, window.innerHeight);
    document.body.appendChild(renderer.domElement);


    const pmremGenerator = new THREE.PMREMGenerator(renderer);

    const hdriLoader = new RGBELoader()
    hdriLoader.load("resources/envmap.hdr", function (texture) {
        const envMap = pmremGenerator.fromEquirectangular(texture).texture;
        texture.dispose();
        scene.environment = envMap;
        scene.background = envMap;
        scene.backgroundBlurriness = 0.3;
    });

    const renderingParams = {
        handColor: 0xefceb9,
    }
    // gui.addColor(renderingParams, 'handColor').onChange((value) => {
    //     leftMesh.material.color.setHex(value);
    //     rightMesh.material.color.setHex(value);
    //     leftMaterial.material.needsUpdate = true;
    //     rightMaterial.material.needsUpdate = true;
    // });


    const hemiLight = new THREE.HemisphereLight(0xffffff, 0x8d8d8d, 3);
    hemiLight.position.set(0, 20, 0);
    // scene.add(hemiLight);

    const dirLight = new THREE.DirectionalLight(0xffffff, 3);
    dirLight.position.set(3, 10, 10);
    dirLight.castShadow = false;
    // scene.add(dirLight);

    // Setup OrbitControls
    const pianoCenter = new THREE.Vector3(0.61431422, -0.074, -0.0055);
    const controls = new OrbitControls(camera, renderer.domElement);
    controls.rotateSpeed = 0.5;
    // const controls = new TrackballControls(camera, renderer.domElement);
    // controls.rotateSpeed = 2.0;
    controls.enableDamping = true;
    controls.dampingFactor = 0.25;
    controls.screenSpacePanning = false;
    controls.minDistance = 0;
    controls.maxDistance = Infinity;
    // Define preset viewpoints
    const presets = {
        top: {
            position: {
                "x": 0.10415014734151176,
                "y": 1.2303206276916157,
                "z": -0.5999895298700443
            }, target: {
                "x": 0.1,
                "y": 0,
                "z": -0.6
            }
        },
        left: {
            position: {
                "x": 0.6998938717565077,
                "y": 1.0171497080001928,
                "z": 0.5578656721849795
            },
            target: {
                "x": 0.13180072175419472,
                "y": 1.5691260771514555e-19,
                "z": -0.5241889198249452
            },
        },
        right: {
            position: {
                "x": 0.6027349580836255,
                "y": 0.818198927359689,
                "z": -1.8632773667524538
            }, target: {
                "x": 0.06154058571770953,
                "y": 1.6977216676322782e-18,
                "z": -0.8159637729174926
            }
        }
    };

// Function to update camera and controls
    function updateCameraAndControls(preset) {
        camera.position.set(preset.position.x, preset.position.y, preset.position.z);
        controls.target.set(preset.target.x, preset.target.y, preset.target.z);
        controls.update();
    }

    // Set up GUI
    // const cameraFolder = gui.addFolder('Camera Presets');
    // // open the folder by default
    // cameraFolder.open();
    const cameraSettings = {
        preset: 'top'
    };

    gui.add(cameraSettings, 'preset', Object.keys(presets))
        .name('Camera Presets')
        .onChange((value) => {
            updateCameraAndControls(presets[value]);
        });
    updateCameraAndControls(presets.top);
    // Load all meshes
    // Create materials
    const whiteMaterial = new THREE.MeshStandardMaterial({
        color: 0xffffff,
        roughness: 0.3,
        metalness: 0.2
    });

    const blackMaterial = new THREE.MeshStandardMaterial({
        color: 0x000000,
        roughness: 0.4,
        metalness: 0.1
    });
    for (let i = 0; i < 88; i++) {
        const objLoader = new OBJLoader();
        const mtlLoader = new MTLLoader();

        const mesh_url = `/piano_mesh/${i}`;
        mtlLoader.load(mesh_url + '.mtl', function (materials) {
            materials.preload();
            const mat = Object.values(materials.materials)[0];
            if (isBlackKey(i + 1)) {
                mat.color.setHex(0x000000);
            } else {
                mat.color.setHex(0xffffff);
            }
            objLoader.setMaterials(materials);
            objLoader.load(mesh_url + '.obj', function (object) {
                object.traverse((child) => {
                    if (child instanceof THREE.Mesh) {
                        // Apply PBR materials
                        child.material = isBlackKey(i + 1) ? blackMaterial.clone() : whiteMaterial.clone();

                        // Enable shadows
                        child.castShadow = true;
                        child.receiveShadow = true;
                    }
                });
                // rotate object 90 along x axis
                object.rotation.x = Math.PI / 2;
                scene.add(object);
                keyObjs[i] = object;
            });
        });
    }
    // Fetch the mesh data (vertices and faces)
    const metadata = await fetchMetaData();
    totalFrames = metadata.num_frames;
    document.getElementById('pieceInformation').innerHTML = `${metadata.name} <br /> by ${metadata.composer}`
    const fps = 60000 / 1001;
    totalDuration = totalFrames / fps;
    // update the duration of the audio
    const minutes = Math.floor(totalDuration / 60);
    const seconds = Math.floor(totalDuration % 60).toString().padStart(2, '0');
    document.getElementById('totalDuration').textContent = `${minutes}:${seconds}`;
    fetchMeshData();
    // wait until frames have more than 600 frames
    const preloadFrames = 60
    while (loadedFrames < preloadFrames) {
        await new Promise(resolve => setTimeout(resolve, 1000));
    }

    const facesData = await fetchFacesData();
    // Extract vertices and faces for the left and right meshes
    const leftFaces = facesData.left_faces.flat();
    const rightFaces = facesData.right_faces.flat();

    // Ensure vertices are set for the first frame
    const leftGeometry = new THREE.BufferGeometry();
    const rightGeometry = new THREE.BufferGeometry();
    const numVertices = 778;

    const leftPositionAttribute = new Float32Array(numVertices * 3);
    const rightPositionAttribute = new Float32Array(numVertices * 3);

    leftGeometry.setAttribute('position', new THREE.BufferAttribute(leftPositionAttribute, 3));
    rightGeometry.setAttribute('position', new THREE.BufferAttribute(rightPositionAttribute, 3));

    leftGeometry.setIndex(leftFaces);
    rightGeometry.setIndex(rightFaces);


    const leftMaterial = new THREE.MeshStandardMaterial({
        // a color that resembs hand
        color: renderingParams.handColor,
        roughness: 1.0,
        metalness: 1.0
    });

    const rightMaterial = leftMaterial.clone();

    // const leftMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000});
    // const rightMaterial = new THREE.MeshBasicMaterial({ color: 0x0000ff});

    const leftMesh = new THREE.Mesh(leftGeometry, leftMaterial);
    leftMesh.frustumCulled = false;
    const rightMesh = new THREE.Mesh(rightGeometry, rightMaterial);
    rightMesh.frustumCulled = false;

    scene.add(leftMesh);
    scene.add(rightMesh);


    // camera.rotation.z = Math.PI / 2;
    console.log("Camera position:", camera.position);
    let axesHelper = new THREE.AxesHelper(20);
    axesHelper.rotation.x = Math.PI / 2;
    // scene.add(axesHelper);

    scene.rotation.x = -Math.PI / 2;

    let currentFrame = 0;

    // Initialize audio
    const audio = document.getElementById('audio');
    const playButton = document.getElementById('playPauseBtn');
    const playPauseIcon = document.getElementById('playPauseIcon');
    const scrubber = document.getElementById('scrubber');
    const bufferedBar = document.getElementById('bufferedBar');

    function isBlackKey(idx) {
        const blackKey = [1, 3, 6, 8, 10];
        // Ensure positive modulo and check if it matches a black key
        return blackKey.includes((idx + 8) % 12);
    }

    let isPlaying = false;
    // Play the audio
    playButton.addEventListener('click', () => {
        if (isPlaying) {
            audio.pause();
            playPauseIcon.className = 'fas fa-play';  // Change to pause icon

        } else {
            audio.play();
            playPauseIcon.className = 'fas fa-pause';  // Change to play icon
        }
        isPlaying = !isPlaying;
    });

    // Animation loop at 60fps
    const interval = 1000 / fps;


    // Periodically preload frames in the background (does not affect the rendering loop)
    setInterval(() => {
        const currentTime = audio.currentTime;
        const frameIndex = Math.floor(currentTime * fps);
        preloadFramesAround(frameIndex);
    }, 500);  // Preload frames every 500 milliseconds

    // a polling function for starting the animation when the frames are loaded
    async function playOnLoad(frameIndex) {
        if (!isPlaying) {
            return;
        }
        try {
            const frameData = await getFrameFromDB(frameIndex);
            if (frameData) {
                audio.play();
            } else {
                setTimeout(() => {
                    playOnLoad(frameIndex);
                }, 500);
            }
        } catch (error) {
            console.error("Error playing on load:", error);
        }
    }

    // Synchronization logic
    function syncAnimationAndAudio() {
        const currentTime = audio.currentTime;
        const frameIndex = Math.floor(currentTime * fps);
        if (frameIndex >= totalFrames) {
            audio.pause();
            return;
        }
        const frameDataThis = getPreloadedFrame(frameIndex);
        if (!frameDataThis) {
            audio.pause();
            playOnLoad(frameIndex);
            return;
        }
        // Update left mesh vertices for the current frame
        for (let i = 0; i < numVertices; i++) {
            for (let j = 0; j < 3; j++) {
                leftPositionAttribute[i * 3 + j] = frameDataThis.left_vertices[i][j];
                rightPositionAttribute[i * 3 + j] = frameDataThis.right_vertices[i][j];
            }
        }


        leftGeometry.computeVertexNormals();
        rightGeometry.computeVertexNormals();

        leftGeometry.attributes.position.needsUpdate = true;
        rightGeometry.attributes.position.needsUpdate = true;


        for (let i = 0; i < 88; i++) {
            const obj = keyObjs[i];
            const mat = keyObjs[i].children[0].material;
            if (frameDataThis.pressed_keys[i] > 0) {
                mat.color.setHex(0x00ff00);
                // also rotate the key
                obj.rotation.z = -Math.PI / 45;
            } else {
                obj.rotation.z = 0;
                if (isBlackKey(i + 1)) {
                    mat.color.setHex(0x000000);
                } else {
                    mat.color.setHex(0xffffff);
                }
            }
            mat.needsUpdate = true;
        }
        // Update the scrubber position
        scrubber.value = (currentTime / totalDuration) * 100;
        document.getElementById('timeDisplay').textContent = `${Math.floor(currentTime / 60)}:${Math.floor(currentTime % 60).toString().padStart(2, '0')}`;
        document.getElementById('playedBar').style.width = scrubber.value + "%";
    }

    audio.ontimeupdate = syncAnimationAndAudio;

    scrubber.addEventListener('input', () => {
        const scrubberValue = scrubber.value;
        const newTime = scrubberValue / 100 * totalDuration;
        audio.currentTime = newTime;
        syncAnimationAndAudio();
    });


    function logCameraSettings() {
        console.log("Camera position:", camera.position);
        console.log("Camera rotation:", camera.rotation);
        console.log("Camera zoom", camera.zoom);
        console.log("Controls target", controls.target);
    }

    // log camera settings every 5 seconds
    // setInterval(logCameraSettings, 5000);

    function animate() {
        syncAnimationAndAudio();
        controls.update();
        renderer.render(scene, camera);
    }

    let lastTime = 0;

    function animationLoop(time) {
        if (time - lastTime >= interval) {
            animate();
            lastTime = time;
        }
        requestAnimationFrame(animationLoop);
    }

    animationLoop(0);

    // Handle window resize
    window.addEventListener('resize', () => {
        camera.aspect = window.innerWidth / window.innerHeight;
        camera.updateProjectionMatrix();
        renderer.setSize(window.innerWidth, window.innerHeight);
    });
}

// Call openDB before starting the application
openDB().then(() => {
    main();
});

	import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.153.0/build/three.module.js';
	import {OrbitControls} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/controls/OrbitControls.js';
	import {TrackballControls} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/controls/TrackballControls.js';
	import {OBJLoader} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/loaders/OBJLoader.js';
	import {MTLLoader} from 'https://cdn.jsdelivr.net/npm/three@0.153.0/examples/jsm/loaders/MTLLoader.js';
	import {RGBELoader} from 'three/addons/loaders/RGBELoader.js';
	import {GUI} from 'three/addons/libs/lil-gui.module.min.js';

	// Get the audio element
	const audioElement = document.getElementById("audio");
	// Set the src of the audio element

	const urlParams = new URLSearchParams(window.location.search);
	let pieceId = parseInt(urlParams.get('id'));
	if (!pieceId) {
	pieceId = 0;
	}
	console.log("Piece ID:", pieceId);
	audioElement.src = `/audio/${pieceId}`;
	let totalFrames = 0;
	let totalDuration = -1;
	let loadedFrames = 0;
	let keyObjs = {};


	document.getElementById('volumeControl').addEventListener('input', () => {
	audio.volume = volumeControl.value;
	if (audio.volume === 0) {
	volumeIcon.className = 'fas fa-volume-mute'; // Mute icon
	} else if (audio.volume <= 0.5) {
	volumeIcon.className = 'fas fa-volume-down'; // Lower volume icon
	} else {
	volumeIcon.className = 'fas fa-volume-up'; // Full volume icon
	}
	});

	async function fetchMetaData() {
	const url = `/metadata/${pieceId}`;
	// read the data from
	const response = await fetch(url);
	const jsonData = await response.json(); // Parse JSON response
	return jsonData;
	}

	async function fetchFacesData() {
	const url = `/mano_faces_data`;
	const response = await fetch(url);
	const jsonData = await response.json();
	return jsonData;
	}

	// Define IndexedDB setup
	const dbName = "MeshFramesDB";
	let db;

	// Define an array of 2000 frames
	let frames = new Array(2000);
	// define preloadFrames
	let preloadedFrames = {};
	const preloadedWindowSize = 600;

	// Function to preload a window of frames
	async function preloadFramesAround(currentFrameIndex) {
	const startFrame = currentFrameIndex
	const endFrame = Math.min(totalFrames, currentFrameIndex + preloadedWindowSize);

	// Loop through the frames in the window and preload them
	for (let i = startFrame; i < endFrame; i++) {
	if (!preloadedFrames[i]) { // If frame is not already loaded
	try {
	const frameData = await getFrameFromDB(i);
	preloadedFrames[i] = frameData;
	} catch (error) {
	console.error(`Error preloading frame ${i}:`, error);
	}
	}
	}

	// Remove frames that are too old from the object
	Object.keys(preloadedFrames).forEach(frameIndex => {
	if (frameIndex < startFrame \|\| frameIndex > endFrame) {
	delete preloadedFrames[frameIndex];
	}
	});
	}

	function getPreloadedFrame(frameIndex) {
	return preloadedFrames[frameIndex];
	}

	// Open or create IndexedDB database
	async function openDB() {
	await deleteDatabase();
	return new Promise((resolve, reject) => {
	const request = indexedDB.open(dbName, 1);

	request.onupgradeneeded = (event) => {
	db = event.target.result;
	// Create an object store for frames with the frame index as the key
	const objectStore = db.createObjectStore("frames", {keyPath: "index"});
	};

	request.onsuccess = (event) => {
	db = event.target.result;
	console.log("IndexedDB opened successfully");
	resolve();
	};

	request.onerror = (event) => {
	console.error("Error opening IndexedDB:", event.target);
	reject();
	};
	});
	}

	function deleteDatabase() {
	return new Promise((resolve, reject) => {
	const deleteRequest = indexedDB.deleteDatabase(dbName);

	deleteRequest.onsuccess = () => {
	console.log("Database deleted successfully.");
	resolve();
	};

	deleteRequest.onerror = (event) => {
	console.error("Error deleting database:", event.target.errorCode);
	reject();
	};

	deleteRequest.onblocked = () => {
	console.warn("Database deletion blocked. Close other tabs using this database.");
	};
	});
	}

	function printAllFramesInDB() {
	return new Promise((resolve, reject) => {
	const transaction = db.transaction(["frames"], "readonly");
	const objectStore = transaction.objectStore("frames");

	const allFrames = [];
	const request = objectStore.openCursor(); // Open a cursor to iterate over all entries

	request.onsuccess = (event) => {
	const cursor = event.target.result;
	if (cursor) {
	// Add frame data to array and print it
	allFrames.push(cursor.value);
	cursor.continue(); // Move to the next entry
	} else {
	console.log("All frames in the database:", allFrames); // Print entire array after iteration
	resolve(allFrames); // Resolve the promise with all the frame data
	}
	};

	request.onerror = (event) => {
	console.error("Error reading from IndexedDB:", event.target.errorCode);
	reject(event.target.errorCode);
	};
	});
	}

	function storeFrameInDB_(frameIndex, frameData) {
	frames[frameIndex] = frameData;
	return Promise.resolve();
	}

	// Store frame in IndexedDB
	function storeFrameInDB(frameIndex, frameData) {
	// console.log("Storing frame:", frameIndex);
	return new Promise((resolve, reject) => {
	const transaction = db.transaction(["frames"], "readwrite");
	const objectStore = transaction.objectStore("frames");
	const request = objectStore.add({index: frameIndex, data: frameData});

	request.onsuccess = () => {
	resolve();
	};

	request.onerror = (event) => {
	console.error("Error storing frame:", event.target, event);
	reject();
	};
	});
	}

	function getFrameFromDB_(frameIndex) {
	const frameData = frames[frameIndex];
	if (frameData) {
	return Promise.resolve(frameData);
	} else {
	// throw an error
	return Promise.reject("Frame not found in IndexedDB");
	}
	}

	// Retrieve frame from IndexedDB
	function getFrameFromDB(frameIndex) {
	return new Promise((resolve, reject) => {
	const transaction = db.transaction(["frames"], "readonly");
	const objectStore = transaction.objectStore("frames");
	const request = objectStore.get(frameIndex);

	request.onsuccess = (event) => {
	if (event.target.result) {
	resolve(event.target.result.data);
	} else {
	reject("Frame not found in IndexedDB");
	}
	};

	request.onerror = (event) => {
	console.error("Error retrieving frame:", event.target, "Frame index:", frameIndex);
	reject();
	};
	});
	}

	// Fetch mesh data and store in IndexedDB
	async function fetchMeshData() {
	const url = `/mano_vertices_data/${pieceId}`;
	const response = await fetch(url);

	if (!response.ok) {
	throw new Error(`HTTP error! Status: ${response.status}`);
	}

	const reader = response.body.getReader();
	const decoder = new TextDecoder("utf-8");
	let buffer = ""; // Buffer to hold incoming data

	const loadingText = document.getElementById('loadingText');

	let startTime = Date.now(); // Record the start time

	while (true) {
	const {done, value} = await reader.read();

	if (done) {
	break;
	}

	const chunkText = decoder.decode(value, {stream: true});
	buffer += chunkText;

	let parts = buffer.split('\n');
	buffer = parts.pop(); // Keep incomplete part in buffer

	// Sequential processing using for...of
	for (const frameJson of parts) {
	try {
	const frameData = JSON.parse(frameJson);
	// console.log("Processing frame:", loadedFrames); // Debugging line

	// Store frame in IndexedDB sequentially
	await storeFrameInDB(loadedFrames, frameData);
	loadedFrames++; // Increment after storing the frame

	const percentage = (loadedFrames / totalFrames) * 100;
	document.getElementById('bufferedBar').style.width = percentage + '%';


	const elapsedTime = (Date.now() - startTime) / 1000;
	const loadRate = loadedFrames / elapsedTime;
	const framesRemaining = totalFrames - loadedFrames;
	const timeRemaining = framesRemaining / loadRate;
	const minutes = Math.floor(timeRemaining / 60);
	const seconds = Math.floor(timeRemaining % 60);

	const elapsedTimeMinutes = Math.floor(elapsedTime / 60);
	const elapsedTimeSeconds = Math.floor(elapsedTime % 60);

	let text = `Loading... ${Math.floor(percentage)}% <br />`
	text += `ETA: ${minutes}m ${seconds}s <br />`
	text += `Elapsed time: ${elapsedTimeMinutes}m ${elapsedTimeSeconds}s`;
	loadingText.innerHTML = text;
	} catch (e) {
	console.error("Error parsing/storing frame:", e);
	}
	}
	}

	loadingText.innerHTML = 'Loading... 100% <br /> Elapsed time: ' + Math.floor((Date.now() - startTime) / 1000) + 's';
	}

	// Fetch frame from IndexedDB for rendering
	async function fetchFrameForRendering(frameIndex) {
	try {
	const frameData = await getFrameFromDB(frameIndex);
	return frameData;
	} catch (error) {
	console.error("Error fetching frame for rendering:", error, "Frame index:", frameIndex);
	return null;
	}
	}


	async function main() {
	console.log("Starting application");
	// Setup the scene, camera, and renderer
	const scene = new THREE.Scene();
	const gui = new GUI();
	const camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 0.1, 1000);
	const renderer = new THREE.WebGLRenderer({canvas: document.getElementById('threeCanvas'), antialias: true});
	renderer.setSize(window.innerWidth, window.innerHeight);
	document.body.appendChild(renderer.domElement);


	const pmremGenerator = new THREE.PMREMGenerator(renderer);

	const hdriLoader = new RGBELoader()
	hdriLoader.load("resources/envmap.hdr", function (texture) {
	const envMap = pmremGenerator.fromEquirectangular(texture).texture;
	texture.dispose();
	scene.environment = envMap;
	scene.background = envMap;
	scene.backgroundBlurriness = 0.3;
	});

	const renderingParams = {
	handColor: 0xefceb9,
	}
	// gui.addColor(renderingParams, 'handColor').onChange((value) => {
	// leftMesh.material.color.setHex(value);
	// rightMesh.material.color.setHex(value);
	// leftMaterial.material.needsUpdate = true;
	// rightMaterial.material.needsUpdate = true;
	// });


	const hemiLight = new THREE.HemisphereLight(0xffffff, 0x8d8d8d, 3);
	hemiLight.position.set(0, 20, 0);
	// scene.add(hemiLight);

	const dirLight = new THREE.DirectionalLight(0xffffff, 3);
	dirLight.position.set(3, 10, 10);
	dirLight.castShadow = false;
	// scene.add(dirLight);

	// Setup OrbitControls
	const pianoCenter = new THREE.Vector3(0.61431422, -0.074, -0.0055);
	const controls = new OrbitControls(camera, renderer.domElement);
	controls.rotateSpeed = 0.5;
	// const controls = new TrackballControls(camera, renderer.domElement);
	// controls.rotateSpeed = 2.0;
	controls.enableDamping = true;
	controls.dampingFactor = 0.25;
	controls.screenSpacePanning = false;
	controls.minDistance = 0;
	controls.maxDistance = Infinity;
	// Define preset viewpoints
	const presets = {
	top: {
	position: {
	"x": 0.10415014734151176,
	"y": 1.2303206276916157,
	"z": -0.5999895298700443
	}, target: {
	"x": 0.1,
	"y": 0,
	"z": -0.6
	}
	},
	left: {
	position: {
	"x": 0.6998938717565077,
	"y": 1.0171497080001928,
	"z": 0.5578656721849795
	},
	target: {
	"x": 0.13180072175419472,
	"y": 1.5691260771514555e-19,
	"z": -0.5241889198249452
	},
	},
	right: {
	position: {
	"x": 0.6027349580836255,
	"y": 0.818198927359689,
	"z": -1.8632773667524538
	}, target: {
	"x": 0.06154058571770953,
	"y": 1.6977216676322782e-18,
	"z": -0.8159637729174926
	}
	}
	};

	// Function to update camera and controls
	function updateCameraAndControls(preset) {
	camera.position.set(preset.position.x, preset.position.y, preset.position.z);
	controls.target.set(preset.target.x, preset.target.y, preset.target.z);
	controls.update();
	}

	// Set up GUI
	// const cameraFolder = gui.addFolder('Camera Presets');
	// // open the folder by default
	// cameraFolder.open();
	const cameraSettings = {
	preset: 'top'
	};

	gui.add(cameraSettings, 'preset', Object.keys(presets))
	.name('Camera Presets')
	.onChange((value) => {
	updateCameraAndControls(presets[value]);
	});
	updateCameraAndControls(presets.top);
	// Load all meshes
	// Create materials
	const whiteMaterial = new THREE.MeshStandardMaterial({
	color: 0xffffff,
	roughness: 0.3,
	metalness: 0.2
	});

	const blackMaterial = new THREE.MeshStandardMaterial({
	color: 0x000000,
	roughness: 0.4,
	metalness: 0.1
	});
	for (let i = 0; i < 88; i++) {
	const objLoader = new OBJLoader();
	const mtlLoader = new MTLLoader();

	const mesh_url = `/piano_mesh/${i}`;
	mtlLoader.load(mesh_url + '.mtl', function (materials) {
	materials.preload();
	const mat = Object.values(materials.materials)[0];
	if (isBlackKey(i + 1)) {
	mat.color.setHex(0x000000);
	} else {
	mat.color.setHex(0xffffff);
	}
	objLoader.setMaterials(materials);
	objLoader.load(mesh_url + '.obj', function (object) {
	object.traverse((child) => {
	if (child instanceof THREE.Mesh) {
	// Apply PBR materials
	child.material = isBlackKey(i + 1) ? blackMaterial.clone() : whiteMaterial.clone();

	// Enable shadows
	child.castShadow = true;
	child.receiveShadow = true;
	}
	});
	// rotate object 90 along x axis
	object.rotation.x = Math.PI / 2;
	scene.add(object);
	keyObjs[i] = object;
	});
	});
	}
	// Fetch the mesh data (vertices and faces)
	const metadata = await fetchMetaData();
	totalFrames = metadata.num_frames;
	document.getElementById('pieceInformation').innerHTML = `${metadata.name} <br /> by ${metadata.composer}`
	const fps = 60000 / 1001;
	totalDuration = totalFrames / fps;
	// update the duration of the audio
	const minutes = Math.floor(totalDuration / 60);
	const seconds = Math.floor(totalDuration % 60).toString().padStart(2, '0');
	document.getElementById('totalDuration').textContent = `${minutes}:${seconds}`;
	fetchMeshData();
	// wait until frames have more than 600 frames
	const preloadFrames = 60
	while (loadedFrames < preloadFrames) {
	await new Promise(resolve => setTimeout(resolve, 1000));
	}

	const facesData = await fetchFacesData();
	// Extract vertices and faces for the left and right meshes
	const leftFaces = facesData.left_faces.flat();
	const rightFaces = facesData.right_faces.flat();

	// Ensure vertices are set for the first frame
	const leftGeometry = new THREE.BufferGeometry();
	const rightGeometry = new THREE.BufferGeometry();
	const numVertices = 778;

	const leftPositionAttribute = new Float32Array(numVertices * 3);
	const rightPositionAttribute = new Float32Array(numVertices * 3);

	leftGeometry.setAttribute('position', new THREE.BufferAttribute(leftPositionAttribute, 3));
	rightGeometry.setAttribute('position', new THREE.BufferAttribute(rightPositionAttribute, 3));

	leftGeometry.setIndex(leftFaces);
	rightGeometry.setIndex(rightFaces);


	const leftMaterial = new THREE.MeshStandardMaterial({
	// a color that resembs hand
	color: renderingParams.handColor,
	roughness: 1.0,
	metalness: 1.0
	});

	const rightMaterial = leftMaterial.clone();

	// const leftMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000});
	// const rightMaterial = new THREE.MeshBasicMaterial({ color: 0x0000ff});

	const leftMesh = new THREE.Mesh(leftGeometry, leftMaterial);
	leftMesh.frustumCulled = false;
	const rightMesh = new THREE.Mesh(rightGeometry, rightMaterial);
	rightMesh.frustumCulled = false;

	scene.add(leftMesh);
	scene.add(rightMesh);


	// camera.rotation.z = Math.PI / 2;
	console.log("Camera position:", camera.position);
	let axesHelper = new THREE.AxesHelper(20);
	axesHelper.rotation.x = Math.PI / 2;
	// scene.add(axesHelper);

	scene.rotation.x = -Math.PI / 2;

	let currentFrame = 0;

	// Initialize audio
	const audio = document.getElementById('audio');
	const playButton = document.getElementById('playPauseBtn');
	const playPauseIcon = document.getElementById('playPauseIcon');
	const scrubber = document.getElementById('scrubber');
	const bufferedBar = document.getElementById('bufferedBar');

	function isBlackKey(idx) {
	const blackKey = [1, 3, 6, 8, 10];
	// Ensure positive modulo and check if it matches a black key
	return blackKey.includes((idx + 8) % 12);
	}

	let isPlaying = false;
	// Play the audio
	playButton.addEventListener('click', () => {
	if (isPlaying) {
	audio.pause();
	playPauseIcon.className = 'fas fa-play'; // Change to pause icon

	} else {
	audio.play();
	playPauseIcon.className = 'fas fa-pause'; // Change to play icon
	}
	isPlaying = !isPlaying;
	});

	// Animation loop at 60fps
	const interval = 1000 / fps;


	// Periodically preload frames in the background (does not affect the rendering loop)
	setInterval(() => {
	const currentTime = audio.currentTime;
	const frameIndex = Math.floor(currentTime * fps);
	preloadFramesAround(frameIndex);
	}, 500); // Preload frames every 500 milliseconds

	// a polling function for starting the animation when the frames are loaded
	async function playOnLoad(frameIndex) {
	if (!isPlaying) {
	return;
	}
	try {
	const frameData = await getFrameFromDB(frameIndex);
	if (frameData) {
	audio.play();
	} else {
	setTimeout(() => {
	playOnLoad(frameIndex);
	}, 500);
	}
	} catch (error) {
	console.error("Error playing on load:", error);
	}
	}

	// Synchronization logic
	function syncAnimationAndAudio() {
	const currentTime = audio.currentTime;
	const frameIndex = Math.floor(currentTime * fps);
	if (frameIndex >= totalFrames) {
	audio.pause();
	return;
	}
	const frameDataThis = getPreloadedFrame(frameIndex);
	if (!frameDataThis) {
	audio.pause();
	playOnLoad(frameIndex);
	return;
	}
	// Update left mesh vertices for the current frame
	for (let i = 0; i < numVertices; i++) {
	for (let j = 0; j < 3; j++) {
	leftPositionAttribute[i * 3 + j] = frameDataThis.left_vertices[i][j];
	rightPositionAttribute[i * 3 + j] = frameDataThis.right_vertices[i][j];
	}
	}


	leftGeometry.computeVertexNormals();
	rightGeometry.computeVertexNormals();

	leftGeometry.attributes.position.needsUpdate = true;
	rightGeometry.attributes.position.needsUpdate = true;


	for (let i = 0; i < 88; i++) {
	const obj = keyObjs[i];
	const mat = keyObjs[i].children[0].material;
	if (frameDataThis.pressed_keys[i] > 0) {
	mat.color.setHex(0x00ff00);
	// also rotate the key
	obj.rotation.z = -Math.PI / 45;
	} else {
	obj.rotation.z = 0;
	if (isBlackKey(i + 1)) {
	mat.color.setHex(0x000000);
	} else {
	mat.color.setHex(0xffffff);
	}
	}
	mat.needsUpdate = true;
	}
	// Update the scrubber position
	scrubber.value = (currentTime / totalDuration) * 100;
	document.getElementById('timeDisplay').textContent = `${Math.floor(currentTime / 60)}:${Math.floor(currentTime % 60).toString().padStart(2, '0')}`;
	document.getElementById('playedBar').style.width = scrubber.value + "%";
	}

	audio.ontimeupdate = syncAnimationAndAudio;

	scrubber.addEventListener('input', () => {
	const scrubberValue = scrubber.value;
	const newTime = scrubberValue / 100 * totalDuration;
	audio.currentTime = newTime;
	syncAnimationAndAudio();
	});


	function logCameraSettings() {
	console.log("Camera position:", camera.position);
	console.log("Camera rotation:", camera.rotation);
	console.log("Camera zoom", camera.zoom);
	console.log("Controls target", controls.target);
	}

	// log camera settings every 5 seconds
	// setInterval(logCameraSettings, 5000);

	function animate() {
	syncAnimationAndAudio();
	controls.update();
	renderer.render(scene, camera);
	}

	let lastTime = 0;

	function animationLoop(time) {
	if (time - lastTime >= interval) {
	animate();
	lastTime = time;
	}
	requestAnimationFrame(animationLoop);
	}

	animationLoop(0);

	// Handle window resize
	window.addEventListener('resize', () => {
	camera.aspect = window.innerWidth / window.innerHeight;
	camera.updateProjectionMatrix();
	renderer.setSize(window.innerWidth, window.innerHeight);
	});
	}

	// Call openDB before starting the application
	openDB().then(() => {
	main();
	});