Question

我正在使用带有着色器的OpenGL; glm为数学。

在我的代码中，我有两个模型：modelA和modelB。我有一个Transformable类，它可以在不同的轴上进行平移，缩放和旋转，然后将它们与变换矩阵相乘，我将用它来定义任何“事物”的变换。重要的是，此Transformable类返回变换矩阵，并将与模型矩阵相乘以应用某个变换。 modelA和modelB都是Model类型。此类继承自Transformable，因为它是可转换的。因此，它有一个返回变换矩阵的函数。问题在于它们汇集在一起：

class scene
{
public:
    scene();
    bool initialize();
    void render();

private:
    Model modelA, modelB;
    glm::mat4 modelMatrix;

    void passUniforms();
};

然后在初始化函数中：

initialize()
{
    modelA.load("file.obj");
    modelB.load("file2.3ds");
    // compile and link shaders
    // init lighting
    // init camera

    modelA.translate(glm::vec3(0.f, 10.f, 0.f));
    modelB.translate(glm::vec3(-10.f, 0.f, 0.f));

    modelMatrix *= modelA.getTransformationMatrix();
}

passUniforms()
{
    auto MVP = projectionMatrix * viewMatrix * modelMatrix;

    GLint MVP_id = glGetUniformLocation(programHandle, "MVP");
    glUniformMatrix4fv(MVP_id, 1, GL_FALSE, glm::value_ptr(MVP));

    // pass other uniforms
}

void render()
{
    passUniforms();
    modelA.render(programHandle);
    modelB.render(programHandle);
}

现在，让我们说清楚：两个模型渲染得很好，我不是制作场景图。照明工作，相机可以查看模型，模型纹理都很好。但是有一个问题：转换都是一样的！

乍一看，我可以看到问题出在哪里：我没有考虑到modelB的转换，所以毫无疑问OpenGL正在根据modelA的转换矩阵转换所有内容。叫我傻，或者我可能就是在这里做点什么;但我现在陷入困境，我可以独立地更新每个模型的位置。我的第一个解决方案是这样做：

initialize()
{
    // load models, compile shaders etc

    modelA.translate(glm::vec3(0.f, 10.f, 0.f));
    modelB.translate(glm::vec3(-10.f, 0.f, 0.f));

    modelMatrix *= modelA.getTransMatrix();
    passUniforms();

    modelMatrix = glm::mat4(1.0);

    modelMatrix *= modelB.getTransMatrix();
    passUniforms();
}

这也不起作用;两种模型仍然具有相同的转换。所以，我想也许它与我的顶点着色器有关，因为那是我应用转换的地方：

#version 430

layout (location = 0) in vec3 vp; // vertex position
layout (location = 1) in vec3 vt; // vertex textures
layout (location = 2) in vec3 vn; // vertex normals

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projMatrix;
uniform mat4 MVP;

// other things

void main()
{
    // eye calculations

    gl_Position = MVP * vec4(vp, 1.0);
}

在撰写本文时，我正在考虑解决此问题可能产生的各种解决方案。虽然，我认为对我自己的代码的客观分析会更好，所以我可以看到我在这里错了。我怎样才能让每个模型都相互独立地进行渲染？我不希望modelA的转换也是modelB的转换。如果此处的信息不够，请询问您需要的其他人。我希望你能在这里理解我的困境。： - ）

Answer 1

即使您没有制作明确的场景图，如果您有多个要渲染的对象，也总会涉及某种简单的场景图。

您必须重置为单位矩阵，并为每个对象分别进行矩阵乘法。

initialize()
{
    modelA.load("file.obj");
    modelB.load("file2.3ds");
    // compile and link shaders
    // init lighting
    // init camera


    modelB.translate(glm::vec3(-10.f, 0.f, 0.f));
}

passUniforms()
{
    auto MVP = projectionMatrix * viewMatrix * modelMatrix;

    GLint MVP_id = glGetUniformLocation(programHandle, "MVP");
    glUniformMatrix4fv(MVP_id, 1, GL_FALSE, glm::value_ptr(MVP));

    // pass other uniforms
}

void render()
{
    modelMatrix = glm::mat4(1.0);
    modelMatrix *= modelA.getTransformationMatrix();
    passUniforms();
    modelA.render(programHandle);

    modelMatrix = glm::mat4(1.0);
    modelMatrix *= modelB.getTransformationMatrix();
    passUniforms();
    modelB.render(programHandle);
}

无需计算反转。

Answer 2

虽然目前尚不清楚您实施的第一个解决方案是哪种功能，但我认为这样的方法可行 -

initialize()
{
    modelA.load("file.obj");
    modelB.load("file2.3ds");
    // compile and link shaders
    // init lighting
    // init camera

    modelA.translate(glm::vec3(0.f, 10.f, 0.f));
    modelB.translate(glm::vec3(-10.f, 0.f, 0.f));
}
void render()
{
   modelMatrix *= modelA.getTransMatrix();
   passUniforms();
   modelA.render(programHandle);

   // use the appropriate func to find inverse here to get original modelMatrix
   // if it not identity
   modelMatrix *= modelA.getTransMatrix().inverse;
   modelMatrix *= modelB.getTransMatrix();
   passUniforms();
   modelB.render(programHandle);
}

不同模型的转换不起作用

2 个答案: