grafika

#include <GL/glew.h>
#include <SFML/Window.hpp>
#include <iostream>
#include <cmath>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>


using namespace std;

void compilation_checking(GLuint shader, string shaderType) {
    GLint isCompiled = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
    if (isCompiled == GL_FALSE)
    {
        GLint maxLength = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
        char* errorLog = new char[maxLength];
        glGetShaderInfoLog(shader, maxLength, &maxLength, errorLog);
        cout << "ERROR " << errorLog << endl;
        glDeleteShader(shader);
        return;
    }
    cout << "Compilation " + shaderType + " shader Ok" << endl;
}

void zmianaWierchołkow(int punkty, const GLint& vbo)
{
    GLfloat* wierzcholki;
    float alfa = 0;
    float delta = 2 * 3.14 / punkty;
    float promien = 1;

    if (punkty < 3)
        return;

    wierzcholki = new GLfloat[punkty * 6];

    for (int i = 0; i < punkty * 6; i += 6)
    {
        wierzcholki[i] = promien * cos(alfa);
        wierzcholki[i + 1] = promien * sin(alfa);
        wierzcholki[i + 2] = 0;
        wierzcholki[i + 3] = (cos(alfa) + 1) / 2.0f;
        wierzcholki[i + 4] = (sin(alfa) + 1) / 2.0f;
        wierzcholki[i + 5] = (cos(alfa) + 1) / 2.0f;
        alfa += delta;
    }

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * punkty * 6, wierzcholki, GL_STATIC_DRAW);

    delete[] wierzcholki;
}


const GLchar* vertexSource = R"glsl(
#version 150 core
in vec3 position;
in vec3 color;
         uniform mat4 model;
         uniform mat4 view;
         uniform mat4 proj;
out vec3 Color;
void main(){
Color = color;
        gl_Position = proj * view * model * vec4(position, 1.0);
}
)glsl";

const GLchar* fragmentSource = R"glsl(
#version 150 core
in vec3 Color;
out vec4 outColor;
void main()
{
outColor = vec4(Color, 1.0);
}
)glsl";

glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);

void kostka(int buffer) {

    int punkty_ = 36;
    float vertices[] = {
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f, 0.0f,
            0.5f, -0.5f, -0.5f,  1.0f, 0.0f, 0.0f,
            0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            -0.5f, -0.5f, -0.5f,  0.0f, 0.0f, 0.0f,

            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 0.0f,
            0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            0.5f,  0.5f,  0.5f,  1.0f, 1.0f, 0.0f,
            0.5f,  0.5f,  0.5f,  1.0f, 1.0f, 0.0f,
            -0.5f,  0.5f,  0.5f,  0.0f, 1.0f, 0.0f,
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 0.0f,

            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            -0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 0.0f,
            -0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,

            0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 0.0f,
            0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,

            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            0.5f, -0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 0.0f,
            -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,

            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
            0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f,
            0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,
            -0.5f,  0.5f,  0.5f,  0.0f, 0.0f, 0.0f,
            -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, 0.0f
    };

    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * punkty_ * 6, vertices, GL_STATIC_DRAW);
}

float obrot = 0;

void ustawKamere(GLint _uniView) {
    float cameraSpeed = 0.009f;

    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
        cameraPos += cameraSpeed * cameraFront;
    }
    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
        cameraPos -= cameraSpeed * cameraFront;
    }
    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
        obrot -= cameraSpeed;
        cameraFront.x = sin(obrot);
        cameraFront.z = -cos(obrot);
    }
    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
        obrot -= cameraSpeed;
        cameraFront.x = sin(obrot);
        cameraFront.z = -cos(obrot);
    }

    glm::mat4 view;
    view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    glUniformMatrix4fv(_uniView, 1, GL_FALSE, glm::value_ptr(view));

}

