289 lines
7.8 KiB
C++
289 lines
7.8 KiB
C++
#include "OpenGLRenderer.h"
|
|
|
|
#include "CameraDefinition.h"
|
|
#include "CloudsRenderer.h"
|
|
#include "Color.h"
|
|
#include "GodRaysSampler.h"
|
|
#include "LightingManager.h"
|
|
#include "Logs.h"
|
|
#include "Maths.h"
|
|
#include "NoiseFunctionSimplex.h"
|
|
#include "OpenGLFunctions.h"
|
|
#include "OpenGLSharedState.h"
|
|
#include "OpenGLSkybox.h"
|
|
#include "OpenGLTerrain.h"
|
|
#include "OpenGLVegetation.h"
|
|
#include "OpenGLWater.h"
|
|
#include "Scenery.h"
|
|
#include "Vector3.h"
|
|
#include "VegetationRenderer.h"
|
|
#include <QMatrix4x4>
|
|
|
|
OpenGLRenderer::OpenGLRenderer(Scenery *scenery) : SoftwareRenderer(scenery) {
|
|
ready = false;
|
|
paused = false;
|
|
displayed = false;
|
|
stopping = false;
|
|
stopped = false;
|
|
vp_width = 1;
|
|
vp_height = 1;
|
|
|
|
mouse_tracking = true;
|
|
mouse_x = 0;
|
|
mouse_y = 0;
|
|
mouse_projected = new Vector3();
|
|
|
|
view_matrix = new QMatrix4x4;
|
|
|
|
setQuality(0.3);
|
|
|
|
functions = new OpenGLFunctions();
|
|
shared_state = new OpenGLSharedState();
|
|
|
|
shared_state->set("viewDistance", 300.0);
|
|
shared_state->set("exposure", to_float(1.2));
|
|
|
|
parts.push_back(skybox = new OpenGLSkybox(this));
|
|
parts.push_back(water = new OpenGLWater(this));
|
|
parts.push_back(terrain = new OpenGLTerrain(this));
|
|
parts.push_back(vegetation = new OpenGLVegetation(this));
|
|
}
|
|
|
|
OpenGLRenderer::~OpenGLRenderer() {
|
|
for (auto part : parts) {
|
|
part->interrupt();
|
|
}
|
|
|
|
delete mouse_projected;
|
|
delete view_matrix;
|
|
|
|
for (auto part : parts) {
|
|
delete part;
|
|
}
|
|
|
|
delete functions;
|
|
delete shared_state;
|
|
}
|
|
|
|
void OpenGLRenderer::prepare() {
|
|
SoftwareRenderer::prepare();
|
|
|
|
getCloudsRenderer()->setEnabled(false);
|
|
getLightingManager()->setSpecularity(false);
|
|
getGodRaysSampler()->setEnabled(false);
|
|
getVegetationRenderer()->setEnabled(false);
|
|
}
|
|
|
|
void OpenGLRenderer::checkForErrors(const string &domain) {
|
|
unsigned int error_code;
|
|
while ((error_code = functions->glGetError()) != GL_NO_ERROR) {
|
|
Logs::warning("OpenGL") << "Error in " << domain << " : " << error_code << endl;
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::destroy() {
|
|
shared_state->destroy(functions);
|
|
|
|
for (auto part : parts) {
|
|
part->destroy();
|
|
}
|
|
|
|
checkForErrors("destroy");
|
|
}
|
|
|
|
void OpenGLRenderer::initialize() {
|
|
bool init = functions->initializeOpenGLFunctions();
|
|
|
|
if (init) {
|
|
Logs::debug("OpenGL") << "Renderer started (version " << functions->glGetString(GL_VERSION) << ", glsl version "
|
|
<< functions->glGetString(GL_SHADING_LANGUAGE_VERSION) << ")" << endl;
|
|
|
|
prepareOpenGLState();
|
|
|
|
prepare();
|
|
|
|
for (auto part : parts) {
|
|
part->initialize();
|
|
part->updateScenery();
|
|
}
|
|
|
|
// Common state values
|
|
shared_state->set("simplexSampler", NoiseFunctionSimplex::getNormalTexture(), true, true);
|
|
|
|
cameraChangeEvent(render_camera);
|
|
|
|
checkForErrors("initialize");
|
|
ready = true;
|
|
} else {
|
|
Logs::error("OpenGL") << "Failed to initialize api bindings" << endl;
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::prepareOpenGLState(bool clear) {
|
|
if (ready) {
|
|
functions->glFrontFace(GL_CCW);
|
|
functions->glCullFace(GL_BACK);
|
|
functions->glEnable(GL_CULL_FACE);
|
|
|
|
functions->glDepthFunc(GL_LESS);
|
|
functions->glDepthMask(GL_TRUE);
|
|
functions->glEnable(GL_DEPTH_TEST);
|
|
|
|
functions->glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
/*functions->glEnable(GL_LINE_SMOOTH);
|
|
functions->glLineWidth(1.0);*/
|
|
|
|
functions->glEnable(GL_BLEND);
|
|
functions->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
functions->glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
if (clear) {
|
|
functions->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
functions->glViewport(0, 0, vp_width, vp_height);
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::setCamera(CameraDefinition *camera) {
|
|
camera->copy(render_camera);
|
|
getScenery()->keepCameraAboveGround(render_camera);
|
|
render_camera->setRenderSize(vp_width, vp_height);
|
|
cameraChangeEvent(render_camera);
|
|
}
|
|
|
|
void OpenGLRenderer::resize(int width, int height) {
|
|
if (ready) {
|
|
vp_width = width;
|
|
vp_height = height;
|
|
|
|
render_camera->setRenderSize(width, height);
|
|
cameraChangeEvent(render_camera);
|
|
|
|
prepareOpenGLState();
|
|
|
|
checkForErrors("resize");
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::paint(bool clear) {
|
|
if (stopping) {
|
|
if (not stopped) {
|
|
destroy();
|
|
stopped = true;
|
|
}
|
|
} else if (ready and not paused) {
|
|
checkForErrors("before_paint");
|
|
if (clear) {
|
|
functions->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
for (auto part : parts) {
|
|
part->render();
|
|
checkForErrors(part->getName());
|
|
}
|
|
|
|
if (mouse_tracking) {
|
|
updateMouseProjection();
|
|
checkForErrors("mouse_tracking");
|
|
}
|
|
|
|
displayed = true;
|
|
}
|
|
}
|
|
|
|
bool OpenGLRenderer::stop() {
|
|
stopping = true;
|
|
return stopped;
|
|
}
|
|
|
|
void OpenGLRenderer::reset() {
|
|
if (ready) {
|
|
for (auto part : parts) {
|
|
part->updateScenery();
|
|
}
|
|
|
|
cameraChangeEvent(render_camera);
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::pause() {
|
|
if (not paused) {
|
|
paused = true;
|
|
for (auto part : parts) {
|
|
part->pause();
|
|
}
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::resume() {
|
|
if (paused) {
|
|
for (auto part : parts) {
|
|
part->resume();
|
|
}
|
|
paused = false;
|
|
}
|
|
}
|
|
|
|
void OpenGLRenderer::setMouseLocation(int x, int y) {
|
|
mouse_x = x;
|
|
mouse_y = y;
|
|
}
|
|
|
|
const Vector3 &OpenGLRenderer::getMouseProjection() {
|
|
return *mouse_projected;
|
|
}
|
|
|
|
void OpenGLRenderer::cameraChangeEvent(CameraDefinition *camera) {
|
|
// Get camera info
|
|
Vector3 location = camera->getLocation();
|
|
Vector3 target = camera->getTarget();
|
|
Vector3 up = camera->getUpVector();
|
|
CameraPerspective perspective = camera->getPerspective();
|
|
|
|
// Compute matrix
|
|
// TODO Switch to CameraDefinition raw transformation matrix (currently produces strange results)
|
|
QMatrix4x4 transform;
|
|
transform.setToIdentity();
|
|
transform.lookAt(QVector3D(location.x, location.y, location.z), QVector3D(target.x, target.y, target.z),
|
|
QVector3D(up.x, up.y, up.z));
|
|
|
|
QMatrix4x4 projection;
|
|
projection.setToIdentity();
|
|
projection.perspective(perspective.yfov * 180.0 / Maths::PI, perspective.xratio, perspective.znear,
|
|
perspective.zfar);
|
|
|
|
*view_matrix = projection * transform;
|
|
|
|
// Set in shaders
|
|
shared_state->set("cameraLocation", location);
|
|
float *matdata = view_matrix->transposed().data();
|
|
shared_state->set("viewMatrix", Matrix4(matdata[0], matdata[1], matdata[2], matdata[3], matdata[4], matdata[5],
|
|
matdata[6], matdata[7], matdata[8], matdata[9], matdata[10], matdata[11],
|
|
matdata[12], matdata[13], matdata[14], matdata[15]));
|
|
|
|
// Broadcast to parts
|
|
vegetation->cameraChanged(camera);
|
|
}
|
|
|
|
double OpenGLRenderer::getPrecision(const Vector3 &) {
|
|
return 0.001;
|
|
}
|
|
|
|
Color OpenGLRenderer::applyMediumTraversal(const Vector3 &, const Color &color) {
|
|
return color;
|
|
}
|
|
|
|
void OpenGLRenderer::updateMouseProjection() {
|
|
GLfloat z;
|
|
functions->glReadPixels(mouse_x, mouse_y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z);
|
|
|
|
QVector4D located(to_float(mouse_x / render_camera->getWidth()), to_float(mouse_y / render_camera->getHeight()), z,
|
|
1.0);
|
|
QVector4D unprojected = view_matrix->inverted() * 2.0 * (located - QVector4D(0.5, 0.5, 0.5, 0.5));
|
|
*mouse_projected = Vector3(unprojected.x() / unprojected.w(), unprojected.y() / unprojected.w(),
|
|
unprojected.z() / unprojected.w());
|
|
|
|
shared_state->set("mouseProjection", *mouse_projected);
|
|
}
|