Skip to content
The Chat Archive
gpt-3.5-turbo-0301· OpenAI WildChat-4.8M (AI2)

объект planeMesh должен находиться в направлении камеры всегда (и при повороте камеры),…

  1. User

    объект planeMesh должен находиться в направлении камеры всегда (и при повороте камеры), на определенном расстоянии от нее, сейчас planeMesh находится в одном месте все время и не поворачивается

    import * as THREE from 'three'; import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls'

    const scene = new THREE.Scene(); const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000); camera.position.z = 5;

    const renderer = new THREE.WebGLRenderer(); renderer.setSize(window.innerWidth, window.innerHeight); document.body.appendChild(renderer.domElement);

    const controls = new OrbitControls( camera, renderer.domElement ); controls.enableZoom = false;

    controls.enableDamping = true; controls.dampingFactor = 0.05;

    const shaderCode = document.getElementById("fragShader").innerHTML; THREE.ImageUtils.crossOrigin = ''; const texture = new THREE.TextureLoader().load('gradient-2.png');

    const loader = new GLTFLoader(); const url = 'GRAF_3_23.glb';

    loader.load(url, function (gltf) { const model = gltf.scene;

    model.traverse((child) => { if (child.isMesh) { const geometry = child.geometry;

      const texturePoint = new THREE.TextureLoader().load('texture3.png');
      
      const sizeVariation = 0.001;
    
      const geometryPoint = new THREE.BufferGeometry();
    
      const positions = geometry.getAttribute('position').array;
    
      
      const randomSize = [];
      for (let i = 0; i < positions.length; i += 3) {
        const startSize = 0.006;
        const size = startSize + (Math.random() * sizeVariation);
        randomSize.push(size, size, size); // каждый размер - это три компоненты размера в формате [x, y, z] 
      }
      // let startSize = 0.06;
      
      const materialPoint = new THREE.PointsMaterial({
        size: 0.03,
        sizeAttenuation: true,
        map: texturePoint,
        alphaTest: 0.01,
        transparent: true,
        color: new THREE.Color(1., 1., 1.),
        opacity: 1.
      });
      
      const sizes = new Float32Array(randomSize);
      geometryPoint.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
    
      const randomPosition = [];
      for (let i = 0; i < positions.length; i += 3) {
        randomPosition.push(10.0*Math.random()-5.0, 10.0*Math.random()-5.0, 10.0*Math.random()-5.0);
      }
      const randomPositionCopy = [...randomPosition];
    
      let increment = 0.002;
    
      geometryPoint.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
    
      const points = new THREE.Points(geometryPoint, materialPoint);
    
    
      geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
      function updateArray(increment) {
        for(let j = 0; j < 75; j++) {
          for(let i = 0; i<randomPosition.length; i++) {
            if (randomPosition[i] < positions[i]) {
              randomPosition[i] = randomPosition[i] + increment;
            } else if(randomPosition[i] > positions[i]) {
              randomPosition[i] = randomPosition[i] - increment;
            } else if((randomPosition[i] - positions[i]) < 0.002) {
              randomPosition[i] = positions[i];
            }
          }
        }
        geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
      }
      function reverseUpdateArray(increment) {
        for(let j = 0; j < 75; j++) {
          for(let i = 0; i<randomPosition.length; i++) {
            if (randomPosition[i] < randomPositionCopy[i]) {
              randomPosition[i] = randomPosition[i] + increment;
            } else if(randomPosition[i] > randomPositionCopy[i]) {
              randomPosition[i] = randomPosition[i] - increment;
            } else if((randomPosition[i] - randomPositionCopy[i]) < 0.002) {
              randomPosition[i] = randomPositionCopy[i];
            }
          }
        }
        geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
      }
    
      let time = 0;
      let sinPosition;
      let sinPosition2;
      let cosPosition;
      let randSignArray = [];
      let sign;
      let ratio = 1.0;
    
      for(let i = 0; i<randomPosition.length; i++) {
        sign = Math.random() < 0.5 ? -1.0 : 1.0;
        randSignArray[i] = sign;
      }
      geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
      // animateVerticles();
      // function animateVerticles() {
      //   requestAnimationFrame(animateVerticles);
      //   time += 0.1;
      //   sinPosition = Math.sin(time)*0.1;
      //   cosPosition = Math.cos(time*0.1)*0.1;
      //   sinPosition2 = Math.sin(time/Math.PI)*0.1;
      //   for(let i = 0; i<randomPosition.length; i++) {
      //     randomPosition[i] += (sinPosition * cosPosition * sinPosition2) * randSignArray[i] * ratio;
      //   }
      //   geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
      // }
    
      window.addEventListener('wheel', function(event) {
        if (event.deltaY > 0) {
          updateArray(increment);
          if(ratio > 0.0) {
            ratio -= 0.01;
          }
        } else {
          reverseUpdateArray(increment);
          ratio += 0.01;
        }
    
      });
    
    
      scene.add(points);
      points.rotateX(Math.PI/2.0);
    }
    

    }); camera.position.z = 3;

    // ________________________________________________________________________________________________________________________________________________

    // Создаем переменные для точки и радиуса
    

    let point = new THREE.Vector3(0, 0, 0); let radius = 1;

    // Создаем функцию для генерации случайной точки внутри заданного радиуса function generateRandomPointInRadius(radius) { let angle1 = Math.random() * 2 * Math.PI; let angle2 = Math.random() * 2 * Math.PI; let x = radius * Math.sin(angle1) * Math.cos(angle2); let y = radius * Math.sin(angle1) * Math.sin(angle2); let z = radius * Math.cos(angle1); return new THREE.Vector3(x, y, z); }

    // Инициализируем переменные для генерации случайной точки let randomPoint = generateRandomPointInRadius(radius); let dist = point.distanceTo(randomPoint); let t = 0;

    // Создаем функцию для анимации точки function animatePoint() { t += 0.01; if (t > 1) { randomPoint = generateRandomPointInRadius(radius); dist = point.distanceTo(randomPoint); t = 0; } let newPos = point.clone().lerp(randomPoint, t); let moveDist = newPos.distanceTo(point); if (moveDist >= dist) { randomPoint = generateRandomPointInRadius(radius); dist = point.distanceTo(randomPoint); t = 0; } point.copy(newPos); }

    // Добавляем точку на сцену let pointGeometry = new THREE.SphereGeometry(0.2, 32, 32); let pointMaterial = new THREE.MeshBasicMaterial({color: 0xff0000}); let pointMesh = new THREE.Mesh(pointGeometry, pointMaterial); pointMesh.position.set(point.x, point.y, point.z); // scene.add(pointMesh);

    // ________________________________________________________________________________________________________________________________________________

    let uniforms = { mouseCoord: {type:'v3', value: new THREE.Vector3()}, tex: { type:'t', value:texture }, res: { type:'v2', value:new THREE.Vector2(window.innerWidth,window.innerHeight)} };

    const planeGeometry = new THREE.PlaneGeometry(1000, 1000); const planeMaterial = new THREE.ShaderMaterial({ uniforms:uniforms, fragmentShader:shaderCode, side: THREE.DoubleSide }); const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial);

    // controls.addEventListener('change', function() { // planeMesh.quaternion.copy(camera.quaternion); // });

    let targetX = 0; let targetY = 0; let currentX = 0; let currentY = 0;

    const wrapperObject = new THREE.Object3D(); // создаем объект-обертку wrapperObject.position.set(0, 0, -10); // устанавливаем нужное расстояние от камеры

    wrapperObject.add(planeMesh); // добавляем объект внутрь обертки

    scene.add(wrapperObject); // добавляем обертку в сцену

    function update() { requestAnimationFrame(update); wrapperObject.lookAt(camera.position); // поворачиваем обертку в направлении камеры const diffX = targetX - currentX; const diffY = targetY - currentY; const distance = Math.sqrt(diffX * diffX + diffY * diffY); const speed = distance / 10; if (distance < 1.0) { currentX = targetX; currentY = targetY; } else { currentX += speed * diffX / distance; currentY += speed * diffY / distance; } } update();

    document.addEventListener('mousemove', (event) => { targetX = event.clientX; targetY = event.clientY; uniforms.mouseCoord.value.x = currentX; uniforms.mouseCoord.value.y = -currentY + window.innerHeight; });

    function animate() { requestAnimationFrame(animate); animatePoint(); controls.update(); uniforms.mouseCoord.value.x = currentX; uniforms.mouseCoord.value.y = -currentY + window.innerHeight; renderer.render(scene, camera); } animate(); });

    // // добавляем слушатель на controls // controls.addEventListener('change', function() { // planeMeshGradient.position.copy(camera.position); // planeMeshGradient.quaternion.copy(camera.quaternion); // });

  2. Assistant

    Для того, чтобы объект planeMesh всегда находился в направлении камеры и находился на определенном расстоянии от нее, можно создать объект-обертку (wrapperObject) и добавить в него planeMesh. Затем этот объект-обертку добавить в сцену. При этом объект-обертку необходимо установить на нужном расстоянии от камеры (wrapperObject.position.set()) и повернуть его в направлении камеры (wrapperObject.lookAt()).

    Для того, чтобы объект всегда находился на определенном расстоянии от камеры, можно использовать метод translateZ() у объекта-обертки. Например:

    // устанавливаем нужное расстояние от камеры wrapperObject.position.set(0, 0, -10);

    // При перемещении камеры все объекты, добавленные в объект-обертку будут следовать за камерой.

    // добавляем объект внутрь обертки wrapperObject.add(planeMesh);

    // добавляем обертку в сцену scene.add(wrapperObject);

    При этом следует обратить внимание на то, что при перемещении камеры и изменении ее направления объект также будет поворачиваться в направлении камеры с помощью метода wrapperObject.lookAt().

  3. User

    весь код

  4. Assistant

    Выше были приведены основные фрагменты кода, которые необходимо изменить для решения поставленной задачи. Далее приведен полный код, включая необходимые зависимости и другие детали.

    import * as THREE from 'three';
    import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
    import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls'
    
    // Создаем сцену, камеру и рендерер
    
    const scene = new THREE.Scene();
    const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
    camera.position.z = 5;
    
    const renderer = new THREE.WebGLRenderer();
    renderer.setSize(window.innerWidth, window.innerHeight);
    document.body.appendChild(renderer.domElement);
    
    // Добавляем орбитальные контролы
    
    const controls = new OrbitControls( camera, renderer.domElement );
    controls.enableZoom = false;
    
    // Добавляем шейдерный код
    
    const shaderCode = document.getElementById("fragShader").innerHTML;
    
    // Загружаем текстуру
    
    THREE.ImageUtils.crossOrigin = '';
    const texture = new THREE.TextureLoader().load('gradient-2.png');
    
    // Загружаем модель
    
    const loader = new GLTFLoader();
    const url = 'GRAF_3_23.glb';
    
    loader.load(url, function (gltf) {
    
      const model = gltf.scene;
      
      model.traverse((child) => {
        if (child.isMesh) {
    
          // Получаем геометрию, текстуру для точек и случайные размеры точек
    
          const geometry = child.geometry;
          const texturePoint = new THREE.TextureLoader().load('texture3.png');
          const sizeVariation = 0.001;
          const randomSize = [];
    
          for (let i = 0; i < positions.length; i += 3) {
            const startSize = 0.006;
            const size = startSize + (Math.random() * sizeVariation);
            randomSize.push(size, size, size); // каждый размер - это три компоненты размера в формате [x, y, z] 
          }
    
          // Создаем геометрию и материал для точек
    
          const geometryPoint = new THREE.BufferGeometry();
          const materialPoint = new THREE.PointsMaterial({
            size: 0.03,
            sizeAttenuation: true,
            map: texturePoint,
            alphaTest: 0.01,
            transparent: true,
            color: new THREE.Color(1., 1., 1.),
            opacity: 1.
          });
    
          // Задаем размеры точек
    
          const sizes = new Float32Array(randomSize);
          geometryPoint.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
    
          // Генерируем случайные позиции для точек 
    
          const randomPosition = [];
          
          for (let i = 0; i < positions.length; i += 3) {
            randomPosition.push(10.0*Math.random()-5.0, 10.0*Math.random()-5.0, 10.0*Math.random()-5.0);
          }
          
          const randomPositionCopy = [...randomPosition];
    
          let increment = 0.002;
       
          geometryPoint.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
    
          const points = new THREE.Points(geometryPoint, materialPoint);
    
          // Обновляем позиции точек в зависимости от события скролла
    
          function updateArray(increment) {
            for(let j = 0; j < 75; j++) {
              for(let i = 0; i<randomPosition.length; i++) {
                if (randomPosition[i] < positions[i]) {
                  randomPosition[i] = randomPosition[i] + increment;
                } else if(randomPosition[i] > positions[i]) {
                  randomPosition[i] = randomPosition[i] - increment;
                } else if((randomPosition[i] - positions[i]) < 0.002) {
                  randomPosition[i] = positions[i];
                }
              }
            }
            geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
          }
    
          function reverseUpdateArray(increment) {
            for(let j = 0; j < 75; j++) {
              for(let i = 0; i<randomPosition.length; i++) {
                if (randomPosition[i] < randomPositionCopy[i]) {
                  randomPosition[i] = randomPosition[i] + increment;
                } else if(randomPosition[i] > randomPositionCopy[i]) {
                  randomPosition[i] = randomPosition[i] - increment;
                } else if((randomPosition[i] - randomPositionCopy[i]) < 0.002) {
                  randomPosition[i] = randomPositionCopy[i];
                }
              }
            }
            geometryPoint.setAttribute('position', new THREE.BufferAttribute(new Float32Array(randomPosition), 3));
          }
    
          let time = 0;
          let sinPosition;
          let sinPosition2;
          let cosPosition;
          let randSignArray = [];
          let sign;
          let ratio = 1.0;
    
          for(let i = 0; i<randomPosition.length; i++) {
            sign = Math.random() < 0.5 ? -1.0 : 1.0;
            randSignArray[i] = sign;
          }
    
          // Добавляем точку на сцену
    
          let point = new THREE.Vector3(0, 0, 0);
          let pointGeometry = new THREE.SphereGeometry(0.2, 32, 32);
          let pointMaterial = new THREE.MeshBasicMaterial({color: 0xff0000});
          let pointMesh = new THREE.Mesh(pointGeometry, pointMaterial);
          pointMesh.position.set(point.x, point