Question

经过相当长的Google会话后，我已经足够了！

我有一个带有一些简单Quad的python / opengl应用程序，我使用gluLookAt在场景中移动。然后我在其中一个Quad上只需要1个纹理，所以我显然现在使用着色器程序为这个Quad。

现在当我使用gluLookAt时，带纹理的Quad不会移动，我也能理解。

现在有什么方法可以以某种方式让gluLookAt函数使用着色器程序，获取当前矩阵堆栈，这样我就可以用它来提供着色器程序，或者我是否必须重写孔应用程序并重新发明glulookup函数{ {3}}（在着色器或CPU上）？

EDIT1： 我用：

python 3.5
PyOpenGL 3.1.0
GLSL 1.4（like he did）

EDIT2（我的解决方案）：

自从我打开这个帖子以来，有些事情发生了变化，但在你的指导下，我设法得到了一个现代的＆amp;稳定的解决方案。

我必须绘制3个主要组件。静态场，一些线（为了更好的可视化）和一些可移动四边形。

现在，字段一次写入数组中的VBO。（与单个绘图命令相比的主要改进）

可移动的正方形和线条的工作原理相同，但它们是动态的，必须每帧重新上传。

Foreach类型的对象我有一个顶点+片段着色器程序。我知道我只能使用一个大的，但这不应该是它应该是。

每个矩阵（模型，视图，投影）都被赋予一个制服，然后与顶点着色器中VBO的顶点相乘。

字段顶点着色器（示例）：

#version 330

uniform mat4 uniform_Model;
uniform mat4 uniform_View;
uniform mat4 uniform_Projection;

in vec3 Quad_Color_Attrib;
in vec3 Quad_Size_Attrib;

out vec3 frag_ColorId;

void main()
{
    // Pass the tex coord straight through to the fragment shader
    frag_ColorId = Quad_Color_Attrib;

    // Remember : inverted !
    gl_Position = uniform_Projection * uniform_View * uniform_Model * vec4(Quad_Size_Attrib,1);
}

我要求的不是正确的方法。（结合新旧OpenGL）不幸的是，我无法分享漏洞代码，但我在这里你可以找到所有opengl密钥代码：

顶点/片段着色器程序加载器：

According to this list

初始化顶点/片段着色器（在本例中为字段）

def init_field(self, p_VertexShaderPath, p_FragmentShaderPath, p_FieldList, p_FieldCount):
    # ############### Field Shader ###############

    # Shader Program
    self.m_FieldShader = LoadShaders(p_VertexShaderPath, p_FragmentShaderPath)
    glUseProgram(self.m_FieldShader)

    # VAO
    self.m_FieldVAO = glGenVertexArrays(1)
    glBindVertexArray(self.m_FieldVAO)

    # Field Definition        
    self.m_FieldCount = p_FieldCount
    t_Vertices = []

    for t_FieldNr in p_FieldList:
        x = p_FieldList[t_FieldNr].m_XPos
        y = p_FieldList[t_FieldNr].m_YPos
        cr = p_FieldList[t_FieldNr].m_Color[0]/255
        cg = p_FieldList[t_FieldNr].m_Color[1]/255
        cb = p_FieldList[t_FieldNr].m_Color[2]/255

        t_Vertices.extend([
             x - 0.5,  y + 0.5, 0.0,  cr, cg, cb,   #  0----1
             x + 0.5,  y + 0.5, 0.0,  cr, cg, cb,   #  |    |
             x + 0.5,  y - 0.5, 0.0,  cr, cg, cb,   #  |    |
             x - 0.5,  y - 0.5, 0.0,  0, 0, 0    #  3----2
        ])

    t_FieldVerticesBuffer = numpy.array(t_Vertices, dtype = numpy.float32)

    # VBO
    self.m_FieldVBO = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, self.m_FieldVBO)
    glBufferData(GL_ARRAY_BUFFER, t_FieldVerticesBuffer.nbytes, t_FieldVerticesBuffer, GL_STATIC_DRAW)

    # VBO Size Attrib
    self.m_FieldVerticesAttrib = glGetAttribLocation(self.m_FieldShader, "Quad_Size_Attrib")
    glEnableVertexAttribArray(self.m_FieldVerticesAttrib)
    glVertexAttribPointer(self.m_FieldVerticesAttrib,
                          3, 
                          GL_FLOAT, 
                          GL_FALSE, 
                          ctypes.sizeof(6*GLfloat), 
                          ctypes.c_void_p(0))

    # VBO Color Attrib                      
    self.m_FieldColorAttrib = glGetAttribLocation(self.m_FieldShader, "Quad_Color_Attrib")
    glEnableVertexAttribArray(self.m_FieldColorAttrib)
    glVertexAttribPointer(self.m_FieldColorAttrib,
                          3, 
                          GL_FLOAT, 
                          GL_FALSE, 
                          ctypes.sizeof(6*GLfloat), 
                          ctypes.c_void_p(12))

    # Uniform Locations
    self.m_Field_ModelMat_Uniform = glGetUniformLocation(self.m_FieldShader, 'uniform_Model')
    self.m_Field_ViewMat_Uniform = glGetUniformLocation(self.m_FieldShader, 'uniform_View')
    self.m_Field_ProjectionMat_Uniform = glGetUniformLocation(self.m_FieldShader, 'uniform_Projection')

    # Detach Shader & VAO
    glBindVertexArray(0)  # unbind the VAO
    glUseProgram(0)  # Disable shader

