The globecomponent code is based off of threejs however the component only mounts once.…
- User
The globecomponent code is based off of threejs however the component only mounts once. Since the application i am rendering the component on is a next js react app, navigating(when using fast refresh over full refresh)from the main page where its on to another page and coming back results in an error where the globe together with the countries, labels and points are shown, but the arcs which should be moving between points in the globe are not shown. How can i use react context to fix this problem. GlobeComponent.jsx: import React, { useEffect, useRef } from 'react'; import { WebGLRenderer, Scene, AmbientLight, DirectionalLight, Color, Fog, PerspectiveCamera, PointLight } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import { createGlowMesh } from 'three-glow-mesh'; import ThreeGlobe from "three-globe"; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json';
let mouseX = 0; let mouseY = 0;
let timeoutId; let renderer, camera, scene, controls; let Globe; let frameId;
const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight }) => { const containerRef = useRef(); let windowHalfX = windowWidth / 2; let windowHalfY = windowHeight / 2;
// Event listeners function onWindowResize() { camera.aspect = windowWidth / windowHeight; camera.updateProjectionMatrix(); windowHalfX = windowWidth; windowHalfY = windowHeight; renderer.setSize(windowWidth, windowHeight); } function onMouseMove(event) { mouseX = event.clientX - windowHalfX; mouseY = event.clientY - windowHalfY; // console.log("x: " + mouseX + " y: " + mouseY); } // Animation function animate() { camera.lookAt(scene.position); controls.update(); renderer.render(scene, camera); frameId = requestAnimationFrame(animate); }useEffect(() => { // Initialize core ThreeJS elements function init() { // Initialize renderer renderer = new WebGLRenderer({ antialias: true, alpha: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(globeWidth, globeHeight); renderer.setClearColor(0x000000, 0); containerRef.current.appendChild(renderer.domElement);
// Initialize scene, light scene = new Scene(); scene.add(new AmbientLight(0xbbbbbb, 0.4)); // Initialize camera, light camera = new PerspectiveCamera(); camera.aspect = globeWidth / globeHeight; camera.updateProjectionMatrix(); var dLight = new DirectionalLight(0xffffff, 0.8); dLight.position.set(-800, 2000, 400); camera.add(dLight); var dLight1 = new DirectionalLight(0x7982f6, 1); dLight1.position.set(-200, 500, 200); camera.add(dLight1); var dLight2 = new PointLight(0x8566cc, 0.5); dLight2.position.set(-200, 500, 200); camera.add(dLight2); camera.position.z = 400; camera.position.x = 0; camera.position.y = 0; scene.add(camera); // Additional effects scene.fog = new Fog(0x535ef3, 400, 2000); // Helpers // const axesHelper = new THREE.AxesHelper(800); // scene.add(axesHelper); // var helper = new THREE.DirectionalLightHelper(dLight); // scene.add(helper); // var helperCamera = new THREE.CameraHelper(dLight.shadow.camera); // scene.add(helperCamera); // Initialize controls controls = new OrbitControls(camera, renderer.domElement); controls.enableDamping = true; controls.dynamicDampingFactor = 0.01; controls.enablePan = false; controls.minDistance = Math.min(globeWidth, globeHeight) / 2; controls.maxDistance = Math.min(globeWidth, globeHeight) / 2; controls.rotateSpeed = 0.8; controls.zoomSpeed = 1; controls.autoRotate = false; controls.minPolarAngle = Math.PI / 3.5; controls.maxPolarAngle = Math.PI - Math.PI / 3; } // Initialize the Globe function initGlobe() { // Initialize the Globe Globe = new ThreeGlobe({ waitForGlobeReady: true, animateIn: true, }) .hexPolygonsData(countries.features) .hexPolygonResolution(3) .hexPolygonMargin(0.7) .showAtmosphere(true) .atmosphereColor("#ffffff") .atmosphereAltitude(0.1) .hexPolygonColor((e) => { if ( ["KEN", "CHN", "FRA", "ZAF", "JPN", "USA", "AUS", "CAN"].includes( e.properties.ISO_A3 ) ) { return "rgba(255,255,255, 1)"; } else return "rgba(255,255,255, 0.5)"; }); // NOTE Arc animations are followed after the globe enters the scene timeoutId = setTimeout(() => { Globe.arcsData(travelHistory.flights) .arcColor((e) => { return e.status ? "#9cff00" : "#ff2e97"; }) .arcAltitude((e) => { return e.arcAlt; }) .arcStroke((e) => { return e.status ? 0.5 : 0.3; }) .arcDashLength(0.9) .arcDashGap(4) .arcDashAnimateTime(1000) .arcsTransitionDuration(1000) .arcDashInitialGap((e) => e.order * 1) .labelsData(airportHistory.airports) .labelColor(() => "#ffffff") .labelDotOrientation((e) => { return e.text === "NGA" ? "top" : "right"; }) .labelDotRadius(0.35) .labelSize((e) => e.size) .labelText("city") .labelResolution(6) .labelAltitude(0.01) .pointsData(airportHistory.airports) .pointColor(() => "#ffffff") .pointsMerge(true) .pointAltitude(0.07) .pointRadius(0.10); }, 1000); Globe.rotateX(-Math.PI * (1 / 50)); Globe.rotateY(-Math.PI * (1 / 9)); Globe.rotateZ(-Math.PI / 60); const globeMaterial = Globe.globeMaterial(); globeMaterial.color = new Color(0x3a228a); globeMaterial.emissive = new Color(0x220038); globeMaterial.emissiveIntensity = 0.1; globeMaterial.shininess = 0.7; // NOTE Cool stuff // globeMaterial.wireframe = true; scene.add(Globe); } init(); initGlobe(); onWindowResize(); animate(); window.addEventListener('resize', onWindowResize, false); renderer.domElement.addEventListener('mousemove', onMouseMove); console.log("Initializing globe animation"); return () => { clearTimeout(timeoutId); window.removeEventListener('resize', onWindowResize); renderer.domElement.removeEventListener('mousemove', onMouseMove); cancelAnimationFrame(frameId); if (containerRef.current) { // Perform more thorough clean-up here // Dispose of the scene's children while (scene.children.length > 0) { const object = scene.children[0]; if (object.dispose) { object.dispose(); } scene.remove(object); } // Dispose of the renderer and any associated resources renderer.dispose(); // Dispose of any controls, if necessary if (controls && controls instanceof OrbitControls && controls.dispose) { controls.dispose(); } if (renderer.domElement.parentNode === containerRef.current) { // Remove the renderer DOM element containerRef.current.removeChild(renderer.domElement); } } };}, []);
return ;
};
export default GlobeComponent;
- Assistant
The error you're experiencing seems to be caused by improper cleanup and reinitialization when the React component mounts and unmounts. Since you're working with Next.js, it's important to remember that the page components may get unmounted and remounted frequently, as users navigate through the app.
One possible solution would involve moving the initialization and cleanup code into a React Context. This way, you can ensure that the Three.js-related resources like renderer, camera, and controls are properly managed across component remounts. Below is a conceptual implementation of how you might structure your context for the Globe application:
// GlobeContext.js import React, { createContext, useState, useEffect, useRef } from 'react'; const GlobeContext = createContext(); export const GlobeProvider = ({ children }) => { const [globeState, setGlobeState] = useState({ initialized: false, // ...other state necessary for your globe }); useEffect(() => { // Initialize Three.js resources // ... setGlobeState({ initialized: true }); // Cleanup function return () => { // Dispose of Three.js resources // ... setGlobeState({ initialized: false }); }; }, []); return ( <GlobeContext.Provider value={{ globeState, setGlobeState }}> {children} </GlobeContext.Provider> ); }; export default GlobeContext;You could then use the context in
GlobeComponent:// GlobeComponent.jsx import React, { useContext, useEffect, useRef } from 'react'; import GlobeContext, { GlobeProvider } from './GlobeContext'; // ... The rest of your imports const GlobeComponent = ({ /*...props*/ }) => { const containerRef = useRef(); const { globeState, setGlobeState } = useContext(GlobeContext); useEffect(() => { if (!globeState.initialized) { // Init Three.js resources if not yet initialized // ... } // Mounted // ... return () => { // Unmounted // Perform cleanup that is non-destructive to global Three.js state }; }, [globeState]); return <div ref={containerRef} />; }; const GlobeComponentWithProvider = (props) => ( <GlobeProvider> <GlobeComponent {...props} /> </GlobeProvider> ); export default GlobeComponentWithProvider;The
GlobeProviderwrapsGlobeComponent, ensuring that the state is preserved across remounts of the component. InsideGlobeComponent, you conditionally initialize Three.js resources based on whether they have been previously initialized or not (globeState.initialized).Additionally, this change implies that your app should not have multiple instances of
GlobeProvider. Ideally, theGlobeProvidershould be placed at a higher level in your component hierarchy, perhaps around the entire part of your application that might unmount and remount the GlobeComponent.Make sure to adapt the above example to fit your specific context needs, such as managing your scene elements, the animation loop, and event handlers. Always strive for complete cleanup to avoid memory leaks, especially with libraries like Three.js that manage a lot of their own state.
- User
Show me a full implementation of the react context taking into account: import React, { useEffect, useRef } from 'react'; import { WebGLRenderer, Scene, AmbientLight, DirectionalLight, Color, Fog, PerspectiveCamera, PointLight } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import { createGlowMesh } from 'three-glow-mesh'; import ThreeGlobe from "three-globe"; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json';
let mouseX = 0; let mouseY = 0;
let timeoutId; let renderer, camera, scene, controls; let Globe; let frameId;
const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight }) => { const containerRef = useRef(); let windowHalfX = windowWidth / 2; let windowHalfY = windowHeight / 2;
// Event listeners function onWindowResize() { camera.aspect = windowWidth / windowHeight; camera.updateProjectionMatrix(); windowHalfX = windowWidth; windowHalfY = windowHeight; renderer.setSize(windowWidth, windowHeight); } function onMouseMove(event) { mouseX = event.clientX - windowHalfX; mouseY = event.clientY - windowHalfY; // console.log("x: " + mouseX + " y: " + mouseY); } // Animation function animate() { camera.lookAt(scene.position); controls.update(); renderer.render(scene, camera); frameId = requestAnimationFrame(animate); }useEffect(() => { // Initialize core ThreeJS elements function init() { // Initialize renderer renderer = new WebGLRenderer({ antialias: true, alpha: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(globeWidth, globeHeight); renderer.setClearColor(0x000000, 0); containerRef.current.appendChild(renderer.domElement);
// Initialize scene, light scene = new Scene(); scene.add(new AmbientLight(0xbbbbbb, 0.4)); // Initialize camera, light camera = new PerspectiveCamera(); camera.aspect = globeWidth / globeHeight; camera.updateProjectionMatrix(); var dLight = new DirectionalLight(0xffffff, 0.8); dLight.position.set(-800, 2000, 400); camera.add(dLight); var dLight1 = new DirectionalLight(0x7982f6, 1); dLight1.position.set(-200, 500, 200); camera.add(dLight1); var dLight2 = new PointLight(0x8566cc, 0.5); dLight2.position.set(-200, 500, 200); camera.add(dLight2); camera.position.z = 400; camera.position.x = 0; camera.position.y = 0; scene.add(camera); // Additional effects scene.fog = new Fog(0x535ef3, 400, 2000); // Helpers // const axesHelper = new THREE.AxesHelper(800); // scene.add(axesHelper); // var helper = new THREE.DirectionalLightHelper(dLight); // scene.add(helper); // var helperCamera = new THREE.CameraHelper(dLight.shadow.camera); // scene.add(helperCamera); // Initialize controls controls = new OrbitControls(camera, renderer.domElement); controls.enableDamping = true; controls.dynamicDampingFactor = 0.01; controls.enablePan = false; controls.minDistance = Math.min(globeWidth, globeHeight) / 2; controls.maxDistance = Math.min(globeWidth, globeHeight) / 2; controls.rotateSpeed = 0.8; controls.zoomSpeed = 1; controls.autoRotate = false; controls.minPolarAngle = Math.PI / 3.5; controls.maxPolarAngle = Math.PI - Math.PI / 3; } // Initialize the Globe function initGlobe() { // Initialize the Globe Globe = new ThreeGlobe({ waitForGlobeReady: true, animateIn: true, }) .hexPolygonsData(countries.features) .hexPolygonResolution(3) .hexPolygonMargin(0.7) .showAtmosphere(true) .atmosphereColor("#ffffff") .atmosphereAltitude(0.1) .hexPolygonColor((e) => { if ( ["KEN", "CHN", "FRA", "ZAF", "JPN", "USA", "AUS", "CAN"].includes( e.properties.ISO_A3 ) ) { return "rgba(255,255,255, 1)"; } else return "rgba(255,255,255, 0.5)"; }); // NOTE Arc animations are followed after the globe enters the scene timeoutId = setTimeout(() => { Globe.arcsData(travelHistory.flights) .arcColor((e) => { return e.status ? "#9cff00" : "#ff2e97"; }) .arcAltitude((e) => { return e.arcAlt; }) .arcStroke((e) => { return e.status ? 0.5 : 0.3; }) .arcDashLength(0.9) .arcDashGap(4) .arcDashAnimateTime(1000) .arcsTransitionDuration(1000) .arcDashInitialGap((e) => e.order * 1) .labelsData(airportHistory.airports) .labelColor(() => "#ffffff") .labelDotOrientation((e) => { return e.text === "NGA" ? "top" : "right"; }) .labelDotRadius(0.35) .labelSize((e) => e.size) .labelText("city") .labelResolution(6) .labelAltitude(0.01) .pointsData(airportHistory.airports) .pointColor(() => "#ffffff") .pointsMerge(true) .pointAltitude(0.07) .pointRadius(0.10); }, 1000); Globe.rotateX(-Math.PI * (1 / 50)); Globe.rotateY(-Math.PI * (1 / 9)); Globe.rotateZ(-Math.PI / 60); const globeMaterial = Globe.globeMaterial(); globeMaterial.color = new Color(0x3a228a); globeMaterial.emissive = new Color(0x220038); globeMaterial.emissiveIntensity = 0.1; globeMaterial.shininess = 0.7; // NOTE Cool stuff // globeMaterial.wireframe = true; scene.add(Globe); } init(); initGlobe(); onWindowResize(); animate(); window.addEventListener('resize', onWindowResize, false); renderer.domElement.addEventListener('mousemove', onMouseMove); console.log("Initializing globe animation"); return () => { clearTimeout(timeoutId); window.removeEventListener('resize', onWindowResize); renderer.domElement.removeEventListener('mousemove', onMouseMove); cancelAnimationFrame(frameId); if (containerRef.current) { // Perform more thorough clean-up here // Dispose of the scene's children while (scene.children.length > 0) { const object = scene.children[0]; if (object.dispose) { object.dispose(); } scene.remove(object); } // Dispose of the renderer and any associated resources renderer.dispose(); // Dispose of any controls, if necessary if (controls && controls instanceof OrbitControls && controls.dispose) { controls.dispose(); } if (renderer.domElement.parentNode === containerRef.current) { // Remove the renderer DOM element containerRef.current.removeChild(renderer.domElement); } } };}, []);
return ;
};
export default GlobeComponent;
- Assistant
Creating a full React Context implementation to manage your globe resources requires a careful approach to ensure that the context provides and cleans up the Three.js resources correctly.
Below, I'll show you a step-by-step approach, demonstrating how to create a
GlobeContextto manage and provide the globe-related state and resources to yourGlobeComponent. Keep in mind that this is a conceptual implementation and you may need to tweak certain parts based on your specific application requirements and state management strategy.First, let's set up the
GlobeContextand its provider:// GlobeContext.js import React, { createContext, useState, useEffect } from 'react'; import { WebGLRenderer, Scene, PerspectiveCamera } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import ThreeGlobe from 'three-globe'; export const GlobeContext = createContext(null); export const GlobeProvider = ({ children }) => { const [globeResources, setGlobeResources] = useState({ renderer: null, scene: null, camera: null, controls: null, globe: null, timeoutId: null, }); useEffect(() => { // Initialize the core Three.js elements const renderer = new WebGLRenderer({ antialias: true, alpha: true }); const scene = new Scene(); const camera = new PerspectiveCamera(); const controls = new OrbitControls(camera, renderer.domElement); const globe = new ThreeGlobe({/* ...initial properties for globe... */}); // ... other properties like lights, fog, etc. setGlobeResources({ renderer, scene, camera, controls, globe, timeoutId: null, // To be set when initiating arcs animation }); return () => { // Clean up the resources renderer.dispose(); controls.dispose(); // ... Additional cleanup logic }; }, []); return ( <GlobeContext.Provider value={globeResources}> {children} </GlobeContext.Provider> ); };Now, let's use this context in the
GlobeComponent:// GlobeComponent.jsx import React, { useContext, useEffect, useRef } from 'react'; import { GlobeContext } from './GlobeContext'; // ... the rest of your imports const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight }) => { const containerRef = useRef(); const { renderer, scene, camera, controls, globe, timeoutId, setGlobeResources, } = useContext(GlobeContext); // ... Event listeners and other functions like onWindowResize, and onMouseMove useEffect(() => { if (!renderer || !scene || !camera || !controls || !globe) return; // Initialize Three.js resources that depend on the DOM or need to be reset renderer.setSize(globeWidth, globeHeight); // ... other properties camera.aspect = globeWidth / globeHeight; camera.updateProjectionMatrix(); // ... other camera properties controls.update(); // required if controls.enableDamping or controls.autoRotate are set to true // Append renderer to the container containerRef.current.appendChild(renderer.domElement); // Set up and start the animation loop const animate = () => { // Animation loop code requestAnimationFrame(animate); }; animate(); return () => { // Clean up event listeners and cancel animation frame // ... }; }, [renderer, scene, camera, controls, globe]); // ... Additional effects to handle window resize and mouse movement return <div ref={containerRef} />; }; export default GlobeComponent;Use the
GlobeProviderto wrap your application or theGlobeComponentto ensure the context is provided:// App.jsx or a higher-order component import React from 'react'; import { GlobeProvider } from './GlobeContext'; import GlobeComponent from './GlobeComponent'; const App = () => { return ( <GlobeProvider> {/* Your other application components */} <GlobeComponent globeWidth={/*...*/} globeHeight={/*...*/} windowWidth={/*...*/} windowHeight={/*...*/} /> {/* Your other application components */} </GlobeProvider> ); }; export default App;Note that in this setup:
- The Three.js resources are managed in the
GlobeContextand initialized in theGlobeProvider. - The
GlobeComponentconsumes the context and takes care of rendering the globe in the DOM, setting up event listeners, and doing cleanup. - The
GlobeProvideris used at the application level to ensure that the context (with the Three.js resources) is available to any components that need it.
This context-based approach gives you a nice separation of concerns, keeping your resource management logic separate and making your components simpler and more focused on rendering. However, whenever working with a context and Three.js, you must carefully manage the resources to prevent memory leaks and ensure proper cleanup.
- The Three.js resources are managed in the
- User
Fill in the commented truncated section
- Assistant
Below you'll find the context initialization and consumption in the
GlobeContext.jsandGlobeComponent.jsxfiles, with the truncated sections filled in.GlobeContext.js
// GlobeContext.js import React, { createContext, useState, useEffect } from 'react'; import { WebGLRenderer, Scene, PerspectiveCamera, AmbientLight, PointLight, DirectionalLight, Color, Fog } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import ThreeGlobe from 'three-globe'; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json'; export const GlobeContext = createContext(null); export const GlobeProvider = ({ children }) => { const [globeResources, setGlobeResources] = useState({ renderer: null, scene: null, camera: null, controls: null, globe: null, timeoutId: null, }); useEffect(() => { // Initialize the core Three.js elements const renderer = new WebGLRenderer({ antialias: true, alpha: true }); const scene = new Scene(); const camera = new PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000); const controls = new OrbitControls(camera, renderer.domElement); // Set up the lighting const ambientLight = new AmbientLight(0xbbbbbb, 0.3); scene.add(ambientLight); const directionalLight = new DirectionalLight(0xffffff, 0.8); directionalLight.position.set(-800, 2000, 400); camera.add(directionalLight); const pointLight = new PointLight(0x8566cc, 0.5); pointLight.position.set(-200, 500, 200); camera.add(pointLight); // Set up the camera position camera.position.z = 400; // Set the fog for the scene if necessary scene.fog = new Fog(0x535ef3, 400, 2000); // Set up controls // ... (Configure your `controls` as needed) // Initialize the Globe const globe = new ThreeGlobe() .hexPolygonsData(countries.features) .hexPolygonResolution(3) .hexPolygonMargin(0.7) .showAtmosphere(true) .atmosphereColor("#ffffff") .atmosphereAltitude(0.1) // ... (Set other initial properties for the globe as needed) // Add the Globe to the scene scene.add(globe); setGlobeResources({ renderer, scene, camera, controls, globe, timeoutId: null, // To be set when initiating arcs animation }); return () => { // Clean up the resources renderer.dispose(); if (controls.dispose) controls.dispose(); // Additional cleanup logic, if required ... }; }, []); return ( <GlobeContext.Provider value={globeResources}> {children} </GlobeContext.Provider> ); };In the context, we have initialized the renderer, scene, and camera. We have added lights, configured the camera position, and set up controls for the camera. Furthermore, we have initialized the globe by specifying the hex polygons data and other properties relevant to the display of the globe.
GlobeComponent.jsx
// GlobeComponent.jsx import React, { useContext, useEffect, useRef } from 'react'; import { GlobeContext } from './GlobeContext'; // ... the rest of your imports const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight }) => { const containerRef = useRef(); const { renderer, scene, camera, controls, globe, timeoutId, setGlobeResources, } = useContext(GlobeContext); // Event listeners and other functions like onWindowResize, onMouseMove, etc. useEffect(() => { if (!renderer || !scene || !camera || !controls || !globe) return; // Set the size of the renderer renderer.setSize(window.innerWidth, window.innerHeight); containerRef.current.appendChild(renderer.domElement); camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); // Begin the Three.js render loop const animate = () => { requestAnimationFrame(animate); controls.update(); renderer.render(scene, camera); }; animate(); // Define and initiate your arcs, labels, and points using the globe instance // ... return () => { // Clean up event listeners and cancel animation frame // ... }; }, [renderer, scene, camera, controls, globe]); // Additional effects to handle window resize and mouse movement // ... return <div ref={containerRef} />; }; export default GlobeComponent;In the
GlobeComponent, the size of the renderer is set, and the renderer's DOM element is appended to the container ref. The camera's aspect ratio is updated, and an animation loop is begun. Additionally, you would define and initiate arcs, labels, and points for the globe using the globe instance that we have stored in the context.Please adjust the provided code as per your requirement. You'll need to properly integrate your globe initialization code to follow best practices for React components and Three.js resource management.
- User
how will this implementation ensure the arcs are shown upon returning to the page using fast refresh
- Assistant
The implementation provided does not ensure that the arcs will show upon returning to the page using fast refresh without including additional logic related to the arc animation state. Fast refresh is a Next.js feature that allows for quick feedback during development by reloading parts of the UI without losing the application state.
To ensure that the arcs are shown when you return to the page using fast refresh, you need to handle the reinitialization of the arcs within the React component lifecycle methods properly. A typical mistake is to assume the component will be totally remounted, but fast refresh may preserve some state, which could lead to unexpected behavior if not managed correctly.
Here's how to modify
GlobeComponentto ensure that the arcs are reinitialized correctly upon returning to the page with fast refresh:// GlobeComponent.jsx import React, { useContext, useEffect, useRef, useCallback } from 'react'; import { GlobeContext } from './GlobeContext'; // ...the rest of your imports const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight }) => { const containerRef = useRef(); const { renderer, scene, camera, controls, globe, timeoutId, setGlobeResources } = useContext(GlobeContext); // Event listeners and other functions like onWindowResize, onMouseMove, etc. // Function to initialize arcs - make sure it's wrapped with useCallback // to ensure a stable reference if needed by dependencies const initializeArcs = useCallback(() => { // Cancel any previously scheduled animation setups if (timeoutId) clearTimeout(timeoutId); const newTimeoutId = setTimeout(() => { globe .arcsData(travelHistory.flights) .arcColor((e) => e.status ? "#9cff00" : "#ff2e97") .arcAltitude((e) => e.arcAlt) .arcStroke((e) => e.status ? 0.5 : 0.3) // ... other properties and method calls related to arc animation // Trigger re-render globe.refresh(); }, 1000); // Update the context with the new timeoutId to ensure cleanup setGlobeResources((prevResources) => ({ ...prevResources, timeoutId: newTimeoutId })); }, [globe, setGlobeResources, timeoutId]); useEffect(() => { if (!renderer || !scene || !camera || !controls || !globe) return; // Append renderer to the container containerRef.current.appendChild(renderer.domElement); // Start the animation loop animate(); // Initialize arcs upon mounting and fast refreshes initializeArcs(); return () => { // Clean up event listeners, cancel animation frame, and clear timeouts // ... }; }, [renderer, scene, camera, controls, globe, initializeArcs]); // Start the animation loop const animate = useCallback(() => { if (!frameId) { // This inner function will be called recursively const loop = () => { frameId = requestAnimationFrame(loop); controls.update(); renderer.render(scene, camera); }; loop(); } }, [camera, controls, renderer, scene]); useEffect(() => { // Cleanup code, invoked when the component unmounts return () => { if (frameId) { cancelAnimationFrame(frameId); frameId = null; } }; }, []); // Additional effects to handle window resize, mouse movement, and other interactivity // ... return <div ref={containerRef} />; }; export default GlobeComponent;In this code:
- A new function
initializeArcswrapped withuseCallbackis used to reset the arc animations each time the component mounts, ensuring consistency after fast refresh. - A new
useEffecthook is introduced to start the animation loop. It will callinitializeArcswhen the component mounts. Thanks to theuseCallbackhook, the reference toinitializeArcswill only change if its dependencies change. The component will now reinitialize the arcs upon each mounting.
Since Next.js's fast refresh may preserve some React state between reloads, the
initializeArcsfunction should be idempotent. It should check if arcs already exist or are in the correct state before attempting to add them again to avoid duplication or conflicts. In the example above, the arcs are set up each time theinitializeArcsfunction is called, but your own logic might need to check for existing arcs first.Finally, bind the
initializeArcsandanimatefunctions in theuseEffecthooks to ensure they are executed correctly upon component mount and to handle cleanup upon unmounting. This ensures that when the component is re-rendered due to fast refresh, all resources are appropriately managed to display the arcs correctly. - A new function
- User
Show me how to account for fast refresh in the following implementation of GlobeComponent: import React, { useEffect, useRef } from 'react'; import { WebGLRenderer, Scene, AmbientLight, DirectionalLight, Color, Fog, PerspectiveCamera, PointLight } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import { createGlowMesh } from 'three-glow-mesh'; import ThreeGlobe from "three-globe"; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json';
let mouseX = 0; let mouseY = 0;
let timeoutId; let renderer, camera, scene, controls; let Globe; let frameId;
const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight, uniqueValue }) => { const containerRef = useRef(); let windowHalfX = windowWidth / 2; let windowHalfY = windowHeight / 2;
// Event listeners function onWindowResize() { camera.aspect = windowWidth / windowHeight; camera.updateProjectionMatrix(); windowHalfX = windowWidth; windowHalfY = windowHeight; renderer.setSize(windowWidth, windowHeight); } function onMouseMove(event) { mouseX = event.clientX - windowHalfX; mouseY = event.clientY - windowHalfY; // console.log("x: " + mouseX + " y: " + mouseY); } // Animation function animate() { camera.lookAt(scene.position); controls.update(); renderer.render(scene, camera); frameId = requestAnimationFrame(animate); }useEffect(() => { // Initialize core ThreeJS elements function init() { // Initialize renderer renderer = new WebGLRenderer({ antialias: true, alpha: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(globeWidth, globeHeight); renderer.setClearColor(0x000000, 0); containerRef.current.appendChild(renderer.domElement);
// Initialize scene, light scene = new Scene(); scene.add(new AmbientLight(0xbbbbbb, 0.4)); // Initialize camera, light camera = new PerspectiveCamera(); camera.aspect = globeWidth / globeHeight; camera.updateProjectionMatrix(); var dLight = new DirectionalLight(0xffffff, 0.8); dLight.position.set(-800, 2000, 400); camera.add(dLight); var dLight1 = new DirectionalLight(0x7982f6, 1); dLight1.position.set(-200, 500, 200); camera.add(dLight1); var dLight2 = new PointLight(0x8566cc, 0.5); dLight2.position.set(-200, 500, 200); camera.add(dLight2); camera.position.z = 400; camera.position.x = 0; camera.position.y = 0; scene.add(camera); // Additional effects scene.fog = new Fog(0x535ef3, 400, 2000); // Helpers // const axesHelper = new THREE.AxesHelper(800); // scene.add(axesHelper); // var helper = new THREE.DirectionalLightHelper(dLight); // scene.add(helper); // var helperCamera = new THREE.CameraHelper(dLight.shadow.camera); // scene.add(helperCamera); // Initialize controls controls = new OrbitControls(camera, renderer.domElement); controls.enableDamping = true; controls.dynamicDampingFactor = 0.01; controls.enablePan = false; controls.minDistance = Math.min(globeWidth, globeHeight) / 2; controls.maxDistance = Math.min(globeWidth, globeHeight) / 2; controls.rotateSpeed = 0.8; controls.zoomSpeed = 1; controls.autoRotate = false; controls.minPolarAngle = Math.PI / 3.5; controls.maxPolarAngle = Math.PI - Math.PI / 3; } // Initialize the Globe function initGlobe() { // Initialize the Globe Globe = new ThreeGlobe({ waitForGlobeReady: true, animateIn: true, }) .hexPolygonsData(countries.features) .hexPolygonResolution(3) .hexPolygonMargin(0.7) .showAtmosphere(true) .atmosphereColor("#ffffff") .atmosphereAltitude(0.1) .hexPolygonColor((e) => { if ( ["KEN", "CHN", "FRA", "ZAF", "JPN", "USA", "AUS", "CAN"].includes( e.properties.ISO_A3 ) ) { return "rgba(255,255,255, 1)"; } else return "rgba(255,255,255, 0.5)"; }); // NOTE Arc animations are followed after the globe enters the scene timeoutId = setTimeout(() => { Globe.arcsData(travelHistory.flights) .arcColor((e) => { return e.status ? "#9cff00" : "#ff2e97"; }) .arcAltitude((e) => { return e.arcAlt; }) .arcStroke((e) => { return e.status ? 0.5 : 0.3; }) .arcDashLength(0.9) .arcDashGap(4) .arcDashAnimateTime(1000) .arcsTransitionDuration(1000) .arcDashInitialGap((e) => e.order * 1) .labelsData(airportHistory.airports) .labelColor(() => "#ffffff") .labelDotOrientation((e) => { return e.text === "NGA" ? "top" : "right"; }) .labelDotRadius(0.35) .labelSize((e) => e.size) .labelText("city") .labelResolution(6) .labelAltitude(0.01) .pointsData(airportHistory.airports) .pointColor(() => "#ffffff") .pointsMerge(true) .pointAltitude(0.07) .pointRadius(0.10); }, 1000); Globe.rotateX(-Math.PI * (1 / 50)); Globe.rotateY(-Math.PI * (1 / 9)); Globe.rotateZ(-Math.PI / 60); const globeMaterial = Globe.globeMaterial(); globeMaterial.color = new Color(0x3a228a); globeMaterial.emissive = new Color(0x220038); globeMaterial.emissiveIntensity = 0.1; globeMaterial.shininess = 0.7; // NOTE Cool stuff // globeMaterial.wireframe = true; scene.add(Globe); } init(); initGlobe(); onWindowResize(); animate(); window.addEventListener('resize', onWindowResize, false); renderer.domElement.addEventListener('mousemove', onMouseMove); console.log("Initializing globe animation"); return () => { clearTimeout(timeoutId); window.removeEventListener('resize', onWindowResize); renderer.domElement.removeEventListener('mousemove', onMouseMove); cancelAnimationFrame(frameId); if (containerRef.current) { // Perform more thorough clean-up here // Dispose of the scene's children while (scene.children.length > 0) { const object = scene.children[0]; if (object.dispose) { object.dispose(); } scene.remove(object); } // Dispose of the renderer and any associated resources renderer.dispose(); // Dispose of any controls, if necessary if (controls && controls instanceof OrbitControls && controls.dispose) { controls.dispose(); } if (renderer.domElement.parentNode === containerRef.current) { // Remove the renderer DOM element containerRef.current.removeChild(renderer.domElement); } } };}, [uniqueValue]);
return ;
};
export default GlobeComponent;
- Assistant
To ensure that your
GlobeComponentresponds properly to Next.js's fast refresh feature, you should watch for changes to your component's props or state that would require a reinitialization of the Three.js scene. The uniqueValue prop seem to be intended for this purpose.Here's the updated
GlobeComponentcode:import React, { useEffect, useRef } from 'react'; import { WebGLRenderer, Scene, AmbientLight, DirectionalLight, Color, Fog, PerspectiveCamera, PointLight } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import ThreeGlobe from "three-globe"; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json'; const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight, uniqueValue }) => { const containerRef = useRef(); const globeRef = useRef(); let windowHalfX = windowWidth / 2; let windowHalfY = windowHeight / 2; let mouseX = 0; let mouseY = 0; let frameId; // Initialize core ThreeJS elements const init = () => { const renderer = new WebGLRenderer({ antialias: true, alpha: true }); // Other initialization code ... // Append renderer to the container, replacing old if exists if (containerRef.current.childNodes.length > 0) { containerRef.current.replaceChild(renderer.domElement, containerRef.current.childNodes[0]); } else { containerRef.current.appendChild(renderer.domElement); } const scene = new Scene(); // ... other properties const camera = new PerspectiveCamera(); // ... other properties // Set ambient light, directional light, point light ... scene.add(new AmbientLight(0xbbbbbb, 0.3)); // ... other light settings const controls = new OrbitControls(camera, renderer.domElement); // ... other controls settings // Return renderer, scene, camera, controls for usage in animate and other functions return { renderer, scene, camera, controls }; }; const initGlobe = (scene) => { // Initialize the Globe const globe = new ThreeGlobe(/* ... */); // ... Set up the globe scene.add(globe); globeRef.current = globe; }; // Function to animate the scene const animate = (renderer, scene, camera, controls) => { const animateFrame = () => { frameId = requestAnimationFrame(animateFrame); controls.update(); renderer.render(scene, camera); }; animateFrame(); }; useEffect(() => { const { renderer, scene, camera, controls } = init(); initGlobe(scene); animate(renderer, scene, camera, controls); window.addEventListener('resize', onWindowResize, false); renderer.domElement.addEventListener('mousemove', onMouseMove); return () => { // Cleanup window.removeEventListener('resize', onWindowResize); renderer.domElement.removeEventListener('mousemove', onMouseMove); // Cancel the animation frame cancelAnimationFrame(frameId); renderer.dispose(); camera.dispose(); controls.dispose(); scene.dispose(); }; }, [uniqueValue]); // Ensure re-initialization on `uniqueValue` change // Event listeners function onWindowResize() { // ... same as before } function onMouseMove(event) { mouseX = event.clientX - windowHalfX; mouseY = event.clientY - windowHalfY; } // Additional code, e.g., starting the arc animations useEffect(() => { if (globeRef.current) { // Start or re-start the arcs, labels, points animations upon uniqueValue change globeRef.current.clear(); // Clearing previous data if any before updating with new ones // Code to set arcs, labels, and points } }, [uniqueValue]); return <div ref={containerRef} />; }; export default GlobeComponent;In this updated
GlobeComponent, we focus on two primary areas:-
React
useEffecthook: The component relies on auniqueValuepassed as a prop to reinitialize the Three.js scene whenever this value changes. The idea is that theuniqueValueshould change whenever you want to restart the globe's animations (which might be an ID, timestamp, or any other value that updates when the page is re-entered). -
Clearing and starting animations: In the additional
useEffecthook, we are now clearing previous globe data and then starting the arcs, labels, and points animations afresh when theuniqueValuechanges.
This approach helps to manage the resources in the Three.js scene during fast refresh and ensures that the scene is initialized in a clean state whenever
uniqueValueupdates.Please make sure any dependent code inside
useEffecthooks responds well to fast refresh. If your animation, event listeners, or visual components rely on global variables or side effects, they should be managed withinuseEffecthooks or encapsulated within functions that will feature in the dependencies array of hooks. -
- User
I have made the correction but now, how do i handle adding the arcs without relying on timeoutId: import React, { useEffect, useRef } from 'react'; import { WebGLRenderer, Scene, AmbientLight, DirectionalLight, Color, Fog, PerspectiveCamera, PointLight } from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; import { createGlowMesh } from 'three-glow-mesh'; import ThreeGlobe from "three-globe"; import countries from './files/globe-data-min.json'; import travelHistory from './files/my-flights.json'; import airportHistory from './files/my-airports.json';
const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight, uniqueValue }) => { const containerRef = useRef(); const globeRef = useRef(); let windowHalfX = windowWidth / 2; let windowHalfY = windowHeight / 2;
let mouseX = 0; let mouseY = 0; let frameId; // Initialize core ThreeJS elements const init = () => { const renderer = new WebGLRenderer({ antialias: true, alpha: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(globeWidth, globeHeight); renderer.setClearColor(0x000000, 0); // Append renderer to the container, replacing old if exists if (containerRef.current.childNodes.length > 0) { containerRef.current.replaceChild(renderer.domElement, containerRef.current.childNodes[0]); } else { containerRef.current.appendChild(renderer.domElement); } const scene = new Scene(); scene.add(new AmbientLight(0xbbbbbb, 0.4)); const camera = new PerspectiveCamera(); camera.aspect = globeWidth / globeHeight; camera.updateProjectionMatrix(); // Set ambient light, directional light, point light … scene.add(new AmbientLight(0xbbbbbb, 0.3)); var dLight = new DirectionalLight(0xffffff, 0.8); dLight.position.set(-800, 2000, 400); camera.add(dLight); var dLight1 = new DirectionalLight(0x7982f6, 1); dLight1.position.set(-200, 500, 200); camera.add(dLight1); var dLight2 = new PointLight(0x8566cc, 0.5); dLight2.position.set(-200, 500, 200); camera.add(dLight2); camera.position.z = 400; camera.position.x = 0; camera.position.y = 0; scene.add(camera); // Additional effects scene.fog = new Fog(0x535ef3, 400, 2000); // Helpers // const axesHelper = new THREE.AxesHelper(800); // scene.add(axesHelper); // var helper = new THREE.DirectionalLightHelper(dLight); // scene.add(helper); // var helperCamera = new THREE.CameraHelper(dLight.shadow.camera); // scene.add(helperCamera); const controls = new OrbitControls(camera, renderer.domElement); controls.enableDamping = true; controls.dynamicDampingFactor = 0.01; controls.enablePan = false; controls.minDistance = Math.min(globeWidth, globeHeight) / 2; controls.maxDistance = Math.min(globeWidth, globeHeight) / 2; controls.rotateSpeed = 0.8; controls.zoomSpeed = 1; controls.autoRotate = false; controls.minPolarAngle = Math.PI / 3.5; controls.maxPolarAngle = Math.PI - Math.PI / 3; // Return renderer, scene, camera, controls for usage in animate and other functions return { renderer, scene, camera, controls }; }; const initGlobe = (scene) => { // Initialize the Globe const globe = new ThreeGlobe({ waitForGlobeReady: true, animateIn: true, }) .hexPolygonsData(countries.features) .hexPolygonResolution(3) .hexPolygonMargin(0.7) .showAtmosphere(true) .atmosphereColor("#ffffff") .atmosphereAltitude(0.1) .hexPolygonColor((e) => { if ( ["KEN", "CHN", "FRA", "ZAF", "JPN", "USA", "AUS", "CAN"].includes( e.properties.ISO_A3 ) ) { return "rgba(255,255,255, 1)"; } else return "rgba(255,255,255, 0.5)"; }); // NOTE Arc animations are followed after the globe enters the scene timeoutId = setTimeout(() => { globe.arcsData(travelHistory.flights) .arcColor((e) => { return e.status ? "#9cff00" : "#ff2e97"; }) .arcAltitude((e) => { return e.arcAlt; }) .arcStroke((e) => { return e.status ? 0.5 : 0.3; }) .arcDashLength(0.9) .arcDashGap(4) .arcDashAnimateTime(1000) .arcsTransitionDuration(1000) .arcDashInitialGap((e) => e.order * 1) .labelsData(airportHistory.airports) .labelColor(() => "#ffffff") .labelDotOrientation((e) => { return e.text === "NGA" ? "top" : "right"; }) .labelDotRadius(0.35) .labelSize((e) => e.size) .labelText("city") .labelResolution(6) .labelAltitude(0.01) .pointsData(airportHistory.airports) .pointColor(() => "#ffffff") .pointsMerge(true) .pointAltitude(0.07) .pointRadius(0.10); }, 1000); globe.rotateX(-Math.PI * (1 / 50)); globe.rotateY(-Math.PI * (1 / 9)); globe.rotateZ(-Math.PI / 60); const globeMaterial = globe.globeMaterial(); globeMaterial.color = new Color(0x3a228a); globeMaterial.emissive = new Color(0x220038); globeMaterial.emissiveIntensity = 0.1; globeMaterial.shininess = 0.7; // NOTE Cool stuff // globeMaterial.wireframe = true; // … Set up the globe scene.add(globe); globeRef.current = globe; }; // Function to animate the scene const animate = (renderer, scene, camera, controls) => { const animateFrame = () => { frameId = requestAnimationFrame(animateFrame); controls.update(); renderer.render(scene, camera); }; animateFrame(); }; useEffect(() => { const { renderer, scene, camera, controls } = init(); initGlobe(scene); animate(renderer, scene, camera, controls); window.addEventListener('resize', onWindowResize, false); renderer.domElement.addEventListener('mousemove', onMouseMove); return () => { // Cleanup window.removeEventListener('resize', onWindowResize); renderer.domElement.removeEventListener('mousemove', onMouseMove); // Cancel the animation frame cancelAnimationFrame(frameId); renderer.dispose(); camera.dispose(); controls.dispose(); scene.dispose(); }; }, [uniqueValue]); // Ensure re-initialization on uniqueValue change // Event listeners function onWindowResize() { camera.aspect = windowWidth / windowHeight; camera.updateProjectionMatrix(); windowHalfX = windowWidth; windowHalfY = windowHeight; renderer.setSize(windowWidth, windowHeight); } function onMouseMove(event) { mouseX = event.clientX - windowHalfX; mouseY = event.clientY - windowHalfY; } // Additional code, e.g., starting the arc animations useEffect(() => { if (globeRef.current) { // Start or re-start the arcs, labels, points animations upon uniqueValue change globeRef.current.clear(); // Clearing previous data if any before updating with new ones // Code to set arcs, labels, and points } }, []); return <div ref={containerRef} />;};
export default GlobeComponent;
- Assistant
To ensure that arc animations are initiated without relying on
timeoutId, you can leverage the completion of the globe's internal "ready" state, if thethree-globelibrary provides such an event, or move the setup inside auseEffectthat tracks when the globe is added to the Three.js scene. Let's refactor the globe initialization to avoid usingsetTimeout:// Import useState from 'react' to keep track of whether the globe is ready import React, { useEffect, useRef, useState } from 'react'; // ...other imports remain the same const GlobeComponent = ({ globeWidth, globeHeight, windowWidth, windowHeight, uniqueValue }) => { // ...other variables and useRef declarations remain the same const [isGlobeReady, setIsGlobeReady] = useState(false); // state to track globe readiness // ...other variables remain the same // ...init and initGlobe functions remain the same // Initialize arcs without setTimeout const initArcs = (globe) => { globe .arcsData(travelHistory.flights) .arcColor(e => e.status ? "#9cff00" : "#ff2e97") .arcAltitude(e => e.arcAlt) .arcStroke(e => e.status ? 0.5 : 0.3) // ...other methods to set arc properties .labelsData(airportHistory.airports) // ...additional label and point setup .pointsData(airportHistory.airports) // ...additional points setup }; useEffect(() => { const { renderer, scene, camera, controls } = init(); const globe = initGlobe(scene); // note this will no longer directly invoke setArcs if (globe) { // check if globe is instantiated // assuming three-globe has a built-in event or method we can use to detect // when it's ready to add arcs, you can replace this with that method setIsGlobeReady(true); // set isGlobeReady state to true when globe is initialized } animate(renderer, scene, camera, controls); // start animation loop // ...existing window event listeners return () => { // ...existing cleanup code }; }, [uniqueValue]); useEffect(() => { if (isGlobeReady && globeRef.current) { // Initialize arcs once globe is ready initArcs(globeRef.current); } }, [isGlobeReady]); // This effect runs when isGlobeReady state changes // ...existing event listeners and resize function return <div ref={containerRef} />; }; export default GlobeComponent;In this updated version, I've introduced a state variable
isGlobeReadythat is intended to be set totruewhen theThreeGlobeinstance is ready to be manipulated. Ideally, you'd use an event or method provided byThreeGlobeto reliably determine when it's safe to continue with the setup.The
initArcsfunction is called within auseEffecthook that watches theisGlobeReadystate. WhenisGlobeReadyturnstrue, the globe's arcs and associated data are initialized. This effectively replaces the need forsetTimeoutby directly tying the initiation of the arcs to the readiness state of the globe, which is a more deterministic way to manage the lifecycle.Please adjust the
initArcsfunction and theisGlobeReadystate mechanism to match the actual way thatThreeGlobesignals its readiness. IfThreeGlobedoesn't provide such an event or method, you might need an alternative approach, such as checking if certain properties or methods exist or setting a flag after initial setup.