mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-01 09:10:18 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
4068ec747b01db762161ef3fc904b8643d96f401
OpenSpace/modules/volume/rendering/renderablevolumegl.cpp
Alexander Bock 906470f28e Untabify the rest of the source files 
Update Ghoul repository
2016-04-18 20:14:29 +02:00

324 lines
12 KiB
C++
Raw Blame History

/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2015 *
* *
* 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 <modules/volume/rendering/renderablevolumegl.h>
#include <openspace/abuffer/abuffer.h>
#include <openspace/engine/configurationmanager.h>
#include <openspace/engine/openspaceengine.h>
#include <openspace/rendering/renderengine.h>
#include <modules/kameleon/include/kameleonwrapper.h>
#include <openspace/scene/scenegraphnode.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/filesystem/file.h>
#include <ghoul/opengl/framebufferobject.h>
#include <ghoul/opengl/programobject.h>
#include <ghoul/io/texture/texturereader.h>
#include <ghoul/opengl/texture.h>
#include <algorithm>
namespace {
const std::string _loggerCat = "RenderableVolumeGL";
const std::string KeyVolume = "Volume";
const std::string KeyHints = "Hints";
const std::string KeyTransferFunction = "TransferFunction";
const std::string KeySampler = "Sampler";
const std::string KeyBoxScaling = "BoxScaling";
const std::string KeyVolumeName = "VolumeName";
const std::string KeyTransferFunctionName = "TransferFunctionName";
}
namespace openspace {
RenderableVolumeGL::RenderableVolumeGL(const ghoul::Dictionary& dictionary)
: RenderableVolume(dictionary)
, _transferFunctionName("")
, _volumeName("")
, _volume(nullptr)
, _transferFunction(nullptr)
, _boxArray(0)
, _vertexPositionBuffer(0)
, _boxProgram(nullptr)
, _boxScaling(1.0, 1.0, 1.0)
, _w(0.f)
, _updateTransferfunction(false)
, _id(-1)
{
std::string name;
bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
assert(success);
_filename = "";
success = dictionary.getValue(KeyVolume, _filename);
if (!success) {
LERROR("Node '" << name << "' did not contain a valid '" << KeyVolume << "'");
return;
}
_filename = absPath(_filename);
if (_filename == "") {
return;
}
LDEBUG("Volume Filename: " << _filename);
dictionary.getValue(KeyHints, _hintsDictionary);
_transferFunction = nullptr;
_transferFunctionFile = nullptr;
_transferFunctionPath = "";
success = dictionary.getValue(KeyTransferFunction, _transferFunctionPath);
if (!success) {
LERROR("Node '" << name << "' did not contain a valid '" <<
KeyTransferFunction << "'");
return;
}
_transferFunctionPath = absPath(_transferFunctionPath);
_transferFunctionFile = new ghoul::filesystem::File(_transferFunctionPath, true);
_samplerFilename = "";
success = dictionary.getValue(KeySampler, _samplerFilename);
if (!success) {
LERROR("Node '" << name << "' did not contain a valid '" << KeySampler << "'");
return;
}
_samplerFilename = absPath(_samplerFilename);
KameleonWrapper kw(_filename);
auto t = kw.getGridUnits();
if (dictionary.hasKey(KeyBoxScaling)) {
glm::vec4 scalingVec4(_boxScaling, _w);
success = dictionary.getValue(KeyBoxScaling, scalingVec4);
if (success) {
_boxScaling = scalingVec4.xyz();
_w = scalingVec4.w;
}
else {
success = dictionary.getValue(KeyBoxScaling, _boxScaling);
if (!success) {
LERROR("Node '" << name << "' did not contain a valid '" <<
KeyBoxScaling << "'");
return;
}
}
}
else {
// Automatic scale detection from model
_boxScaling = kw.getModelScale();
if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
// Earth radius
_boxScaling.x *= 6.371f;
_boxScaling.y *= 6.371f;
_boxScaling.z *= 6.371f;
_w = 6;
}
else if (std::get<0>(t) == "m" && std::get<1>(t) == "radian" && std::get<2>(t) == "radian") {
// For spherical coordinate systems the radius is in meter
_w = -log10(1.0f/kw.getGridMax().x);
}
else {
LWARNING("Unsupported units for automatic scale detection");
}
}
_pscOffset = kw.getModelBarycenterOffset();
if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
// Earth radius
_pscOffset[0] *= 6.371f;
_pscOffset[1] *= 6.371f;
_pscOffset[2] *= 6.371f;
_pscOffset[3] = 6;
}
else {
// Current spherical models no need for offset
}
dictionary.getValue(KeyVolumeName, _volumeName);
dictionary.getValue(KeyTransferFunctionName, _transferFunctionName);
setBoundingSphere(PowerScaledScalar::CreatePSS(glm::length(_boxScaling)*pow(10,_w)));
}
RenderableVolumeGL::~RenderableVolumeGL() {
}
bool RenderableVolumeGL::isReady() const {
bool ready = true;
ready &= (_boxProgram != nullptr);
ready &= (_volume != nullptr);
ready &= (_transferFunction != nullptr);
return ready;
}
bool RenderableVolumeGL::initialize() {
// @TODO fix volume and transferfunction names --jonasstrandstedt
if(_filename != "") {
_volume = loadVolume(_filename, _hintsDictionary);
_volume->uploadTexture();
OsEng.renderEngine().aBuffer()->addVolume(_volumeName, _volume);
}
if(_transferFunctionPath != "") {
_transferFunction = loadTransferFunction(_transferFunctionPath);
_transferFunction->uploadTexture();
OsEng.renderEngine().aBuffer()->addTransferFunction(_transferFunctionName, _transferFunction);
auto textureCallback = [this](const ghoul::filesystem::File& file) {
_updateTransferfunction = true;
};
_transferFunctionFile->setCallback(textureCallback);
}
// add the sampler and get the ID
_id = OsEng.renderEngine().aBuffer()->addSamplerfile(_samplerFilename);
OsEng.configurationManager().getValue("RaycastProgram", _boxProgram);
// ============================
// GEOMETRY (box)
// ============================
const GLfloat size = 0.5f;
const GLfloat vertex_data[] = {
// x, y, z, s,
-size, -size, size, _w,
size, size, size, _w,
-size, size, size, _w,
-size, -size, size, _w,
size, -size, size, _w,
size, size, size, _w,
-size, -size, -size, _w,
size, size, -size, _w,
-size, size, -size, _w,
-size, -size, -size, _w,
size, -size, -size, _w,
size, size, -size, _w,
size, -size, -size, _w,
size, size, size, _w,
size, -size, size, _w,
size, -size, -size, _w,
size, size, -size, _w,
size, size, size, _w,
-size, -size, -size, _w,
-size, size, size, _w,
-size, -size, size, _w,
-size, -size, -size, _w,
-size, size, -size, _w,
-size, size, size, _w,
-size, size, -size, _w,
size, size, size, _w,
-size, size, size, _w,
-size, size, -size, _w,
size, size, -size, _w,
size, size, size, _w,
-size, -size, -size, _w,
size, -size, size, _w,
-size, -size, size, _w,
-size, -size, -size, _w,
size, -size, -size, _w,
size, -size, size, _w,
};
glGenVertexArrays(1, &_boxArray); // generate array
glBindVertexArray(_boxArray); // bind array
glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer); // bind buffer
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);
return isReady();
}
bool RenderableVolumeGL::deinitialize() {
if (_volume)
delete _volume;
if (_transferFunctionFile)
delete _transferFunctionFile;
if (_transferFunction)
delete _transferFunction;
_volume = nullptr;
_transferFunctionFile = nullptr;
_transferFunction = nullptr;
glDeleteVertexArrays(1, &_boxArray);
glGenBuffers(1, &_vertexPositionBuffer);
return true;
}
void RenderableVolumeGL::render(const RenderData& data) {
if(_updateTransferfunction) {
_updateTransferfunction = false;
ghoul::opengl::Texture* transferFunction = loadTransferFunction(_transferFunctionPath);
if(transferFunction) {
const void* data = transferFunction->pixelData();
glBindBuffer(GL_COPY_READ_BUFFER, *transferFunction);
_transferFunction->bind();
glTexImage1D( GL_TEXTURE_1D, 0, _transferFunction->internalFormat(),
static_cast<GLsizei>(_transferFunction->width()),0, _transferFunction->format(),
_transferFunction->dataType(), data);
delete transferFunction;
LDEBUG("Updated transferfunction!");
}
}
glm::mat4 transform = glm::mat4(1.0);
transform = glm::scale(transform, _boxScaling);
// fetch data
psc currentPosition = data.position;
currentPosition += _pscOffset; // Move box to model barycenter
_boxProgram->activate();
_boxProgram->setUniform("volumeType", _id);
_boxProgram->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
_boxProgram->setUniform("modelTransform", transform);
setPscUniforms(_boxProgram, &data.camera, currentPosition);
// make sure GL_CULL_FACE is enabled (it should be)
glEnable(GL_CULL_FACE);
// Draw backface
glCullFace(GL_FRONT);
glBindVertexArray(_boxArray);
glDrawArrays(GL_TRIANGLES, 0, 6*6);
// Draw frontface (now the normal cull face is is set)
glCullFace(GL_BACK);
glDrawArrays(GL_TRIANGLES, 0, 6*6);
_boxProgram->deactivate();
}
void RenderableVolumeGL::update(const UpdateData& data) {
}
} // namespace openspace
Reference in New Issue View Git Blame Copy Permalink