spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <iostream>
#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>
#include <vector>

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>

#include "ShaderUtils.h"
#include "Shape.h"
#include "ShapeGenerator.h"

class Window{
    GLFWwindow* glfwWindow;

    GLuint shaderProgram;

    std::vector<Shape*> shapes;

    GLFWwindow* createGLFWwindow(int width, int height, std::string title);
    void adjustViewport();
    void sendDataToOpenGL();
    void useShaders();
    void mainLoop();
    void quit();

public:
    Window(int width, int height, std::string title);
};

C-/C++-Quelltext

#include "Window.h"

Window::Window(int width, int height, std::string title){

    if(glfwInit() != GL_TRUE){
        std::cout << "Failed to initialize GLFW!" << std::endl;
        glfwTerminate();
        //TODO quit execution
    }

    glfwWindow = createGLFWwindow(width, height, title);
    if(glfwWindow == NULL) {
        //TODO quit execution
    };

    glClearColor(0.0f, 0.0f, 0.1f, 1.0f);

    useShaders();
    sendDataToOpenGL();
    mainLoop();
    quit();
}

void Window::useShaders(){

    // create Shader
    GLuint vertexShader = ShaderUtils::loadShader("../res/shaders/VertexShader.vs", GL_VERTEX_SHADER);
    GLuint fragmentShader = ShaderUtils::loadShader("../res/shaders/FragmentShader.fs", GL_FRAGMENT_SHADER);

    shaderProgram = ShaderUtils::linkShaderProgram(vertexShader, fragmentShader, 0);

    glUseProgram(shaderProgram);

}

void Window::sendDataToOpenGL(){

    // Location of variable "position" (VertexShader) in VAO
    GLint positionLoc = glGetAttribLocation(shaderProgram, "position");
    GLint colorLoc = glGetAttribLocation(shaderProgram, "color");

    Shape* arrow = ShapeGenerator::createArrow(positionLoc, colorLoc);
    shapes.push_back(arrow);

    Shape* tri = ShapeGenerator::createTriangle(positionLoc, colorLoc);
    //shapes.push_back(tri);
}

void Window::mainLoop(){

    // main Loop
    while(!glfwWindowShouldClose(glfwWindow)){
        adjustViewport();
        glClear(GL_COLOR_BUFFER_BIT);

        for(auto itr = shapes.begin(); itr != shapes.end(); ++itr){
            (*itr)->draw();
        }

        glfwSwapBuffers(glfwWindow);
        glfwPollEvents();
    }

}

void Window::quit(){
    glfwDestroyWindow(glfwWindow);
    glfwTerminate();

    for(auto itr = shapes.begin(); itr != shapes.end(); ++itr){
        delete *itr;
    }
}

void Window::adjustViewport(){
    GLint height, width;
    glfwGetWindowSize(glfwWindow, &width, &height);
    glViewport(0, 0, width, height);
}

GLFWwindow* Window::createGLFWwindow(int width, int height, std::string title){
    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    GLFWwindow* window = glfwCreateWindow(width, height, title.c_str(), NULL, NULL);
    if(window == NULL){
        std::cout << "Window could not be created!" << std::endl;
        glfwTerminate();
        return NULL;
    }

    // Context creation...
    glfwMakeContextCurrent(window);

    // ...before glew initialisation ;)
    glewExperimental=GL_TRUE;
    GLenum err = glewInit();
    if(err != GLEW_OK){
        std::cout << "Failed to Init GLEW!" << std::endl;
        std::cout << glewGetErrorString(err) << std::endl;
        glfwTerminate();
        return NULL;
    }

    std::cout << glGetString(GL_VERSION) << std::endl;

    return window;
}

C-/C++-Quelltext

#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>

struct Vertex{
    glm::vec3 position;
    glm::vec3 color;
};

class Shape{

    GLuint VBOID, EBOID, VAOID;
    GLuint numElements;
    GLint positionLoc, colorLoc;

    void generateVAO();
public:
    Shape();
    Shape(GLuint pVBOID, GLuint pEBOID, GLuint pNumElements, GLint pPositionLoc, GLint pColorLoc);
    ~Shape();

    void draw();
};

C-/C++-Quelltext

#include "Shape.h"
#include "Window.h"
#include <iostream>

