KlassischeKeplerKriege/game/renderer_polygon_3d/renderer_polygon_3d.cpp
Andreas Ortmann 6b8227b0c3 ups
2016-09-29 00:52:58 +02:00

230 lines
6.6 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>
namespace endofthejedi {
void RendererPolygon3d::setup()
{
std::cout<<"setup polygon 3d" << std::endl;
//m_missileModel = new PolygonModel("../data/mesh/quad_screen_coords.stl");
addModel("../data/mesh/small_atomic_bomb.stl", &m_missileModel);
//addModel("../data/mesh/planet_128.stl", &m_planetModel);
addModel("../data/mesh/planet_12.stl", &m_planetModel);
addModel("../data/mesh/planet_12.stl", &m_shipModel);
size_t n = 100;
m_particles = new ParticleBatch(n, 0.05, 3.0);
// distribute in a circle
for (size_t i=0; i<n; i++) {
float t = 2.0 * M_PI * i / (float) n;
t += 0.2*util::randf_m1_1();
glm::vec2 v = 0.2f*glm::vec2(sin(t), cos(t));
m_particles->setParticle(
i,
//glm::vec2(i/(float) n, 0.0),
glm::vec2(0.0, 0.0),
v);
}
m_particles->upload();
std::string vss_simple =
"#version 120\n"
"varying vec3 vertex;\n"
"void main()\n"
"{\n"
" gl_Position = gl_Vertex;\n"
" vertex = gl_Position.xyz;\n"
"}\n"
;
std::string fss_simple =
"#version 120\n"
"varying vec3 vertex;\n"
"void main()\n"
"{\n"
" gl_FragColor = vec4(0.5+0.5*vertex.xyz, 1.0);\n"
"}\n"
;
std::string vss_game_objects =
"#version 120\n"
"varying vec3 vertex;\n"
"uniform mat4 model;\n"
"void main()\n"
"{\n"
//" vec3 p = position + scale*gl_Vertex.xyz;\n"
" vec3 p = (model*gl_Vertex).xyz;\n"
" gl_Position = vec4(p, 1.0);\n"
" vertex = p.xyz;\n"
"}\n"
;
std::string fss_game_objects =
"#version 120\n"
"varying vec3 vertex;\n"
"uniform vec3 color;\n"
"void main()\n"
"{\n"
//" gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
//" gl_FragColor = vec4(0.5+0.5*vertex.xyz, 1.0);\n"
" gl_FragColor = vec4(color, 1.0);\n"
"}\n"
;
m_shader.init();
#if 0
(void) vss_game_objects;
(void) fss_game_objects;
m_shader.load(vss_simple.c_str(), GL_VERTEX_SHADER);
m_shader.load(fss_simple.c_str(), GL_FRAGMENT_SHADER);
#else
(void) vss_simple;
(void) fss_simple;
m_shader.load(vss_game_objects.c_str(), GL_VERTEX_SHADER);
m_shader.load(fss_game_objects.c_str(), GL_FRAGMENT_SHADER);
#endif
}
void RendererPolygon3d::render(const game::State *state)
{
glClearColor(0.0, 0.0, 0.0, 1.0);
m_state = state;
m_shader.bind();
// TODO :Z?
renderPlanets();
renderShips();
renderMissiles();
renderParticles();
//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();
}
void RendererPolygon3d::renderParticles()
{
//m_particles->bind();
m_particles->render();
}
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 = glm::vec3(0.7, 0.2, 0.1);
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("color"), 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("color"), 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)->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.02f, a);
}
glm::mat4 RendererPolygon3d::computeModelMatrix(const game::Ship *ship)
{
// TODO: rotate them before shooting, that looks better
return computeModelMatrix(ship->position, m_state->shipRadius());
}
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;
}
}