diff --git a/Debug/grk-cw8.exe b/Debug/grk-cw8.exe index 4abcd4c..a8a7364 100644 Binary files a/Debug/grk-cw8.exe and b/Debug/grk-cw8.exe differ diff --git a/Debug/grk-cw8.log b/Debug/grk-cw8.log index 25ef898..ad7d530 100644 --- a/Debug/grk-cw8.log +++ b/Debug/grk-cw8.log @@ -1,10 +1,19 @@ - orbita.cpp -D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\orbita.cpp(171,20): warning C4244: "inicjowanie": konwersja z "double" do "float", możliwa utrata danych -D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\orbita.cpp(186,229): warning C4305: "argument": obcięcie z "double" do "T" + projekt.cpp +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(80,43): warning C4305: "argument": obcięcie z "double" do "float" +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(174,66): warning C4305: "argument": obcięcie z "double" do "physx::PxReal" +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(182,64): warning C4305: "argument": obcięcie z "double" do "physx::PxReal" +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(379,60): warning C4244: "argument": konwersja z "double" do "float", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(380,60): warning C4244: "argument": konwersja z "double" do "float", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(393,57): warning C4244: "=": konwersja z "double" do "float", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(419,57): warning C4244: "=": konwersja z "double" do "float", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(432,30): warning C4244: "inicjowanie": konwersja z "double" do "float", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(447,243): warning C4305: "argument": obcięcie z "double" do "T" with [ T=float ] +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(493,15): warning C4244: "argument": konwersja z "time_t" do "unsigned int", możliwa utrata danych +D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\src\projekt.cpp(524,49): warning C4244: "=": konwersja z "double" do "float", możliwa utrata danych Camera.obj : warning LNK4075: zignorowano opcję „/EDITANDCONTINUE” z powodu określenia opcji „/INCREMENTAL:NO” PhysXExtensions_static_32.lib(ExtCpuWorkerThread.obj) : warning LNK4099: nie znaleziono pliku PDB „PhysXExtensions_static_32.pdb” z elementem „PhysXExtensions_static_32.lib(ExtCpuWorkerThread.obj)” lub w pozycji „D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\Debug\PhysXExtensions_static_32.pdb”; obiekt zostanie skonsolidowany bez informacji debugowania PhysXExtensions_static_32.lib(ExtDefaultCpuDispatcher.obj) : warning LNK4099: nie znaleziono pliku PDB „PhysXExtensions_static_32.pdb” z elementem „PhysXExtensions_static_32.lib(ExtDefaultCpuDispatcher.obj)” lub w pozycji „D:\Documents\2020\studia\s3e1\grafika\Projekt_Grafika\Debug\PhysXExtensions_static_32.pdb”; obiekt zostanie skonsolidowany bez informacji debugowania diff --git a/Debug/grk-cw8.pdb b/Debug/grk-cw8.pdb index 3b7c72e..43d4b14 100644 Binary files a/Debug/grk-cw8.pdb and b/Debug/grk-cw8.pdb differ diff --git a/Debug/grk-cw8.tlog/CL.command.1.tlog b/Debug/grk-cw8.tlog/CL.command.1.tlog index aa64e95..64f112a 100644 Binary files a/Debug/grk-cw8.tlog/CL.command.1.tlog and b/Debug/grk-cw8.tlog/CL.command.1.tlog differ diff --git a/Debug/grk-cw8.tlog/CL.read.1.tlog b/Debug/grk-cw8.tlog/CL.read.1.tlog index 5044b3d..0b14a8b 100644 Binary files a/Debug/grk-cw8.tlog/CL.read.1.tlog and b/Debug/grk-cw8.tlog/CL.read.1.tlog differ diff --git a/Debug/grk-cw8.tlog/CL.write.1.tlog b/Debug/grk-cw8.tlog/CL.write.1.tlog index 035bb51..6952d11 100644 Binary files a/Debug/grk-cw8.tlog/CL.write.1.tlog and b/Debug/grk-cw8.tlog/CL.write.1.tlog differ diff --git a/Debug/grk-cw8.tlog/link.command.1.tlog b/Debug/grk-cw8.tlog/link.command.1.tlog index 5bc2bb8..adbdbbf 100644 Binary files a/Debug/grk-cw8.tlog/link.command.1.tlog and b/Debug/grk-cw8.tlog/link.command.1.tlog differ diff --git a/Debug/grk-cw8.tlog/link.read.1.tlog b/Debug/grk-cw8.tlog/link.read.1.tlog index 3483bf3..1af81a6 100644 Binary files a/Debug/grk-cw8.tlog/link.read.1.tlog and b/Debug/grk-cw8.tlog/link.read.1.tlog differ diff --git a/Debug/grk-cw8.tlog/link.write.1.tlog b/Debug/grk-cw8.tlog/link.write.1.tlog index e386518..1ddeb21 100644 Binary files a/Debug/grk-cw8.tlog/link.write.1.tlog and b/Debug/grk-cw8.tlog/link.write.1.tlog differ diff --git a/Debug/orbita.obj b/Debug/orbita.obj index 97a3178..8ed8f4e 100644 Binary files a/Debug/orbita.obj and b/Debug/orbita.obj differ diff --git a/Debug/projekt.obj b/Debug/projekt.obj new file mode 100644 index 0000000..e2c4b98 Binary files /dev/null and b/Debug/projekt.obj differ diff --git a/Debug/vc142.idb b/Debug/vc142.idb index 1a7d2b9..b9671cf 100644 Binary files a/Debug/vc142.idb and b/Debug/vc142.idb differ diff --git a/Debug/vc142.pdb b/Debug/vc142.pdb index d1d0121..c426962 100644 Binary files a/Debug/vc142.pdb and b/Debug/vc142.pdb differ diff --git a/grk-cw8.vcxproj b/grk-cw8.vcxproj index 6635407..7064fe6 100644 --- a/grk-cw8.vcxproj +++ b/grk-cw8.vcxproj @@ -12,8 +12,8 @@ - + diff --git a/grk-cw8.vcxproj.filters b/grk-cw8.vcxproj.filters index 5760c53..4b9884f 100644 --- a/grk-cw8.vcxproj.filters +++ b/grk-cw8.vcxproj.filters @@ -51,7 +51,7 @@ Source Files - + Source Files diff --git a/src/projekt.cpp b/src/projekt.cpp new file mode 100644 index 0000000..2ff9649 --- /dev/null +++ b/src/projekt.cpp @@ -0,0 +1,552 @@ +#include "glew.h" +#include "freeglut.h" +#include "glm.hpp" +#include "ext.hpp" +#include +#include +#include + +#include "Shader_Loader.h" +#include "Render_Utils.h" +#include "Camera.h" +#include "Texture.h" +#include "Physics.h" +#include "Skybox.h" + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" + +GLuint programColor; +GLuint programTexture; +GLuint programSkybox; +GLuint programSun; +GLuint cubemapTexture; +GLuint skyboxVAO, skyboxVBO; + +Core::Shader_Loader shaderLoader; + +obj::Model planeModel; +obj::Model boxModel; +obj::Model shipModel; +obj::Model boosterModel; +obj::Model platformModel; +obj::Model craneModel; +obj::Model lampModel; +glm::mat4 boxModelMatrix; +Core::RenderContext planeContext, boxContext, shipContext, boosterContext, platformContext, craneContext, lampContext; +GLuint boxTexture, groundTexture, shipTexture, stoneTexture, redTex, yellowTex; + +glm::vec3 cameraPos = glm::vec3(-40, 5, 0); +glm::vec3 cameraDir; +glm::vec3 cameraSide; +float cameraAngle = 0; +glm::mat4 cameraMatrix, perspectiveMatrix; + +glm::vec3 lightDir = glm::normalize(glm::vec3(0.5, -1, -0.5)); +glm::vec3 lightPos = glm::vec3(-15.75, 2, 0); + +float appLoadingTime; + +obj::Model shipModelOrbit; +obj::Model sphereModelOrbit; +obj::Model stationModelOrbit; + +GLuint textureAsteroid; +GLuint textureShip; +GLuint textureSun; +GLuint textureEarthHighres; +GLuint textureMoon; + +Core::RenderContext shipContextOrbit, sphereContextOrbit, stationContextOrbit; + +float frustumScale = 1.f; +bool loading = false; +bool reload = false; +float orbitSpeed = 0.005f; + +// skybox +std::vector faces +{ + "textures/skybox/stars.jpeg", + "textures/skybox/stars.jpeg", + "textures/skybox/stars.jpeg", + "textures/skybox/stars.jpeg", + "textures/skybox/stars.jpeg", + "textures/skybox/stars.jpeg", +}; + + +// Initalization of physical scene (PhysX) +Physics pxScene(9.8 /* gravity (m/s^2) */); + + +// fixed timestep for stable and deterministic simulation +const double physicsStepTime = 1.f / 60.f; +double physicsTimeToProcess = 0; +double startupTime = 0; + +// physical objects +PxRigidStatic* planeBody = nullptr; +PxMaterial* planeMaterial = nullptr; +std::vector boxBodies; +PxMaterial* boxMaterial = nullptr; + + +// renderable objects (description of a single renderable instance) +struct Renderable { + Core::RenderContext* context; + glm::mat4 modelMatrix; + GLuint textureId; +}; +std::vector renderables; + + + +void initRenderables() +{ + // load models + planeModel = obj::loadModelFromFile("models/plane2.obj"); + boxModel = obj::loadModelFromFile("models/box.obj"); + shipModel = obj::loadModelFromFile("models/ship.obj"); + boosterModel = obj::loadModelFromFile("models/booster.obj"); + platformModel = obj::loadModelFromFile("models/platform4.obj"); + craneModel = obj::loadModelFromFile("models/crane.obj"); + lampModel = obj::loadModelFromFile("models/lamp2.obj"); + + planeContext.initFromOBJ(planeModel); + boxContext.initFromOBJ(boxModel); + shipContext.initFromOBJ(shipModel); + boosterContext.initFromOBJ(boosterModel); + platformContext.initFromOBJ(platformModel); + craneContext.initFromOBJ(craneModel); + lampContext.initFromOBJ(lampModel); + + // load textures + groundTexture = Core::LoadTexture("textures/sand.jpg"); + boxTexture = Core::LoadTexture("textures/a.jpg"); + shipTexture = Core::LoadTexture("textures/ship.png"); + stoneTexture = Core::LoadTexture("textures/stone.png"); + redTex = Core::LoadTexture("textures/redTex.png"); + yellowTex = Core::LoadTexture("textures/yellowTex.jpg"); + + // This time we organize all the renderables in a list + // of basic properties (model, transform, texture), + // to unify their rendering and simplify their managament + // in connection to the physics simulation + + // create ground + Renderable* ground = new Renderable(); + ground->context = &planeContext; + ground->textureId = groundTexture; + renderables.emplace_back(ground); + + Renderable* booster = new Renderable(); + booster->context = &boosterContext; + booster->textureId = shipTexture; + renderables.emplace_back(booster); + + Renderable* spaceship = new Renderable(); + spaceship->context = &shipContext; + spaceship->textureId = shipTexture; + renderables.emplace_back(spaceship); + + Renderable* platform = new Renderable(); + platform->context = &platformContext; + platform->textureId = stoneTexture; + renderables.emplace_back(platform); + + Renderable* crane = new Renderable(); + crane->context = &craneContext; + crane->textureId = redTex; + renderables.emplace_back(crane); + + Renderable* lamp = new Renderable(); + lamp->context = &lampContext; + lamp->textureId = yellowTex; + renderables.emplace_back(lamp); + +} + +void initPhysicsScene() +{ + + planeBody = pxScene.physics->createRigidStatic(PxTransformFromPlaneEquation(PxPlane(0, 10, 0, 0))); + planeMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6); + PxShape* planeShape = pxScene.physics->createShape(PxPlaneGeometry(), *planeMaterial); + planeBody->attachShape(*planeShape); + planeShape->release(); + planeBody->userData = renderables[0]; + pxScene.scene->addActor(*planeBody); + + + boxMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6); + + + PxRigidDynamic* boosterBody = pxScene.physics->createRigidDynamic(PxTransform(0, -3, 0)); //desired position - 3 + PxShape* boosterShape = pxScene.physics->createShape(PxBoxGeometry(1, 8, 1), *boxMaterial); + boosterShape->setLocalPose(PxTransform(0, 11, 0)); + boosterBody->attachShape(*boosterShape); + boosterShape->release(); + boosterBody->userData = renderables[1]; + pxScene.scene->addActor(*boosterBody); + boxBodies.push_back(boosterBody); + + PxRigidDynamic* spaceshipBody = pxScene.physics->createRigidDynamic(PxTransform(0, -3, 0)); // desiredPosition - 19 + PxShape* spaceshipShape = pxScene.physics->createShape(PxBoxGeometry(1, 1, 1), *boxMaterial); + spaceshipShape->setLocalPose(PxTransform(0, 20, 0)); + spaceshipBody->attachShape(*spaceshipShape); + spaceshipShape->release(); + spaceshipBody->userData = renderables[2]; + pxScene.scene->addActor(*spaceshipBody); + boxBodies.push_back(spaceshipBody); + +} + +void updateTransforms() +{ + // Here we retrieve the current transforms of the objects from the physical simulation. + auto actorFlags = PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC; + PxU32 nbActors = pxScene.scene->getNbActors(actorFlags); + if (nbActors) + { + std::vector actors(nbActors); + pxScene.scene->getActors(actorFlags, (PxActor**)&actors[0], nbActors); + for (auto actor : actors) + { + // We use the userData of the objects to set up the model matrices + // of proper renderables. + if (!actor->userData) continue; + Renderable* renderable = (Renderable*)actor->userData; + + // get world matrix of the object (actor) + PxMat44 transform = actor->getGlobalPose(); + auto& c0 = transform.column0; + auto& c1 = transform.column1; + auto& c2 = transform.column2; + auto& c3 = transform.column3; + + // set up the model matrix used for the rendering + renderable->modelMatrix = glm::mat4( + c0.x, c0.y, c0.z, c0.w, + c1.x, c1.y, c1.z, c1.w, + c2.x, c2.y, c2.z, c2.w, + c3.x, c3.y, c3.z, c3.w); + } + } +} + +void keyboard(unsigned char key, int x, int y) +{ + float angleSpeed = 0.5f; + float moveSpeed = 0.5f; + switch (key) + { + //case 'z': cameraAngle -= angleSpeed; break; + //case 'x': cameraAngle += angleSpeed; break; + //case 'd': cameraPos += glm::cross(cameraDir, glm::vec3(0, 1, 0)) * moveSpeed; break; + //case 'a': cameraPos -= glm::cross(cameraDir, glm::vec3(0, 1, 0)) * moveSpeed; break; + //case 'e': cameraPos += glm::vec3(0, 1, 0) * moveSpeed; break; + //case 'q': cameraPos -= glm::vec3(0, 1, 0) * moveSpeed; break; + + case 'w': + if (orbitSpeed < 0.02f) { + orbitSpeed += 0.001f; + } + break; + case 's': + if (orbitSpeed > 0.001f) { + orbitSpeed -= 0.001f; + } + break; + } +} + +void mouse(int x, int y) +{ + +} + + +glm::mat4 createCameraMatrixOrbit() +{ + float time = glutGet(GLUT_ELAPSED_TIME) / 1000.0f - appLoadingTime; + + // Obliczanie kierunku patrzenia kamery (w plaszczyznie x-z) przy uzyciu zmiennej cameraAngle kontrolowanej przez klawisze. + cameraPos = glm::rotate(cameraPos, orbitSpeed, glm::vec3(0, 1, 0)); + //cameraDir = glm::vec3(cosf(cameraAngle), 0.0f, sinf(cameraAngle)); + cameraDir = glm::normalize(glm::vec3(0, 0, 0) - cameraPos); + glm::vec3 up = glm::vec3(0, 1, 0); + + return Core::createViewMatrix(cameraPos, cameraDir, up); +} + + +void drawObject(GLuint program, Core::RenderContext context, glm::mat4 modelMatrix, glm::vec3 color) +{ + glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z); + + glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix; + glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix); + glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation); + + Core::DrawContext(context); +} + + +glm::mat4 createCameraMatrix() +{ + cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle), 0, sinf(cameraAngle))); + glm::vec3 up = glm::vec3(0, 1, 0); + cameraSide = glm::cross(cameraDir, up); + + PxTransform position = boxBodies[1]->getGlobalPose(); + cameraPos.y = position.p.y - 5 + 19; + + return Core::createViewMatrix(cameraPos, cameraDir, up); +} + +void drawObjectColor(Core::RenderContext* context, glm::mat4 modelMatrix, glm::vec3 color) +{ + GLuint program = programColor; + + glUseProgram(program); + + glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z); + glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z); + glUniform3f(glGetUniformLocation(program, "lightPos"), lightPos.x, lightPos.y, lightPos.z); + + glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix; + glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation); + glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix); + + Core::DrawContext(*context); + + glUseProgram(0); +} + +void drawObjectTexture(Core::RenderContext* context, glm::mat4 modelMatrix, GLuint textureId) +{ + GLuint program = programTexture; + + glUseProgram(program); + + glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z); + glUniform3f(glGetUniformLocation(program, "lightPos"), lightPos.x, lightPos.y, lightPos.z); + Core::SetActiveTexture(textureId, "textureSampler", program, 0); + + glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix; + glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation); + glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix); + + Core::DrawContext(*context); + + glUseProgram(0); +} + +void renderScene() +{ + //start + if (!loading) { + double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0 - appLoadingTime; + static double prevTime = time; + double dtime = time - prevTime; + prevTime = time; + + // Update physics + if (dtime < 1.f) { + physicsTimeToProcess += dtime; + while (physicsTimeToProcess > 0) { + // here we perform the physics simulation step + pxScene.step(physicsStepTime); + physicsTimeToProcess -= physicsStepTime; + } + } + + // Update of camera and perspective matrices + cameraMatrix = createCameraMatrix(); + perspectiveMatrix = Core::createPerspectiveMatrix(0.1f, 1000.f); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glClearColor(0.0f, 0.1f, 0.3f, 1.0f); + + Skybox::drawSkybox(programSkybox, cameraMatrix, perspectiveMatrix, cubemapTexture); + + // update transforms from physics simulation + updateTransforms(); + + + if (time > 2 && time < 7) { + boxBodies[0]->setLinearVelocity(PxVec3(0, time * 0.8, 0)); + boxBodies[1]->setLinearVelocity(PxVec3(0, time * 0.8, 0)); + } + + if (time > 7 && time < 15) { + boxBodies[1]->setLinearVelocity(PxVec3(0, 15, 0)); + } + + if (time > 15) { + loading = true; + lightDir = glm::normalize(glm::vec3(1.0f, -1.0f, -1.0f)); + lightPos = glm::vec3(0, 0, -800); + cameraAngle = glm::radians(0.0f); + cameraPos = glm::vec3(0, 0, 250); + appLoadingTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0; + } + + + // render models + for (Renderable* renderable : renderables) { + drawObjectTexture(renderable->context, renderable->modelMatrix, renderable->textureId); + + } + + glutSwapBuffers(); + } + + + //loading screen + else if (!reload) { + + float time = glutGet(GLUT_ELAPSED_TIME) / 1000.0f - appLoadingTime; + + if (time < 3) { + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glClearColor(1.f, 1.f, 1.f, 1.0f); + glutSwapBuffers(); + } + else { + reload = true; + appLoadingTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0; + } + } + + + //orbit + else + { + float time = glutGet(GLUT_ELAPSED_TIME) / 1000.0f - appLoadingTime; + + // opcjonalny ruch swiatla do testow + bool animateLight = false; + if (animateLight) { + float lightAngle = (glutGet(GLUT_ELAPSED_TIME) / 1000.0f) * 3.14 / 8; + lightDir = glm::normalize(glm::vec3(sin(lightAngle), -1.0f, cos(lightAngle))); + } + + // Aktualizacja macierzy widoku i rzutowania. + cameraMatrix = createCameraMatrixOrbit(); + perspectiveMatrix = Core::createPerspectiveMatrix(0.1f, 1500.f); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glClearColor(0.0f, 0.3f, 0.3f, 1.0f); + + // skybox + Skybox::drawSkybox(programSkybox, cameraMatrix, perspectiveMatrix, cubemapTexture); + + //SHIP + glm::mat4 shipModelOrbitMatrix = glm::translate(cameraPos + cameraDir * 4.f + glm::vec3(0, -0.25f, 0)) * glm::rotate(glm::orientedAngle(glm::vec3(0, 0, 1), cameraDir, glm::vec3(0, 1, 0)), glm::vec3(0, 1, 0)) * glm::scale(glm::vec3(0.2)) * glm::translate(glm::vec3(2, 0, 0)); + drawObjectTexture(&shipContextOrbit, shipModelOrbitMatrix, textureShip); + + //SUN + //drawObjectTexture(&sphereModelOrbit, glm::translate(glm::vec3(0, 0, 0)) * glm::scale(glm::vec3(20.f)), textureSun); + + //STATION + drawObjectColor(&stationContextOrbit, glm::rotate(time / 2.0f, glm::vec3(0, 1, 0)) * glm::translate(glm::vec3(0, 0, 200)) * glm::scale(glm::vec3(5)), glm::vec3(0.5)); + + //EARTH nieruchoma - �atwiejsze dla naszej cutscenki + drawObjectTexture(&sphereContextOrbit, glm::scale(glm::vec3(45)), textureEarthHighres); + + //MOON + drawObjectTexture(&sphereContextOrbit, glm::rotate(time / 50.0f, glm::vec3(0, 1, 0)) * glm::translate(glm::vec3(0, 0, 300)) * glm::scale(glm::vec3(20)), textureMoon); + + + // sun + glUseProgram(programSun); + glUniform3f(glGetUniformLocation(programSun, "lightPos"), lightPos.x, lightPos.y, lightPos.z); + glUniform3f(glGetUniformLocation(programSun, "cameraPos"), cameraPos.x, cameraPos.y, cameraPos.z); + drawObject(programSun, sphereContextOrbit, glm::translate(lightPos) * glm::scale(glm::vec3(10.f)), glm::vec3(1.0f, 0.8f, 0.2f)); + + glUseProgram(0); + + glutSwapBuffers(); + } +} + + +void shutdown() +{ + shaderLoader.DeleteProgram(programColor); + shaderLoader.DeleteProgram(programTexture); + + planeContext.initFromOBJ(planeModel); + boxContext.initFromOBJ(boxModel); + shipContext.initFromOBJ(shipModel); + boosterContext.initFromOBJ(boosterModel); + platformContext.initFromOBJ(platformModel); + craneContext.initFromOBJ(craneModel); + lampContext.initFromOBJ(lampModel); +} + + +void init() +{ + srand(time(0)); + glEnable(GL_DEPTH_TEST); + programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag"); + programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag"); + programSkybox = shaderLoader.CreateProgram("shaders/shader_skybox.vert", "shaders/shader_skybox.frag"); + + cubemapTexture = Skybox::loadCubemap(faces); + + glEnable(GL_DEPTH_TEST); + + programSun = shaderLoader.CreateProgram("shaders/shader_4_2.vert", "shaders/shader_4_2.frag"); + + shipModelOrbit = obj::loadModelFromFile("models/ship_orbita.obj"); + shipContextOrbit.initFromOBJ(shipModelOrbit); + + stationModelOrbit = obj::loadModelFromFile("models/spaceStation.obj"); + stationContextOrbit.initFromOBJ(stationModelOrbit); + + sphereModelOrbit = obj::loadModelFromFile("models/sphere.obj"); + sphereContextOrbit.initFromOBJ(sphereModelOrbit); + + textureShip = Core::LoadTexture("textures/ship.png"); + textureEarthHighres = Core::LoadTexture("textures/4k_earth_daymap.png"); + textureAsteroid = Core::LoadTexture("textures/asteroid.png"); + textureSun = Core::LoadTexture("textures/2k_sun_texture.png"); + textureMoon = Core::LoadTexture("textures/2k_moon.png"); + + programSkybox = shaderLoader.CreateProgram("shaders/shader_skybox.vert", "shaders/shader_skybox.frag"); + + initRenderables(); + initPhysicsScene(); + appLoadingTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0; +} + +void idle() +{ + glutPostRedisplay(); +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); + glutInitWindowPosition(200, 200); + glutInitWindowSize(600, 600); + glutCreateWindow("Projekt GRK"); + glewInit(); + + init(); + glutKeyboardFunc(keyboard); + glutPassiveMotionFunc(mouse); + glutDisplayFunc(renderScene); + glutIdleFunc(idle); + + glutMainLoop(); + + shutdown(); + + return 0; +}