Question

我有这个功能“cameraControl（const float＆amp; movementVleocity）”，什么都不做......我的意思是：

inline void controlCamera(const float& movementVelocity)
{

}

...我在主循环中这样称呼它：

basicCamera.controlCamera(2.0);

一切都很好......我的模型绘制并且没关系，直到......我添加了第二个这样的论点：

inline void controlCamera(const float& movementVelocity, const float& cameraVelocity)
{

}

...并在主循环中调用它：

basicCamera.controlCamera(2.0, 2.0);

得到一个黑屏...我的模型不再显示了...... 这绝对没有任何意义，我可以与... ...

编辑：

camera.h

#ifndef CAMERA_H_INCLUDED
#define CAMERA_H_INCLUDED

#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtx/rotate_vector.hpp>

#include <iostream>

using namespace std;
using namespace glm;

class camera
{
    public:
        camera(const vec3& position, const float& fieldOfView, const float& aspectRatio, const float& nearestDistance,
                const float& furtherDistance, const vec3& cameraForward, const vec3& cameraUp)
        {
            m_cameraPosition = position;
            m_cameraForward = cameraForward;
            m_cameraUp = cameraUp;
            m_cameraYaw = 0.0;
            m_cameraPitch = 0.0;

            m_perspective = perspective(fieldOfView, aspectRatio, nearestDistance, furtherDistance);
        }

        inline void lockCamera()
        {
            if(m_cameraYaw < 0)
                m_cameraYaw += 360;
            if(m_cameraYaw > 360)
                m_cameraYaw -= 360;
            if(m_cameraPitch > 90)
                m_cameraPitch = 90;
            if(m_cameraPitch < -90)
                m_cameraPitch = -90;
        }

        inline void moveCameraHorizontal(const float& direction, const float& distance)
        {
            m_cameraPosition.x = sinf(m_cameraYaw + direction) * distance;
            m_cameraPosition.z = cosf(m_cameraPitch + direction) * distance;
        }

        inline void moveCameraVertical(const float& direction, const float& distance)
        {
            m_cameraPosition.y = sinf(m_cameraPitch + direction) * distance;
        }

        inline void controlCamera(const float& movementVelocity, const float& cameraVelocity)
        {

        }

        inline mat4 getViewPerspective() const
        {
            return m_perspective * lookAt(m_cameraPosition, m_cameraPosition - m_cameraForward, m_cameraUp);
        }

    private:
        mat4 m_perspective;
        vec3 m_cameraPosition;
        vec3 m_cameraForward;
        vec3 m_cameraUp;
        float m_cameraYaw;
        float m_cameraPitch;
};

#endif // CAMERA_H_INCLUDED

的main.cpp

int main()
{
    // Initialize GLFW.
    if(!glfwInit())
    {
        cout << "GLFW could not initialize." << endl;
        return -1;
    }

    // Create window.
    GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "add_mesh_class", NULL, NULL);
    glfwMakeContextCurrent(window);

    // Initialize GLEW.
    GLuint err = glewInit();
    if(err != GLEW_OK)
    {
        cout << "GLEW could not initialize." << endl;
        glfwTerminate();
        return -1;
    }

    // Model data.
    mesh model_mesh("models/sky_ship.obj");
    float model_rotation = 0.0;

    // Initialize shaders.
    shader basicShader("shaders/basic");
    basicShader.useShader();

    // Initialize texture.
    texture model_texture("textures/red_lines.jpg");
    model_texture.useTexture(0);

    // Transformation class.
    transform mvTransform;

    // Camera class.
    camera basicCamera(vec3(0.0, 0.0, -5.0), 70, WINDOW_WIDTH / WINDOW_HEIGHT, 0.1, 1000.0, vec3(0.0, 0.0, -1.0), vec3(0.0, 1.0, 0.0));

    // Main loop.
    glEnable(GL_DEPTH_TEST);
    while(!glfwWindowShouldClose(window))
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Logic.
        model_rotation += 0.02;

        // Camera.
        basicCamera.lockCamera();
        basicCamera.controlCamera(2.0f, 2.0f);

        // Render.
        mvTransform.setRotation(model_rotation, vec3(0.0, 1.0, 0.0));
        mvTransform.setTranslation(vec3(0.0, 0.0, 0.0));
        basicShader.update(mvTransform, basicCamera);
        model_mesh.draw();

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

Answer 1

它可能是一个内存损坏错误，通过添加额外的参数，你巧妙地改变内存中的数据布局，并导致bug有一个明显的效果，在你摆脱它之前 - 即你是仍然覆盖记忆，但碰巧覆盖了一些不重要的东西。

通常编译器会删除你的函数，因为它什么都不做，但是我猜测你是在调试模式下进行编译，所以它可能不会对它进行优化。

在C ++函数中添加第二个参数会阻止OpenGL绘制？

1 个答案: