Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

Here is what my code does: The main is of rank 1. Under rank 1 line there will be 3…

  1. User

    Here is what my code does: The main 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.

    Make the middle line have the same fractal underneath it as well. Although it will need the y dimension changing for only the specific case of the middle line.

    Instead of: y: 1/2 of way across rank 1 line's y (toward the middle)

    Make the y: y: 1/3 of either left of right's height (in a zigzag pattern so downward for the left and upward for the right)

    // 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);
    
  2. Assistant

    To achieve the desired fractal pattern where the middle line recursively generates its own fractal with a zigzag pattern (downward for left and upward for right), you'll need to modify the regenerateFractal function in your Three.js code. Specifically, you'll adjust how the y-coordinate is calculated for the middle line during each iteration (rank) of the fractal generation.

    Below is a step-by-step guide along with the updated code to implement these changes:

    Overview of Changes

    1. Introduce Zigzag Direction Control:

      • Use a flag or a direction variable to alternate the y-coordinate adjustments for the middle line, creating the zigzag effect.
    2. Separate Middle Line Processing:

      • Identify the middle line in each set of sub-lines generated from a parent line.
      • Apply different y-coordinate calculations for the middle line based on the current zigzag direction.
    3. Recursive or Iterative Processing:

      • Modify the fractal generation logic to handle the middle line uniquely at each rank.

    Updated Code with Explanations

    Let's walk through the updated regenerateFractal function with comments explaining each change.

    <!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 (unchanged)
        const zoomSpeed = 0.8;
        // ... [Zoom logic code remains unchanged]
        window.addEventListener('wheel', onWheel, { passive: false });
        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 (unchanged)
        // ... [Panning code remains unchanged]
    
        // 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,
            isMiddle: false // Flag to identify middle lines
          }];
    
          // Initialize zigzag direction: true for upward, false for downward
          let zigzagDirection = true;
    
          // 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 the third points based on the given conditions
              const x0_2 = line.x1 + deltaX / 3;
              // Adjust y based on whether it's a middle line and the current zigzag direction
              let y0_2;
              if (line.isMiddle) {
                y0_2 = line.y1 + (zigzagDirection ? -deltaY / 3 : deltaY / 3);
              } else {
                y0_2 = line.y1 + deltaY / 2;
              }
    
              const x1_2 = line.x2 - deltaX / 3;
              let y1_2;
              if (line.isMiddle) {
                y1_2 = line.y2 + (zigzagDirection ? -deltaY / 3 : deltaY / 3);
              } else {
                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,
                isMiddle: false // These are side lines, not middle
              });
    
              // 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,
                isMiddle: false // These are side lines, not middle
              });
    
              // 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;
              // This is the middle line
              nextLines.push({
                x1: x0_2,
                y1: y0_2,
                z1: z,
                x2: x1_2,
                y2: y1_2,
                z2: z,
                isMiddle: true // Mark middle lines for zigzag
              });
            }
    
            // Alternate zigzag direction for the next rank
            zigzagDirection = !zigzagDirection;
    
            // 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
          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);
    
      </script>
    </body>
    </html>
    

    Detailed Explanation of Changes

    1. Zigzag Direction Control:

      • Introduced a zigzagDirection boolean variable initialized to true. This variable toggles between true and false at each rank to alternate the direction of the zigzag (upward or downward).
      • Inside the loop for each rank, after processing all lines, the zigzagDirection is toggled using zigzagDirection = !zigzagDirection;.
    2. Identifying Middle Lines:

      • Each line in the currentLines array now has an additional property isMiddle which is a boolean flag indicating whether the line is a middle line.
      • When adding sub-lines to nextLines, the middle line is marked with isMiddle: true, while the side lines are marked with isMiddle: false.
    3. Adjusting Y-Coordinates for Middle Lines:

      • For middle lines (isMiddle: true), the y-coordinate is adjusted by deltaY / 3 or -deltaY / 3 based on the current zigzagDirection.
        • Upward Zigzag (zigzagDirection === true): y-coordinate increases by deltaY / 3.
        • Downward Zigzag (zigzagDirection === false): y-coordinate decreases by deltaY / 3.
      • For side lines (isMiddle: false), the y-coordinate continues to be adjusted by deltaY / 2, as in the original logic.
    4. Marking Middle Lines for Recursion:

      • By marking middle lines with isMiddle: true, during subsequent iterations (ranks), these lines will further generate their own sub-fractals with the adjusted y-coordinates, creating the recursive fractal pattern only for the middle lines.
    5. Maintaining Efficient Buffer Usage:

      • The fractal lines are generated iteratively and stored in a single BufferGeometry. This approach ensures high performance even with a large number of lines.

    Visualizing the Zigzag Fractal

    With these changes, the fractal will now exhibit a zigzag pattern for the middle lines at each rank. The zigzagDirection ensures that the middle lines alternate between upward and downward adjustments, creating a visually appealing and symmetric fractal pattern.

    Here's how the fractal generation works at each rank:

    1. Rank 1 (Initial Main Line):

      • A single horizontal line from (-50, 0, 0) to (50, 0, 0).
    2. Rank 2:

      • Three lines are generated:
        • Left Side Line: From (-50, 0, 0) to ( -50 + (100 / 3), 0 + 0/2, 0 ) => Left third.
        • Middle Line: From ( -50 + (100 / 3), 0 + 0/2, 0 ) to ( 50 - (100 / 3), 0 - 0/2, 0 ) => Middle third (will have recursion with zigzag).
        • Right Side Line: From ( 50 - (100 / 3), 0 - 0/2, 0 ) to (50, 0, 0) => Right third.
    3. Rank 3 and Beyond:

      • Only the middle lines from the previous rank will generate their own sub-lines with adjusted y-coordinates based on the current zigzag direction.

    Additional Enhancements (Optional)

    1. Dynamic Control of Max Ranks:

      • You can add a GUI (e.g., using dat.GUI) to allow real-time adjustment of maxRanks for interactive exploration of the fractal complexity.
    2. Color Gradients:

      • Apply color gradients or varying line thickness based on the rank to enhance visual depth.
    3. Performance Optimization:

      • For extremely high maxRanks, consider implementing spatial partitioning or level-of-detail (LOD) techniques to maintain performance.
    4. Interactivity Enhancements:

      • Allow users to click and drag any line segment (not just the main line) to dynamically alter the fractal structure.

    Conclusion

    By introducing a zigzag direction control and distinguishing between middle and side lines during fractal generation, the updated regenerateFractal function creates a more complex and visually engaging fractal pattern. The recursive behavior is applied specifically to the middle lines, and the zigzag alternation ensures symmetry and aesthetic appeal.

    Feel free to further customize the fractal by experimenting with different ratios, directions, and recursion depths to achieve the exact pattern you desire.