Part of the Khronos Group

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 1 of 1

Thread: Basic vertex shader binding & input

  1. #1
    Junior Member Newbie
    Join Date
    Aug 2018

    Basic vertex shader binding & input

    Hi, so I have been trying this for over a week before a post, any prods welcomed.
    I've got a simple vertex shader, that feeds a frag shader, both shaders and source come from a qt example, I'm trying to port to OpenGL running on Windowz:

    Code glsl:
    #version 330 core
    attribute vec4 aPosition;                               
    attribute vec2 aTexCoord;                               
    uniform mat4 uModelViewProjectionMatrix;
    varying vec2 vTexCoord;
    void main() 
       // gl_Position  contains the position of the current vertex
       // the clip-space output position of the current vertex.
       gl_Position = uModelViewProjectionMatrix * aPosition;
       vTexCoord = aTexCoord;

    And this is how I'm trying to feed it:

    Code cpp:
       m_expansion_shader = LoadShader(false, vertex_path.c_str(), pixel_path.c_str());
       if (!m_expansion_shader)
          return -1;
       if (printProgramInfoLog(m_expansion_shader) == GL_FALSE)
          return 0;
       // Generate two slots for the vertex and color buffers
       GLuint _vao;
       // Generate and bind the vertex array object
       glGenVertexArrays(1, &_vao); CheckGLError();
       glBindVertexArray(_vao); CheckGLError();
       GLuint _vbo[2];
       // Generate two slots for the vertex and position buffers
       glGenBuffers(2, _vbo); CheckGLError();
       m_vertexPosition_location = glGetAttribLocation(m_expansion_shader, "aPosition"); CheckGLError();
       glEnableVertexAttribArray(m_vertexPosition_location); CheckGLError();
       glBindBuffer(GL_ARRAY_BUFFER, _vbo[0]); CheckGLError();
       glBufferData(GL_ARRAY_BUFFER, sizeof(m_v_array), m_v_array, GL_DYNAMIC_DRAW); CheckGLError();
       m_textureCoord_Location = glGetAttribLocation(m_expansion_shader, "aTexCoord"); CheckGLError();
       glEnableVertexAttribArray(m_textureCoord_Location); CheckGLError();
       glBindBuffer(GL_ARRAY_BUFFER, _vbo[1]); CheckGLError();
       glBufferData(GL_ARRAY_BUFFER, sizeof(m_tx_array), m_tx_array, GL_DYNAMIC_DRAW); CheckGLError();
       // Specify the location of the uniform variable
       m_uModelViewProjectionMatrix = glGetUniformLocation(m_expansion_shader, "uModelViewProjectionMatrix");CheckGLError();
       m_aspect_window = static_cast<GLfloat>(m_clientRect.right) / static_cast<GLfloat>(m_clientRect.bottom);
       glViewport(0, 0, m_clientRect.right, m_clientRect.bottom);
    const GLfloat m_modelviewmatrix[] = {
       1.0f, 0.0f, 0.0f, 0.0f,
       0.0f, 1.0f, 0.0f, 0.0f,
       0.0f, 0.0f, 1.0f, 0.0f,
       0.0f, 0.0f, 0.0f, 1.0f
          // Start using shader program to expand background image
          glUseProgram(m_expansion_shader); CheckGLError();
          // Lock the shared surface
          wglDXLockObjectsNV(m_hDX9Device, 1, &m_hGLSharedTexture); CheckGLError();
          glEnable(GL_TEXTURE_2D); CheckGLError();
          glBindTexture(GL_TEXTURE_2D, m_GLTexture); CheckGLError();
          SetCurrentShaderParms(m_aspect_window, (float)m_src_w, (float)m_src_h); CheckGLError();
          /* From original qt shader application - set m_uModelViewProjectionMatrix - this is all wrong*/
          //const QSize sz = QSize(painter->device()->width() * aspect, painter->device()->height() * aspect);
          //QMatrix4x4 m;
          //m.ortho(0, sz.width(), sz.height(), 0, -999999, 999999); // ortho(float left, float right, float bottom, float top, float nearPlane, float farPlane)
          //m_projectionMatrix is never changed - it is set to constant value :
          //m_modelViewMatrix // set depending on current screen size only.
          glUniformMatrix4fv(m_uModelViewProjectionMatrix, 1, GL_FALSE,/*m_projectionMatrix**/m_modelviewmatrix); CheckGLError();
          m_tx_array[0] = (float)0;
          m_tx_array[1] = (float)0;
          m_tx_array[2] = (float)m_src_w; //1280
          m_tx_array[3] = (float)0;
          m_tx_array[4] = (float)m_src_w; //1280
          m_tx_array[5] = (float)m_src_h; //1280
          m_tx_array[7] = (float)0;
          m_tx_array[8] = (float)m_src_h; //1280
          m_v_array[0] = (float)m_clientRect.left;
          m_v_array[1] = (float);
          m_v_array[2] = (float)m_clientRect.right; // 1280
          m_v_array[3] = (float);
          m_v_array[4] = (float)m_clientRect.right; // 1280
          m_v_array[5] = (float)m_clientRect.bottom; // 1280
          m_v_array[6] = (float)m_clientRect.left;
          m_v_array[7] = (float)m_clientRect.bottom; // 1280
       m_indices_for_render_quads[0] = 0;
       m_indices_for_render_quads[1] = 1;
       m_indices_for_render_quads[2] = 2;
       m_indices_for_render_quads[3] = 0;
       m_indices_for_render_quads[4] = 2;
       m_indices_for_render_quads[5] = 3;
         // glBindVertexArray(0); CheckGLError();
          glVertexAttribPointer(m_vertexPosition_location, VERTEX_POS_SIZE, GL_FLOAT, GL_FALSE, 0, m_v_array); CheckGLError();
          glVertexAttribPointer(m_textureCoord_Location, VERTEX_TEXCOORD0_SIZE, GL_FLOAT, GL_FALSE, 0, m_tx_array); CheckGLError();
          glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, m_indices_for_render_quads); CheckGLError();
          // Unlock the shared surface
          wglDXUnlockObjectsNV(m_hDX9Device, 1, &m_hGLSharedTexture); CheckGLError();

    Full (attempt) source file:

    Appreciated in advance, I can't see any samples that match what I'm trying to achieve, I'm new to openGL unfortunately for me.
    Sure there are some school boy errors.
    Last edited by Dark Photon; 09-02-2018 at 12:54 PM.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts