Jump to content
  • Advertisement
Sign in to follow this  
CirdanValen

Problem with my projection or vertex buffer?

This topic is 1399 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

I'm having a strange problem, and I don't know what could be causing it. My current code is identical to how I've done this before. 

 

My results:

 

fu55D9z.png

 

What I expect:

3x3 rectangle in the top left corner

 

[source]

#include <stdio.h>
#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include "lodepng.h"
 
static const int FALSE = 0;
static const int TRUE = 1;
 
static const char* VERT_SHADER =
    "#version 330\n"
 
    "layout(location=0) in vec4 VertexPosition; "
    "layout(location=1) in vec2 UV;"
    "uniform mat4 uProjectionMatrix;"
    /*"out vec2 TexCoords;"*/
 
    "void main(void) {"
    "    gl_Position = uProjectionMatrix*VertexPosition;"
    /*"    TexCoords = UV;"*/
    "}";
 
static const char* FRAG_SHADER =
    "#version 330\n"
 
    /*"uniform sampler2D uDiffuseTexture;"
    "uniform vec4 uColor;"
    "in vec2 TexCoords;"*/
    "out vec4 FragColor;"
 
    "void main(void) {"
   /* "    vec4 texel = texture2D(uDiffuseTexture, TexCoords);"
    "    if(texel.a <= 0) {"
    "         discard;"
    "    }"
    "    FragColor = texel;"*/
    "    FragColor = vec4(1.f);"
    "}";
 
static int g_running;
static GLFWwindow *gl_window;
static float gl_projectionMatrix[16];
 
/*
    Structures
*/
typedef struct _Vertex {
    float x, y, z, w;
    float u, v;
} Vertex;
 
typedef struct _Position {
    float x, y;
} Position;
 
typedef struct _Bitmap {
    unsigned char *pixels;
    unsigned int width, height;
} Bitmap;
 
typedef struct _Texture {
    GLuint id;
    unsigned int width, height;
} Texture;
 
typedef struct _VertexBuffer {
    GLuint bufferObj, vertexArray;
} VertexBuffer;
 
typedef struct _ShaderProgram {
    GLuint vertexShader, fragmentShader, program;
} ShaderProgram;
 
/*
  http://en.wikipedia.org/wiki/Orthographic_projection
*/
void createOrthoProjection(float *projection, float width, float height, float far, float near)  {
 
    const float left = 0;
    const float right = width;
    const float top = 0;
    const float bottom = height;
    
    projection[0] = 2.f / (right - left);
    projection[1] = 0.f;
    projection[2] = 0.f;
    projection[3] = -(right+left) / (right-left);
    projection[4] = 0.f;
    projection[5] = 2.f / (top - bottom);
    projection[6] = 0.f;
    projection[7] = -(top + bottom) / (top - bottom);
    projection[8] = 0.f;
    projection[9] = 0.f;
    projection[10] = -2.f / (far-near);
    projection[11] = (far+near)/(far-near);
    projection[12] = 0.f;
    projection[13] = 0.f;
    projection[14] = 0.f;
    projection[15] = 1.f;
}
 
/*
    Textures
*/
void loadBitmap(const char *filename, Bitmap *bitmap, int *success) {
    int error = lodepng_decode32_file(&bitmap->pixels, &bitmap->width, &bitmap->height, filename);
 
    if (error != 0) {
        printf("Failed to load bitmap. ");
        printf(lodepng_error_text(error));
        success = FALSE;
        return;
    }
}
 
void destroyBitmap(Bitmap *bitmap) {
    free(bitmap->pixels);
}
 
void createTexture(Texture *texture, const Bitmap *bitmap) {
    texture->id = 0;
    glGenTextures(1, &texture->id);
    glBindTexture(GL_TEXTURE_2D, texture);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap->width, bitmap->height, 0, 
            GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels);
 
    glBindTexture(GL_TEXTURE_2D, 0);
}
 
void destroyTexture(Texture *texture) {
    glDeleteTextures(1, &texture->id);
    texture->id = 0;
}
 
/*
    Vertex Buffer
*/
void createVertexBuffer(VertexBuffer *vertexBuffer, Vertex *vertices) {
    glGenBuffers(1, &vertexBuffer->bufferObj);
    glGenVertexArrays(1, &vertexBuffer->vertexArray);
    glBindVertexArray(vertexBuffer->vertexArray);
 
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer->bufferObj);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * 6, (const GLvoid*)vertices, GL_STATIC_DRAW);
 
    const unsigned int uvOffset = sizeof(float) * 4;
 
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)uvOffset);
 
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}
 
void destroyVertexBuffer(VertexBuffer *vertexBuffer) {
    glDeleteBuffers(1, &vertexBuffer->bufferObj);
    glDeleteVertexArrays(1, &vertexBuffer->vertexArray);
}
 
void bindVertexBuffer(VertexBuffer *vertexBuffer) {
    glBindVertexArray(vertexBuffer->vertexArray);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer->bufferObj);
}
 
void drawVertexBufferMode(GLenum mode) {
    glDrawArrays(mode, 0, 6);
}
 
void drawVertexBuffer() {
    drawVertexBufferMode(GL_TRIANGLES);
}
 
void unbindVertexBuffer() {
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}
 
