323 lines
9.7 KiB
C++
323 lines
9.7 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"
|
||
|
|
||
|
Core::Shader_Loader shaderLoader;
|
||
|
GLuint programColor;
|
||
|
GLuint programTexture;
|
||
|
|
||
|
obj::Model planeModel, spaceshipModel, boosterModel;
|
||
|
Core::RenderContext planeContext, spaceshipContext, boosterContext;
|
||
|
GLuint boxTexture, groundTexture;
|
||
|
|
||
|
glm::vec3 cameraPos = glm::vec3(0, 5, 40);
|
||
|
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));
|
||
|
|
||
|
|
||
|
// 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;
|
||
|
bool applied2 = false;
|
||
|
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/plane.obj");
|
||
|
spaceshipModel = obj::loadModelFromFile("models/ship.obj");
|
||
|
boosterModel = obj::loadModelFromFile("models/booster.obj");
|
||
|
|
||
|
planeContext.initFromOBJ(planeModel);
|
||
|
spaceshipContext.initFromOBJ(spaceshipModel);
|
||
|
boosterContext.initFromOBJ(boosterModel);
|
||
|
|
||
|
// load textures
|
||
|
groundTexture = Core::LoadTexture("textures/sand.jpg");
|
||
|
boxTexture = Core::LoadTexture("textures/a.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 = boxTexture;
|
||
|
renderables.emplace_back(booster);
|
||
|
|
||
|
Renderable* spaceship = new Renderable();
|
||
|
spaceship->context = &spaceshipContext;
|
||
|
spaceship->textureId = boxTexture;
|
||
|
renderables.emplace_back(spaceship);
|
||
|
}
|
||
|
|
||
|
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.1f;
|
||
|
float moveSpeed = 0.1f;
|
||
|
switch (key)
|
||
|
{
|
||
|
case 'z': cameraAngle -= angleSpeed; break;
|
||
|
case 'x': cameraAngle += angleSpeed; break;
|
||
|
case 'w': cameraPos += cameraDir * moveSpeed; break;
|
||
|
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
||
|
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
||
|
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void mouse(int x, int y)
|
||
|
{
|
||
|
|
||
|
}
|
||
|
|
||
|
glm::mat4 createCameraMatrix()
|
||
|
{
|
||
|
cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle - glm::radians(90.0f)), 0, sinf(cameraAngle - glm::radians(90.0f))));
|
||
|
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);
|
||
|
|
||
|
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);
|
||
|
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()
|
||
|
{
|
||
|
double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0 - startupTime;
|
||
|
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();
|
||
|
|
||
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||
|
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||
|
|
||
|
// 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 && !applied2) {
|
||
|
applied2 = true;
|
||
|
boxBodies[1]->setLinearVelocity(PxVec3(0, 25, 0));
|
||
|
}
|
||
|
|
||
|
|
||
|
// render models
|
||
|
for (Renderable* renderable : renderables) {
|
||
|
drawObjectTexture(renderable->context, renderable->modelMatrix, renderable->textureId);
|
||
|
|
||
|
}
|
||
|
|
||
|
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");
|
||
|
|
||
|
initRenderables();
|
||
|
initPhysicsScene();
|
||
|
startupTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
|
||
|
}
|
||
|
|
||
|
void shutdown()
|
||
|
{
|
||
|
shaderLoader.DeleteProgram(programColor);
|
||
|
shaderLoader.DeleteProgram(programTexture);
|
||
|
}
|
||
|
|
||
|
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("OpenGL + PhysX");
|
||
|
glewInit();
|
||
|
|
||
|
init();
|
||
|
glutKeyboardFunc(keyboard);
|
||
|
glutPassiveMotionFunc(mouse);
|
||
|
glutDisplayFunc(renderScene);
|
||
|
glutIdleFunc(idle);
|
||
|
|
||
|
glutMainLoop();
|
||
|
|
||
|
shutdown();
|
||
|
|
||
|
return 0;
|
||
|
}
|