int main()
{
    sf::ContextSettings settings;
    settings.depthBits = 24;
    settings.stencilBits = 8;

    // Okno renderingu
    sf::Window window(sf::VideoMode(800, 600, 32), "OpenGL", sf::Style::Titlebar | sf::Style::Close, settings);

    // Inicjalizacja GLEW
    glewExperimental = GL_TRUE;
    glewInit();

    // Utworzenie VAO (Vertex Array Object)
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    GLuint vbo;
    glGenBuffers(1, &vbo);

    //zmianaWierchołkow(3, vbo);
    kostka(vbo);

    GLuint vertexShader =
        glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexSource, NULL);
    glCompileShader(vertexShader);

    compilation_checking(vertexShader, "vertex");

    GLuint fragmentShader =
        glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
    glCompileShader(fragmentShader);


    compilation_checking(vertexShader, "fragment");

    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glBindFragDataLocation(shaderProgram, 0, "outColor");
    glLinkProgram(shaderProgram);
    glUseProgram(shaderProgram);

    GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
    glEnableVertexAttribArray(posAttrib);
    glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), 0);
    GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
    glEnableVertexAttribArray(colAttrib);
    glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));

    glm::mat4 model = glm::mat4(1.0f);
    model = glm::rotate(model, glm::radians(45.0f), glm::vec3(0.0f, 0.0f, 1.0f));

    GLint uniTrans = glGetUniformLocation(shaderProgram, "model");
    glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));

    GLint uniView = glGetUniformLocation(shaderProgram, "view");

    glm::mat4 proj = glm::perspective(glm::radians(45.0f), 800.0f / 800.0f, 0.06f, 100.0f);
    GLint uniProj = glGetUniformLocation(shaderProgram, "proj");


    glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));


    bool running = true;

    GLint mysz_y = 0;
    int punkty = 3; //36?
    GLint prymitywy[] = { GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP,  GL_POLYGON };
    GLint prymityw = GL_TRIANGLE_FAN;

    glEnable(GL_DEPTH_TEST);

    while (running) {
        sf::Event windowEvent;
        while (window.pollEvent(windowEvent)) {
            switch (windowEvent.type) {
            case sf::Event::Closed:
                running = false;
                break;
            case sf::Event::KeyPressed:
                switch (windowEvent.key.code)
                {
                    case sf::Keyboard::Escape:
                        running = false;
                        break;
                    case sf::Keyboard::Num1:
                        prymityw = prymitywy[0];
                        break;
                    case sf::Keyboard::Num2:
                        prymityw = prymitywy[1];
                        break;
                    case sf::Keyboard::Num3:
                        prymityw = prymitywy[2];
                        break;
                    case sf::Keyboard::Num4:
                        prymityw = prymitywy[3];
                        break;
                    case sf::Keyboard::Num5:
                        prymityw = prymitywy[4];
                        break;
                    case sf::Keyboard::Num6:
                        prymityw = prymitywy[5];
                        break;
                    case sf::Keyboard::Num7:
                        prymityw = prymitywy[6];
                        break;
                    case sf::Keyboard::Num8:
                        prymityw = prymitywy[7];
                        break;
                    case sf::Keyboard::Num9:
                        prymityw = prymitywy[8];
                        break;
                    case sf::Keyboard::Num0:
                        prymityw = prymitywy[9];
                        break;
                }
                break;
            //case sf::Event::MouseMoved:
            //  if (windowEvent.mouseMove.y > mysz_y)
            //  {
            //      punkty++;
            //      mysz_y = windowEvent.mouseMove.y;
            //  } else {
            //      if (punkty > 3)
            //          punkty--;
            //      mysz_y = windowEvent.mouseMove.y;
            //  }

                zmianaWierchołkow(punkty, vbo);

                break;
            }
        }

        ustawKamere(uniView);

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


        glDrawArrays(prymityw, 0, 36);
        window.display();
    }
    glDeleteProgram(shaderProgram);
    glDeleteShader(fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteBuffers(1, &vbo);
    glDeleteVertexArrays(1, &vao);

    window.close();
    return 0;
}