/*
    Shaders
*/
void compileShader(ShaderProgram *shaderProgram, const char *vertexSrc, const char *fragSrc) {
    GLenum err;
    shaderProgram->vertexShader = glCreateShader(GL_VERTEX_SHADER);
    shaderProgram->fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    if (shaderProgram->vertexShader == 0) {
        printf("Failed to create vertex shader.");
        return;
    }
 
    if (shaderProgram->fragmentShader == 0) {
        printf("Failed to create fragment shader.");
        return;
    }
 
    glShaderSource(shaderProgram->vertexShader, 1, &vertexSrc, NULL);
    glCompileShader(shaderProgram->vertexShader);
    glGetShaderiv(shaderProgram->vertexShader, GL_COMPILE_STATUS, &err);
 
    if (err != GL_TRUE) {
        printf("Failed to compile vertex shader.");
        return;
    }
 
    glShaderSource(shaderProgram->fragmentShader, 1, &fragSrc, NULL);
    glCompileShader(shaderProgram->fragmentShader);
    glGetShaderiv(shaderProgram->fragmentShader, GL_COMPILE_STATUS, &err);
 
    if (err != GL_TRUE) {
        printf("Failed to compile fragment shader.");
        return;
    }
 
    shaderProgram->program = glCreateProgram();
    glAttachShader(shaderProgram->program, shaderProgram->vertexShader);
    glAttachShader(shaderProgram->program, shaderProgram->fragmentShader);
    glLinkProgram(shaderProgram->program);
    
    glGetProgramiv(shaderProgram->program, GL_LINK_STATUS, &err);
 
    if (err != GL_TRUE) {
        printf("Failed to link shader.");
        return;
    }
}
 
void destroyShader(ShaderProgram *shaderProgram) {
    glDetachShader(shaderProgram->program, shaderProgram->vertexShader);
    glDetachShader(shaderProgram->program, shaderProgram->fragmentShader);
 
    glDeleteShader(shaderProgram->vertexShader);
    glDeleteShader(shaderProgram->fragmentShader);
 
    glDeleteProgram(shaderProgram->program);
}
 
GLuint getUniformLocation(const char *name, ShaderProgram *program) {
    GLuint result = 0;
    result = glGetUniformLocation(program->program, name);
 
    return result;
}
 
void setUniformMatrix(float *matrix, const char *name, ShaderProgram *program) {
    GLuint loc = getUniformLocation(name, program);
 
    if (loc == -1) {
        printf("Failed to get uniform location in setUniformMatrix.\n");
        return;
    }
 
    glUniformMatrix4fv(loc, 1, GL_FALSE, matrix);
}
 
/*
    General functions
*/
static int isRunning() {
    return g_running && !glfwWindowShouldClose(gl_window);
}
 
static void initializeGLFW(GLFWwindow **window, int width, int height, int *success) {
    if (!glfwInit()) {
        printf("Failed it inialize GLFW.");
        *success = FALSE;
       return;
    }
    
    glfwWindowHint(GLFW_RESIZABLE, 0);
    *window = glfwCreateWindow(width, height, "Alignments", NULL, NULL);
    
    if (!*window) {
        printf("Failed to create window.");
        glfwTerminate();
        *success = FALSE;
        return;
    }
    
    glfwMakeContextCurrent(*window);
 
    GLenum glewErr = glewInit();
    if (glewErr != GLEW_OK) {
        printf("Failed to initialize GLEW.");
        printf(glewGetErrorString(glewErr));
        *success = FALSE;
        return;
    }
 
    glClearColor(0.f, 0.f, 0.f, 1.f);
    glViewport(0, 0, width, height);
    *success = TRUE;
}
 
int main(int argc, char **argv) {
    
    int err = FALSE;
    initializeGLFW(&gl_window, 480, 320, &err);
    glDisable(GL_DEPTH_TEST);
    if (err == FALSE) {
        return 1;
    }
    
    createOrthoProjection(gl_projectionMatrix, 480.f, 320.f, 0.f, 1.f);
    
    g_running = TRUE;
    
    ShaderProgram shader;
    compileShader(&shader, VERT_SHADER, FRAG_SHADER);
    glUseProgram(shader.program);
    setUniformMatrix(&gl_projectionMatrix, "uProjectionMatrix", &shader);
 
    Vertex rectangle[6];
    VertexBuffer vbo;
    rectangle[0] = (Vertex){0.f, 0.f, 0.f, 1.f, 0.f, 0.f}; // Top left
    rectangle[1] = (Vertex){3.f, 0.f, 0.f, 1.f, 1.f, 0.f}; // Top right
    rectangle[2] = (Vertex){0.f, 3.f, 0.f, 1.f, 0.f, 1.f}; // Bottom left
    rectangle[3] = (Vertex){3.f, 0.f, 0.f, 1.f, 1.f, 0.f}; // Top left
    rectangle[4] = (Vertex){0.f, 3.f, 0.f, 1.f, 0.f, 1.f}; // Bottom left
    rectangle[5] = (Vertex){3.f, 3.f, 0.f, 1.f, 1.f, 1.f}; // Bottom right
 
    createVertexBuffer(&vbo, &rectangle);
    
 
    bindVertexBuffer(&vbo);
    
    while (isRunning()) {
        glClear(GL_COLOR_BUFFER_BIT);
        glfwPollEvents();
 
        
        drawVertexBuffer();
        
 
        glfwSwapBuffers(gl_window);
    }
    
    unbindVertexBuffer(&vbo);
 
    glUseProgram(0);
    destroyShader(&shader);
    destroyVertexBuffer(&vbo);
    glfwTerminate();
    return 0;
}
[/source]

Share this post


Link to post
Share on other sites
Advertisement
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!