mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-07 04:00:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Updated absPath in shaders compilation.

Browse Source
This commit is contained in:
Jonathas Costa
2017-12-18 10:26:26 -05:00
parent 61b2c82b92
commit c7a784f01e
4 changed files with 43 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ext/ghoul

Submodule ext/ghoul updated: 52bb0bae10...38ef288aa1

51
modules/atmosphere/rendering/atmospheredeferredcaster.cpp
View File

@@ -66,6 +66,7 @@
#include <ghoul/opengl/texture.h>
#include <ghoul/opengl/textureunit.h>
#include <ghoul/opengl/programobject.h>
#include <ghoul/filesystem/filesystem.h>
#include <openspace/engine/openspaceengine.h>
#include <openspace/util/powerscaledcoordinate.h>
#include <openspace/util/updatestructures.h>
@@ -491,8 +492,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_transmittanceProgramObject) {
_transmittanceProgramObject = ghoul::opengl::ProgramObject::Build(
"transmittanceCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/transmittance_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/transmittance_calc_fs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/transmittance_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/transmittance_calc_fs.glsl"));
}
using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
_transmittanceProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -502,8 +503,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_irradianceProgramObject) {
_irradianceProgramObject = ghoul::opengl::ProgramObject::Build(
"irradianceCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/irradiance_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/irradiance_calc_fs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_calc_fs.glsl"));
}
_irradianceProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_irradianceProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -511,8 +512,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_irradianceSupTermsProgramObject) {
_irradianceSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
"irradianceSupTermsCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_fs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_fs.glsl"));
}
_irradianceSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_irradianceSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -521,9 +522,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_inScatteringProgramObject) {
_inScatteringProgramObject = ghoul::opengl::ProgramObject::Build(
"inScatteringCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/inScattering_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/inScattering_calc_fs.glsl",
"${MODULE_ATMOSPHERE}/shaders/inScattering_calc_gs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_fs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_gs.glsl"));
}
_inScatteringProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_inScatteringProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -531,9 +532,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_inScatteringSupTermsProgramObject) {
_inScatteringSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
"inScatteringSupTermsCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_fs.glsl",
"${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_gs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_fs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_gs.glsl"));
}
_inScatteringSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_inScatteringSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -542,8 +543,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_deltaEProgramObject) {
_deltaEProgramObject = ghoul::opengl::ProgramObject::Build(
"deltaECalcProgram",
"${MODULE_ATMOSPHERE}/shaders/deltaE_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaE_calc_fs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/deltaE_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaE_calc_fs.glsl"));
}
_deltaEProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_deltaEProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -552,8 +553,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_irradianceFinalProgramObject) {
_irradianceFinalProgramObject = ghoul::opengl::ProgramObject::Build(
"irradianceEFinalProgram",
"${MODULE_ATMOSPHERE}/shaders/irradiance_final_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/irradiance_final_fs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_final_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_final_fs.glsl"));
}
_irradianceFinalProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_irradianceFinalProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -562,9 +563,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_deltaSProgramObject) {
_deltaSProgramObject = ghoul::opengl::ProgramObject::Build(
"deltaSCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/deltaS_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaS_calc_fs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaS_calc_gs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_fs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_gs.glsl"));
}
_deltaSProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_deltaSProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -572,9 +573,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_deltaSSupTermsProgramObject) {
_deltaSSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
"deltaSSUPTermsCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_fs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_gs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_fs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_gs.glsl"));
}
_deltaSSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_deltaSSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -583,9 +584,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
if (!_deltaJProgramObject) {
_deltaJProgramObject = ghoul::opengl::ProgramObject::Build(
"deltaJCalcProgram",
"${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_vs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_fs.glsl",
"${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_gs.glsl");
absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_vs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_fs.glsl"),
absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_gs.glsl"));
}
_deltaJProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_deltaJProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);

7
modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
View File

