Three.js 使用对象旋转光线投射器

我有一个可以在房间里拖动和旋转的对象

我的物体上有4个光线投射器，分别投射到物体的后部、前部、左侧和右侧，以查看它是否与某些墙相交。 到现在为止，我没有任何问题，一切正常

现在如果我把我的物体旋转60度，Racaster的原点在我物体的错误位置。 有没有办法将光线投射器“粘贴”到对象上

我有一个工作版本，当我只是旋转90度的步骤，但一切都不工作

为了更好的理解，我做了一些截图。箭头是射线

创建我的脚轮的代码：

/*** Returns 4 Raycasterst as array. Raycasters cast from right,left,front and back of the object */
createCasters(obj: THREE.Object3D, helper: THREE.BoxHelper ) {
    let bb = helper.geometry.boundingBox;

    let origin = obj.position.clone();
    origin.x = bb.getCenter().x;
    origin.y = bb.getCenter().y;
    origin.z = bb.getCenter().z;

    var matrix = new THREE.Matrix4();
    matrix.extractRotation(obj.matrix);

    let objDirection = obj.getWorldDirection();


    let directionRight = new THREE.Vector3(1, 0, 0);
    directionRight = directionRight.applyMatrix4(matrix);

    let directionLeft = new THREE.Vector3(-1, 0, 0);
    directionLeft = directionLeft.applyMatrix4(matrix);

    let directionFront = new THREE.Vector3(0, 0, 1);
    directionFront = directionFront.applyMatrix4(matrix);

    let directionBack = new THREE.Vector3(0, 0, -1);
    directionBack = directionBack.applyMatrix4(matrix);

    let left: THREE.Vector3, right: THREE.Vector3, front: THREE.Vector3, back: THREE.Vector3;
    // Vorne
    if (directionLeft.x == -1 || directionRight.x == 1) {
        left = new THREE.Vector3( obj.position.x, bb.getCenter().y,  obj.position.z + bb.getSize().z / 2 );
        right = new THREE.Vector3( obj.position.x + bb.getSize().x , bb.getCenter().y, obj.position.z+ bb.getSize().z / 2 );

        front = new THREE.Vector3(obj.position.x + bb.getSize().x/2, bb.getCenter().y, obj.position.z + bb.getSize().z / 2 );
        back = new THREE.Vector3( obj.position.x + bb.getSize().x/2, bb.getCenter().y, obj.position.z ); 
    }
    // Links
    else if (directionLeft.z == 1 || directionRight.z == -1) {
        left = new THREE.Vector3( obj.position.x + bb.getSize().x/2 , bb.getCenter().y, obj.position.z );
        right = new THREE.Vector3( obj.position.x + bb.getSize().x/2, bb.getCenter().y, obj.position.z - bb.getSize().z );

        front = new THREE.Vector3(obj.position.x + bb.getSize().x , bb.getCenter().y, obj.position.z - bb.getSize().z/2 );
        back = new THREE.Vector3(obj.position.x  , bb.getCenter().y, obj.position.z - bb.getSize().z/2);
    }
    // Rechts
    else if (directionLeft.z == -1 || directionRight.z == 1) {
        left = new THREE.Vector3(obj.position.x - bb.getSize().x/2, bb.getCenter().y, obj.position.z);
        right = new THREE.Vector3(obj.position.x - bb.getSize().x/2, bb.getCenter().y, obj.position.z + bb.getSize().z);

        front = new THREE.Vector3(obj.position.x - bb.getSize().x , bb.getCenter().y, obj.position.z + bb.getSize().z/2 );
        back = new THREE.Vector3(obj.position.x  , bb.getCenter().y, obj.position.z + bb.getSize().z/2);
    }
    // Hinten
    else if (directionLeft.x == 1 || directionRight.x == -1) {

        left = new THREE.Vector3(obj.position.x , bb.getCenter().y, obj.position.z - bb.getSize().z/2);
        right = new THREE.Vector3(obj.position.x - bb.getSize().x , bb.getCenter().y, obj.position.z- bb.getSize().z/2);

        front = new THREE.Vector3( obj.position.x - bb.getSize().x/2, bb.getCenter().y, obj.position.z - bb.getSize().z);
        back = new THREE.Vector3( obj.position.x - bb.getSize().x/2, bb.getCenter().y, obj.position.z ); 
    }
    // Schräg
    else {
        left = new THREE.Vector3( obj.position.x  , bb.getCenter().y, bb.getCenter().z);
        right = new THREE.Vector3( obj.position.x + bb.getSize().x , bb.getCenter().y, bb.getCenter().z);

        front = new THREE.Vector3( obj.position.x, bb.getCenter().y, obj.position.z);
        back = new THREE.Vector3( obj.position.x, bb.getCenter().y, obj.position.z);


        // #### Schräg nach oben ####
        if ( objDirection.z < 1 && objDirection.z > 0 ) {
            left = new THREE.Vector3( obj.position.x  , bb.getCenter().y, bb.getCenter().z);
            right = new THREE.Vector3( obj.position.x + bb.getSize().x , bb.getCenter().y, bb.getCenter().z);

            front = new THREE.Vector3( obj.position.x, bb.getCenter().y, obj.position.z);
            back = new THREE.Vector3( obj.position.x, bb.getCenter().y, obj.position.z);
          }
        if (objDirection.z > -1 && objDirection.z < 0) {

          }
      // ##########################
    }


    let raycasterLeft = new THREE.Raycaster(left, directionLeft);
    let raycasterRight = new THREE.Raycaster(right, directionRight);
    let raycasterFront = new THREE.Raycaster(front, directionFront);
    let raycasterBack = new THREE.Raycaster(back, directionBack);

    return [raycasterLeft, raycasterRight, raycasterFront, raycasterBack];
}

