mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-13 07:21:08 -06:00
403 lines
14 KiB
C++
403 lines
14 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014 *
|
|
* *
|
|
* 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. *
|
|
****************************************************************************************/
|
|
|
|
// open space includes
|
|
#include <openspace/rendering/planets/RenderablePlanetProjection.h>
|
|
#include <openspace/util/constants.h>
|
|
#include <openspace/rendering/planets/planetgeometryprojection.h>
|
|
|
|
#include <ghoul/io/texture/texturereader.h>
|
|
#include <ghoul/opengl/textureunit.h>
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
|
|
#include <openspace/util/time.h>
|
|
#include <openspace/util/spicemanager.h>
|
|
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <sgct.h>
|
|
#include <iomanip>
|
|
|
|
#define _USE_MATH_DEFINES
|
|
#include <math.h>
|
|
|
|
namespace {
|
|
const std::string _loggerCat = "RenderablePlanetProjection";
|
|
}
|
|
|
|
namespace openspace {
|
|
RenderablePlanetProjection::RenderablePlanetProjection(const ghoul::Dictionary& dictionary)
|
|
: Renderable(dictionary)
|
|
, _colorTexturePath("colorTexture", "Color Texture")
|
|
, _projectionTexturePath("colorTexture", "Color Texture")
|
|
, _programObject(nullptr)
|
|
, _texture(nullptr)
|
|
, _textureProj(nullptr)
|
|
, _geometry(nullptr)
|
|
{
|
|
std::string name;
|
|
bool success = dictionary.getValue(constants::scenegraphnode::keyName, name);
|
|
assert(success);
|
|
|
|
std::string path;
|
|
success = dictionary.getValue(constants::scenegraph::keyPathModule, path);
|
|
assert(success);
|
|
|
|
ghoul::Dictionary geometryDictionary;
|
|
success = dictionary.getValue(
|
|
constants::renderableplanet::keyGeometry, geometryDictionary);
|
|
if (success) {
|
|
geometryDictionary.setValue(constants::scenegraphnode::keyName, name);
|
|
geometryDictionary.setValue(constants::scenegraph::keyPathModule, path);
|
|
_geometry = planetgeometryprojection::PlanetGeometryProjection::createFromDictionary(geometryDictionary);
|
|
}
|
|
|
|
dictionary.getValue(constants::renderableplanet::keyFrame, _target);
|
|
|
|
// TODO: textures need to be replaced by a good system similar to the geometry as soon
|
|
// as the requirements are fixed (ab)
|
|
std::string texturePath = "";
|
|
success = dictionary.getValue("Textures.Color", texturePath);
|
|
if (success){
|
|
_colorTexturePath = path + "/" + texturePath;
|
|
}
|
|
success = dictionary.getValue("Textures.Project", texturePath);
|
|
if (success){
|
|
_projectionTexturePath = path + "/" + texturePath;
|
|
}
|
|
addPropertySubOwner(_geometry);
|
|
|
|
addProperty(_colorTexturePath);
|
|
_colorTexturePath.onChange(std::bind(&RenderablePlanetProjection::loadTexture, this));
|
|
addProperty(_projectionTexturePath);
|
|
_projectionTexturePath.onChange(std::bind(&RenderablePlanetProjection::loadTexture, this));
|
|
}
|
|
|
|
RenderablePlanetProjection::~RenderablePlanetProjection(){
|
|
deinitialize();
|
|
}
|
|
|
|
bool RenderablePlanetProjection::initialize(){
|
|
bool completeSuccess = true;
|
|
if (_programObject == nullptr)
|
|
completeSuccess
|
|
&= OsEng.ref().configurationManager().getValue("projectiveProgram", _programObject);
|
|
|
|
loadTexture();
|
|
completeSuccess &= (_texture != nullptr);
|
|
completeSuccess &= (_textureProj != nullptr);
|
|
|
|
completeSuccess &= _geometry->initialize(this);
|
|
|
|
return completeSuccess;
|
|
}
|
|
|
|
bool RenderablePlanetProjection::deinitialize(){
|
|
_geometry->deinitialize();
|
|
delete _geometry;
|
|
_geometry = nullptr;
|
|
delete _texture;
|
|
_texture = nullptr;
|
|
delete _textureProj;
|
|
_textureProj = nullptr;
|
|
return true;
|
|
}
|
|
|
|
bool RenderablePlanetProjection::isReady() const {
|
|
return (_geometry != nullptr);
|
|
}
|
|
|
|
void RenderablePlanetProjection::render(const RenderData& data)
|
|
{
|
|
if (!_programObject) return;
|
|
if (!_textureProj) return;
|
|
|
|
// activate shader
|
|
_programObject->activate();
|
|
|
|
// scale the planet to appropriate size since the planet is a unit sphere
|
|
glm::mat4 transform = glm::mat4(1);
|
|
|
|
//earth needs to be rotated for that to work.
|
|
glm::mat4 rot = glm::rotate(transform, 90.f, glm::vec3(1, 0, 0));
|
|
|
|
for (int i = 0; i < 3; i++){
|
|
for (int j = 0; j < 3; j++){
|
|
transform[i][j] = _stateMatrix[i][j];
|
|
}
|
|
}
|
|
transform = transform* rot;
|
|
if (_target == "IAU_JUPITER"){ // tmp scale of jupiterx = 0.935126
|
|
transform *= glm::scale(glm::mat4(1), glm::vec3(1, 0.935126, 1));
|
|
}
|
|
|
|
// PROJECTIVE TEXTURING----------------------------------------------------------
|
|
// get fov
|
|
std::string shape, instrument;
|
|
std::vector<glm::dvec3> bounds;
|
|
glm::dvec3 boresight;
|
|
bool found = openspace::SpiceManager::ref().getFieldOfView("NH_LORRI", shape, instrument, boresight, bounds);
|
|
if (!found) LERROR("Could not locate instrument");
|
|
|
|
psc position;
|
|
double lightTime = 0.0;
|
|
SpiceManager::ref().getTargetPosition("NEW HORIZONS", "JUPITER BARYCENTER","GALACTIC", "NONE", _time, position, lightTime);
|
|
position[3] += 3;
|
|
glm::vec3 nh_pos = position.vec3();
|
|
|
|
//get up-vecto
|
|
//rotate boresight into correct alignment
|
|
glm::vec3 bsight(_instrumentMatrix*boresight); // lookat must be vec3
|
|
glm::vec3 uptmp(_instrumentMatrix*glm::dvec3(data.camera.lookUpVector()));
|
|
|
|
//create view matrix
|
|
glm::vec3 e3 = glm::normalize(bsight);
|
|
glm::vec3 e1 = glm::normalize(glm::cross(uptmp, e3));
|
|
glm::vec3 e2 = glm::normalize(glm::cross(e3, e1));
|
|
|
|
glm::mat4 projViewMatrix = glm::mat4( e1.x, e2.x, e3.x, 0.f,
|
|
e1.y, e2.y, e3.y, 0.f,
|
|
e1.z, e2.z, e3.z, 0.f,
|
|
-glm::dot(e1, nh_pos), -glm::dot(e2, nh_pos), -glm::dot(e3, nh_pos), 1.f);
|
|
//create perspective projection matrix
|
|
glm::mat4 projProjectionMatrix = glm::perspective(0.2907f, 1.f, 0.2f, 1000000.0f);
|
|
//bias matrix
|
|
glm::mat4 projNormalizationMatrix = glm::mat4(0.5f, 0 , 0 , 0,
|
|
0 , 0.5f, 0 , 0,
|
|
0 , 0 , 0.5f, 0,
|
|
0.5f, 0.5f, 0.5f, 1 );
|
|
|
|
glm::mat4 m = projNormalizationMatrix*projProjectionMatrix*projViewMatrix;
|
|
// setup the data to the shader
|
|
_programObject->setUniform("ProjectorMatrix", m);
|
|
_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
|
|
_programObject->setUniform("ModelTransform", transform);
|
|
_programObject->setAttribute("boresight", bsight);
|
|
setPscUniforms(_programObject, &data.camera, data.position);
|
|
|
|
// Bind texture
|
|
ghoul::opengl::TextureUnit unit;
|
|
unit.activate();
|
|
_texture->bind();
|
|
_programObject->setUniform("texture1", unit); // jupiter
|
|
|
|
ghoul::opengl::TextureUnit unit2;
|
|
unit2.activate();
|
|
_textureProj->bind();
|
|
_programObject->setUniform("texture2", unit2); // proj
|
|
|
|
// render
|
|
_geometry->render();
|
|
|
|
// disable shader
|
|
_programObject->deactivate();
|
|
|
|
static int callCount = 0;
|
|
callCount++;
|
|
|
|
if (callCount > 1000){
|
|
callCount = 0;
|
|
|
|
_textureProj->downloadTexture();
|
|
_texture->downloadTexture();
|
|
|
|
auto uvToModel = [](float u, float v, float radius[2], float fsegments)->glm::vec4{
|
|
|
|
const float fj = u * fsegments;
|
|
const float fi = v * fsegments;
|
|
|
|
const float theta = fi * float(M_PI) / fsegments; // 0 -> PI
|
|
const float phi = fj * float(M_PI) * 2.0f / fsegments;
|
|
|
|
const float x = radius[0] * sin(phi) * sin(theta); //
|
|
const float y = radius[0] * cos(theta); // up
|
|
const float z = radius[0] * cos(phi) * sin(theta); //
|
|
|
|
return glm::vec4(x, y, z, radius[1]);
|
|
};
|
|
|
|
auto uvToIndex = [](const glm::vec2 &uv, int w, int h, int &i, int &j){
|
|
i = static_cast<int>(uv.x * float(w));
|
|
j = static_cast<int>(uv.y * float(h));
|
|
};
|
|
|
|
auto inRange = [](int x, int a, int b)->bool{
|
|
return (x >= a && x <= b);
|
|
};
|
|
|
|
auto pscToMeter = [](glm::vec4 v1, glm::vec2 v2)->glm::vec4{
|
|
float factor = v2.x * pow(10, v2.y + v1.w);
|
|
return glm::vec4(v1.xyz * factor, 1.0);
|
|
};
|
|
|
|
typedef glm::detail::tvec3<glm::detail::uint8> rgb;
|
|
|
|
auto bilinear = [](const ghoul::opengl::Texture* dest, const ghoul::opengl::Texture* source, float x, float y, float i, float j){
|
|
int px = (int)x; // floor of x
|
|
int py = (int)y; // floor of y
|
|
int tx;
|
|
int ty;
|
|
rgb p1, p2, p3, p4;
|
|
//original
|
|
rgb p0 = source->texel<rgb>(px, py);
|
|
// load the four neighboring pixels
|
|
// right
|
|
if (px + 1 < source->width() - 1){
|
|
p1 = source->texel<rgb>(px + 1, py);
|
|
}else{
|
|
p1 = rgb(0);
|
|
}
|
|
// left
|
|
if (px - 1 > 0){
|
|
p2 = source->texel<rgb>(px-1, py);
|
|
}else{
|
|
p2 = rgb(0);
|
|
}
|
|
// top
|
|
if (py + 1 < source->height() - 1){
|
|
p3 = source->texel<rgb>(px, py + 1);
|
|
}
|
|
else{
|
|
p3 = rgb(0);
|
|
}
|
|
// bottom
|
|
if (py - 1 > 0){
|
|
p4 = source->texel<rgb>(px, py - 1);
|
|
}else{
|
|
p4 = rgb(0);
|
|
}
|
|
|
|
|
|
// Calculate the weights for each pixel
|
|
float fx = x - px;
|
|
float fy = y - py;
|
|
float fx1 = 1.0f - fx;
|
|
float fy1 = 1.0f - fy;
|
|
|
|
int w1 = fx1 * fy1 * 256.0f;
|
|
int w2 = fx * fy1 * 256.0f;
|
|
int w3 = fx1 * fy * 256.0f;
|
|
int w4 = fx * fy * 256.0f;
|
|
|
|
// Calculate the weighted sum of pixels (for each color channel)
|
|
int outr = p1.r * w1 + p2.r * w2 + p3.r * w3 + p4.r * w4;
|
|
int outg = p1.g * w1 + p2.g * w2 + p3.g * w3 + p4.g * w4;
|
|
int outb = p1.b * w1 + p2.b * w2 + p3.b * w3 + p4.b * w4;
|
|
//int outa = p1.a * w1 + p2.a * w2 + p3.a * w3 + p4.a * w4;
|
|
|
|
return rgb(outr, outg, outb);
|
|
};
|
|
|
|
|
|
const float w = _texture->width();
|
|
const float h = _texture->height();
|
|
const float wp = _textureProj->width();
|
|
const float hp = _textureProj->height();
|
|
|
|
for (int i = 0; i < w; ++i) {
|
|
for (int j = 0; j < h; ++j) {
|
|
// "Shader code"
|
|
|
|
// Texture coordinates
|
|
float u = float(i) / w;
|
|
float v = float(j) / h;
|
|
|
|
// Psc scaling
|
|
glm::vec2 scaling = data.camera.scaling();
|
|
|
|
// Convert texture coordinates to model coordinates
|
|
float radius[2] = { 0.71492f, 8.f };
|
|
glm::vec4 in_position = uvToModel(u, v, radius, 200);
|
|
bool frontfacing = glm::dot(bsight, glm::vec3((transform*in_position).xyz)) < 0;
|
|
|
|
// Convert psc to meters
|
|
glm::vec4 raw_pos = pscToMeter(in_position, scaling);
|
|
|
|
// Transform model coordinates to world coordinates
|
|
glm::vec4 projected = m * transform * raw_pos;
|
|
|
|
projected.x /= projected.w;
|
|
projected.y /= projected.w;
|
|
|
|
// To do : use bilinear interpolation
|
|
int x, y;
|
|
glm::vec2 uv;
|
|
uv.x = projected.x;
|
|
uv.y = projected.y;
|
|
uvToIndex(uv, wp, hp, x, y);
|
|
|
|
if (frontfacing && inRange(x, 0, wp - 1) && inRange(y, 0, hp - 1)){
|
|
_texture->texel<rgb>(i, j) = bilinear(_texture, _textureProj, uv.x, uv.y, i, j);// _textureProj->texel<rgb>(x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Upload textures
|
|
//_textureProj->uploadTexture();
|
|
_texture->uploadTexture();
|
|
}
|
|
|
|
}
|
|
|
|
void RenderablePlanetProjection::update(const UpdateData& data){
|
|
// set spice-orientation in accordance to timestamp
|
|
_time = data.time;
|
|
openspace::SpiceManager::ref().getPositionTransformMatrix(_target, "GALACTIC", data.time, _stateMatrix);
|
|
openspace::SpiceManager::ref().getPositionTransformMatrix("NH_LORRI", "GALACTIC", data.time, _instrumentMatrix);
|
|
|
|
}
|
|
|
|
void RenderablePlanetProjection::loadTexture()
|
|
{
|
|
delete _texture;
|
|
_texture = nullptr;
|
|
if (_colorTexturePath.value() != "") {
|
|
_texture = ghoul::io::TextureReader::loadTexture(absPath(_colorTexturePath));
|
|
if (_texture) {
|
|
LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
|
|
_texture->uploadTexture();
|
|
|
|
// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
|
|
_texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
|
|
}
|
|
}
|
|
|
|
|
|
delete _textureProj;
|
|
_textureProj = nullptr;
|
|
if (_colorTexturePath.value() != "") {
|
|
_textureProj = ghoul::io::TextureReader::loadTexture(absPath(_projectionTexturePath));
|
|
if (_textureProj) {
|
|
LDEBUG("Loaded texture from '" << absPath(_projectionTexturePath) << "'");
|
|
_textureProj->uploadTexture();
|
|
|
|
// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
|
|
_textureProj->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
|
|
_textureProj->setWrapping(ghoul::opengl::Texture::WrappingMode::ClampToBorder);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace openspace
|