屏幕绘制周期

现在这只是psydo代码：

OpenGLEnv.Clear()
OpenGLEnv.SetCamera()
OpenGLEnv.DrawField()
OpenGLEnv.FlipBuffer()

所以SetCamera设置了ViewMat和ProjectionMat。

def SetCamera(self, camera, zoom_distance):
    self.m_ViewMat = lookAt(glm.vec3(-camera[0], -camera[1], zoom_distance),  # Camera is at (x,x,x), in World Space
                            glm.vec3(-camera[0], -camera[1], -100),  # and looks at the origin
                            glm.vec3(0, 1, 0)) #  Head is up (set to 0,-1,0 to look upside-down)
    self.m_ProjectionMat = perspective(45, self.m_AspectRatio, 1, 1000.0)

绘制字段例程

使用此功能，我将从VBO中绘制顶点。

def DrawField(self):
    glUseProgram(self.m_FieldShader)       # Use shader

    self.m_ModelMat = glm.mat4(1)  # Reset ModelMat
    # ############################
    # 1. Scale          self.ModelMat = scale(self.ModelMat,glm.vec3(10,10,10))
    # 2. Rotation       self.ModelMat = rotate(self.ModelMat, self.test, glm.vec3(0,1,0))
    # 3. Translate      self.ModelMat = translate(self.ModelMat,glm.vec3(0,0,0))
    ####################################

    glUniformMatrix4fv(self.m_Field_ModelMat_Uniform, 1, GL_FALSE, numpy.squeeze(numpy.asarray(self.m_ModelMat.value)))
    glUniformMatrix4fv(self.m_Field_ViewMat_Uniform, 1, GL_FALSE, numpy.squeeze(numpy.asarray(self.m_ViewMat.value)))
    glUniformMatrix4fv(self.m_Field_ProjectionMat_Uniform, 1, GL_FALSE, numpy.squeeze(numpy.asarray(self.m_ProjectionMat.value)))

    glBindVertexArray(self.m_FieldVAO)
    glBindBuffer(GL_ARRAY_BUFFER, self.m_FieldVBO)

    # Draw Field
    glDrawArrays(GL_QUADS, 0, 4*self.m_FieldCount)

    # Disable shader and unbind VAO
    glBindVertexArray(0)
    glUseProgram(0)

二手图书馆：

GLM（我认为是这一个Link to a gist）
OpenGL（PyOpenGL 3.1.0）
numpy的
数学

Answer 1

您可以决定：

您可以使用OpenGL 2，这使得事情变得更加容易，并且意味着没有着色器编程，但效率会降低。
如果您必须绘制至少1000个三角形或想要添加凹凸贴图或其他特效，您应该考虑使用着色器。这意味着：
- 在你的顶点着色器中，你需要一个uniform mat4 modelviewMatrix;，它必须与你的顶点位置相乘。 http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices/#the-model-matrix
不要使用 Python＆amp; Pyopengl，如果你的目标是高效率（自己的经验）
- 我建议您使用Java和jogl（我目前的配置）。然后我可以为你提供我的相机课程。
我可能也将我的相机类移植到Python，但它依赖于jogl Matrix4类等等，但如果pyopengl也提供这个数学助手类（Matrix4，Quaternion，...）< / p>

编辑：

顶点着色器：

#version 330

uniform mat4 uniform_Transformation;
uniform mat4 uniform_Modelview;
uniform mat4 uniform_Projection;

in vec4 attribute_Position;
in vec4 texcoords;

out vec4 texcoords_pass;

void main(void) 
{ 
  texcoords_pass=texcoords;
  vec4 transformedPoint=attribute_Position*uniform_Transformation;
  vec4 toCamera=transformedPoint*uniform_Modelview;
  gl_Position = vec4(toCamera*uniform_Projection);
}

Fragment Shader：

#version 330

uniform sampler2D tex;

in vec2 texcoords_pass;

out vec4 mgl_FragColor;

void main (void)
{ 
  vec4 texture_color =  texture(tex,texcoords_pass);
  if (texture_color.w == 0) {
      discard;
  }
  mgl_FragColor=vec4(texture_color.x,texture_color.y,texture_color.z,1.0f);
}

关于矩阵：

uniform_Transformation是转换矩阵。它用于旋转，缩放，翻转，镜像和移动模型，在您的情况下。
uniform_Modelview是视图矩阵。它主要是相机。它定义了相机的旋转方式和位置。
uniform_Projection是投影矩阵。它是关于透视投影的。在此处阅读更多相关信息：http://www.songho.ca/opengl/gl_projectionmatrix.html

希望它有所帮助！

是否可以将gluLookAt与顶点着色器一起使用？

1 个答案: