Question

我一直在开发一个3D棋盘，但我一直试图将这些碎片拖了几天。

一旦我使用我的光线投射器选择一个物体，我开始我的拖动功能，它计算鼠标的当前位置（在世界坐标中）与其先前的位置之间的差异，然后我通过它们的差异来翻译我的对象坐标。

我通过绘制线来调试我的光线投射器，所以我确信这些坐标是准确的。

根据光线施法者坐标翻译我的物体只会使物体移动实际距离的一小部分。

我错过了一步吗？

-Calvin

我相信我的问题出在这行代码中......

glm::vec3 World_Delta = Current_World_Location - World_Start_Location;

如果我将等式乘以20，对象开始移动的次数就像我预期的那样，但它永远不会完全准确。

以下是一些相关代码

光线投射：

void CastRay(int mouse_x, int mouse_y) {

int Object_Selected = -1;
float Closest_Object = -1;

//getWorldCoordinates calls glm::unproject
nearPoint = Input_Math.getWorldCoordinates(glm::vec3(mouse_x, Window_Input_Info.getScreenHeight()-mouse_y, 0.0f));
farPoint = Input_Math.getWorldCoordinates(glm::vec3(mouse_x, Window_Input_Info.getScreenHeight()-mouse_y, 1.0f));

glm::vec3 direction = Input_Math.normalize(farPoint - nearPoint);

//getObjectStack() Retrieves all objects in the current scene
std::vector<LoadOBJ> objectList = Object_Input_Info.getObjectStack();
for (int i = 0; i < objectList.size(); i++) {
    std::vector<glm::vec3> Vertices = objectList[i].getVertices();
    for(int j = 0; j < Vertices.size(); j++) {
        if ( ( j + 1 ) % 3 == 0 ) {
            glm::vec3 face_normal = Input_Math.normalize(Input_Math.CrossProduct(Vertices[j-1] - Vertices[j-2], Vertices[j] - Vertices[j-2]));
            float nDotL = glm::dot(direction, face_normal);
            if (nDotL <= 0.0f ) { //if nDotL == 0 { Perpindicular } else if nDotL < 0 { SameDirection } else { OppositeDirection }
                float distance = glm::dot(face_normal, (Vertices[j-2] - nearPoint)) / nDotL;
                glm::vec3 p = nearPoint + distance * direction;
                glm::vec3 n1 = Input_Math.CrossProduct(Vertices[j-1] - Vertices[j-2], p - Vertices[j-2]);
                glm::vec3 n2 = Input_Math.CrossProduct(Vertices[j] - Vertices[j-1], p - Vertices[j-1]);
                glm::vec3 n3 = Input_Math.CrossProduct(Vertices[j-2] - Vertices[j], p - Vertices[j]);
                if( glm::dot(face_normal, n1) >= 0.0f && glm::dot(face_normal, n2) >= 0.0f && glm::dot(face_normal, n3) >= 0.0f ) {
                    if(p.z > Closest_Object) {

                        //I Create this "dragplane" to be used by my dragging function.
                        Drag_Plane[0] = (glm::vec3(Vertices[j-2].x, Vertices[j-2].y, p.z ));
                        Drag_Plane[1] = (glm::vec3(Vertices[j-1].x, Vertices[j-1].y, p.z ));
                        Drag_Plane[2] = (glm::vec3(Vertices[j].x  , Vertices[j].y  , p.z ));

                        //This is the object the we selected in the scene
                        Object_Selected = i; 

                        //These are the coordinate the ray intersected the object
                        World_Start_Location = p;

                    }
                }
            }
        }
    }
}
if(Object_Selected >= 0) { //If an object was intersected by the ray
    //selectObject -> Simply sets the boolean "dragging" to true
    selectObject(Object_Selected, mouse_x, mouse_y);
}

拖动如果

void DragObject(int mouse_x, int mouse_y) {

 if(dragging) {

    //Finds the Coordinates where the ray intersects the "DragPlane" set by original object intersection
    farPoint = Input_Math.getWorldCoordinates(glm::vec3(mouse_x, Window_Input_Info.getScreenHeight()-mouse_y, 1.0f));
    nearPoint = Input_Math.getWorldCoordinates(glm::vec3(mouse_x, Window_Input_Info.getScreenHeight()-mouse_y, 0.0f));
    glm::vec3 direction = Input_Math.normalize(farPoint - nearPoint);
    glm::vec3 face_normal = Input_Math.normalize(Input_Math.CrossProduct(Drag_Plane[1] - Drag_Plane[0], Drag_Plane[2] - Drag_Plane[0]));
    float nDotL = glm::dot(direction, face_normal);
    float distance = glm::dot(face_normal, (Drag_Plane[0] - nearPoint)) / nDotL;
    glm::vec3 Current_World_Location = nearPoint + distance * direction;

    //Calculate the difference between the current mouse location and its previous location
    glm::vec3 World_Delta = Current_World_Location - World_Start_Location;

    //Set the "start location" to the current location for the next loop
    World_Start_Location = Current_World_Location;

    //get the current object
    Object_Input_Info = Object_Input_Info.getObject(currentObject);

    //adds a translation matrix to the stack
    Object_Input_Info.TranslateVertices(World_Delta.x, World_Delta.y, World_Delta.z);

    //calculates the new vertices
    Object_Input_Info.Load_Data();

    //puts the new object back
    Object_Input_Info.Update_Object_Stack(currentObject);

 }
}

Answer 1

我的报道问题已经遇到了类似的问题。您可以执行以下操作，而不是在鼠标移动过程中跟踪转换：在鼠标按钮回调中，将“Delta”矢量从鼠标位置（在世界坐标中）（P_mouse）存储到对象位置（P_object）。它会是这样的：

Delta = P_object - P_mouse;

对于鼠标动作回调的每次调用，您只需通过以下方式更新对象位置：

P_object = P_mouse + Delta;

请注意，Delta在整个拖动过程中是不变的。

使用C ++和OpenGL拖动三维对象

1 个答案: