文本分割错误导致的OpenGL高度图

Question

I am trying to create a heightmap from 25 float values like so:

#define HEIGHT_VERTS 5
#define VALS_PER_VERT_HEIGHT 5

float heightmapVerts[ HEIGHT_VERTS*VALS_PER_VERT_HEIGHT ] = {
            //5    
            -0.9, -0.6, -0.4, -0.6, -0.9,
            -0.2, 0.1, 0.3, 0.1, -0.3,
            0, 0.4, 0.8, 0.4, 0,
            -0.2, 0.1, 0.3, 0.1, -0.3,
            0.5, -0.6, -0.4, -0.6, -0.9,    
    };

I am getting a segmentation fault when calling:

    glDrawArrays(GL_TRIANGLES, 0, HEIGHT_VERTS);

I have been suggested that it's because the size argument of glVertexAttribPointer() must be 1, 2, 3, or 4. I pass 5 with:

glVertexAttribPointer(vertLocHeight, VALS_PER_VERT_HEIGHT, GL_FLOAT, GL_FALSE, 0, 0);

but I get another error saying that I have too many vertices if these values are smaller (eg: #define VALS_PER_VERT_HEIGHT 3)

error: too many initializers for ‘float [15]’ 

I have attached the rest of my code for some context, I am very very new to OpenGL so I apologize if the code is messy.

#include <stdio.h>
// GLEW loads OpenGL extensions. Required for all OpenGL programs.
#include <GL/glew.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
// Utility code to load and compile GLSL shader programs
#include "shader.hpp"
#include <iostream>
#include <fstream>
#include <vector>
#include "glm/glm.hpp"

#define WINDOW_WIDTH    400
#define WINDOW_HEIGHT   400

#define VALS_PER_VERT_HEIGHT 5//5
#define VALS_PER_COLOUR_HEIGHT 4
#define HEIGHT_VERTS 5 //height map vertices per line

using namespace std;

// Handle to our VAO generated in setShaderData method
//heightmap


unsigned int vertexVaoHandleHeight;

// Handle to our shader program
unsigned int programID;

/**
 * Sets the shader uniforms and vertex data
 * This happens ONCE only, before any frames are rendered
 * @param id, Shader program object to use
 * @returns 0 for success, error otherwise
 */
int setShaderData(const unsigned int &id) 
{   
    float heightmapVerts[ HEIGHT_VERTS*VALS_PER_VERT_HEIGHT ] = {
            //5    
            -0.9, -0.6, -0.4, -0.6, -0.9,
            -0.2, 0.1, 0.3, 0.1, -0.3,
            0, 0.4, 0.8, 0.4, 0,
            -0.2, 0.1, 0.3, 0.1, -0.3,
            0.5, -0.6, -0.4, -0.6, -0.9,    
    };



    // Colours for each vertex; red, green, blue and alpha
    // This data is indexed the same order as the vertex data, but reads 4 values
    // Alpha will not be used directly in this example program
        float heightColours[ HEIGHT_VERTS*VALS_PER_COLOUR_HEIGHT ] = {
            0.8f, 0.7f, 0.5f, 1.0f,
            0.3f, 0.7f, 0.1f, 1.0f,
            0.8f, 0.2f, 0.5f, 1.0f,        
    };  

    // heightmap stuff ##################################################   
    // Generate storage on the GPU for our triangle and make it current.
    // A VAO is a set of data buffers on the GPU
    glGenVertexArrays(1, &vertexVaoHandleHeight);
    glBindVertexArray(vertexVaoHandleHeight);       

    // Generate new buffers in our VAO
    // A single data buffer store for generic, per-vertex attributes
    unsigned int bufferHeight[2];
    glGenBuffers(2, bufferHeight);
    // Allocate GPU memory for our vertices and copy them over
    glBindBuffer(GL_ARRAY_BUFFER, bufferHeight[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*HEIGHT_VERTS*VALS_PER_VERT_HEIGHT, heightmapVerts, GL_STATIC_DRAW);
    // Do the same for our vertex colours
    glBindBuffer(GL_ARRAY_BUFFER, bufferHeight[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*HEIGHT_VERTS*VALS_PER_COLOUR_HEIGHT, heightColours, GL_STATIC_DRAW);    

    // Now we tell OpenGL how to interpret the data we just gave it
    // Tell OpenGL what shader variable it corresponds to
    // Tell OpenGL how it's formatted (floating point, 3 values per vertex)
    int vertLocHeight = glGetAttribLocation(id, "a_vertex");
    glBindBuffer(GL_ARRAY_BUFFER, bufferHeight[0]);
    glEnableVertexAttribArray(vertLocHeight);
    glVertexAttribPointer(vertLocHeight, VALS_PER_VERT_HEIGHT, GL_FLOAT, GL_FALSE, 0, 0);

    // Do the same for the vertex colours
    int colourLocHeight = glGetAttribLocation(id, "a_colour");
    glBindBuffer(GL_ARRAY_BUFFER, bufferHeight[1]);
    glEnableVertexAttribArray(colourLocHeight);
    glVertexAttribPointer(colourLocHeight, VALS_PER_COLOUR_HEIGHT, GL_FLOAT, GL_FALSE, 0, 0);
    // heightmap stuff ##################################################

    // An argument of zero un-binds all VAO's and stops us
    // from accidentally changing the VAO state
    glBindVertexArray(0);
    // The same is true for buffers, so we un-bind it too
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    return 0;   // return success
}
/**
 * Renders a frame of the state and shaders we have set up to the window
 * Executed each time a frame is to be drawn.
 */
void render() 
{
    // Clear the previous pixels we have drawn to the colour buffer (display buffer)
    // Called each frame so we don't draw over the top of everything previous
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(programID);

    // HEIGHT MAP STUFF ###################################
    // Make the VAO with our vertex data buffer current
    glBindVertexArray(vertexVaoHandleHeight);
    // Send command to GPU to draw the data in the current VAO as triangles
    //CRASHES HERE
    glDrawArrays(GL_TRIANGLES, 0, HEIGHT_VERTS);

    glBindVertexArray(0);   // Un-bind the VAO

    // HEIGHT MAP STUFF ###################################

    glutSwapBuffers();  // Swap the back buffer with the front buffer, showing what has been rendered

    glFlush();  // Guarantees previous commands have been completed before continuing
}

Answer 1

You are messing things up.

1) With glVertexAttribPointer() , you setup vertex attributes - those are almost always vectors of some kind. For vertex position, if you need to draw scene in 2D, pass size = 2 (because each vertex has x and y coordinates), for 3D - pass 3 (x, y, z).

2) I think your interpretation of heightmap is also quite incorrect. You filled array only with height values (in 3D space, those are Y coordinates). But where are X and Z? You need to render vertices , so you need to pass all x, y and z coords, so OpenGL can know where each point should be rendered.

Your program crashes, because you send not enough data and OpenGL tries to read from memory, that doesn't belong to you.

I assume, that you want a heightmap, which is a 5x5 grid? Init data this way:

float heightmapVerts[25] =
{
  //leave this as it is right now
};

vec3 vertices[5][5];

for(int z_num = 0; z_num < 5; ++z_num)
{
  for(int x_num = 0; x_num < 5; ++x_num)
  {
    vertices[z_num][x_num].x = x_num * 0.5f;
    vertices[z_num][x_num].z = z_num * 0.5f;
    vertices[z_num][x_num].y = heightmapVerts[z_num * 5 + x_num];
  }
}

Then you can call:

glVertexAttribPointer(vertLocHeight, 3, GL_FLOAT, GL_FALSE, 0, 0);

Update:

vec3 stands for 3-dimensional vector. I wrote it as pseudocode to illustrate conception, but for the sake of simplicity, you may want to use this great library: OpenGL Mathematics .

Update 2:

One more thing: color data is also set improperly. You probably want color to be an RGB value, so every vertex needs additional 3 floats to represent its color. Also, position and color should be place in single VBO, there is no need for separating them.

I am not sure, if you got all basics required to do any simple drawings. You may want to read these articles:

OpenGL Wiki

This nice tutorial

Lighthouse 3D