Game.cpp

//#define GLM_FORCE_RADIANS

#include "Game.h"
#include "3rd\glm\gtc\matrix_transform.hpp"
#include "3rd\glm\glm.hpp"
#include "Content.h"
#include "Keyboard.h"

Game::Game(void)
{

}

Game::~Game(void)
{
}

// inicjalizacja parametrow renderingu
void Game::Init()
{
    mov = 0.0f;
    scale = 0.01f;
    // przesuniecie boxa
    var = 0.0f;
    direction = 0;
    // parametry polozenia i ruchu gracza
    sceneWidth = 10;
    sceneHeight = 8;
    rotate = -90;
    speed = 0.05f; // predkosc ruchu czajnika
    posX = 0.0f;
    posY = 0.0f;

    theta = 1.0f;
    Effect::ShadersDirectory = "";
    glClearColor(0.6f, 0.5f, 1.0f, 1.0f );

    //stworzenie figury (quada) do wyświetlania render targetów
    quad = new Quad();

    // wczytanie tekstury
    tex = Content::LoadTexture("../resources/test.png");

    // wczytanie modelu
    testModel = Content::LoadModel( "../resources/teaPot.ASE" );

    //ustawienie materiału
    glm::mat4x4 mm;
    for(int i = 0; i < testModel->Elements(); i++)
    {
        //ustawienie koloru materiału dla pobranego modelu
        testModel->GetMesh(i)->GetMaterial().Color = glm::vec3(1,1,0);
        //podmiana tekstury w modelu
        testModel->GetMesh(i)->GetMaterial().texture = tex;

        mm = testModel->GetMesh(i)->getLocalWorld();
    }

    // drugi model (sciany na scenie)
    sceneModelBox = Content::LoadModel("../resources/cube.ASE");
    for(int i = 0; i < sceneModelBox->Elements(); i++) {
        sceneModelBox->GetMesh(i)->GetMaterial().Color = glm::vec3( 0.5f, 0.5f, 0.5f );
    }


    //////////////////////////////////////// RENDER TARGETS
    rtTMO = new RenderTarget2D( 800, 600, GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT, GL_DEPTH24_STENCIL8 );
    rt = new RenderTarget2D( 800, 600, GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_DEPTH24_STENCIL8 );


    /////////////////////////////////////// SHADERS
    // wczytanie i inicjalizacja shadera obliczajacego kolor powierzchni obiektu
    // wczytuje shadery (wspiera jedynie fragment (.ps) i vertex shadery (.vs), wystarczy podać nazwę pliku bez rozszerzenia)
    shaderColor= new Effect( "shaders/color" );
    // kompilacja shadera, alteratywnie można wykorzystać CreateShaderInfo, ktory wypisze w konsoli dane nt. shadera oraz ewnetualne błędy.
    shaderColor->CreateShader();

    // wczytanie i inicjalizacja shadera obliczajacego mapowanie tonow
    shaderTMO = new Effect( "shaders/tmo" );
    shaderTMO->CreateShader();

    // wczytanie i inicjalizacja shadera renderujacego obraz do framebuffera
    shaderTextureDrawer = new Effect( "shaders/texture" );
    shaderTextureDrawer->CreateShader();


    /////////////////////////////////////// KAMERA
    // ustawienie parametrów kamery (konstruktor przyjmuje rozdzielczość viewportu),
    // domyślny field of view to 45*, można zmienić metodą SetFOV(float)
    camera = Camera( 800, 600 );
    camera.setPosition(glm::vec3( 0, 0, 15 ));
    camera.setTarget(glm::vec3( 0, 0, 0 ));
    //camera.setFOV( 60.0f );

    // polozenie zrodla swiatla
    LightPosition = glm::vec3(10,10,10);
}

// obsluga klawiatury, zmiana parametrow renderingu
void Game::Update()
{
    theta += 0.02f;
    if(Keyboard::isPressed('W'))
    {
        LightPosition.z += 0.1f;
    }
    if(Keyboard::isPressed('S'))
    {
        LightPosition.z -= 0.1f;
    }
    if(Keyboard::isPressed('A'))
    {
        LightPosition.x -= 0.1f;
    }
    if(Keyboard::isPressed('D'))
    {
        LightPosition.x += 0.1f;
    }


    if(Keyboard::isPressed(GLFW_KEY_UP)) {
        mov += 0.01f;
    }
    if(Keyboard::isPressed(GLFW_KEY_DOWN)) {
        mov -= 0.01f;
    }

    if(Keyboard::isPressed(GLFW_KEY_RIGHT)) {
        scale += 0.001f;
        //rotate += 0.4f;
    }
    if(Keyboard::isPressed(GLFW_KEY_LEFT)) {
        //rotate -= 0.4f;
        scale -= 0.001f;
    }

    if(Keyboard::isPressed(GLFW_KEY_ESCAPE))
    {
        glfwSetWindowShouldClose(glfwGetCurrentContext(), GL_TRUE);
    }

    // zmiana parametrow kamery w czasie ruchu
    camera.setPosition(glm::vec3( posX, posY, 0.6 ));

    glm::mat4 camRot = glm::rotate(glm::mat4(1.0f), (rotate+90), glm::vec3( 0.0f, 0.0f, 1.0f));
    glm::vec4 up = camRot * glm::vec4(0,1,0,1);

    float upX = (float)cos((rotate) * 3.14 / 180);
    float upY = (float)sin((rotate) * 3.14 / 180);
    camera.setUp( glm::vec3( upX, -upY,0) );

    float camTZ = 0;
    float camTY = posY - 3*upY;
    float camTX = posX + 3*upX;
    camera.setTarget(glm::vec3(camTX, camTY, camTZ));

}


