mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-12 22:50:13 -06:00
561 lines
20 KiB
C++
561 lines
20 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2016 *
|
|
* *
|
|
* 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. *
|
|
****************************************************************************************/
|
|
|
|
#include <openspace/rendering/abufferrenderer.h>
|
|
#include <openspace/rendering/raycastermanager.h>
|
|
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/engine/wrapper/windowwrapper.h>
|
|
#include <openspace/rendering/renderengine.h>
|
|
#include <openspace/rendering/volumeraycaster.h>
|
|
#include <openspace/scene/scene.h>
|
|
#include <openspace/util/camera.h>
|
|
#include <openspace/util/updatestructures.h>
|
|
|
|
|
|
#include <ghoul/opengl/programobject.h>
|
|
#include <ghoul/opengl/textureunit.h>
|
|
#include <ghoul/misc/dictionary.h>
|
|
#include <ghoul/misc/exception.h>
|
|
|
|
|
|
|
|
#include <string>
|
|
#include <iterator>
|
|
|
|
namespace {
|
|
const std::string _loggerCat = "ABufferRenderer";
|
|
const std::string BoundsFragmentShaderPath = "${SHADERS}/abuffer/boundsabuffer.frag";
|
|
const std::string RenderFragmentShaderPath = "${SHADERS}/abuffer/renderabuffer.frag";
|
|
const std::string PostRenderFragmentShaderPath = "${SHADERS}/abuffer/postrenderabuffer.frag";
|
|
const int MaxRaycasters = 32;
|
|
const int MaxLayers = 32;
|
|
const int MaxAverageLayers = 8;
|
|
}
|
|
|
|
namespace openspace {
|
|
|
|
|
|
ABufferRenderer::ABufferRenderer()
|
|
: _camera(nullptr)
|
|
, _scene(nullptr)
|
|
, _resolution(glm::ivec2(0))
|
|
, _dirtyResolution(true)
|
|
, _dirtyRaycastData(true)
|
|
, _dirtyRendererData(true)
|
|
, _dirtyResolveDictionary(true)
|
|
, _resolveProgram(nullptr) { }
|
|
|
|
ABufferRenderer::~ABufferRenderer() {}
|
|
|
|
|
|
void ABufferRenderer::initialize() {
|
|
LINFO("Initializing ABufferRenderer");
|
|
const GLfloat size = 1.0f;
|
|
const GLfloat vertex_data[] = {
|
|
// x y s t
|
|
-size, -size, 0.0f, 1.0f,
|
|
size, size, 0.0f, 1.0f,
|
|
-size, size, 0.0f, 1.0f,
|
|
-size, -size, 0.0f, 1.0f,
|
|
size, -size, 0.0f, 1.0f,
|
|
size, size, 0.0f, 1.0f,
|
|
};
|
|
|
|
|
|
glGenVertexArrays(1, &_screenQuad);
|
|
glBindVertexArray(_screenQuad);
|
|
|
|
glGenBuffers(1, &_vertexPositionBuffer);
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
|
|
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, reinterpret_cast<void*>(0));
|
|
glEnableVertexAttribArray(0);
|
|
|
|
glGenTextures(1, &_anchorPointerTexture);
|
|
glGenBuffers(1, &_anchorPointerTextureInitializer);
|
|
glGenBuffers(1, &_atomicCounterBuffer);
|
|
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, _atomicCounterBuffer);
|
|
glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_DYNAMIC_COPY);
|
|
glGenBuffers(1, &_fragmentBuffer);
|
|
glGenTextures(1, &_fragmentTexture);
|
|
|
|
glGenTextures(1, &_mainColorTexture);
|
|
glGenTextures(1, &_mainDepthTexture);
|
|
glGenFramebuffers(1, &_mainFramebuffer);
|
|
|
|
GLint defaultFbo;
|
|
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo);
|
|
|
|
|
|
|
|
updateResolution();
|
|
updateRendererData();
|
|
updateRaycastData();
|
|
updateResolveDictionary();
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, _mainFramebuffer);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, _mainColorTexture, 0);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D_MULTISAMPLE, _mainDepthTexture, 0);
|
|
|
|
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
LERROR("Main framebuffer is not complete");
|
|
}
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, defaultFbo);
|
|
|
|
|
|
try {
|
|
ghoul::Dictionary dict;
|
|
dict.setValue("resolveData", _resolveDictionary);
|
|
dict.setValue("rendererData", _rendererData);
|
|
|
|
_resolveProgram = ghoul::opengl::ProgramObject::Build("ABuffer Resolve",
|
|
"${SHADERS}/abuffer/resolveabuffer.vert",
|
|
"${SHADERS}/abuffer/resolveabuffer.frag",
|
|
dict);
|
|
} catch (ghoul::RuntimeError e) {
|
|
LERROR(e.message);
|
|
}
|
|
|
|
OsEng.renderEngine().raycasterManager().addListener(*this);
|
|
}
|
|
|
|
void ABufferRenderer::deinitialize() {
|
|
LINFO("Deinitializing ABufferRenderer");
|
|
glDeleteBuffers(1, &_fragmentBuffer);
|
|
glDeleteTextures(1, &_fragmentTexture);
|
|
|
|
glDeleteTextures(1, &_anchorPointerTexture);
|
|
glDeleteBuffers(1, &_anchorPointerTextureInitializer);
|
|
glDeleteBuffers(1, &_atomicCounterBuffer);
|
|
|
|
glDeleteBuffers(1, &_vertexPositionBuffer);
|
|
glDeleteVertexArrays(1, &_screenQuad);
|
|
|
|
OsEng.renderEngine().raycasterManager().removeListener(*this);
|
|
}
|
|
|
|
void ABufferRenderer::raycastersChanged(VolumeRaycaster& raycaster, bool attached) {
|
|
(void) raycaster;
|
|
(void) attached;
|
|
_dirtyRaycastData = true;
|
|
}
|
|
|
|
void ABufferRenderer::update() {
|
|
// Make sure that the fragment buffer has the correct resoliution
|
|
// according to the output render buffer size
|
|
if (_dirtyResolution) {
|
|
updateResolution();
|
|
}
|
|
|
|
// Make sure that the renderengine gets the correct render data
|
|
// to feed into all render programs.
|
|
// This will trigger a recompilation of all the shader programs
|
|
// involved in rendering geometries.
|
|
if (_dirtyRendererData) {
|
|
updateRendererData();
|
|
}
|
|
|
|
// Make sure that all raycaster data is up to date.
|
|
if (_dirtyRaycastData) {
|
|
updateRaycastData();
|
|
}
|
|
|
|
// Make sure that the resolve dictionary is up to date.
|
|
// The resolve dictionary contains information for all
|
|
// ray casters, including shader include paths.
|
|
|
|
if (_dirtyResolveDictionary) {
|
|
updateResolveDictionary();
|
|
ghoul::Dictionary dict;
|
|
dict.setValue("resolveData", _resolveDictionary);
|
|
dict.setValue("rendererData", _rendererData);
|
|
_resolveProgram->setDictionary(dict);
|
|
}
|
|
|
|
// If the resolve dictionary changed (or a file changed on disk)
|
|
// then rebuild the resolve program.
|
|
if (_resolveProgram->isDirty()) {
|
|
try {
|
|
_resolveProgram->rebuildFromFile();
|
|
} catch (ghoul::RuntimeError& error) {
|
|
LERROR(error.message);
|
|
}
|
|
}
|
|
|
|
for (auto &program : _boundsPrograms) {
|
|
if (program.second->isDirty()) {
|
|
try {
|
|
program.second->rebuildFromFile();
|
|
} catch (ghoul::RuntimeError e) {
|
|
LERROR(e.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void ABufferRenderer::render(float blackoutFactor, bool doPerformanceMeasurements) {
|
|
if (_scene == nullptr) return;
|
|
if (_camera == nullptr) return;
|
|
|
|
|
|
|
|
_mainColorTextureUnit = std::make_unique<ghoul::opengl::TextureUnit>();
|
|
_mainColorTextureUnit->activate();
|
|
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, _mainColorTexture);
|
|
|
|
_mainDepthTextureUnit = std::make_unique<ghoul::opengl::TextureUnit>();
|
|
_mainDepthTextureUnit->activate();
|
|
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, _mainDepthTexture);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
GLint defaultFbo;
|
|
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, _mainFramebuffer);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Reset
|
|
clear();
|
|
glEnable(GL_DEPTH_TEST);
|
|
glEnable(GL_BLEND);
|
|
|
|
// Step 1: Render geometries to the fragment buffer
|
|
|
|
// Bind head-pointer image for read-write
|
|
glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, _atomicCounterBuffer);
|
|
glBindImageTexture(0, _anchorPointerTexture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
|
|
glBindImageTexture(1, _fragmentTexture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI);
|
|
|
|
// Render the scene to the fragment buffer. Collect renderer tasks (active raycasters)
|
|
RenderData data{ *_camera, psc(), doPerformanceMeasurements };
|
|
RendererTasks tasks;
|
|
_scene->render(data, tasks);
|
|
|
|
_rendererTasks = std::make_unique<RendererTasks>(tasks);
|
|
_renderData = std::make_unique<RenderData>(data);
|
|
_blackoutFactor = blackoutFactor;
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, defaultFbo);
|
|
|
|
|
|
// Step 2: Perform raycasting tasks requested by the scene
|
|
for (const RaycasterTask& raycasterTask : tasks.raycasterTasks) {
|
|
VolumeRaycaster* raycaster = raycasterTask.raycaster;
|
|
ghoul::opengl::ProgramObject* program = _boundsPrograms[raycaster].get();
|
|
if (program) {
|
|
program->activate();
|
|
program->setUniform("_exit_", false);
|
|
raycaster->renderEntryPoints(raycasterTask.renderData, *program);
|
|
program->setUniform("_exit_", true);
|
|
raycaster->renderExitPoints(raycasterTask.renderData, *program);
|
|
program->deactivate();
|
|
}
|
|
else {
|
|
LWARNING("Raycaster is not attached when trying to perform raycaster task");
|
|
}
|
|
}
|
|
|
|
// Step 3: Resolve the buffer
|
|
_resolveProgram->activate();
|
|
|
|
// TEMPORARY GAMMA CORRECTION.
|
|
|
|
float gamma = 1.0;
|
|
glm::vec3 cameraPos = data.camera.position().vec3();
|
|
float maxComponent = std::max(std::max(std::abs(cameraPos.x), std::abs(cameraPos.y)), std::abs(cameraPos.z));
|
|
float logDistance = std::log(glm::length(cameraPos / maxComponent) * maxComponent) / std::log(10);
|
|
|
|
float minLogDist = 15;
|
|
float maxLogDist = 20;
|
|
|
|
float t = (logDistance - minLogDist) / (maxLogDist - minLogDist);
|
|
t = glm::clamp(t, 0.0f, 1.0f);
|
|
gamma = 1.0 * (1 - t) + 2.2 * t;
|
|
|
|
_resolveProgram->setUniform("gamma", gamma);
|
|
|
|
// END TEMPORARY GAMMA CORRECTION.
|
|
|
|
preRaycast(*_resolveProgram);
|
|
glBindVertexArray(_screenQuad);
|
|
glDrawArrays(GL_TRIANGLES, 0, 6);
|
|
postRaycast(*_resolveProgram);
|
|
|
|
_resolveProgram->deactivate();
|
|
|
|
_scene->postRender(data);
|
|
|
|
_mainColorTextureUnit = nullptr;
|
|
_mainDepthTextureUnit = nullptr;
|
|
}
|
|
|
|
|
|
void ABufferRenderer::preRaycast(ghoul::opengl::ProgramObject& program) {
|
|
|
|
program.setUniform("mainColorTexture", _mainColorTextureUnit->unitNumber());
|
|
program.setUniform("mainDepthTexture", _mainDepthTextureUnit->unitNumber());
|
|
|
|
for (const auto& raycastData : _raycastData) {
|
|
raycastData.first->preRaycast(raycastData.second, program);
|
|
|
|
glm::vec3 localCameraPosition;
|
|
bool cameraIsInside = raycastData.first->cameraIsInside(*_renderData, localCameraPosition);
|
|
int uniformIndex = raycastData.second.id + 1; // uniforms are indexed from 1 (not from 0)
|
|
program.setUniform("insideRaycaster" + std::to_string(uniformIndex), cameraIsInside);
|
|
if (cameraIsInside) {
|
|
program.setUniform("cameraPosInRaycaster" + std::to_string(uniformIndex), localCameraPosition);
|
|
}
|
|
}
|
|
|
|
// 3b: Set "global" uniforms, and start the resolve pass.
|
|
program.setUniform("blackoutFactor", _blackoutFactor);
|
|
program.setUniform("nAaSamples", _nAaSamples);
|
|
}
|
|
|
|
void ABufferRenderer::postRaycast(ghoul::opengl::ProgramObject& program) {
|
|
for (const auto& raycastData : _raycastData) {
|
|
raycastData.first->postRaycast(raycastData.second, program);
|
|
}
|
|
}
|
|
|
|
void ABufferRenderer::setScene(Scene* scene) {
|
|
_scene = scene;
|
|
}
|
|
|
|
void ABufferRenderer::setCamera(Camera* camera) {
|
|
_camera = camera;
|
|
}
|
|
|
|
void ABufferRenderer::setResolution(glm::ivec2 res) {
|
|
if (res != _resolution) {
|
|
_resolution = res;
|
|
_dirtyResolution = true;
|
|
}
|
|
}
|
|
|
|
void ABufferRenderer::setNAaSamples(int nAaSamples) {
|
|
_nAaSamples = nAaSamples;
|
|
if (_nAaSamples == 0) {
|
|
_nAaSamples = 1;
|
|
}
|
|
if (_nAaSamples > 8) {
|
|
LERROR("Framebuffer renderer does not support more than 8 MSAA samples.");
|
|
_nAaSamples = 8;
|
|
}
|
|
_dirtyResolution = true;
|
|
}
|
|
|
|
void ABufferRenderer::clear() {
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
|
|
glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
|
|
|
static const GLuint zero = 1;
|
|
glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, _atomicCounterBuffer);
|
|
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(zero), &zero);
|
|
glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, 0);
|
|
|
|
}
|
|
|
|
void ABufferRenderer::updateResolution() {
|
|
int totalPixels = _resolution.x * _resolution.y;
|
|
glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, totalPixels * sizeof(GLuint), NULL, GL_STATIC_DRAW);
|
|
|
|
GLuint* data = (GLuint*)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
|
|
memset(data, 0x00, totalPixels * sizeof(GLuint));
|
|
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
|
|
|
glBindBuffer(GL_TEXTURE_BUFFER, _fragmentBuffer);
|
|
glBufferData(GL_TEXTURE_BUFFER, MaxAverageLayers*totalPixels*sizeof(GLuint) * 4, NULL, GL_DYNAMIC_COPY);
|
|
|
|
glBindTexture(GL_TEXTURE_BUFFER, _fragmentTexture);
|
|
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, _fragmentBuffer);
|
|
glBindTexture(GL_TEXTURE_BUFFER, 0);
|
|
|
|
glBindImageTexture(1, _fragmentTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32UI);
|
|
|
|
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, _mainColorTexture);
|
|
|
|
glTexImage2DMultisample(
|
|
GL_TEXTURE_2D_MULTISAMPLE,
|
|
_nAaSamples,
|
|
GL_RGBA,
|
|
GLsizei(_resolution.x),
|
|
GLsizei(_resolution.y),
|
|
true);
|
|
|
|
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, _mainDepthTexture);
|
|
glTexImage2DMultisample(
|
|
GL_TEXTURE_2D_MULTISAMPLE,
|
|
_nAaSamples,
|
|
GL_DEPTH_COMPONENT32F,
|
|
GLsizei(_resolution.x),
|
|
GLsizei(_resolution.y),
|
|
true);
|
|
|
|
|
|
_dirtyResolution = false;
|
|
}
|
|
|
|
|
|
|
|
void ABufferRenderer::updateResolveDictionary() {
|
|
ghoul::Dictionary dict;
|
|
|
|
ghoul::Dictionary raycastersDict;
|
|
|
|
for (const auto &raycastPair : _raycastData) {
|
|
ghoul::Dictionary innerDict;
|
|
int id = raycastPair.second.id;
|
|
std::string namespaceName = raycastPair.second.namespaceName;
|
|
std::string raycastPath = raycastPair.first->getRaycastPath();
|
|
|
|
innerDict.setValue("id", id);
|
|
innerDict.setValue("namespace", namespaceName);
|
|
innerDict.setValue("bitmask", 1 << id);
|
|
innerDict.setValue("raycastPath", raycastPath);
|
|
|
|
raycastersDict.setValue(std::to_string(id), innerDict);
|
|
}
|
|
|
|
dict.setValue("raycasters", raycastersDict);
|
|
|
|
ghoul::Dictionary helperPathsDict;
|
|
for (int i = 0; i < _helperPaths.size(); i++) {
|
|
helperPathsDict.setValue(std::to_string(i), _helperPaths[i]);
|
|
}
|
|
|
|
dict.setValue("helperPaths", helperPathsDict);
|
|
dict.setValue("raycastingEnabled", _raycastData.size() > 0);
|
|
dict.setValue("storeSorted", true);
|
|
dict.setValue("nRaycasters", static_cast<unsigned long long>(_raycastData.size()));
|
|
|
|
_resolveDictionary = dict;
|
|
|
|
OsEng.renderEngine().setResolveData(dict);
|
|
|
|
_dirtyResolveDictionary = false;
|
|
}
|
|
|
|
void ABufferRenderer::updateRaycastData() {
|
|
|
|
_raycastData.clear();
|
|
_boundsPrograms.clear();
|
|
_helperPaths.clear();
|
|
|
|
const std::vector<VolumeRaycaster*>& raycasters = OsEng.renderEngine().raycasterManager().raycasters();
|
|
|
|
std::map<std::string, int> namespaceIndices;
|
|
int nextId = 0; // raycaster ids are positive integers starting at 0. (for raycasters, fragment type is id+1)
|
|
int nextNamespaceIndex = 0;
|
|
|
|
for (auto &raycaster : raycasters) {
|
|
if (nextId > MaxRaycasters) {
|
|
int nIgnored = MaxRaycasters - raycasters.size();
|
|
LWARNING("ABufferRenderer does not support more than 32 raycasters. Ignoring " << nIgnored << " raycasters");
|
|
break;
|
|
}
|
|
|
|
RaycastData data;
|
|
data.id = nextId++;
|
|
|
|
std::string helperPath = raycaster->getHelperPath();
|
|
// Each new helper path generates a new namespace,
|
|
// to avoid glsl name collisions between raycaster implementaitons.
|
|
// Assign a new namespace or find an already created index.
|
|
|
|
if (helperPath == "") {
|
|
data.namespaceName = "NAMESPACE_" + std::to_string(nextNamespaceIndex++);
|
|
} else {
|
|
auto iter = namespaceIndices.find(helperPath);
|
|
if (iter == namespaceIndices.end()) {
|
|
int namespaceIndex = nextNamespaceIndex++;
|
|
data.namespaceName = std::to_string(namespaceIndex);
|
|
namespaceIndices[helperPath] = namespaceIndex;
|
|
_helperPaths.push_back(helperPath);
|
|
}
|
|
else {
|
|
data.namespaceName = "NAMESPACE_" + std::to_string(iter->second);
|
|
}
|
|
}
|
|
|
|
_raycastData[raycaster] = data;
|
|
std::string vsPath = raycaster->getBoundsVsPath();
|
|
std::string fsPath = raycaster->getBoundsFsPath();
|
|
ghoul::Dictionary dict;
|
|
|
|
// set path to the current renderer's main fragment shader
|
|
dict.setValue("rendererData", _rendererData);
|
|
// parameterize the main fragment shader program with specific contents.
|
|
// fsPath should point to a shader file defining a Fragment getFragment() function
|
|
// instead of a void main() setting glFragColor, glFragDepth, etc.
|
|
dict.setValue("fragmentPath", fsPath);
|
|
dict.setValue("fragmentType", data.id + 1);
|
|
try {
|
|
_boundsPrograms[raycaster] = ghoul::opengl::ProgramObject::Build("Volume " + std::to_string(data.id) + " bounds", vsPath, BoundsFragmentShaderPath, dict);
|
|
}
|
|
catch (ghoul::RuntimeError& error) {
|
|
LERROR(error.message);
|
|
}
|
|
}
|
|
|
|
_dirtyRaycastData = false;
|
|
_dirtyResolveDictionary = true;
|
|
|
|
}
|
|
|
|
|
|
void ABufferRenderer::updateRendererData() {
|
|
ghoul::Dictionary dict;
|
|
dict.setValue("windowWidth", _resolution.x);
|
|
dict.setValue("windowHeight", _resolution.y);
|
|
dict.setValue("fragmentRendererPath", std::string(RenderFragmentShaderPath));
|
|
dict.setValue("postFragmentRendererPath", std::string(PostRenderFragmentShaderPath));
|
|
dict.setValue("maxLayers", MaxLayers);
|
|
dict.setValue("maxTotalFragments", MaxLayers * _resolution.x * _resolution.y);
|
|
|
|
_rendererData = dict;
|
|
|
|
OsEng.renderEngine().setRendererData(dict);
|
|
_dirtyRendererData = false;
|
|
}
|
|
|
|
}
|