mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-04-28 14:59:31 -05:00
Code Issues Packages Projects Releases Wiki Activity

Remove nonfunctioning ABufferRenderer from RenderEngine

Browse Source
This commit is contained in:
Alexander Bock
2021-07-30 12:00:56 +02:00
parent c0941a1243
commit c4bddacfeb
16 changed files with 64 additions and 1674 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
-2
View File
@@ -132,8 +132,6 @@ if (MSVC)
set(GHOUL_OPTIMIZATION_ENABLE_OTHER_OPTIMIZATIONS ${OPENSPACE_OPTIMIZATION_ENABLE_OTHER_OPTIMIZATIONS} CACHE BOOL "" FORCE)
endif ()
option(OPENSPACE_WITH_ABUFFER_RENDERER "Compile ABuffer Renderer" OFF)
if (UNIX)
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -stdlib=libc++")
include/openspace/engine/configuration.h
+3 -5
View File
@@ -98,16 +98,14 @@ struct Configuration {
bool usePerProfileCache = false;
bool isRenderingOnMasterDisabled = false;
glm::dvec3 globalRotation = glm::dvec3(0.0);
glm::dvec3 screenSpaceRotation = glm::dvec3(0.0);
glm::dvec3 masterRotation = glm::dvec3(0.0);
glm::vec3 globalRotation = glm::vec3(0.0);
glm::vec3 screenSpaceRotation = glm::vec3(0.0);
glm::vec3 masterRotation = glm::vec3(0.0);
bool isConsoleDisabled = false;
bool bypassLauncher = false;
std::map<std::string, ghoul::Dictionary> moduleConfigurations;
std::string renderingMethod = "Framebuffer";
struct OpenGLDebugContext {
bool isActive = false;
bool isSynchronous = true;
include/openspace/rendering/abufferrenderer.h
-183
View File
@@ -1,183 +0,0 @@
/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2021 *
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
* software and associated documentation files (the "Software"), to deal in the Software *
* without restriction, including without limitation the rights to use, copy, modify, *
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
* permit persons to whom the Software is furnished to do so, subject to the following *
* conditions: *
* *
* The above copyright notice and this permission notice shall be included in all copies *
* or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#ifndef __OPENSPACE_CORE___ABUFFERRENDERER___H__
#define __OPENSPACE_CORE___ABUFFERRENDERER___H__
#ifdef OPENSPACE_WITH_ABUFFER_RENDERER
#include <openspace/rendering/renderer.h>
#include <openspace/rendering/raycasterlistener.h>
#include <ghoul/glm.h>
#include <ghoul/misc/dictionary.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <map>
#include <memory>
#include <string>
#include <vector>
namespace ghoul::filesystem { class File; }
namespace ghoul::opengl {
class ProgramObject;
class Texture;
} // namespace ghoul::opengl
namespace openspace {
struct RaycasterTask;
class RenderableVolume;
class Camera;
class Scene;
struct RaycastData;
class ABufferRenderer : public Renderer, public RaycasterListener {
public:
virtual ~ABufferRenderer() = default;
void initialize() override;
void deinitialize() override;
void setResolution(glm::ivec2 res) override;
void setNAaSamples(int nAaSamples) override;
void setBlurrinessLevel(int level) override;
void setHDRExposure(float hdrExposure) override;
void setGamma(float gamma) override;
void setMaxWhite(float maxWhite) override;
void setToneMapOperator(int tmOp) override;
void setBloomThreMin(float minV) override;
void setBloomThreMax(float maxV) override;
void setBloomOrigFactor(float origFactor) override;
void setBloomNewFactor(float newFactor) override;
void setKey(float key) override;
void setYwhite(float white) override;
void setTmoSaturation(float sat) override;
void setHue(float hue) override;
void setValue(float value) override;
void setSaturation(float sat) override;
void setLightness(float lightness) override;
void setColorSpace(unsigned int colorspace) override;
void enableBloom(bool enable) override;
void enableHistogram(bool enable) override;
int nAaSamples() const override;
const std::vector<double>& mSSAPattern() const override;
using Renderer::preRaycast;
void preRaycast(const RaycasterTask& raycasterTask);
using Renderer::postRaycast;
void postRaycast(const RaycasterTask& raycasterTask);
void update() override;
void render(Scene* scene, Camera* camera, float blackoutFactor) override;
/**
* Update render data
* Responsible for calling renderEngine::setRenderData
*/
virtual void updateRendererData() override;
virtual void raycastersChanged(VolumeRaycaster& raycaster,
IsAttached attached) override;
private:
void clear();
void updateResolution();
void updateRaycastData();
void updateResolveDictionary();
void updateMSAASamplingPattern();
void saveTextureToMemory(GLenum color_buffer_attachment, int width, int height,
std::vector<double> & memory) const;
glm::ivec2 _resolution = glm::ivec2(0);
bool _dirtyResolution = true;
bool _dirtyRendererData = true;
bool _dirtyRaycastData = true;
bool _dirtyResolveDictionary = true;
std::unique_ptr<ghoul::opengl::ProgramObject> _resolveProgram = nullptr;
/**
* When a volume is attached or detached from the scene graph,
* the resolve program needs to be recompiled.
* The _volumes map keeps track of which volumes that can
* be rendered using the current resolve program, along with their raycast data
* (id, namespace, etc)
*/
std::map<VolumeRaycaster*, RaycastData> _raycastData;
std::map<
VolumeRaycaster*, std::unique_ptr<ghoul::opengl::ProgramObject>
> _boundsPrograms;
std::vector<std::string> _helperPaths;
ghoul::Dictionary _resolveDictionary;
GLuint _mainColorTexture;
GLuint _mainDepthTexture;
GLuint _mainFramebuffer;
GLuint _screenQuad;
GLuint _anchorPointerTexture;
GLuint _anchorPointerTextureInitializer;
GLuint _atomicCounterBuffer;
GLuint _fragmentBuffer;
GLuint _fragmentTexture;
GLuint _vertexPositionBuffer;
int _nAaSamples;
int _blurrinessLevel = 1;
float _hdrExposure = 0.4f;
float _hdrBackground = 2.8f;
float _gamma = 2.2f;
float _maxWhite = 1.f;
float _blackoutFactor;
bool _bloomEnabled = false;
float _bloomThresholdMin = 0.0;
float _bloomThresholdMax = 1.0;
float _bloomOrigFactor = 1.0;
float _bloomNewFactor = 1.0;
int _toneMapOperator = 0;
bool _histogramEnabled = false;
int _numberOfBins = 1024; // JCC TODO: Add a parameter control for this.
float _tmoKey = 0.18f;
float _tmoYwhite = 1e6f;
float _tmoSaturation = 1.0f;
float _hue = 1.f;
float _saturation = 1.f;
float _value = 1.f;
float _lightness = 1.f;
unsigned int _colorSpace = 1;
std::vector<double> _mSAAPattern;
ghoul::Dictionary _rendererData;
};
} // namespace openspace
#endif // OPENSPACE_WITH_ABUFFER_RENDERER
#endif // __OPENSPACE_CORE___ABUFFERRENDERER___H__
include/openspace/rendering/framebufferrenderer.h
+16 -18
View File
@@ -25,8 +25,6 @@
#ifndef __OPENSPACE_CORE___FRAMEBUFFERRENDERER___H__
#define __OPENSPACE_CORE___FRAMEBUFFERRENDERER___H__
#include <openspace/rendering/renderer.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/rendering/raycasterlistener.h>
#include <openspace/rendering/deferredcasterlistener.h>
@@ -56,14 +54,14 @@ struct RaycasterTask;
class Scene;
struct UpdateStructures;
class FramebufferRenderer : public Renderer, public RaycasterListener,
class FramebufferRenderer : public RaycasterListener,
public DeferredcasterListener
{
public:
virtual ~FramebufferRenderer() = default;
void initialize() override;
void deinitialize() override;
void initialize();
void deinitialize();
void updateResolution();
void updateRaycastData();
@@ -72,33 +70,33 @@ public:
void updateFXAA();
void updateDownscaledVolume();
void setResolution(glm::ivec2 res) override;
void setHDRExposure(float hdrExposure) override;
void setGamma(float gamma) override;
void setHue(float hue) override;
void setValue(float value) override;
void setSaturation(float sat) override;
void setResolution(glm::ivec2 res);
void setHDRExposure(float hdrExposure);
void setGamma(float gamma);
void setHue(float hue);
void setValue(float value);
void setSaturation(float sat);
void enableFXAA(bool enable) override;
void setDisableHDR(bool disable) override;
void enableFXAA(bool enable);
void setDisableHDR(bool disable);
void update() override;
void update();
void performRaycasterTasks(const std::vector<RaycasterTask>& tasks,
const glm::ivec4& viewport);
void performDeferredTasks(const std::vector<DeferredcasterTask>& tasks,
const glm::ivec4& viewport);
void render(Scene* scene, Camera* camera, float blackoutFactor) override;
void render(Scene* scene, Camera* camera, float blackoutFactor);
/**
* Update render data
* Responsible for calling renderEngine::setRenderData
*/
virtual void updateRendererData() override;
virtual void updateRendererData();
virtual void raycastersChanged(VolumeRaycaster& raycaster,
RaycasterListener::IsAttached attached) override;
RaycasterListener::IsAttached attached);
virtual void deferredcastersChanged(Deferredcaster& deferredcaster,
DeferredcasterListener::IsAttached isAttached) override;
DeferredcasterListener::IsAttached isAttached);
private:
using RaycasterProgObjMap = std::map<
include/openspace/rendering/renderengine.h
+2 -28
View File
@@ -33,6 +33,7 @@
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/properties/triggerproperty.h>
#include <openspace/rendering/framebufferrenderer.h>
#include <chrono>
#include <filesystem>
@@ -54,7 +55,6 @@ namespace scripting { struct LuaLibrary; }
class Camera;
class RaycasterManager;
class DeferredcasterManager;
class Renderer;
class Scene;
class SceneManager;
class ScreenLog;
@@ -63,12 +63,6 @@ struct ShutdownInformation;
class RenderEngine : public properties::PropertyOwner {
public:
enum class RendererImplementation {
Framebuffer = 0,
ABuffer,
Invalid
};
RenderEngine();
~RenderEngine();
@@ -80,9 +74,6 @@ public:
Scene* scene();
void updateScene();
const Renderer& renderer() const;
RendererImplementation rendererImplementation() const;
ghoul::opengl::OpenGLStateCache& openglStateCache();
void updateShaderPrograms();
@@ -120,24 +111,11 @@ public:
void removeRenderProgram(ghoul::opengl::ProgramObject* program);
/**
* Set raycasting uniforms on the program object, and setup raycasting.
*/
void preRaycast(ghoul::opengl::ProgramObject& programObject);
/**
* Tear down raycasting for the specified program object.
*/
void postRaycast(ghoul::opengl::ProgramObject& programObject);
/**
* Set the camera to use for rendering
*/
void setCamera(Camera* camera);
void setRendererFromString(const std::string& renderingMethod);
/**
* Lets the renderer update the data to be brought into the rendererer programs
* as a 'rendererData' variable in the dictionary.
@@ -176,9 +154,6 @@ public:
uint64_t frameNumber() const;
private:
void setRenderer(std::unique_ptr<Renderer> renderer);
RendererImplementation rendererFromString(const std::string& renderingMethod) const;
void renderScreenLog();
void renderVersionInformation();
void renderCameraInformation();
@@ -188,8 +163,7 @@ private:
Camera* _camera = nullptr;
Scene* _scene = nullptr;
std::unique_ptr<Renderer> _renderer;
RendererImplementation _rendererImplementation = RendererImplementation::Invalid;
FramebufferRenderer _renderer;
ghoul::Dictionary _rendererData;
ghoul::Dictionary _resolveData;
ScreenLog* _log = nullptr;
include/openspace/rendering/renderer.h
-83
View File
@@ -1,83 +0,0 @@
/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2021 *
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
* software and associated documentation files (the "Software"), to deal in the Software *
* without restriction, including without limitation the rights to use, copy, modify, *
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
* permit persons to whom the Software is furnished to do so, subject to the following *
* conditions: *
* *
* The above copyright notice and this permission notice shall be included in all copies *
* or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#ifndef __OPENSPACE_CORE___RENDERER___H__
#define __OPENSPACE_CORE___RENDERER___H__
#include <ghoul/glm.h>
#include <vector>
namespace ghoul { class Dictionary; }
namespace ghoul::filesystem { class File; }
namespace ghoul::opengl {
class ProgramObject;
class Texture;
} // namespace ghoul::opengl
namespace openspace {
class RenderableVolume;
class Camera;
class Scene;
class Renderer {
public:
virtual ~Renderer() = default;
virtual void initialize() = 0;
virtual void deinitialize() = 0;
virtual void setResolution(glm::ivec2 res) = 0;
virtual void setHDRExposure(float hdrExposure) = 0;
virtual void setGamma(float gamma) = 0;
virtual void setHue(float hue) = 0;
virtual void setValue(float value) = 0;
virtual void setSaturation(float sat) = 0;
virtual void enableFXAA(bool enable) = 0;
virtual void setDisableHDR(bool disable) = 0;
/**
* Set raycasting uniforms on the program object, and setup raycasting.
*/
virtual void preRaycast(ghoul::opengl::ProgramObject& /*programObject*/) {};
/**
* Tear down raycasting for the specified program object.
*/
virtual void postRaycast(ghoul::opengl::ProgramObject& /*programObject*/) {};
virtual void update() = 0;
virtual void render(Scene* scene, Camera* camera, float blackoutFactor) = 0;
/**
* Update render data
* Responsible for calling renderEngine::setRenderData
*/
virtual void updateRendererData() = 0;
};
} // openspace
#endif // __OPENSPACE_CORE___RENDERER___H__
modules/base/rendering/renderableplane.cpp
+1 -15
View File
@@ -255,21 +255,7 @@ void RenderablePlane::render(const RenderData& data, RendererTasks&) {
_shader->setUniform("multiplyColor", _multiplyColor);
bool usingFramebufferRenderer = global::renderEngine->rendererImplementation() ==
RenderEngine::RendererImplementation::Framebuffer;
bool usingABufferRenderer = global::renderEngine->rendererImplementation() ==
RenderEngine::RendererImplementation::ABuffer;
if (usingABufferRenderer) {
_shader->setUniform(
"additiveBlending",
_blendMode == static_cast<int>(BlendMode::Additive)
);
}
bool additiveBlending =
(_blendMode == static_cast<int>(BlendMode::Additive)) && usingFramebufferRenderer;
bool additiveBlending = (_blendMode == static_cast<int>(BlendMode::Additive));
if (additiveBlending) {
glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
modules/base/rendering/renderablesphere.cpp
+2 -12
View File
@@ -398,24 +398,14 @@ void RenderableSphere::render(const RenderData& data, RendererTasks&) {
glDisable(GL_CULL_FACE);
}
bool usingFramebufferRenderer = global::renderEngine->rendererImplementation() ==
RenderEngine::RendererImplementation::Framebuffer;
bool usingABufferRenderer = global::renderEngine->rendererImplementation() ==
RenderEngine::RendererImplementation::ABuffer;
if (usingABufferRenderer && _useAdditiveBlending) {
_shader->setUniform("additiveBlending", true);
}
if (usingFramebufferRenderer && _useAdditiveBlending) {
if (_useAdditiveBlending) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glDepthMask(false);
}
_sphere->render();
if (usingFramebufferRenderer && _useAdditiveBlending) {
if (_useAdditiveBlending) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(true);
}
modules/base/rendering/renderabletrail.cpp
+4 -12
View File
@@ -430,14 +430,8 @@ void RenderableTrail::render(const RenderData& data, RendererTasks&) {
/*glm::ivec2 resolution = global::renderEngine.renderingResolution();
_programObject->setUniform(_uniformCache.resolution, resolution);*/
const bool usingFramebufferRenderer =
global::renderEngine->rendererImplementation() ==
RenderEngine::RendererImplementation::Framebuffer;
if (usingFramebufferRenderer) {
glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
const bool renderLines = (_appearance.renderingModes == RenderingModeLines) ||
(_appearance.renderingModes == RenderingModeLinesPoints);
@@ -508,10 +502,8 @@ void RenderableTrail::render(const RenderData& data, RendererTasks&) {
glBindVertexArray(0);
if (usingFramebufferRenderer) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(true);
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(true);
_programObject->deactivate();
}
modules/fieldlinessequence/rendering/renderablefieldlinessequence.cpp
+3 -16
View File
@@ -1112,22 +1112,9 @@ void RenderableFieldlinesSequence::render(const RenderData& data, RendererTasks&
bool additiveBlending = false;
if (_pColorABlendEnabled) {
const auto renderer = global::renderEngine->rendererImplementation();
const bool usingFBufferRenderer = renderer ==
RenderEngine::RendererImplementation::Framebuffer;
const bool usingABufferRenderer = renderer ==
RenderEngine::RendererImplementation::ABuffer;
if (usingABufferRenderer) {
_shaderProgram->setUniform("usingAdditiveBlending", _pColorABlendEnabled);
}
additiveBlending = usingFBufferRenderer;
if (additiveBlending) {
glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
additiveBlending = true;
glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
glBindVertexArray(_vertexArrayObject);
openspace.cfg
-1
View File
@@ -236,7 +236,6 @@ GlobalRotation = { 0.0, 0.0, 0.0 }
MasterRotation = { 0.0, 0.0, 0.0 }
ScreenSpaceRotation = { 0.0, 0.0, 0.0 }
RenderingMethod = "Framebuffer"
OpenGLDebugContext = {
Activate = true,
FilterIdentifier = {
src/CMakeLists.txt
-7
View File
@@ -108,7 +108,6 @@ set(OPENSPACE_SOURCE
${OPENSPACE_BASE_DIR}/src/properties/vector/vec3property.cpp
${OPENSPACE_BASE_DIR}/src/properties/vector/vec4property.cpp
${OPENSPACE_BASE_DIR}/src/query/query.cpp
${OPENSPACE_BASE_DIR}/src/rendering/abufferrenderer.cpp
${OPENSPACE_BASE_DIR}/src/rendering/dashboard.cpp
${OPENSPACE_BASE_DIR}/src/rendering/dashboard_lua.inl
${OPENSPACE_BASE_DIR}/src/rendering/dashboarditem.cpp
@@ -284,7 +283,6 @@ set(OPENSPACE_HEADER
${OPENSPACE_BASE_DIR}/include/openspace/properties/vector/vec3property.h
${OPENSPACE_BASE_DIR}/include/openspace/properties/vector/vec4property.h
${OPENSPACE_BASE_DIR}/include/openspace/query/query.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/abufferrenderer.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/dashboard.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/dashboarditem.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/dashboardtextitem.h
@@ -298,7 +296,6 @@ set(OPENSPACE_HEADER
${OPENSPACE_BASE_DIR}/include/openspace/rendering/raycasterlistener.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/raycastermanager.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/renderable.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/renderer.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/renderengine.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/screenspacerenderable.h
${OPENSPACE_BASE_DIR}/include/openspace/rendering/texturecomponent.h
@@ -464,10 +461,6 @@ endif ()
set_openspace_compile_settings(openspace-core)
target_link_libraries(openspace-core PUBLIC Ghoul spice external-curl)
if (OPENSPACE_WITH_ABUFFER_RENDERER)
target_compile_definitions(openspace-core PUBLIC "OPENSPACE_WITH_ABUFFER_RENDERER")
endif ()
# Just in case, create the bin directory
add_custom_command(
TARGET openspace-core
src/engine/configuration.cpp
+3 -24
View File
@@ -161,15 +161,6 @@ namespace {
// resolution ('framebuffer'). This value defaults to 'window'
std::optional<Scaling> onScreenTextScaling;
// List from RenderEngine::setRendererFromString
enum class RenderingMethod {
Framebuffer,
ABuffer
};
// The renderer that is use after startup. The renderer 'ABuffer' requires support
// for at least OpenGL 4.3
std::optional<RenderingMethod> renderingMethod;
// Toggles whether the master in a multi-application setup should be rendering or
// just managing the state of the network. This is desired in cases where the
// master computer does not have the resources to render a scene
@@ -178,16 +169,16 @@ namespace {
// Applies a global view rotation. Use this to rotate the position of the focus
// node away from the default location on the screen. This setting persists even
// when a new focus node is selected. Defined using roll, pitch, yaw in radians
std::optional<glm::dvec3> globalRotation;
std::optional<glm::vec3> globalRotation;
// Applies a view rotation for only the master node, defined using roll, pitch yaw
// in radians. This can be used to compensate the master view direction for tilted
// display systems in clustered immersive environments
std::optional<glm::dvec3> masterRotation;
std::optional<glm::vec3> masterRotation;
// Applies a global rotation for all screenspace renderables. Defined using roll,
// pitch, yaw in radians
std::optional<glm::dvec3> screenSpaceRotation;
std::optional<glm::vec3> screenSpaceRotation;
// If this value is set to 'true' the ingame console is disabled, locking the
// system down against random access
@@ -415,18 +406,6 @@ void parseLuaState(Configuration& configuration) {
c.globalRotation = p.globalRotation.value_or(c.globalRotation);
c.masterRotation = p.masterRotation.value_or(c.masterRotation);
c.screenSpaceRotation = p.screenSpaceRotation.value_or(c.screenSpaceRotation);
if (p.renderingMethod.has_value()) {
switch (*p.renderingMethod) {
case Parameters::RenderingMethod::Framebuffer:
c.renderingMethod = "Framebuffer";
break;
case Parameters::RenderingMethod::ABuffer:
c.renderingMethod = "ABuffer";
break;
default:
throw ghoul::MissingCaseException();
}
}
c.isConsoleDisabled = p.disableInGameConsole.value_or(c.isConsoleDisabled);
if (p.logging.has_value()) {
if (p.logging->logLevel.has_value()) {
src/rendering/abufferrenderer.cpp
-1062
View File
File diff suppressed because it is too large Load Diff
src/rendering/renderengine.cpp
+30 -182
View File
@@ -32,7 +32,6 @@
#include <openspace/interaction/navigationhandler.h>
#include <openspace/interaction/orbitalnavigator.h>
#include <openspace/mission/missionmanager.h>
#include <openspace/rendering/abufferrenderer.h>
#include <openspace/rendering/dashboard.h>
#include <openspace/rendering/deferredcastermanager.h>
#include <openspace/rendering/helper.h>
@@ -302,57 +301,27 @@ RenderEngine::RenderEngine()
addProperty(_showVersionInfo);
addProperty(_showCameraInfo);
_enableFXAA.onChange([this]() {
if (_renderer) {
_renderer->enableFXAA(_enableFXAA);
}
});
_enableFXAA.onChange([this]() { _renderer.enableFXAA(_enableFXAA); });
addProperty(_enableFXAA);
_disableHDRPipeline.onChange([this]() {
if (_renderer) {
_renderer->setDisableHDR(_disableHDRPipeline);
}
_renderer.setDisableHDR(_disableHDRPipeline);
});
addProperty(_disableHDRPipeline);
_hdrExposure.onChange([this]() {
if (_renderer) {
_renderer->setHDRExposure(_hdrExposure);
}
});
_hdrExposure.onChange([this]() { _renderer.setHDRExposure(_hdrExposure); });
addProperty(_hdrExposure);
_gamma.onChange([this]() {
if (_renderer) {
_renderer->setGamma(_gamma);
}
});
_gamma.onChange([this]() { _renderer.setGamma(_gamma); });
addProperty(_gamma);
_hue.onChange([this]() {
if (_renderer) {
const float h = _hue / 360.f;
_renderer->setHue(h);
}
});
_hue.onChange([this]() { _renderer.setHue(_hue / 360.f); });
addProperty(_hue);
_saturation.onChange([this]() {
if (_renderer) {
_renderer->setSaturation(_saturation);
}
});
_saturation.onChange([this]() { _renderer.setSaturation(_saturation); });
addProperty(_saturation);
_value.onChange([this]() {
if (_renderer) {
_renderer->setValue(_value);
}
});
_value.onChange([this]() { _renderer.setValue(_value); });
addProperty(_value);
addProperty(_globalBlackOutFactor);
@@ -414,39 +383,16 @@ RenderEngine::RenderEngine()
RenderEngine::~RenderEngine() {} // NOLINT
void RenderEngine::setRendererFromString(const std::string& renderingMethod) {
ZoneScoped
_rendererImplementation = rendererFromString(renderingMethod);
std::unique_ptr<Renderer> newRenderer = nullptr;
switch (_rendererImplementation) {
case RendererImplementation::Framebuffer:
newRenderer = std::make_unique<FramebufferRenderer>();
break;
case RendererImplementation::ABuffer:
#ifdef OPENSPACE_WITH_ABUFFER_RENDERER
newRenderer = std::make_unique<ABufferRenderer>();
#endif // OPENSPACE_WITH_ABUFFER_RENDERER
break;
case RendererImplementation::Invalid:
LFATAL(fmt::format("Rendering method '{}' not available", renderingMethod));
return;
}
setRenderer(std::move(newRenderer));
}
void RenderEngine::initialize() {
ZoneScoped
// We have to perform these initializations here as the OsEng has not been initialized
// in our constructor
_globalRotation = static_cast<glm::vec3>(global::configuration->globalRotation);
_screenSpaceRotation =
static_cast<glm::vec3>(global::configuration->screenSpaceRotation);
_masterRotation = static_cast<glm::vec3>(global::configuration->masterRotation);
_globalRotation = global::configuration->globalRotation;
_screenSpaceRotation = global::configuration->screenSpaceRotation;
_masterRotation = global::configuration->masterRotation;
_disableMasterRendering = global::configuration->isRenderingOnMasterDisabled;
_screenshotUseDate = global::configuration->shouldUseScreenshotDate;
#ifdef GHOUL_USE_DEVIL
ghoul::io::TextureReader::ref().addReader(
@@ -499,8 +445,6 @@ void RenderEngine::initialize() {
);
}
}
_screenshotUseDate = global::configuration->shouldUseScreenshotDate;
}
void RenderEngine::initializeGL() {
@@ -508,21 +452,10 @@ void RenderEngine::initializeGL() {
LTRACE("RenderEngine::initializeGL(begin)");
std::string renderingMethod = global::configuration->renderingMethod;
if (renderingMethod == "ABuffer") {
using Version = ghoul::systemcapabilities::Version;
// The default rendering method has a requirement of OpenGL 4.3, so if we are
// below that, we will fall back to frame buffer operation
if (OpenGLCap.openGLVersion() < Version{ 4,3,0 }) {
LINFO("Falling back to framebuffer implementation due to OpenGL limitations");
renderingMethod = "Framebuffer";
}
}
LINFO(fmt::format("Setting renderer from string: {}", renderingMethod));
setRendererFromString(renderingMethod);
_renderer.setResolution(renderingResolution());
_renderer.enableFXAA(_enableFXAA);
_renderer.setHDRExposure(_hdrExposure);
_renderer.initialize();
// set the close clip plane and the far clip plane to extreme values while in
// development
@@ -532,45 +465,15 @@ void RenderEngine::initializeGL() {
// initialized window
_horizFieldOfView = static_cast<float>(global::windowDelegate->getHorizFieldOfView());
configuration::Configuration::FontSizes fontSize = global::configuration->fontSize;
{
ZoneScopedN("Font: FrameInfo")
TracyGpuZone("Font: FrameInfo")
_fontFrameInfo = global::fontManager->font(
KeyFontMono,
global::configuration->fontSize.frameInfo
);
}
{
ZoneScopedN("Font: Shutdown")
TracyGpuZone("Font: Shutdown")
_fontShutdown = global::fontManager->font(
KeyFontMono,
global::configuration->fontSize.shutdown
);
}
{
ZoneScopedN("Font: CameraInfo")
TracyGpuZone("Font: CameraInfo")
_fontCameraInfo = global::fontManager->font(
KeyFontMono,
global::configuration->fontSize.cameraInfo
);
}
{
ZoneScopedN("Font: VersionInfo")
TracyGpuZone("Font: VersionInfo")
_fontVersionInfo = global::fontManager->font(
KeyFontMono,
global::configuration->fontSize.versionInfo
);
}
{
ZoneScopedN("Font: Log")
TracyGpuZone("Font: Log")
_fontLog = global::fontManager->font(
KeyFontLight,
global::configuration->fontSize.log
);
ZoneScopedN("Fonts")
TracyGpuZone("Fonts")
_fontFrameInfo = global::fontManager->font(KeyFontMono, fontSize.frameInfo);
_fontShutdown = global::fontManager->font(KeyFontMono, fontSize.shutdown);
_fontCameraInfo = global::fontManager->font(KeyFontMono, fontSize.cameraInfo);
_fontVersionInfo = global::fontManager->font(KeyFontMono, fontSize.versionInfo);
_fontLog = global::fontManager->font(KeyFontLight, fontSize.log);
}
{
@@ -588,7 +491,7 @@ void RenderEngine::initializeGL() {
void RenderEngine::deinitializeGL() {
ZoneScoped
_renderer = nullptr;
_renderer.deinitialize();
}
void RenderEngine::updateScene() {
@@ -633,7 +536,7 @@ void RenderEngine::updateRenderer() {
const bool windowResized = global::windowDelegate->windowHasResized();
if (windowResized) {
_renderer->setResolution(renderingResolution());
_renderer.setResolution(renderingResolution());
using FR = ghoul::fontrendering::FontRenderer;
FR::defaultRenderer().setFramebufferSize(fontResolution());
@@ -643,7 +546,7 @@ void RenderEngine::updateRenderer() {
static_cast<float>(global::windowDelegate->getHorizFieldOfView());
}
_renderer->update();
_renderer.update();
}
void RenderEngine::updateScreenSpaceRenderables() {
@@ -737,9 +640,9 @@ void RenderEngine::render(const glm::mat4& sceneMatrix, const glm::mat4& viewMat
_lastFrameTime = now + std::chrono::microseconds(static_cast<int>(delta));
}
const bool masterEnabled = delegate.isMaster() ? !_disableMasterRendering : true;
if (masterEnabled && !delegate.isGuiWindow() && _globalBlackOutFactor > 0.f) {
_renderer->render(
const bool renderingEnabled = delegate.isMaster() ? !_disableMasterRendering : true;
if (renderingEnabled && !delegate.isGuiWindow() && _globalBlackOutFactor > 0.f) {
_renderer.render(
_scene,
_camera,
_globalBlackOutFactor
@@ -776,7 +679,7 @@ void RenderEngine::render(const glm::mat4& sceneMatrix, const glm::mat4& viewMat
RenderFont(*_fontFrameInfo, penPosition, res);
}
if (masterEnabled && !delegate.isGuiWindow() && _globalBlackOutFactor > 0.f) {
if (renderingEnabled && !delegate.isGuiWindow() && _globalBlackOutFactor > 0.f) {
ZoneScopedN("Render Screenspace Renderable")
std::vector<ScreenSpaceRenderable*> ssrs;
@@ -968,14 +871,6 @@ void RenderEngine::setCamera(Camera* camera) {
_camera = camera;
}
const Renderer& RenderEngine::renderer() const {
return *_renderer;
}
RenderEngine::RendererImplementation RenderEngine::rendererImplementation() const {
return _rendererImplementation;
}
ghoul::opengl::OpenGLStateCache& RenderEngine::openglStateCache() {
if (_openglStateCache == nullptr) {
_openglStateCache = ghoul::opengl::OpenGLStateCache::instance();
@@ -1127,39 +1022,10 @@ unsigned int RenderEngine::latestScreenshotNumber() const {
return _latestScreenshotNumber;
}
void RenderEngine::preRaycast(ghoul::opengl::ProgramObject& programObject) {
_renderer->preRaycast(programObject);
}
void RenderEngine::postRaycast(ghoul::opengl::ProgramObject& programObject) {
_renderer->postRaycast(programObject);
}
void RenderEngine::setRenderer(std::unique_ptr<Renderer> renderer) {
ZoneScoped
if (_renderer) {
_renderer->deinitialize();
}
_renderer = std::move(renderer);
_renderer->setResolution(renderingResolution());
_renderer->enableFXAA(_enableFXAA);
_renderer->setHDRExposure(_hdrExposure);
_renderer->initialize();
}
scripting::LuaLibrary RenderEngine::luaLibrary() {
return {
"",
{
{
"setRenderer",
&luascriptfunctions::setRenderer,
{},
"string",
"Sets the renderer (ABuffer or FrameBuffer)"
},
{
"addScreenSpaceRenderable",
&luascriptfunctions::addScreenSpaceRenderable,
@@ -1266,24 +1132,6 @@ std::vector<ScreenSpaceRenderable*> RenderEngine::screenSpaceRenderables() const
return res;
}
RenderEngine::RendererImplementation RenderEngine::rendererFromString(
const std::string& renderingMethod) const
{
const std::map<std::string, RenderEngine::RendererImplementation> RenderingMethods = {
#ifdef OPENSPACE_WITH_ABUFFER_RENDERER
{ "ABuffer", RendererImplementation::ABuffer },
#endif // OPENSPACE_WITH_ABUFFER_RENDERER
{ "Framebuffer", RendererImplementation::Framebuffer }
};
if (RenderingMethods.find(renderingMethod) != RenderingMethods.end()) {
return RenderingMethods.at(renderingMethod);
}
else {
return RendererImplementation::Invalid;
}
}
void RenderEngine::renderCameraInformation() {
ZoneScoped
src/rendering/renderengine_lua.inl
-24
View File
@@ -26,30 +26,6 @@
namespace openspace::luascriptfunctions {
/**
* \ingroup LuaScripts
* setRenderer(string):
* Set renderer
*/
int setRenderer(lua_State* L) {
ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::setRenderer");
const int type = lua_type(L, -1);
if (type != LUA_TSTRING) {
return ghoul::lua::luaError(L, "Expected argument of type 'string'");
}
const std::string& renderer = ghoul::lua::value<std::string>(
L,
1,
ghoul::lua::PopValue::Yes
);
global::renderEngine->setRendererFromString(renderer);
ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
return 0;
}
int addScreenSpaceRenderable(lua_State* L) {
ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::addScreenSpaceRenderable");