Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

fix that center centering at grid array center, so it can zoom normally right at the…

  1. User

    fix that center centering at grid array center, so it can zoom normally right at the center of 3d matrix cube point structure.:const canvas = document.getElementById("canvas"); const ctx = canvas.getContext("2d");

    canvas.width = window.innerWidth; canvas.height = window.innerHeight;

    const rotationSpeed = 0.001; const gridSize = 50; const gridSpacing = 25; const zoomStep = 5; const minZoom = 100; const maxZoom = 10000; const centerFocus = 180;

    let grid = []; for (let x = -gridSize; x <= gridSize; x += gridSpacing) { for (let y = -gridSize; y <= gridSize; y += gridSpacing) { for (let z = -gridSize; z <= gridSize; z += gridSpacing) { grid.push({ x, y, z }); } } }

    let lastClickedPoint = null; const clickedPoints = []; let angleX = 0; let angleY = 0; let zoom = 800; let dragStart = null;

    function rotate(point, angleX, angleY) { const { x, y, z } = point;

    const offsetX = ((centerFocus - minZoom) / (centerFocus - minZoom)) * gridSize / 2; const offsetZ = ((maxZoom - centerFocus) / (maxZoom - minZoom)) * gridSize / 2;

    const xPos = x - offsetX; const yPos = y - offsetX; const zPos = z - offsetZ;

    const cosX = Math.cos(angleX); const sinX = Math.sin(angleX); const cosY = Math.cos(angleY); const sinY = Math.sin(angleY);

    const newY = yPos * cosX - zPos * sinX; const newZ = yPos * sinX + zPos * cosX; const newX = xPos * cosY - newZ * sinY; const newZ2 = xPos * sinY + newZ * cosY;

    return { x: newX + offsetX, y: newY + offsetX, z: newZ2 + offsetZ }; }

    function calculateGridCenter(grid) { let totalX = 0; let totalY = 0; let totalZ = 0; const pointsCount = grid.length;

    for (const point of grid) { totalX += point.x; totalY += point.y; totalZ += point.z; }

    return { x: totalX / pointsCount, y: totalY / pointsCount, z: totalZ / pointsCount, }; }

    const gridCenter = calculateGridCenter(grid);

    function project(point, width, height, center) { const { x, y, z } = point;

    const offsetX = (x - gridCenter.x) * zoom / 10000; const offsetY = (y - gridCenter.y) * zoom / 10000; const offsetZ = (z - gridCenter.z) * zoom / 10000;

    const scale = zoom / (zoom / 2 + offsetZ); const newX = offsetX * scale + width / 2; const newY = offsetY * scale + height / 2;

    return { x: newX, y: newY, scale }; }

    function findClosestPoint(point) { const threshold = 20; let minDist = Infinity; let minIndex = -1;

    for (let i = 0; i < grid.length; i++) { const projected = project(rotate(grid[i], angleX, angleY), canvas.width, canvas.height); const dx = point.x - projected.x; const dy = point.y - projected.y; const dist = Math.sqrt(dx * dx + dy * dy);

    if (dist < minDist && dist <= threshold) {
      minDist = dist;
      minIndex = i;
    }
    

    }

    return minIndex !== -1 ? grid[minIndex] : null; }

    let mouseDown = false; let activeLine = null; const lines = [];

    canvas.addEventListener("wheel", (e) => { e.preventDefault(); zoom += e.deltaY * -0.1 * zoomStep; zoom = Math.min(Math.max(zoom, minZoom), maxZoom); // Limit zoom to min and max thresholds });

    canvas.addEventListener("mousedown", (e) => { dragStart = { x: e.clientX, y: e.clientY }; });

    canvas.addEventListener("mousemove", (e) => { if (dragStart) { const deltaX = e.clientX - dragStart.x; const deltaY = e.clientY - dragStart.y; angleX += deltaY * 0.01; angleY += deltaX * 0.01; dragStart = { x: e.clientX, y: e.clientY }; } });

    canvas.addEventListener("mouseup", (e) => { mouseDown = false; dragStart = null; if (activeLine !== null) { const canvasRect = canvas.getBoundingClientRect(); const mouseX = e.clientX - canvasRect.left; const mouseY = e.clientY - canvasRect.top; const endPoint = findClosestPoint({ x: mouseX, y: mouseY });

    if (endPoint !== activeLine[activeLine.length - 1]) { activeLine.push(endPoint); lines.push(activeLine); } activeLine = null; }

    if (lastClickedPoint !== null) { const canvasRect = canvas.getBoundingClientRect(); const mouseX = e.clientX - canvasRect.left; const mouseY = e.clientY - canvasRect.top; const clickedPoint = findClosestPoint({ x: mouseX, y: mouseY });

    if (clickedPoint !== null) { if (lastClickedPoint === clickedPoint) { lastClickedPoint = null; } else { lines.push([lastClickedPoint, clickedPoint]); clickedPoints.push(clickedPoint); lastClickedPoint = null; } } } else { const canvasRect = canvas.getBoundingClientRect(); const mouseX = e.clientX - canvasRect.left; const mouseY = e.clientY - canvasRect.top; const clickedPoint = findClosestPoint({ x: mouseX, y: mouseY });

    if (clickedPoint !== null) { lastClickedPoint = clickedPoint; clickedPoints.push(clickedPoint); } } }); function drawLine(line) { ctx.beginPath();

    for (let i = 0; i < line.length - 1; i++) { const projectedStart = project(rotate(line[i], angleX, angleY), canvas.width, canvas.height); const projectedEnd = project(rotate(line[i + 1], angleX, angleY), canvas.width, canvas.height);

    ctx.moveTo(projectedStart.x, projectedStart.y);
    ctx.lineTo(projectedEnd.x, projectedEnd.y);
    

    }

    ctx.strokeStyle = "rgba(25,200,25,0.2)"; ctx.lineWidth = 2; ctx.stroke(); }

    function draw() { ctx.fillStyle = "rgba(1,2,1,0.8)"; ctx.fillRect(0, 0, canvas.width, canvas.height);

    for (const point of grid) { const rotated = rotate(point, angleX, angleY); const projected = project(rotated, canvas.width, canvas.height);

    ctx.beginPath();
    ctx.arc(projected.x, projected.y, 2 * projected.scale, 0, Math.PI * 2);
    ctx.closePath();
    const gradient = ctx.createRadialGradient(projected.x, projected.y, 0, projected.x, projected.y, 2 * projected.scale);
    gradient.addColorStop(0, "rgba(255,155,255,0.5)");
    gradient.addColorStop(0.5, "rgba(55,255,25,0.8)");
    gradient.addColorStop(1, "rgba(55,25,255,0.2)");
    ctx.fillStyle = gradient;
    ctx.fill();
    

    }

    // Drawing clicked points in green ctx.fillStyle = "rgba(255,200,50,0.5)"; for (const clickedPoint of clickedPoints) { const rotated = rotate(clickedPoint, angleX, angleY); const projected = project(rotated, canvas.width, canvas.height);

    ctx.beginPath();
    ctx.arc(projected.x, projected.y, 4 * projected.scale, 0, Math.PI * 2);
    ctx.closePath();
    ctx.fill();
    

    }

    for (const line of lines) { drawLine(line); }

    if (activeLine !== null) { drawLine(activeLine); }

    angleX += rotationSpeed; angleY += rotationSpeed;

    requestAnimationFrame(draw); }

    draw();

  2. Assistant

    Based on your description, I believe you want the rotation and zooming to be centered on the center of the grid (center of the 3D matrix cube). I have made adjustments to the code to center the rotation and zooming around the calculated grid center. I hope this resolves your issues.

    const canvas = document.getElementById("canvas");
    const ctx = canvas.getContext("2d");
    
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
    
    const rotationSpeed = 0.001;
    const gridSize = 50;
    const gridSpacing = 25;
    const zoomStep = 5;
    const minZoom = 100;
    const maxZoom = 10000;
    
    let grid = [];
    for (let x = -gridSize; x <= gridSize; x += gridSpacing) {
      for (let y = -gridSize; y <= gridSize; y += gridSpacing) {
        for (let z = -gridSize; z <= gridSize; z += gridSpacing) {
          grid.push({ x, y, z });
        }
      }
    }
    
    let lastClickedPoint = null;
    const clickedPoints = [];
    let angleX = 0;
    let angleY = 0;
    let zoom = 800;
    let dragStart = null;
    
    function rotate(point, angleX, angleY) {
      const { x, y, z } = point;
    
      const cosX = Math.cos(angleX);
      const sinX = Math.sin(angleX);
      const cosY = Math.cos(angleY);
      const sinY = Math.sin(angleY);
    
      const newY = cosX * (y - gridCenter.y) - sinX * (z - gridCenter.z) + gridCenter.y;
      const newZ = sinX * (y - gridCenter.y) + cosX * (z - gridCenter.z) + gridCenter.z;
      const newX = cosY * (x - gridCenter.x) - sinY * (newZ - gridCenter.z) + gridCenter.x;
    
      return { x: newX, y: newY, z: newZ };
    }
    
    function calculateGridCenter(grid) {
      let totalX = 0;
      let totalY = 0;
      let totalZ = 0;
      const pointsCount = grid.length;
    
      for (const point of grid) {
        totalX += point.x;
        totalY += point.y;
        totalZ += point.z;
      }
    
      return {
        x: totalX / pointsCount,
        y: totalY / pointsCount,
        z: totalZ / pointsCount,
      };
    }
    
    const gridCenter = calculateGridCenter(grid);
    
    function project(point, width, height) {
      const { x, y, z } = point;
    
      const scale = zoom / (zoom + z - gridCenter.z);
      const newX = ((x - gridCenter.x) * scale) + width / 2;
      const newY = ((y - gridCenter.y) * scale) + height / 2;
    
      return { x: newX, y: newY, scale };
    }
    
    // Rest of the code, with "center" argument removed from project().
    

    Now, the center of rotation and zoom should be at the center of the grid. All other functionalities should work the same.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.