Shape::Shape(GLuint pVBOID, GLuint pEBOID, GLuint pNumElements, GLint pPositionLoc, GLint pColorLoc): VBOID(pVBOID), EBOID(pEBOID), numElements(pNumElements), positionLoc(pPositionLoc), colorLoc(pColorLoc){
    generateVAO();
}

void Shape::generateVAO(){
    glGenVertexArrays(1, &VAOID);
    glBindVertexArray(VBOID);

    // Location of variable "position" (VertexShader) in VAO
    glEnableVertexAttribArray(positionLoc);
    glEnableVertexAttribArray(colorLoc);
    glBindBuffer(GL_ARRAY_BUFFER, VBOID);

    // Variable Location, Elements per Vertex, Datatype, normalized, stride, startposition
    glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), 0);
    glVertexAttribPointer(colorLoc, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (void*)(3 * sizeof(float)));
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindVertexArray(0);
}

Shape::~Shape(){
    glDeleteBuffers(1, &VBOID);
    glDeleteBuffers(1, &EBOID);
    glDeleteBuffers(1, &VAOID);
}

void Shape::draw(){

    std::cout << "1" << std::endl;

    glBindVertexArray(VBOID);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOID);

    std::cout << "2" << std::endl;

    glDrawElements(GL_TRIANGLES, 3 * numElements, GL_UNSIGNED_SHORT, NULL);

    std::cout << "3" << std::endl;

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}

C-/C++-Quelltext

#pragma once
#include <GL/glew.h>
#include "Shape.h"

class ShapeGenerator{

public:
    static Shape* createTriangle(GLint positionLoc, GLint colorLoc);
    static Shape* createArrow(GLint positionLoc, GLint colorLoc);

};

C-/C++-Quelltext

#include "ShapeGenerator.h"

Shape* ShapeGenerator::createTriangle(GLint positionLoc, GLint colorLoc){
    GLuint VBOID, EBOID;

    glGenBuffers(1, &VBOID);
    glGenBuffers(1, &EBOID);

    Vertex vertecies[] = {
        glm::vec3(+0.00f, +0.75f, +0.00f),
        glm::vec3(+1.0f, +0.0f, +0.0f),
        glm::vec3(-0.75f, -0.75f, +0.00f),
        glm::vec3(+0.0f, +1.0f, +0.0f),
        glm::vec3(+0.75f, -0.75f, +0.00f),
        glm::vec3(+0.0f, +0.0f, +1.0f),
    };

    GLushort indexdata[] = {
        0, 1, 2
    };

    glBindBuffer(GL_ARRAY_BUFFER, VBOID);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertecies), vertecies, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOID);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexdata), indexdata, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    return new Shape(VBOID, EBOID, 1, positionLoc, colorLoc);
}

Shape* ShapeGenerator::createArrow(GLint positionLoc, GLint colorLoc){
    GLuint VBOID, EBOID;

    glGenBuffers(1, &VBOID);
    Vertex vertecies[] = {
        glm::vec3(+0.00f, +0.75f, +0.0f),   // 0
        glm::vec3(+0.0f, +0.0f, +1.0f),
        glm::vec3(-0.50f, +0.25f, +0.0f),   // 1
        glm::vec3(+0.5f, +0.0f, +0.5f),
        glm::vec3(-0.25f, +0.25f, +0.0f),   // 2
        glm::vec3(+0.5f, +0.0f, +0.5f),
        glm::vec3(-0.25f, -0.50f, +0.0f),   // 3
        glm::vec3(+1.0f, +0.0f, +0.0f),
        glm::vec3(+0.25f, -0.50f, +0.0f),   // 4
        glm::vec3(+1.0f, +0.0f, +0.0f),
        glm::vec3(+0.25f, +0.25f, +0.0f),   // 5
        glm::vec3(+0.5f, +0.0f, +0.5f),
        glm::vec3(+0.50f, +0.25f, +0.0f),   // 6
        glm::vec3(+0.5f, +0.0f, +0.5f),
    };

    glBindBuffer(GL_ARRAY_BUFFER, VBOID);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertecies), vertecies, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    GLushort indexdata[] = {
        0, 1, 2,
        0, 2, 5,
        0, 5, 6,
        2, 3, 5,
        3, 4, 5
    };

    glGenBuffers(1, &EBOID);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOID);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexdata), indexdata, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    Shape* ret = new Shape(VBOID, EBOID, 5, positionLoc, colorLoc);
    return ret;
}