/***返回4个Raycasterst作为数组。光线投射器从对象的右侧、左侧、前部和后部投射*/
createCasters（obj:THREE.Object3D，helper:THREE.BoxHelper）{
设bb=helper.geometry.boundingBox；
让origin=obj.position.clone（）；
origin.x=bb.getCenter（）.x；
origin.y=bb.getCenter（）.y；
origin.z=bb.getCenter（）.z；
var矩阵=新的三个.Matrix4（）；
矩阵旋转（obj矩阵）；
设objDirection=obj.getWorldDirection（）；
设directionRight=new-THREE.Vector3（1,0,0）；
directionRight=directionRight.ApplyMatrix X4（矩阵）；
设directionLeft=new-thire.Vector3（-1,0,0）；
directionLeft=directionLeft.applyMatrix4（矩阵）；
设directionFront=new-THREE.Vector3（0,0,1）；
directionFront=directionFront.ApplyMatrix X4（矩阵）；
设directionBack=new-THREE.Vector3（0,0，-1）；
directionBack=directionBack.ApplyMatrix X4（矩阵）；
左：三。向量3，右：三。向量3，前：三。向量3，后：三。向量3；
//沃恩
if（directionLeft.x==1 | | directionRight.x==1）{
左=新的3.Vector3（对象位置x，bb.getCenter（）.y，对象位置z+bb.getSize（）.z/2）；
右=新的三个向量3（obj.position.x+bb.getSize（）.x，bb.getCenter（）.y，obj.position.z+bb.getSize（）.z/2）；
前端=新的三个矢量3（对象位置x+bb.getSize（）.x/2，bb.getCenter（）.y，对象位置z+bb.getSize（）.z/2）；
back=新的3.Vector3（obj.position.x+bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z）；
}
//链接
else if（directionLeft.z==1 | | directionRight.z==1）{
左=新的三个矢量3（对象位置x+bb.getSize（）.x/2，bb.getCenter（）.y，对象位置z）；
右=新的三个.Vector3（obj.position.x+bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z）；
front=新的三个向量3（obj.position.x+bb.getSize（）.x，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z/2）；
back=新的3.Vector3（obj.position.x，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z/2）；
}
//记录
else if（directionLeft.z=-1 | | directionRight.z==1）{
左=新的3.Vector3（obj.position.x-bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z）；
右=新的三个.Vector3（obj.position.x-bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z+bb.getSize（）.z）；
front=新的三个向量3（obj.position.x-bb.getSize（）.x，bb.getCenter（）.y，obj.position.z+bb.getSize（）.z/2）；
back=新的三个向量3（obj.position.x，bb.getCenter（）.y，obj.position.z+bb.getSize（）.z/2）；
}
//暗示
else if（directionLeft.x==1 | | directionRight.x==1）{
左=新的3.Vector3（obj.position.x，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z/2）；
右=新的三个向量3（obj.position.x-bb.getSize（）.x，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z/2）；
front=新的3.Vector3（obj.position.x-bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z-bb.getSize（）.z）；
back=新的3.Vector3（obj.position.x-bb.getSize（）.x/2，bb.getCenter（）.y，obj.position.z）；
}
//施拉格
否则{
左=新的3.Vector3（对象位置x，bb.getCenter（）.y，bb.getCenter（）.z）；
右=新的3.Vector3（obj.position.x+bb.getSize（）.x，bb.getCenter（）.y，bb.getCenter（）.z）；
front=新的三个矢量3（obj.position.x，bb.getCenter（）.y，obj.position.z）；
back=新的三个向量3（obj.position.x，bb.getCenter（）.y，obj.position.z）；
//######Schräg nach oben####
if（objDirection.z<1&&objDirection.z>0）{
左=新的3.Vector3（对象位置x，bb.getCenter（）.y，bb.getCenter（）.z）；
右=新的3.Vector3（obj.position.x+bb.getSize（）.x，bb.getCenter（）.y，bb.getCenter（）.z）；
front=新的三个矢量3（obj.position.x，bb.getCenter（）.y，obj.position.z）；
back=新的三个向量3（obj.position.x，bb.getCenter（）.y，obj.position.z）；
}
if（objDirection.z>-1&&objDirection.z<0）{
}
// ##########################
}
让raycasterLeft=新的三个。Raycaster（左，方向左）；
让raycasterRight=new-THREE.Raycaster（right，directionRight）；
让光线投射器前部=新的三个。光线投射器（前部，方向前部）；
让raycasterBack=new-THREE.Raycaster（back，directionBack）；
返回[光线投射器左，光线投射器右，光线投射器前，光线投射器后]；
}

首先，看起来您正在创建许多新对象（

Vector3

s）。如果可能的话，尝试一次性创建并重新使用它们。这对于频繁运行的函数尤其重要，因为在垃圾收集决定运行之前，您将用新对象污染堆（而且您永远不知道何时会运行）

第二，你只需要一个。只需使用检查的每个方向的新信息更新其

ray

属性。例如：

// raycaster is a THREE.Raycaster
// direction is a THREE.Vector3

// check +x
direction.set(1, 0, 0);
direction.applyQuaternion(caster.quaternion);
raycaster.ray.origin.copy(caster.boundingBox.getCenter());
raycaster.ray.direction.copy(direction);
results = raycaster.intersectObjects(scene);
if(results){
  // handle results
}

// check -x
direction.set(-1, 0, 0);
direction.applyQuaternion(caster.quaternion);
raycaster.ray.origin.copy(caster.boundingBox.getCenter());
raycaster.ray.direction.copy(direction);
results = raycaster.intersectObjects(scene);
if(results){
  // handle results
}

// and so on...

---

您可能可以看到模式，并可以构建一个函数来处理这些重复的代码。

您必须通过发布一些代码来帮助我们！如果您不发布一个最小的、完整的、可验证的示例，那么很难看出您的项目出了什么问题。看这里：当然，对不起。我想是这样的