// rysowanie planszy gry skladajacej sie z obiektow sceneModelBox
void Game::drawScene( void ) {

    int i = 0;

    shaderColor->GetParameter("matColor")->SetValue(sceneModelBox->GetMesh(i)->GetMaterial().Color);
    shaderColor->GetParameter("mode")->SetValue(-1.0f);

    this->shaderColor->GetParameter("World")->SetValue(
        sceneModelBox->GetMesh(i)->getLocalWorld() *
        glm::translate(glm::mat4(1.0f), glm::vec3(var, 10.0f, 0.0f)) *
        glm::rotate(glm::mat4(1.0f), 0.0f, glm::vec3(1.0f, 0.0f, 0.0f)) *
        glm::scale(glm::mat4(1.0f), glm::vec3(0.01f, 0.01f, 0.04f))
    );
    // rysowanie modelu
    sceneModelBox->GetMesh(i)->Draw();

    this->shaderColor->GetParameter("World")->SetValue(
        sceneModelBox->GetMesh(i)->getLocalWorld() *
        glm::translate(glm::mat4(1.0f), glm::vec3(2.0f, 10.0f, mov)) *
        glm::rotate(glm::mat4(1.0f), 0.0f, glm::vec3(1.0f, 0.0f, 0.0f)) *
        glm::scale(glm::mat4(1.0f), glm::vec3(0.01f, 0.01f, scale))
    );
    // rysowanie modelu
    sceneModelBox->GetMesh(i)->Draw();

    if (direction)
    {
        var -= 0.05f;
    }
    else
    {
        var += 0.05f;
    }
    if (var >= 5.0f)
    {
        direction = 1;
    }
    if (var <= 0.0f)
    {
        direction = 0;
    }
}


// rysowanie sceny (glowna petla)
void Game::Redraw()
{
    //ustawienie textury do ktorej chcemy renderować
    rt->SetRenderTarget();
    glClearColor(0.6f, 0.5f, 1.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //ustawienie shadera e jako aktywnego
    shaderColor->Apply();
    //ustawienie macierzy widoku i projekcji
    shaderColor->GetParameter("View")->SetValue(camera.getView());
    shaderColor->GetParameter("Projection")->SetValue(camera.getProjection());
    //ustawienie pozycji światła i camery
    shaderColor->GetParameter("LightPosition")->SetValue(LightPosition);
    shaderColor->GetParameter("EyePosition")->SetValue(camera.getPosition());

    int i = 0;

    //ustawienie koloru materiału
    shaderColor->GetParameter("matColor")->SetValue(testModel->GetMesh(i)->GetMaterial().Color);

    if(testModel->GetMesh(i)->GetMaterial().texture != NULL)
    {
        //jeśli mamy teksturę to ją bindujemy i ustawiamy tryb teskturowania w shaderze
        shaderColor->GetParameter("mode")->SetValue(1.0f);
        shaderColor->GetParameter("tex")->SetValue(*testModel->GetMesh(i)->GetMaterial().texture);
    }
    else
    {
        //włączenie trybu bez tekstury
        shaderColor->GetParameter("mode")->SetValue(-1.0f);
    }

    // ustawienie transformacji obiektu
    // model może się składać z kilku części (meshy) które znajdują się w przestrzeni lokalnej modelu,
    // musimy skorygować ich pozycję i przekształcić do przestrzeni naszego świata,
    // w tym celu wyciągamy macierz transformacji mesha testModel->GetMesh(i)->getLocalWorld(),
    // a następnie przekształcamy w podobny sposób jak w starszych wersjach OpenGL

    for(int i = 0; i < testModel->Elements(); i++) {

        shaderColor->GetParameter("World")->SetValue(

            testModel->GetMesh(i)->getLocalWorld() *
                glm::translate(glm::mat4(1.0f), glm::vec3( posX, posY, 0 )) *
                glm::rotate(glm::mat4(1.0f), -rotate, glm::vec3( 0.0f, 0.0f, 1.0f )) *
                glm::rotate(glm::mat4(1.0f), 90.0f, glm::vec3( 1.0f, 0.0f, 0.0f )) *

                glm::scale(glm::mat4(1.0f), glm::vec3( 0.1, 0.1, 0.1 ))
                );

        // rysowanie modelu
        testModel->GetMesh(i)->Draw();
    }

    // rysowanie sceny
    drawScene();


    // mapowanie tonow za pomoca drugiego shadera, wynik renderowany jest do drugiego render targetu (rtTMO)
    rtTMO->SetRenderTarget();
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    shaderTMO->Apply();
    shaderTMO->GetParameter("tex")->SetValue(*rt);
    shaderTMO->GetParameter("gamma")->SetValue(1.6f);
    quad->Draw(0, 0, 800, 600, shaderTMO->GetParameter("World"));

    //rendering na ekran (do framebuffera)
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glViewport(0, 0, 800, 600);
    glClearColor(0.0, 0.0, 0.0, 0.0); //zmiana glClearColor by sprawdzić czy faktycznie wyrenderowaliśmy coś do tekstury
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    shaderTextureDrawer->Apply();
    quad->Draw(0, 0, 800, 600, shaderTextureDrawer->GetParameter("World"));

}