spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void main()
{
gl_Position=gl_Vertex;
}

C-/C++-Quelltext

void main()
{
    gl_FragColor=vec4(0,1,0,1);
}

C-/C++-Quelltext

#include <stdio.h>
#include <glew.h>
#include <glut.h>
#include "Plane.h"
#include "Shader.h"

Plane *plane;
GLint ShPrg;

void InitOpenGL()
{
    glClearColor(0, 0, 0, 1);
}

void InitGame()
{
    // Zu Testzwecken.
    Shader vertexShader;
    ShPrg=vertexShader.createShader("VertexShader.glsl","FragmentShader.glsl");
    plane=new Plane();
}

void GameLoop()
{

}

void Display()
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    GameLoop();

    glColor4f(1, 0, 0, 1);

    plane->Draw(ShPrg);

    glutSwapBuffers();
}

void Reshape(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, (GLdouble)w / (GLdouble)h, 1, 200);
}

int main()
{
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(1024, 768);

    glutCreateWindow("MyOpenGL");

    InitOpenGL();
    glewInit();
    InitGame();

    glutDisplayFunc(Display);
    glutReshapeFunc(Reshape);

    glutMainLoop();

    delete plane;
    return 0;
}

C-/C++-Quelltext

#pragma once
class Plane {
public:
    Plane();
    ~Plane();

    void Draw(GLuint ShPrg);
private:
    GLuint VertexBuffer, IndexBuffer;

    GLfloat Vertices[18]={
        -.5, .5,-5,
        .5, .5,-5,
        -.5, -.5,-5,

        .5,-.5,-5,
        .5, .5,-5,
        -.5, .5,-5
    };

    GLbyte Indices[6] = {
        0,1,2,
        1,2,3
    };
};

C-/C++-Quelltext

#include <glew.h>

#include "Plane.h"

#define BUFFER_OFFSET(i) ((void*)(i))

Plane::Plane()
{
    // Vor glGenBuffers muss in main.cpp glewInit ausgeführt werden.
    glGenBuffers(1, &VertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);

    glGenBuffers(1, &IndexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);
}

Plane::~Plane()
{
    glDeleteBuffers(1, &VertexBuffer);
    glDeleteBuffers(1, &IndexBuffer);
}

void Plane::Draw(GLuint ShPrg)
{
    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));   //The starting point of the VBO,   glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);

    glUseProgram(ShPrg);

    glDrawElements(GL_TRIANGLES, 18, GL_UNSIGNED_BYTE, 0);

    glDisableVertexAttribArray(0);
    glDisableClientState(GL_ARRAY_BUFFER);
}

C-/C++-Quelltext

#pragma once

class Shader
{
public:
    Shader();
    ~Shader();

    int createShader(char *VertexFile,char *FragmentFile);

};

C-/C++-Quelltext

#include "Shader.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string>
#include <glew.h>

Shader::Shader()
{

}

Shader::~Shader()
{

}

int Shader::createShader(char *VertexFile,char *FragmentFile)
{
    std::fstream VertFile(VertexFile);
    std::string Code;
    if (VertFile.is_open())
    {
        std::string line;
        while (std::getline(VertFile, line))
        {
            line += "\n";
            Code += line;
        }
        VertFile.close();
    }

    GLint VertShader,FragShader;

    const char *VertShBuffer= Code.c_str();
    VertShader=glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(VertShader, 1, &VertShBuffer, NULL);
    glCompileShader(VertShader);
    GLint Status;
    glGetShaderiv(VertShader, GL_COMPILE_STATUS, &Status);
    if (Status != GL_TRUE)
    {
        char buffer[512];
        glGetShaderInfoLog(VertShader, 512, NULL, buffer);
        std::cout << buffer;
    }

    Code.clear();

    std::fstream FragFile(FragmentFile);
    if (FragFile.is_open())
    {
        std::string line;
        while (std::getline(FragFile, line))
        {
            line += "\n";
            Code += line;
        }
        FragFile.close();
    }

    FragShader = glCreateShader(GL_FRAGMENT_SHADER);
    const char *FragShBuffer = Code.c_str();
    glShaderSource(FragShader, 1, &FragShBuffer, NULL);
    glCompileShader(FragShader);
    glGetShaderiv(FragShader, GL_COMPILE_STATUS, &Status);
    if (Status != GL_TRUE)
    {
        char buffer[512];
        glGetShaderInfoLog(FragShader, 512, NULL, buffer);
        std::cout << "FragmentShader Error "<<buffer;
    }

    GLuint Prg = glCreateProgram();
    glAttachShader(Prg, VertShader);
    glAttachShader(Prg, FragShader);

    glLinkProgram(Prg);
    GLint linked;
    glGetProgramiv(Prg, GL_LINK_STATUS, &linked);
    if (linked)
    {
        // ok!
        std::cout << "Shader link sucesfull !";
    }

    glDetachShader(Prg, VertShader);
    glDetachShader(Prg, FragShader);

    glDeleteShader(VertShader);
    glDeleteShader(FragShader);

    return Prg;
}