296 lines
8.9 KiB
C++
296 lines
8.9 KiB
C++
#include "renderer_polygon_3d.hpp"
|
|
|
|
#include <iostream>
|
|
|
|
#include <glm/gtc/type_ptr.hpp>
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
#include <glm/gtx/euler_angles.hpp>
|
|
#include <glm/gtc/random.hpp>
|
|
|
|
namespace endofthejedi {
|
|
void RendererPolygon3d::setup()
|
|
{
|
|
m_lastTime = -1.0;
|
|
|
|
std::cout<<"setup polygon 3d" << std::endl;
|
|
|
|
m_shader.init();
|
|
|
|
#if 0
|
|
std::string vss_simple = "../data/shader/simple.vert";
|
|
std::string fss_simple = "../data/shader/simple.frag";
|
|
m_shader.loadFile(vss_simple, GL_VERTEX_SHADER);
|
|
m_shader.loadFile(fss_simple, GL_FRAGMENT_SHADER);
|
|
#else
|
|
std::string vss_game_objects = "../data/shader/gameobjects.vert";
|
|
std::string fss_game_objects = "../data/shader/gameobjects.frag";
|
|
m_shader.loadFile(vss_game_objects, GL_VERTEX_SHADER);
|
|
m_shader.loadFile(fss_game_objects, GL_FRAGMENT_SHADER);
|
|
#endif
|
|
|
|
addModel("../data/mesh/small_atomic_bomb.stl", &m_missileModel);
|
|
addModel("../data/mesh/planet_12.stl", &m_planetModel);
|
|
addModel("../data/mesh/ship_ufo.stl", &m_shipModel);
|
|
}
|
|
|
|
void RendererPolygon3d::render(const game::State *state)
|
|
{
|
|
if (m_lastTime == -1.0) {
|
|
m_lastTime = state->timestamp();
|
|
}
|
|
|
|
float dt = state->timestamp() - m_lastTime;
|
|
if (dt < 0.0) {
|
|
dt = 0.0;
|
|
}
|
|
|
|
m_state = state;
|
|
advanceGraphicObjects(dt);
|
|
|
|
// TODO: add stars (texture)
|
|
// TODO: add dust particles
|
|
// TODO: add little rocks flying around
|
|
|
|
glClearColor(0.0, 0.0, 0.0, 1.0);
|
|
|
|
m_shader.bind();
|
|
|
|
// TODO: add ONE sun planet
|
|
// TODO: add lights for explosions
|
|
|
|
glm::vec3 c = glm::vec3(1.0, 1.0, 0.8);
|
|
glUniform3f(m_shader.location("lightColor"), c.x, c.y, c.z);
|
|
|
|
glm::vec3 p = glm::vec3(0.3f, 0.4f, 0.0f);
|
|
glUniform3f(m_shader.location("lightPosition"), p.x, p.y, p.z);
|
|
|
|
renderPlanets();
|
|
renderShips();
|
|
renderMissiles();
|
|
|
|
renderParticles();
|
|
|
|
renderTraces();
|
|
|
|
//glColor3f(1.0, 0.0, 0.0);
|
|
//glBegin(GL_QUADS);
|
|
//glVertex2f(-1.0f, -1.0f);
|
|
//glVertex2f(1.0f, -1.0f);
|
|
//glVertex2f(1.0f, 1.0f);
|
|
//glVertex2f(-1.0f, 1.0f);
|
|
//glEnd();
|
|
|
|
m_lastTime = state->timestamp();
|
|
}
|
|
|
|
void RendererPolygon3d::renderParticles()
|
|
{
|
|
for (ParticleBatch *batch : m_particles) {
|
|
batch->bind();
|
|
batch->render();
|
|
}
|
|
}
|
|
|
|
void RendererPolygon3d::addExplosionEffect(size_t id, const glm::vec2 &pos, size_t n, float duration)
|
|
{
|
|
//float particleRadius = 0.005;
|
|
//float particleRadius = 0.003;
|
|
float particleRadius = 0.01;
|
|
|
|
// TODO: use this as shader input too and make the area 2x around this
|
|
// so that it stays hot/yellow for 2/3 of the time
|
|
float explSize = 0.01f;
|
|
|
|
float maxVelocity = 0.2f;
|
|
|
|
ParticleBatch *batch = new ParticleBatch(id, n, particleRadius, duration);
|
|
batch->setCenter(glm::vec3(pos, 0.0));
|
|
batch->setMaxVelocity(maxVelocity);
|
|
|
|
for (size_t i=0; i<n; i++) {
|
|
// distribute in a circle
|
|
//float t = 2.0 * M_PI * i / (float) n;
|
|
//t += 0.2*util::randf_m1_1();
|
|
|
|
// with random velocities
|
|
// this is 3d because it looks better if some particles leave/enter
|
|
// the space and they are not all on one plane.
|
|
// especially in 3d this would look bad without 3d velocity vector.
|
|
//glm::vec3 v = 0.5f*glm::vec3(sin(t), cos(t), util::randf_m1_1());
|
|
|
|
glm::vec3 v = glm::ballRand(maxVelocity);
|
|
v *= util::randf_0_1() + util::randf_0_1();
|
|
|
|
batch->setParticle(i, glm::vec3(pos, 0.0) + glm::ballRand(explSize), v);
|
|
}
|
|
|
|
batch->upload();
|
|
|
|
m_particles.push_back(batch);
|
|
}
|
|
|
|
void RendererPolygon3d::advanceGraphicObjects(float dt)
|
|
{
|
|
for (const game::Explosion *expl : m_state->explosions) {
|
|
bool gotIt = false;
|
|
for (ParticleBatch *batch : m_particles) {
|
|
if (batch->id() == expl->id) {
|
|
gotIt = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!gotIt) {
|
|
addExplosionEffect(expl->id, expl->position, 500, 5.0);
|
|
}
|
|
}
|
|
|
|
if (m_particles.size() == 0) {
|
|
addExplosionEffect(0, glm::vec2(0.0, 0.0), 1000, 5.0);
|
|
}
|
|
|
|
std::vector<ParticleBatch*> rm;
|
|
|
|
for (ParticleBatch *batch : m_particles) {
|
|
batch->tick(dt);
|
|
if (batch->done()) {
|
|
rm.push_back(batch);
|
|
}
|
|
}
|
|
|
|
for (ParticleBatch *batch : rm) {
|
|
m_particles.remove(batch);
|
|
delete(batch);
|
|
}
|
|
}
|
|
|
|
void RendererPolygon3d::renderPlanets()
|
|
{
|
|
m_planetModel->bind();
|
|
|
|
for (const game::Planet *planet : m_state->planets) {
|
|
glm::mat4 model = computeModelMatrix(planet);
|
|
glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));
|
|
|
|
glm::vec3 c = planet->getColor();
|
|
glUniform3f(m_shader.location("materialColor"), c.x, c.y, c.z);
|
|
glUniform3f(m_shader.location("color"), c.x, c.y, c.z);
|
|
|
|
m_planetModel->render();
|
|
}
|
|
}
|
|
|
|
void RendererPolygon3d::renderMissiles()
|
|
{
|
|
m_missileModel->bind();
|
|
|
|
for (const game::Player *player : m_state->players) {
|
|
for (const game::Missile *missile : player->missiles) {
|
|
glm::vec3 c = glm::vec3(1.0, 1.0, 0.3);
|
|
glUniform3f(m_shader.location("materialColor"), c.x, c.y, c.z);
|
|
|
|
glm::mat4 model = computeModelMatrix(missile);
|
|
glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));
|
|
|
|
m_missileModel->render();
|
|
}
|
|
}
|
|
}
|
|
|
|
void RendererPolygon3d::renderShips()
|
|
{
|
|
m_shipModel->bind();
|
|
|
|
for (const game::Ship *ship : m_state->ships) {
|
|
glm::mat4 model = computeModelMatrix(ship);
|
|
glUniformMatrix4fv(m_shader.location("model"), 1, GL_FALSE, glm::value_ptr(model));
|
|
|
|
glm::vec3 c = glm::vec3(0.1, 1.0, 0.2);
|
|
glUniform3f(m_shader.location("materialColor"), c.x, c.y, c.z);
|
|
|
|
m_shipModel->render();
|
|
}
|
|
}
|
|
|
|
void RendererPolygon3d::addModel(const std::string &filename, PolygonModel **dest)
|
|
{
|
|
//std::cout<<"adding a model: " << filename << std::endl;
|
|
|
|
*dest = new PolygonModel(filename);
|
|
if (!(*dest)->import()) {
|
|
std::cout<<"error: failed to load needed model!!!" << std::endl << std::endl;
|
|
exit(-1);
|
|
}
|
|
|
|
(*dest)->setup(&m_shader);
|
|
(*dest)->uploadToOpenGl();
|
|
|
|
m_models.push_back(*dest);
|
|
}
|
|
|
|
glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Planet *planet)
|
|
{
|
|
return computeModelMatrix(planet->position, planet->radius);
|
|
}
|
|
|
|
glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Missile *missile)
|
|
{
|
|
glm::vec2 vn = glm::normalize(missile->velocity);
|
|
float a = std::atan2(vn.y, vn.x);
|
|
|
|
// TODO: which visual size has the rocket? in game its just a point with
|
|
// no size because all others have size.
|
|
return computeModelMatrix(missile->position, 0.03f, a);
|
|
}
|
|
|
|
glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Ship *ship)
|
|
{
|
|
// TODO: rotate them before shooting, that looks better
|
|
glm::mat4 mat = computeModelMatrix(ship->position, m_state->shipRadius());
|
|
// XXX model is flipped
|
|
//glm::mat4 mat = computeModelMatrix(ship->position, 0.3);
|
|
mat = glm::rotate(mat, (float) M_PI, glm::vec3(0.0f, 1.0f, 0.0f));
|
|
return mat;
|
|
}
|
|
|
|
glm::mat4 RendererPolygon3d::computeModelMatrix(const glm::vec2 &pos, float scale, float angle)
|
|
{
|
|
// init as identity matrix
|
|
glm::mat4 model;
|
|
|
|
model = glm::translate(model, glm::vec3(pos, 0.0));
|
|
|
|
if (scale != 1.0) {
|
|
model = glm::scale(model, glm::vec3(scale));
|
|
}
|
|
|
|
if (angle != 0.0) {
|
|
model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));
|
|
}
|
|
|
|
return model;
|
|
}
|
|
|
|
void RendererPolygon3d::renderTraces()
|
|
{
|
|
// revert to default
|
|
glUseProgram(0);
|
|
|
|
// TODO dont use line mode. make that with own quads
|
|
glPolygonMode(GL_FRONT, GL_LINE);
|
|
for (const game::Trace *trace : m_state->traces) {
|
|
float fade_out = 1.0;
|
|
if (trace->missile == nullptr) {
|
|
fade_out = 1.0 - (trace->age / trace->maxAge);
|
|
}
|
|
|
|
glColor3f(0.0, 0.0, 1.0*fade_out);
|
|
glBegin(GL_LINE_STRIP);
|
|
for (const game::Trace::TracePoint &tp : trace->points) {
|
|
glVertex2f(tp.position.x, tp.position.y);
|
|
}
|
|
glEnd();
|
|
}
|
|
glPolygonMode(GL_FRONT, GL_FILL);
|
|
}
|
|
}
|