Lets refer back to my original thesis for the fractal pattern The main existing line is…
- User
Lets refer back to my original thesis for the fractal pattern
The main existing line is of rank 1. Under rank 1 line there will be 3 lines on rank 2 following these conditions: The first line's first point is tied to the leftmost vertex of the rank 1 line. This line's other point is defined as such: x: 1/3 of way across rank 1 line's x (toward the middle) y: 1/2 of way across rank 1 line's y (toward the middle)
The second line's first point is tied to the rightmost vertex of the rank 1 line. This line's other point is defined as such: x: 1/3 of way across rank 1 line's x (toward the middle) y: 1/2 of way across rank 1 line's y (toward the middle)
The line in the middle joins the leftmost and rightmost lines.
Currently the 'line in the middle' does not have a fractal underneath it. I'd like the line in the middle to have, in the fractal underneath, a zig-zag pattern based on these dimensions:
The zigzag should consist of 3 lines.
The first line's first point is tied to the leftmost vertex of the middle line. This line's other point is defined as such: x: 1/3 of way across the middle line's x (toward the middle) y: 1/3 of the height of either of the two other lines on the same rank (there is left, middle and right lines - either the left or the right's height as they are the same)
The second line's first point is tied to the rightmost vertex of the middle line. This line's other point is defined as such: x: 1/3 of way across the middle line's x (toward the middle) y: 1/3 of the height of either of the two other lines on the same rank (there is left, middle and right lines - either the left or the right's height as they are the same)
The last line joins the leftmost and rightmost lines in the middle.
This should create a sort of zig-zag pattern in fractal underneath the main middle line.
This piece is important:
THE ZIG-ZAG PATTERN SHOULD HAVE A FRACTAL UNDERNEATH IT TOO. THIS FRACTAL SHOULD HAVE THE SAME DIMENSIONS AS THE ORIGINAL FRACTAL INCLUDING THE ZIG-ZAG. THE ZIG-ZAG IS TO BE TREATED NO DIFFERENT AND IS NO DIFFERENT THAN THE MAIN FRACTAL OTHER THAN IT'S DIMENSIONS AND POSITION.
Please output full modified code
// Scene setup const scene = new THREE.Scene(); scene.background = new THREE.Color(0x000000); // Camera setup const aspectRatio = window.innerWidth / window.innerHeight; const cameraSize = 200; const camera = new THREE.OrthographicCamera( -cameraSize * aspectRatio, cameraSize * aspectRatio, cameraSize, -cameraSize, 1, 1000 ); camera.position.set(0, 0, 500); const renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setSize(window.innerWidth, window.innerHeight); document.body.appendChild(renderer.domElement); // Zoom logic (based on mouse wheel and key modifiers) const zoomSpeed = 0.8; function onWheel(event) { event.preventDefault(); const rect = renderer.domElement.getBoundingClientRect(); const mouseX = ((event.clientX - rect.left) / rect.width) * 2 - 1; const mouseY = -((event.clientY - rect.top) / rect.height) * 2 + 1; const mouseWorld = new THREE.Vector3(mouseX, mouseY, 0).unproject(camera); const zoomFactor = 1 - event.deltaY * 0.001 * zoomSpeed; const ctrlPressed = event.ctrlKey; const shiftPressed = event.shiftKey; if (ctrlPressed) { camera.left = (camera.left - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.right = (camera.right - mouseWorld.x) * zoomFactor + mouseWorld.x; } else if (shiftPressed) { camera.top = (camera.top - mouseWorld.y) * zoomFactor + mouseWorld.y; camera.bottom = (camera.bottom - mouseWorld.y) * zoomFactor + mouseWorld.y; } else { camera.left = (camera.left - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.right = (camera.right - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.top = (camera.top - mouseWorld.y) * zoomFactor + mouseWorld.y; camera.bottom = (camera.bottom - mouseWorld.y) * zoomFactor + mouseWorld.y; } camera.updateProjectionMatrix(); } // Prevent default browser behavior for wheel scrolling with Control or Shift key window.addEventListener('wheel', onWheel, { passive: false }); // Prevent default context menu on right-click window.addEventListener('contextmenu', (event) => { event.preventDefault(); }); // Render loop function animate() { requestAnimationFrame(animate); renderer.render(scene, camera); } // Handle window resize function onWindowResize() { const aspect = window.innerWidth / window.innerHeight; camera.left = -cameraSize * aspect; camera.right = cameraSize * aspect; camera.top = cameraSize; camera.bottom = -cameraSize; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); regenerateFractal(); } window.addEventListener('resize', onWindowResize); // Initialize animation animate(); // Panning functionality let isPanning = false; let isDraggingEndpoint = false; let selectedEndpointIndex = null; const previousMousePosition = new THREE.Vector2(); // Raycaster for detecting line interaction const raycaster = new THREE.Raycaster(); const mouse = new THREE.Vector2(); // Interactive main line code const lineMaterial = new THREE.LineBasicMaterial({ color: 0xffffff }); const mainLineGeometry = new THREE.BufferGeometry(); const mainLinePositions = new Float32Array([ -50, 0, 0, // Start point 50, 0, 0 // End point ]); mainLineGeometry.setAttribute('position', new THREE.BufferAttribute(mainLinePositions, 3)); const mainLine = new THREE.Line(mainLineGeometry, lineMaterial); mainLine.frustumCulled = false; scene.add(mainLine); // Fractal lines as a single LineSegments object const fractalMaterial = new THREE.LineBasicMaterial({ color: 0xffffff }); const fractalGeometry = new THREE.BufferGeometry(); const maxRanks = 10; // Parameter to control number of ranks // Calculate total number of lines based on maxRanks const totalLines = (Math.pow(3, maxRanks + 1) - 3) / 2; const fractalPositions = new Float32Array(totalLines * 2 * 3); // Each line has 2 points, each point has 3 coordinates fractalGeometry.setAttribute('position', new THREE.BufferAttribute(fractalPositions, 3)); fractalGeometry.setDrawRange(0, 0); // Initially no fractal lines fractalGeometry.attributes.position.setUsage(THREE.DynamicDrawUsage); // Inform Three.js that we'll be updating this buffer frequently const fractalLineSegments = new THREE.LineSegments(fractalGeometry, fractalMaterial); fractalLineSegments.frustumCulled = false; scene.add(fractalLineSegments); /** * Function to regenerate the fractal lines based on the current main line and maxRanks. * This function uses an iterative, rank-by-rank approach to generate all lines up to maxRanks. */ function regenerateFractal() { const positions = fractalGeometry.attributes.position.array; let offset = 0; const startX = mainLinePositions[0]; const startY = mainLinePositions[1]; const startZ = mainLinePositions[2]; const endX = mainLinePositions[3]; const endY = mainLinePositions[4]; const endZ = mainLinePositions[5]; // Initialize array for the current lines (starting with the main line) let currentLines = [{ x1: startX, y1: startY, z1: startZ, x2: endX, y2: endY, z2: endZ }]; // Iterate through each rank for (let rank = 1; rank <= maxRanks; rank++) { const nextLines = []; // Process each line in the current rank for (const line of currentLines) { const deltaX = line.x2 - line.x1; const deltaY = line.y2 - line.y1; const z = line.z1; // Assuming z is constant // Calculate intermediate points based on the given conditions const x0_2 = line.x1 + deltaX / 3; const y0_2 = line.y1 + deltaY / 2; const x1_2 = line.x2 - deltaX / 3; const y1_2 = line.y2 - deltaY / 2; // Line 1: from (x1, y1, z) to (x0_2, y0_2, z) positions[offset++] = line.x1; positions[offset++] = line.y1; positions[offset++] = z; positions[offset++] = x0_2; positions[offset++] = y0_2; positions[offset++] = z; nextLines.push({ x1: line.x1, y1: line.y1, z1: z, x2: x0_2, y2: y0_2, z2: z }); // Line 2: from (x2, y2, z) to (x1_2, y1_2, z) positions[offset++] = line.x2; positions[offset++] = line.y2; positions[offset++] = z; positions[offset++] = x1_2; positions[offset++] = y1_2; positions[offset++] = z; nextLines.push({ x1: x1_2, y1: y1_2, z1: z, x2: line.x2, y2: line.y2, z2: z }); // Line 3: from (x0_2, y0_2, z) to (x1_2, y1_2, z) positions[offset++] = x0_2; positions[offset++] = y0_2; positions[offset++] = z; positions[offset++] = x1_2; positions[offset++] = y1_2; positions[offset++] = z; nextLines.push({ x1: x0_2, y1: y0_2, z1: z, x2: x1_2, y2: y1_2, z2: z }); } // Prepare for the next rank currentLines = nextLines; } // Update the draw range based on the number of vertices generated fractalGeometry.setDrawRange(0, offset / 3); // Mark the attribute as needing an update fractalGeometry.attributes.position.needsUpdate = true; // Optional: Compute the bounding sphere for better rendering performance (can be skipped if unnecessary) fractalGeometry.computeBoundingSphere(); // Debugging: Log the total number of lines generated console.log(`Fractal regenerated with maxRanks=${maxRanks}. Total Lines: ${offset / 6}`); } // Initial fractal generation regenerateFractal(); /** * Function to update fractal lines when the main line changes. * This function cleans up any existing fractal lines and regenerates them based on the new main line. */ function updateFractalLines() { // Since we're reusing the buffer, simply regenerate the fractal regenerateFractal(); } // Set the distance for grabbing the line (in world units) const distanceForGrab = 2; // Set the raycaster's line precision raycaster.params.Line.threshold = distanceForGrab; // Predefine vectors to avoid excessive allocations const mouseWorld = new THREE.Vector3(); const deltaWorld = new THREE.Vector3(); const currentMouse = new THREE.Vector2(); const previousMouseWorld = new THREE.Vector3(); // Mouse down event function onMouseDown(event) { if (event.button === 2) { // Right-click for panning isPanning = true; previousMousePosition.set(event.clientX, event.clientY); } else if (event.button === 0) { // Left-click for dragging endpoints const rect = renderer.domElement.getBoundingClientRect(); mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1; mouse.y = - ((event.clientY - rect.top) / rect.height) * 2 + 1; raycaster.setFromCamera(mouse, camera); const intersects = raycaster.intersectObject(mainLine, true); if (intersects.length > 0) { const intersectPoint = intersects[0].point; const startX = mainLinePositions[0]; const startY = mainLinePositions[1]; const endX = mainLinePositions[3]; const endY = mainLinePositions[4]; const distanceToStart = intersectPoint.distanceTo(new THREE.Vector3(startX, startY, 0)); const distanceToEnd = intersectPoint.distanceTo(new THREE.Vector3(endX, endY, 0)); selectedEndpointIndex = (distanceToStart < distanceToEnd) ? 0 : 1; isDraggingEndpoint = true; previousMousePosition.set(event.clientX, event.clientY); } } } // Mouse move event function onMouseMove(event) { if (isPanning) { const deltaX = event.clientX - previousMousePosition.x; const deltaY = event.clientY - previousMousePosition.y; const zoomFactorX = camera.right - camera.left; const zoomFactorY = camera.top - camera.bottom; const panX = (deltaX / window.innerWidth) * zoomFactorX; const panY = (deltaY / window.innerHeight) * zoomFactorY; camera.left -= panX; camera.right -= panX; camera.top += panY; camera.bottom += panY; camera.updateProjectionMatrix(); previousMousePosition.set(event.clientX, event.clientY); } else if (isDraggingEndpoint) { const rect = renderer.domElement.getBoundingClientRect(); currentMouse.set( ((event.clientX - rect.left) / rect.width) * 2 - 1, - ((event.clientY - rect.top) / rect.height) * 2 + 1 ); // Convert screen coordinates to world coordinates const projector = new THREE.Vector3(currentMouse.x, currentMouse.y, 0).unproject(camera); const prevProjector = new THREE.Vector3( ((previousMousePosition.x - rect.left) / rect.width) * 2 - 1, - ((previousMousePosition.y - rect.top) / rect.height) * 2 + 1, 0 ).unproject(camera); deltaWorld.subVectors(projector, prevProjector); // Update the selected endpoint const index = selectedEndpointIndex * 3; mainLinePositions[index] += deltaWorld.x; mainLinePositions[index + 1] += deltaWorld.y; // Mark the position attribute as needing update mainLineGeometry.attributes.position.needsUpdate = true; mainLineGeometry.computeBoundingSphere(); previousMousePosition.set(event.clientX, event.clientY); // Update fractal lines after changing the main line updateFractalLines(); } } // Mouse up event function onMouseUp(event) { if (event.button === 2) { // Right-click isPanning = false; } else if (event.button === 0) { // Left-click isDraggingEndpoint = false; } } // Add event listeners for mouse actions window.addEventListener('mousedown', onMouseDown); window.addEventListener('mousemove', onMouseMove); window.addEventListener('mouseup', onMouseUp); - Assistant
Certainly! Below is the fully modified HTML code incorporating your fractal generation requirements. The key changes are made in the
regenerateFractalfunction to implement the zig-zag pattern for the middle lines and ensure that each zig-zag line recursively generates its own fractal pattern. Comments have been added to highlight these modifications for clarity.<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>High-Performance Three.js Fractal Pattern</title> <style> body { margin: 0; } canvas { display: block; } </style> </head> <body> <script type="module"> import * as THREE from './three.module.js'; // Scene setup const scene = new THREE.Scene(); scene.background = new THREE.Color(0x000000); // Camera setup const aspectRatio = window.innerWidth / window.innerHeight; const cameraSize = 200; const camera = new THREE.OrthographicCamera( -cameraSize * aspectRatio, cameraSize * aspectRatio, cameraSize, -cameraSize, 1, 1000 ); camera.position.set(0, 0, 500); const renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setSize(window.innerWidth, window.innerHeight); document.body.appendChild(renderer.domElement); // Zoom logic (based on mouse wheel and key modifiers) const zoomSpeed = 0.8; function onWheel(event) { event.preventDefault(); const rect = renderer.domElement.getBoundingClientRect(); const mouseX = ((event.clientX - rect.left) / rect.width) * 2 - 1; const mouseY = -((event.clientY - rect.top) / rect.height) * 2 + 1; const mouseWorld = new THREE.Vector3(mouseX, mouseY, 0).unproject(camera); const zoomFactor = 1 - event.deltaY * 0.001 * zoomSpeed; const ctrlPressed = event.ctrlKey; const shiftPressed = event.shiftKey; if (ctrlPressed) { camera.left = (camera.left - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.right = (camera.right - mouseWorld.x) * zoomFactor + mouseWorld.x; } else if (shiftPressed) { camera.top = (camera.top - mouseWorld.y) * zoomFactor + mouseWorld.y; camera.bottom = (camera.bottom - mouseWorld.y) * zoomFactor + mouseWorld.y; } else { camera.left = (camera.left - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.right = (camera.right - mouseWorld.x) * zoomFactor + mouseWorld.x; camera.top = (camera.top - mouseWorld.y) * zoomFactor + mouseWorld.y; camera.bottom = (camera.bottom - mouseWorld.y) * zoomFactor + mouseWorld.y; } camera.updateProjectionMatrix(); } // Prevent default browser behavior for wheel scrolling with Control or Shift key window.addEventListener('wheel', onWheel, { passive: false }); // Prevent default context menu on right-click window.addEventListener('contextmenu', (event) => { event.preventDefault(); }); // Render loop function animate() { requestAnimationFrame(animate); renderer.render(scene, camera); } // Handle window resize function onWindowResize() { const aspect = window.innerWidth / window.innerHeight; camera.left = -cameraSize * aspect; camera.right = cameraSize * aspect; camera.top = cameraSize; camera.bottom = -cameraSize; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); regenerateFractal(); } window.addEventListener('resize', onWindowResize); // Initialize animation animate(); // Panning functionality let isPanning = false; let isDraggingEndpoint = false; let selectedEndpointIndex = null; const previousMousePosition = new THREE.Vector2(); // Raycaster for detecting line interaction const raycaster = new THREE.Raycaster(); const mouse = new THREE.Vector2(); // Interactive main line code const lineMaterial = new THREE.LineBasicMaterial({ color: 0xffffff }); const mainLineGeometry = new THREE.BufferGeometry(); const mainLinePositions = new Float32Array([ -50, 0, 0, // Start point 50, 0, 0 // End point ]); mainLineGeometry.setAttribute('position', new THREE.BufferAttribute(mainLinePositions, 3)); const mainLine = new THREE.Line(mainLineGeometry, lineMaterial); mainLine.frustumCulled = false; scene.add(mainLine); // Fractal lines as a single LineSegments object const fractalMaterial = new THREE.LineBasicMaterial({ color: 0xffffff }); const fractalGeometry = new THREE.BufferGeometry(); const maxRanks = 10; // Parameter to control number of ranks // Estimated maximum number of lines based on maxRanks // Each normal line generates 3 lines, each zig-zag line generates 3 lines // Total lines = 3^maxRanks const totalLines = Math.pow(3, maxRanks + 1); const fractalPositions = new Float32Array(totalLines * 2 * 3); // Each line has 2 points, each point has 3 coordinates fractalGeometry.setAttribute('position', new THREE.BufferAttribute(fractalPositions, 3)); fractalGeometry.setDrawRange(0, 0); // Initially no fractal lines fractalGeometry.attributes.position.setUsage(THREE.DynamicDrawUsage); // Inform Three.js that we'll be updating this buffer frequently const fractalLineSegments = new THREE.LineSegments(fractalGeometry, fractalMaterial); fractalLineSegments.frustumCulled = false; scene.add(fractalLineSegments); /** * Recursive function to generate fractal lines. * @param {Object} line - The line object with x1, y1, x2, y2. * @param {number} currentRank - The current rank of the fractal. * @param {number} maxRank - The maximum rank to generate. * @param {Float32Array} positions - The buffer array to store line positions. * @param {Object} offsetObj - An object containing the current offset in the buffer. */ function generateFractal(line, currentRank, maxRank, positions, offsetObj) { if (currentRank > maxRank) return; const deltaX = line.x2 - line.x1; const deltaY = line.y2 - line.y1; // Calculate points for division const x0 = line.x1 + deltaX / 3; const y0 = line.y1 + deltaY / 2; const x1 = line.x2 - deltaX / 3; const y1 = line.y2 - deltaY / 2; // Generate left line positions[offsetObj.offset++] = line.x1; positions[offsetObj.offset++] = line.y1; positions[offsetObj.offset++] = 0; positions[offsetObj.offset++] = x0; positions[offsetObj.offset++] = y0; positions[offsetObj.offset++] = 0; // Push the left line for next iteration generateFractal({x1: line.x1, y1: line.y1, x2: x0, y2: y0}, currentRank + 1, maxRank, positions, offsetObj); // Generate right line positions[offsetObj.offset++] = line.x2; positions[offsetObj.offset++] = line.y2; positions[offsetObj.offset++] = 0; positions[offsetObj.offset++] = x1; positions[offsetObj.offset++] = y1; positions[offsetObj.offset++] = 0; // Push the right line for next iteration generateFractal({x1: x1, y1: y1, x2: line.x2, y2: line.y2}, currentRank + 1, maxRank, positions, offsetObj); // Generate middle line - Zig-Zag Pattern // First line of zig-zag const middleLineMidX = (x0 + x1) / 2; const zigZagHeight = Math.abs(line.y2 - line.y1) / 2; // 1/3 of height of other lines as per thesis const zzX1 = x0 + (deltaX / 3); const zzY1 = y0 + (zigZagHeight / 3); const zzX2 = x1 - (deltaX / 3); const zzY2 = y1 + (zigZagHeight / 3); // Line from (x0, y0) to (zzX1, zzY1) positions[offsetObj.offset++] = x0; positions[offsetObj.offset++] = y0; positions[offsetObj.offset++] = 0; positions[offsetObj.offset++] = zzX1; positions[offsetObj.offset++] = zzY1; positions[offsetObj.offset++] = 0; // Push the first zig-zag line for next iteration generateFractal({x1: x0, y1: y0, x2: zzX1, y2: zzY1}, currentRank + 1, maxRank, positions, offsetObj); // Line from (x1, y1) to (zzX2, zzY2) positions[offsetObj.offset++] = x1; positions[offsetObj.offset++] = y1; positions[offsetObj.offset++] = 0; positions[offsetObj.offset++] = zzX2; positions[offsetObj.offset++] = zzY2; positions[offsetObj.offset++] = 0; // Push the second zig-zag line for next iteration generateFractal({x1: zzX2, y1: zzY2, x2: x1, y2: y1}, currentRank + 1, maxRank, positions, offsetObj); // Line connecting the two zig-zag points positions[offsetObj.offset++] = zzX1; positions[offsetObj.offset++] = zzY1; positions[offsetObj.offset++] = 0; positions[offsetObj.offset++] = zzX2; positions[offsetObj.offset++] = zzY2; positions[offsetObj.offset++] = 0; // Push the connecting line for next iteration generateFractal({x1: zzX1, y1: zzY1, x2: zzX2, y2: zzY2}, currentRank + 1, maxRank, positions, offsetObj); } /** * Function to regenerate the fractal lines based on the current main line and maxRanks. * This function uses a recursive approach to generate all lines up to maxRanks. */ function regenerateFractal() { const positions = fractalGeometry.attributes.position.array; let offsetObj = { offset: 0 }; const startX = mainLinePositions[0]; const startY = mainLinePositions[1]; const endX = mainLinePositions[3]; const endY = mainLinePositions[4]; const mainFractalLine = { x1: startX, y1: startY, x2: endX, y2: endY }; // Start recursive fractal generation generateFractal(mainFractalLine, 1, maxRanks, positions, offsetObj); // Update the draw range based on the number of vertices generated fractalGeometry.setDrawRange(0, offsetObj.offset); // Mark the attribute as needing an update fractalGeometry.attributes.position.needsUpdate = true; // Optional: Compute the bounding sphere for better rendering performance (can be skipped if unnecessary) fractalGeometry.computeBoundingSphere(); // Debugging: Log the total number of lines generated console.log(`Fractal regenerated with maxRanks=${maxRanks}. Total Vertex Points: ${offsetObj.offset}`); } // Initial fractal generation regenerateFractal(); /** * Function to update fractal lines when the main line changes. * This function cleans up any existing fractal lines and regenerates them based on the new main line. */ function updateFractalLines() { // Since we're reusing the buffer, simply regenerate the fractal regenerateFractal(); } // Set the distance for grabbing the line (in world units) const distanceForGrab = 2; // Set the raycaster's line precision raycaster.params.Line.threshold = distanceForGrab; // Predefine vectors to avoid excessive allocations const mouseWorld = new THREE.Vector3(); const deltaWorld = new THREE.Vector3(); const currentMouse = new THREE.Vector2(); const previousMouseWorld = new THREE.Vector3(); // Mouse down event function onMouseDown(event) { if (event.button === 2) { // Right-click for panning isPanning = true; previousMousePosition.set(event.clientX, event.clientY); } else if (event.button === 0) { // Left-click for dragging endpoints const rect = renderer.domElement.getBoundingClientRect(); mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1; mouse.y = - ((event.clientY - rect.top) / rect.height) * 2 + 1; raycaster.setFromCamera(mouse, camera); const intersects = raycaster.intersectObject(mainLine, true); if (intersects.length > 0) { const intersectPoint = intersects[0].point; const startPoint = new THREE.Vector3(mainLinePositions[0], mainLinePositions[1], 0); const endPoint = new THREE.Vector3(mainLinePositions[3], mainLinePositions[4], 0); const distanceToStart = intersectPoint.distanceTo(startPoint); const distanceToEnd = intersectPoint.distanceTo(endPoint); selectedEndpointIndex = (distanceToStart < distanceToEnd) ? 0 : 1; isDraggingEndpoint = true; previousMousePosition.set(event.clientX, event.clientY); } } } // Mouse move event function onMouseMove(event) { if (isPanning) { const deltaX = event.clientX - previousMousePosition.x; const deltaY = event.clientY - previousMousePosition.y; const zoomFactorX = camera.right - camera.left; const zoomFactorY = camera.top - camera.bottom; const panX = (deltaX / window.innerWidth) * zoomFactorX; const panY = (deltaY / window.innerHeight) * zoomFactorY; camera.left -= panX; camera.right -= panX; camera.top += panY; camera.bottom += panY; camera.updateProjectionMatrix(); previousMousePosition.set(event.clientX, event.clientY); } else if (isDraggingEndpoint) { const rect = renderer.domElement.getBoundingClientRect(); currentMouse.set( ((event.clientX - rect.left) / rect.width) * 2 - 1, - ((event.clientY - rect.top) / rect.height) * 2 + 1 ); // Convert screen coordinates to world coordinates const projector = new THREE.Vector3(currentMouse.x, currentMouse.y, 0).unproject(camera); const prevProjector = new THREE.Vector3( ((previousMousePosition.x - rect.left) / rect.width) * 2 - 1, - ((previousMousePosition.y - rect.top) / rect.height) * 2 + 1, 0 ).unproject(camera); deltaWorld.subVectors(projector, prevProjector); // Update the selected endpoint const index = selectedEndpointIndex * 3; mainLinePositions[index] += deltaWorld.x; mainLinePositions[index + 1] += deltaWorld.y; // Mark the position attribute as needing update mainLineGeometry.attributes.position.needsUpdate = true; mainLineGeometry.computeBoundingSphere(); previousMousePosition.set(event.clientX, event.clientY); // Update fractal lines after changing the main line updateFractalLines(); } } // Mouse up event function onMouseUp(event) { if (event.button === 2) { // Right-click isPanning = false; } else if (event.button === 0) { // Left-click isDraggingEndpoint = false; } } // Add event listeners for mouse actions window.addEventListener('mousedown', onMouseDown); window.addEventListener('mousemove', onMouseMove); window.addEventListener('mouseup', onMouseUp); </script> </body> </html>Key Modifications and Explanations:
-
Recursive Fractal Generation:
-
generateFractalFunction:- This is a new recursive function that generates fractal lines based on your thesis.
- For each line, it creates three sub-lines: two side lines and a middle zig-zag pattern.
- The zig-zag pattern consists of three lines forming a "V" shape, which themselves can have fractals recursively applied.
-
Zig-Zag Implementation:
- Instead of adding a straight middle line, the zig-zag is created by calculating two additional points (
zzX1, zzY1andzzX2, zzY2) which form the peaks of the zig-zag. - These points are calculated based on the dimensions specified in your thesis (e.g.,
1/3of the way across the x-axis and1/3of the height for the y-axis). - The connecting line between these two points creates the zig-zag pattern.
- Instead of adding a straight middle line, the zig-zag is created by calculating two additional points (
-
-
Buffer Management:
-
Preallocating the Buffer:
- The
totalLinesis estimated based onmaxRanksto ensure theFloat32Arraycan accommodate all possible line segments. - Each line consists of two points, and each point has three coordinates (x, y, z), hence the size
totalLines * 2 * 3.
- The
-
Using an Offset Object:
- An
offsetObjis used to keep track of the current position in the buffer array during the recursive generation. This avoids passing and returning the offset value through the recursive calls.
- An
-
-
Regenerate Fractal Function:
regenerateFractalFunction:- This function initializes the fractal generation by defining the main fractal line (from the start to the end of
mainLine). - It then calls the
generateFractalfunction to recursively populate thefractalPositionsarray. - After the recursive generation, it updates the buffer's draw range and marks the position attribute for update.
- This function initializes the fractal generation by defining the main fractal line (from the start to the end of
-
Event Handling and Interactivity:
-
Dragging Endpoints:
- When you drag an endpoint of the main line, the
regenerateFractalfunction is called to update the fractal based on the new main line position.
- When you drag an endpoint of the main line, the
-
Panning and Zooming:
- These functionalities remain unchanged and allow for intuitive navigation of the fractal pattern.
-
-
Performance Considerations:
-
Dynamic Draw Usage:
- The buffer geometry is set to
DynamicDrawUsageto inform Three.js that the buffer will be updated frequently.
- The buffer geometry is set to
-
Computing Bounding Sphere:
- After regenerating the fractal, the bounding sphere is computed to optimize rendering performance.
-
-
Debugging:
- A console log statement has been added to indicate when the fractal is regenerated and display the total number of vertex points generated. This can help in monitoring performance and ensuring correctness.
How It Works:
-
Main Line Interaction:
- The main line is interactive. You can drag its endpoints using the left mouse button to reshape the fractal.
- Right-click and drag to pan the view.
-
Fractal Generation:
- Upon any change to the main line, the
regenerateFractalfunction is invoked. - This function starts the recursive generation of fractal lines based on the main line's current position.
- Each line generates three new lines according to the specified rules, including the zig-zag pattern for the middle line.
- The process repeats recursively up to the defined
maxRanks.
- Upon any change to the main line, the
-
Rendering:
- All fractal lines are rendered as
LineSegmentsin a singleBufferGeometryfor high performance. - As the fractal grows exponentially with each rank, it's important to keep
maxRanksat a reasonable value to maintain performance.
- All fractal lines are rendered as
Usage Tips:
-
Adjusting
maxRanks:- The
maxRanksvariable controls the depth of the fractal. Increasing it will create more detailed fractals but may impact performance.
- The
-
Optimizing Performance:
- Consider implementing level-of-detail (LOD) techniques or culling strategies if you plan to increase
maxRankssignificantly.
- Consider implementing level-of-detail (LOD) techniques or culling strategies if you plan to increase
-
Customizing the Zig-Zag:
- The current implementation uses
1/3of the x-axis and1/3of the height for the zig-zag dimensions. You can adjust these ratios to alter the appearance of the zig-zag pattern.
- The current implementation uses
This modified code should now generate a fractal pattern with the desired zig-zag middle lines, each recursively containing their own fractal patterns. Feel free to adjust
maxRanksand other parameters to explore different fractal complexities and behaviors. -