653 lines
21 KiB
C++
653 lines
21 KiB
C++
#include "glew.h"
|
||
#include "freeglut.h"
|
||
#include "glm.hpp"
|
||
#include "ext.hpp"
|
||
#include <iostream>
|
||
#include <cmath>
|
||
#include <vector>
|
||
|
||
#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 cubemapTexture2;
|
||
GLuint cubemapTexture3;
|
||
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;
|
||
glm::vec3 stationPos;
|
||
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;
|
||
bool end = false;
|
||
float orbitSpeed = 0.003f;
|
||
|
||
// skybox
|
||
std::vector<std::string> 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",
|
||
};
|
||
// skybox
|
||
std::vector<std::string> faces2
|
||
{
|
||
"textures/skybox/stars3.jpeg",
|
||
"textures/skybox/stars3.jpeg",
|
||
"textures/skybox/stars3.jpeg",
|
||
"textures/skybox/stars3.jpeg",
|
||
"textures/skybox/stars3.jpeg",
|
||
"textures/skybox/stars3.jpeg",
|
||
};
|
||
|
||
std::vector<std::string> faces3
|
||
{
|
||
"textures/skybox/stars4.jpeg",
|
||
"textures/skybox/stars4.jpeg",
|
||
"textures/skybox/stars4.jpeg",
|
||
"textures/skybox/stars4.jpeg",
|
||
"textures/skybox/stars4.jpeg",
|
||
"textures/skybox/stars4.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<PxRigidDynamic*> boxBodies;
|
||
PxMaterial* boxMaterial = nullptr;
|
||
|
||
|
||
// renderable objects (description of a single renderable instance)
|
||
struct Renderable {
|
||
Core::RenderContext* context;
|
||
glm::mat4 modelMatrix;
|
||
GLuint textureId;
|
||
};
|
||
std::vector<Renderable*> 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<PxRigidActor*> 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.0001f;
|
||
}
|
||
break;
|
||
case 's':
|
||
if (orbitSpeed > 0.001f) {
|
||
orbitSpeed -= 0.0001f;
|
||
}
|
||
break;
|
||
|
||
case 'd':
|
||
if (orbitSpeed < 0.02f) {
|
||
orbitSpeed += 0.001f;
|
||
}
|
||
break;
|
||
case 'a':
|
||
if (orbitSpeed > 0.001f) {
|
||
orbitSpeed -= 0.001f;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
void mouse(int x, int y)
|
||
{
|
||
|
||
}
|
||
|
||
glm::mat4 createCameraMatrixLoading()
|
||
{
|
||
float time = glutGet(GLUT_ELAPSED_TIME) / 1000.0f - appLoadingTime;
|
||
|
||
cameraDir = glm::normalize(glm::vec3(0, 0, 0) - cameraPos);
|
||
glm::vec3 up = glm::vec3(0, 1, 0);
|
||
|
||
return Core::createViewMatrix(cameraPos, cameraDir, up);
|
||
}
|
||
|
||
|
||
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 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 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, 1500.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(0.0f, 0.1f, 0.3f, 1.0f);
|
||
|
||
//cameraMatrix = createCameraMatrixLoading();
|
||
// perspectiveMatrix = Core::createPerspectiveMatrix(0.1f, 1000.f);
|
||
Skybox::drawSkybox(programSkybox, cameraMatrix, perspectiveMatrix, cubemapTexture2);
|
||
|
||
|
||
glutSwapBuffers();
|
||
}
|
||
else {
|
||
reload = 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.f, 0.f, -250.f);
|
||
stationPos = glm::vec3(0.f, -0.65f, 245.5f);
|
||
appLoadingTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
|
||
}
|
||
}
|
||
|
||
|
||
//orbit
|
||
else if (!end)
|
||
{
|
||
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
|
||
glm::mat4 stationmat = glm::rotate(time / 5.0f, glm::vec3(0, 1, 0)) * glm::translate(stationPos) * glm::scale(glm::vec3(0.4)) * glm::rotate(glm::radians(-90.0f), glm::vec3(0, 1, 0));
|
||
drawObjectTexture(&stationContextOrbit, stationmat, shipTexture);
|
||
|
||
//stationmat = perspectiveMatrix * stationmat;
|
||
glm::vec3 stationPos = glm::vec3(stationmat[3][0], stationmat[3][1], stationmat[3][2]);
|
||
|
||
|
||
float distance = sqrt((cameraPos.x - stationPos.x)*(cameraPos.x - stationPos.x) + (cameraPos.z - stationPos.z)* (cameraPos.z - stationPos.z));
|
||
std::cout << "distance: " << distance << std::endl;
|
||
//std::cout << "cameraPos.x: " << cameraPos.x << "cameraPos.z: " << cameraPos.z <<std::endl;
|
||
//std::cout << "stationPos.x: " << stationPos.x << "stationPos.z: " << stationPos.z << std::endl;
|
||
if (distance < 5) {
|
||
end = 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;
|
||
}
|
||
|
||
//EARTH nieruchoma - <20>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();
|
||
}
|
||
|
||
//end
|
||
else
|
||
{
|
||
float time = glutGet(GLUT_ELAPSED_TIME) / 1000.0f - appLoadingTime;
|
||
|
||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||
|
||
cameraMatrix = createCameraMatrixLoading();
|
||
perspectiveMatrix = Core::createPerspectiveMatrix(0.1f, 1500.f);
|
||
Skybox::drawSkybox(programSkybox, cameraMatrix, perspectiveMatrix, cubemapTexture3);
|
||
|
||
glutSwapBuffers();
|
||
}
|
||
}
|
||
|
||
|
||
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);
|
||
cubemapTexture2 = Skybox::loadCubemap(faces2);
|
||
cubemapTexture3 = Skybox::loadCubemap(faces3);
|
||
|
||
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();
|
||
}
|
||
|
||
void onReshape(int width, int height)
|
||
{
|
||
frustumScale = (float)width / height;
|
||
|
||
glViewport(0, 0, width, height);
|
||
}
|
||
|
||
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);
|
||
glutReshapeFunc(onReshape);
|
||
|
||
glutMainLoop();
|
||
|
||
shutdown();
|
||
|
||
return 0;
|
||
}
|