@@ -1554,9 +1554,10 @@ void RenderableBillboardsCloud::loadPolygonGeometryForRendering() {
void RenderableBillboardsCloud::renderPolygonGeometry(GLuint vao) {
std::unique_ptr<ghoul::opengl::ProgramObject> program =
ghoul::opengl::ProgramObject::Build("RenderableBillboardsCloud_Polygon",
"${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_vs.glsl",
"${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_fs.glsl",
"${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_gs.glsl");
absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_vs.glsl"),
absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_fs.glsl"),
absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_gs.glsl")
);
program->activate();
static const float black[] = { 0.0f, 0.0f, 0.0f, 0.0f };

24
src/rendering/framebufferrenderer.cpp
View File

@@ -461,8 +461,8 @@ void FramebufferRenderer::updateRaycastData() {
outsideDict.setValue("getEntryPath", GetEntryOutsidePath);
_raycastPrograms[raycaster] = ghoul::opengl::ProgramObject::Build(
"Volume " + std::to_string(data.id) + " raycast",
vsPath,
RaycastFragmentShaderPath,
absPath(vsPath),
absPath(RaycastFragmentShaderPath),
outsideDict
);
} catch (ghoul::RuntimeError e) {
@@ -473,8 +473,8 @@ void FramebufferRenderer::updateRaycastData() {
insideDict.setValue("getEntryPath", GetEntryInsidePath);
_insideRaycastPrograms[raycaster] = ghoul::opengl::ProgramObject::Build(
"Volume " + std::to_string(data.id) + " inside raycast",
"${SHADERS}/framebuffer/resolveframebuffer.vert",
RaycastFragmentShaderPath,
absPath("${SHADERS}/framebuffer/resolveframebuffer.vert"),
absPath(RaycastFragmentShaderPath),
insideDict
);
}
@@ -519,8 +519,8 @@ void FramebufferRenderer::updateDeferredcastData() {
//deferredDict.setValue("getEntryPath", GetEntryOutsidePath);
_deferredcastPrograms[deferredcaster] = ghoul::opengl::ProgramObject::Build(
"Deferred " + std::to_string(data.id) + " raycast",
vsPath,
deferredShaderPath,
absPath(vsPath),
absPath(deferredShaderPath),
deferredDict);
using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
_deferredcastPrograms[deferredcaster]->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -538,8 +538,8 @@ void FramebufferRenderer::updateHDRData() {
try {
_hdrBackGroundProgram = ghoul::opengl::ProgramObject::Build(
"HDR Background Control",
"${SHADERS}/framebuffer/hdrBackground.vert",
"${SHADERS}/framebuffer/hdrBackground.frag"
absPath("${SHADERS}/framebuffer/hdrBackground.vert"),
absPath("${SHADERS}/framebuffer/hdrBackground.frag")
);
using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
_hdrBackGroundProgram->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -666,8 +666,8 @@ void FramebufferRenderer::updateMSAASamplingPattern() {
try {
pixelSizeProgram = ghoul::opengl::ProgramObject::Build(
"OnePixel MSAA",
"${SHADERS}/framebuffer/pixelSizeMSAA.vert",
"${SHADERS}/framebuffer/pixelSizeMSAA.frag"
absPath("${SHADERS}/framebuffer/pixelSizeMSAA.vert"),
absPath("${SHADERS}/framebuffer/pixelSizeMSAA.frag")
);
}
catch (const ghoul::RuntimeError& e) {
@@ -814,8 +814,8 @@ void FramebufferRenderer::updateMSAASamplingPattern() {
try {
nOneStripProgram = ghoul::opengl::ProgramObject::Build(
"OneStrip MSAA",
"${SHADERS}/framebuffer/nOneStripMSAA.vert",
"${SHADERS}/framebuffer/nOneStripMSAA.frag"
absPath("${SHADERS}/framebuffer/nOneStripMSAA.vert"),
absPath("${SHADERS}/framebuffer/nOneStripMSAA.frag")
);
}
catch (const ghoul::RuntimeError& e) {