mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-06 11:29:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Feature/matrix maintenance (#2875)

Browse Source 
* Split RenderableSphere class into a local and an online sphere

* Make the video sphere derive from the regular sphere

* Make RenderableTimeVaryingSphere derive from RenderableSphere

* Some clean up

* Add general functions for renderable matrix calculations

* Make RenderableSphere and Plane use them

* Fix an issue with the RenderablePlane shader

* Make one function that returns all three types of render matrices

* Make more Renderables use the general matric calculation function

* Make more Renderable use the general matrix function

* Simplify alternative transforms for matrix calculations

* Small clean-up

* Update RenderableModel (again) to use new transform functions

* Make calc all matrix function to return tuple

* Update some more places
This commit is contained in:
Malin E
2023-09-21 14:22:36 +02:00
committed by GitHub
parent 36ee6840b5
commit ce789fcd22
42 changed files with 270 additions and 317 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/openspace/rendering/renderable.h
+65 -1
View File
@@ -141,8 +141,72 @@ protected:
// An optional renderbin that renderables can use for certain components, in cases
// where all parts of the renderable should not be rendered in the same bin
std::optional<RenderBin> _secondaryRenderBin;
private:
struct AlternativeTransform {
std::optional<glm::dvec3> translation = std::nullopt;
std::optional<glm::dmat3> rotation = std::nullopt;
std::optional<glm::dvec3> scale = std::nullopt;
};
/**
* Calculates the model transformation matrix with the given data and returns it
*
* \param data the RenderData for the object that the model transformation matrix
* should be calculated for
* \param altTransform an object containing alternative transformations to use instead
* of those given in data. The transforms can be translation, rotation and
* scale.
*
* \return the resulting model transformation matrix in double precision
*/
glm::dmat4 calcModelTransform(const RenderData& data,
const AlternativeTransform& altTransform = {}) const;
/**
* Calculates the model view transformation matrix with the given data and returns it
*
* \param data the RenderData for the object that the model view transformation matrix
* should be calculated for
* \param modelTransform an alternative model transformation matrix to use. If not
* provided the function will calculate a new one.
*
* \return the resulting model view transformation matrix in double precision
*/
glm::dmat4 calcModelViewTransform(const RenderData& data,
std::optional<glm::dmat4> modelTransform = std::nullopt) const;
/**
* Calculates the model view projection transformation matrix with the given data and
* returns it
*
* \param data the RenderData for the object that the model view projection
* transformation matrix should be calculated for
* \param modelTransform an alternative model transformation matrix to use. If not
* provided the function will calculate a new one.
*
* \return the resulting model view projection transformation matrix in double
* precision
*/
glm::dmat4 calcModelViewProjectionTransform(const RenderData& data,
std::optional<glm::dmat4> modelTransform = std::nullopt) const;
/**
* Calculates the model, model view, and the model view projection transformation
* matricies with the given data and returns them in a tuple object
*
* \param data the RenderData for the object that the transforms should be
* calculated for
* \param altModelTransform an object containing alternative transformations to use
* instead of those given in data. The transforms can be translation, rotation
* and scale.
*
* \return a tuple object containing the resulting model, model view, and the
* model view projection transformation matrices
*/
std::tuple<glm::dmat4, glm::dmat4, glm::dmat4> calcAllTransforms(
const RenderData& data, const AlternativeTransform& altModelTransform = {}) const;
private:
double _boundingSphere = 0.0;
double _interactionSphere = 0.0;
SceneGraphNode* _parent = nullptr;
modules/base/rendering/grids/renderableboxgrid.cpp
+4 -11
View File
@@ -168,18 +168,11 @@ void RenderableBoxGrid::deinitializeGL() {
void RenderableBoxGrid::render(const RenderData& data, RendererTasks&){
_gridProgram->activate();
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewTransform;
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data);
_gridProgram->setUniform("modelViewTransform", modelViewTransform);
_gridProgram->setUniform("MVPTransform", modelViewProjectionMatrix);
_gridProgram->setUniform("MVPTransform", modelViewProjectionTransform);
_gridProgram->setUniform("opacity", opacity());
_gridProgram->setUniform("gridColor", _color);
@@ -227,7 +220,7 @@ void RenderableBoxGrid::render(const RenderData& data, RendererTasks&){
const glm::vec3 orthoUp = glm::normalize(
glm::vec3(worldToModelTransform * glm::dvec4(up, 0.0))
);
_labels->render(data, modelViewProjectionMatrix, orthoRight, orthoUp);
_labels->render(data, modelViewProjectionTransform, orthoRight, orthoUp);
}
}
modules/base/rendering/grids/renderablegrid.cpp
+3 -6
View File
@@ -245,12 +245,9 @@ void RenderableGrid::deinitializeGL() {
void RenderableGrid::render(const RenderData& data, RendererTasks&){
_gridProgram->activate();
const glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelTransform = calcModelTransform(data);
const glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelMatrix;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewTransform;
@@ -260,7 +257,7 @@ void RenderableGrid::render(const RenderData& data, RendererTasks&){
glm::vec3 right = glm::cross(viewDirection, lookup);
const glm::vec3 up = glm::cross(right, viewDirection);
const glm::dmat4 worldToModelTransform = glm::inverse(modelMatrix);
const glm::mat4 worldToModelTransform = glm::inverse(modelTransform);
glm::vec3 orthoRight = glm::normalize(
glm::vec3(worldToModelTransform * glm::vec4(right, 0.0))
);
modules/base/rendering/grids/renderableradialgrid.cpp
+4 -12
View File
@@ -199,19 +199,11 @@ void RenderableRadialGrid::deinitializeGL() {
void RenderableRadialGrid::render(const RenderData& data, RendererTasks&) {
_gridProgram->activate();
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewTransform =
data.camera.combinedViewMatrix() * modelTransform;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewTransform;
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data);
_gridProgram->setUniform("modelViewTransform", modelViewTransform);
_gridProgram->setUniform("MVPTransform", modelViewProjectionMatrix);
_gridProgram->setUniform("MVPTransform", modelViewProjectionTransform);
_gridProgram->setUniform("opacity", opacity());
_gridProgram->setUniform("gridColor", _color);
@@ -261,7 +253,7 @@ void RenderableRadialGrid::render(const RenderData& data, RendererTasks&) {
const glm::vec3 orthoUp = glm::normalize(
glm::vec3(worldToModelTransform * glm::dvec4(up, 0.0))
);
_labels->render(data, modelViewProjectionMatrix, orthoRight, orthoUp);
_labels->render(data, modelViewProjectionTransform, orthoRight, orthoUp);
}
}
modules/base/rendering/grids/renderablesphericalgrid.cpp
+4 -12
View File
@@ -185,19 +185,11 @@ void RenderableSphericalGrid::deinitializeGL() {
void RenderableSphericalGrid::render(const RenderData& data, RendererTasks&){
_gridProgram->activate();
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewTransform =
data.camera.combinedViewMatrix() * modelTransform;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewTransform;
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data);
_gridProgram->setUniform("modelViewTransform", modelViewTransform);
_gridProgram->setUniform("MVPTransform", modelViewProjectionMatrix);
_gridProgram->setUniform("MVPTransform", modelViewProjectionTransform);
_gridProgram->setUniform("opacity", opacity());
_gridProgram->setUniform("gridColor", _color);
@@ -246,7 +238,7 @@ void RenderableSphericalGrid::render(const RenderData& data, RendererTasks&){
const glm::vec3 orthoUp = glm::normalize(
glm::vec3(worldToModelTransform * glm::dvec4(up, 0.0))
);
_labels->render(data, modelViewProjectionMatrix, orthoRight, orthoUp);
_labels->render(data, modelViewProjectionTransform, orthoRight, orthoUp);
}
}
modules/base/rendering/renderablecartesianaxes.cpp
+1 -7
View File
@@ -181,13 +181,7 @@ void RenderableCartesianAxes::deinitializeGL() {
void RenderableCartesianAxes::render(const RenderData& data, RendererTasks&){
_program->activate();
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
modelTransform;
const glm::dmat4 modelViewTransform = calcModelViewTransform(data);
_program->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
_program->setUniform("projectionTransform", data.camera.projectionMatrix());
modules/base/rendering/renderabledisc.cpp
+3 -7
View File
@@ -148,16 +148,12 @@ void RenderableDisc::deinitializeGL() {
void RenderableDisc::render(const RenderData& data, RendererTasks&) {
_shader->activate();
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
const glm::dmat4 modelViewProjectionTransform =
calcModelViewProjectionTransform(data);
_shader->setUniform(
_uniformCache.modelViewProjection,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(modelViewProjectionTransform)
);
_shader->setUniform(_uniformCache.width, _width);
_shader->setUniform(_uniformCache.opacity, opacity());
modules/base/rendering/renderablelabel.cpp
+3 -5
View File
@@ -412,10 +412,8 @@ void RenderableLabel::render(const RenderData& data, RendererTasks&) {
}
glm::dmat4 modelMatrix(1.0);
glm::dmat4 modelViewMatrix = data.camera.combinedViewMatrix() * modelMatrix;
glm::dmat4 projectionMatrix = glm::dmat4(data.camera.projectionMatrix());
glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
const glm::dmat4 modelViewProjectionTransform =
calcModelViewProjectionTransform(data, modelMatrix);
glm::dvec3 cameraViewDirectionWorld = -data.camera.viewDirectionWorldSpace();
glm::dvec3 cameraUpDirectionWorld = data.camera.lookUpVectorWorldSpace();
@@ -432,7 +430,7 @@ void RenderableLabel::render(const RenderData& data, RendererTasks&) {
}
glm::dvec3 orthoUp = glm::normalize(glm::cross(cameraViewDirectionWorld, orthoRight));
renderLabels(data, modelViewProjectionMatrix, orthoRight, orthoUp, fadeInVariable);
renderLabels(data, modelViewProjectionTransform, orthoRight, orthoUp, fadeInVariable);
global::renderEngine->openglStateCache().resetBlendState();
global::renderEngine->openglStateCache().resetDepthState();
modules/base/rendering/renderablemodel.cpp
+4 -8
View File
@@ -790,14 +790,10 @@ void RenderableModel::render(const RenderData& data, RendererTasks&) {
_program->activate();
// Model transform and view transform needs to be in double precision
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), glm::dvec3(_pivot.value())) *
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
glm::scale(_modelTransform.value(), glm::dvec3(_modelScale));
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
modelTransform;
glm::dmat4 modelTransform = calcModelTransform(data);
modelTransform = glm::translate(modelTransform, glm::dvec3(_pivot.value()));
modelTransform *= glm::scale(_modelTransform.value(), glm::dvec3(_modelScale));
const glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
int nLightSources = 0;
_lightIntensitiesBuffer.resize(_lightSources.size());
modules/base/rendering/renderablenodeline.cpp
+3 -7
View File
@@ -386,13 +386,9 @@ void RenderableNodeLine::render(const RenderData& data, RendererTasks&) {
);
}
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
modelTransform * anchorTranslation;
const glm::dmat4 modelTransform = calcModelTransform(data);
const glm::dmat4 modelViewTransform =
calcModelViewTransform(data, modelTransform) * anchorTranslation;
_program->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
_program->setUniform("projectionTransform", data.camera.projectionMatrix());
modules/base/rendering/renderableplane.cpp
+19 -17
View File
@@ -29,14 +29,11 @@
#include <openspace/documentation/verifier.h>
#include <openspace/engine/globals.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/scene/scenegraphnode.h>
#include <openspace/util/updatestructures.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/io/texture/texturereader.h>
#include <ghoul/misc/defer.h>
#include <ghoul/misc/profiling.h>
#include <ghoul/opengl/programobject.h>
#include <ghoul/opengl/texture.h>
#include <ghoul/opengl/textureunit.h>
#include <ghoul/glm.h>
#include <glm/gtx/string_cast.hpp>
@@ -44,6 +41,11 @@
#include <variant>
namespace {
constexpr std::array<const char*, 6> UniformNames = {
"modelViewProjection", "modelViewTransform", "colorTexture", "opacity",
"mirrorBackside", "multiplyColor"
};
enum BlendMode {
Normal = 0,
Additive
@@ -213,6 +215,8 @@ void RenderablePlane::initializeGL() {
);
}
);
ghoul::opengl::updateUniformLocations(*_shader, _uniformCache, UniformNames);
}
void RenderablePlane::deinitializeGL() {
@@ -237,9 +241,9 @@ void RenderablePlane::render(const RenderData& data, RendererTasks&) {
ZoneScoped;
_shader->activate();
_shader->setUniform("opacity", opacity());
_shader->setUniform(_uniformCache.opacity, opacity());
_shader->setUniform("mirrorBackside", _mirrorBackside);
_shader->setUniform(_uniformCache.mirrorBackside, _mirrorBackside);
glm::dvec3 objectPositionWorld = glm::dvec3(
glm::translate(
@@ -262,26 +266,23 @@ void RenderablePlane::render(const RenderData& data, RendererTasks&) {
cameraOrientedRotation :
glm::dmat4(data.modelTransform.rotation);
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
rotationTransform *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewTransform =
data.camera.combinedViewMatrix() * modelTransform;
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data, { .rotation = rotationTransform });
_shader->setUniform("modelViewProjectionTransform",
data.camera.projectionMatrix() * glm::mat4(modelViewTransform));
_shader->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
_shader->setUniform(
_uniformCache.modelViewProjection,
glm::mat4(modelViewProjectionTransform)
);
_shader->setUniform(_uniformCache.modelViewTransform, glm::mat4(modelViewTransform));
ghoul::opengl::TextureUnit unit;
unit.activate();
bindTexture();
defer { unbindTexture(); };
_shader->setUniform("texture1", unit);
_shader->setUniform(_uniformCache.colorTexture, unit);
_shader->setUniform("multiplyColor", _multiplyColor);
_shader->setUniform(_uniformCache.multiplyColor, _multiplyColor);
bool additiveBlending = (_blendMode == static_cast<int>(BlendMode::Additive));
if (additiveBlending) {
@@ -311,6 +312,7 @@ void RenderablePlane::update(const UpdateData&) {
if (_shader->isDirty()) {
_shader->rebuildFromFile();
ghoul::opengl::updateUniformLocations(*_shader, _uniformCache, UniformNames);
}
if (_planeIsDirty) {
modules/base/rendering/renderableplane.h
+4 -2
View File
@@ -28,11 +28,10 @@
#include <openspace/rendering/renderable.h>
#include <openspace/properties/optionproperty.h>
#include <openspace/properties/stringproperty.h>
#include <openspace/properties/scalar/boolproperty.h>
#include <openspace/properties/vector/vec2property.h>
#include <openspace/properties/vector/vec3property.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <ghoul/opengl/uniformcache.h>
namespace ghoul::filesystem { class File; }
@@ -83,6 +82,9 @@ protected:
private:
bool _planeIsDirty = false;
UniformCache(modelViewProjection, modelViewTransform, colorTexture, opacity,
mirrorBackside, multiplyColor) _uniformCache;
};
} // namespace openspace
modules/base/rendering/renderableprism.cpp
+6 -9
View File
@@ -328,17 +328,14 @@ void RenderablePrism::render(const RenderData& data, RendererTasks&) {
_shader->activate();
// Model transform and view transform needs to be in double precision
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::mat4 modelViewProjectionTransform =
data.camera.projectionMatrix() *
glm::mat4(data.camera.combinedViewMatrix() * modelTransform);
const glm::dmat4 modelViewProjectionTransform =
calcModelViewProjectionTransform(data);
// Uniforms
_shader->setUniform(_uniformCache.modelViewProjection, modelViewProjectionTransform);
_shader->setUniform(
_uniformCache.modelViewProjection,
glm::mat4(modelViewProjectionTransform)
);
_shader->setUniform(_uniformCache.color, glm::vec4(_lineColor.value(), opacity()));
// Render
modules/base/rendering/renderablesphere.cpp
+4 -13
View File
@@ -235,26 +235,17 @@ void RenderableSphere::deinitializeGL() {
void RenderableSphere::render(const RenderData& data, RendererTasks&) {
Orientation orientation = static_cast<Orientation>(_orientation.value());
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat3 modelRotation =
glm::dmat3(data.modelTransform.rotation);
// Activate shader
using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
_shader->activate();
_shader->setIgnoreUniformLocationError(IgnoreError::Yes);
glm::mat4 modelViewProjection = data.camera.projectionMatrix() *
glm::mat4(data.camera.combinedViewMatrix() * modelTransform);
_shader->setUniform(_uniformCache.modelViewProjection, modelViewProjection);
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data);
glm::dmat3 modelRotation = glm::dmat3(data.modelTransform.rotation);
const glm::dmat4 modelViewTransform =
data.camera.combinedViewMatrix() * modelTransform;
_shader->setUniform(_uniformCache.modelViewTransform, glm::mat4(modelViewTransform));
_shader->setUniform(_uniformCache.modelViewProjection, glm::mat4(modelViewProjectionTransform));
glm::mat3 modelViewRotation = glm::mat3(
glm::dmat3(data.camera.viewRotationMatrix()) * modelRotation
modules/base/rendering/renderabletrail.cpp
+3 -5
View File
@@ -291,9 +291,10 @@ void RenderableTrail::internalRender(bool renderLines, bool renderPoints,
// We pass in the model view transformation matrix as double in order to maintain
// high precision for vertices; especially for the trails, a high vertex precision
// is necessary as they are usually far away from their reference
glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
_programObject->setUniform(
_uniformCache.modelView,
data.camera.combinedViewMatrix() * modelTransform * info._localTransform
modelViewTransform * info._localTransform
);
const int sorting = [](RenderInformation::VertexSorting s) {
@@ -391,10 +392,7 @@ void RenderableTrail::render(const RenderData& data, RendererTasks&) {
_programObject->activate();
_programObject->setUniform(_uniformCache.opacity, opacity());
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelTransform = calcModelTransform(data);
_programObject->setUniform(_uniformCache.projection, data.camera.projectionMatrix());
modules/base/shaders/plane_fs.glsl
+4 -9
View File
@@ -29,8 +29,7 @@ in vec3 vs_gNormal;
in float vs_screenSpaceDepth;
in vec2 vs_st;
uniform sampler2D texture1;
uniform bool additiveBlending;
uniform sampler2D colorTexture;
uniform float opacity = 1.0;
uniform bool mirrorBackside = true;
uniform vec3 multiplyColor;
@@ -39,14 +38,14 @@ uniform vec3 multiplyColor;
Fragment getFragment() {
Fragment frag;
if (gl_FrontFacing) {
frag.color = texture(texture1, vs_st);
frag.color = texture(colorTexture, vs_st);
}
else {
if (mirrorBackside) {
frag.color = texture(texture1, vec2(1.0 - vs_st.s, vs_st.t));
frag.color = texture(colorTexture, vec2(1.0 - vs_st.s, vs_st.t));
}
else {
frag.color = texture(texture1, vs_st);
frag.color = texture(colorTexture, vs_st);
}
}
@@ -59,10 +58,6 @@ Fragment getFragment() {
frag.depth = vs_screenSpaceDepth;
if (additiveBlending) {
frag.blend = BLEND_MODE_ADDITIVE;
}
// G-Buffer
frag.gPosition = vs_gPosition;
frag.gNormal = vec4(vs_gNormal, 1.0);
modules/base/shaders/plane_vs.glsl
+2 -2
View File
@@ -34,13 +34,13 @@ out vec3 vs_gNormal;
out float vs_screenSpaceDepth;
out vec2 vs_st;
uniform mat4 modelViewProjectionTransform;
uniform mat4 modelViewProjection;
uniform mat4 modelViewTransform;
void main() {
vec4 position = vec4(in_position.xyz * pow(10, in_position.w), 1);
vec4 positionClipSpace = modelViewProjectionTransform * position;
vec4 positionClipSpace = modelViewProjection * position;
vec4 positionScreenSpace = z_normalization(positionClipSpace);
gl_Position = positionScreenSpace;
modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+3 -9
View File
@@ -702,15 +702,9 @@ void RenderableBillboardsCloud::render(const RenderData& data, RendererTasks&) {
}
}
glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewMatrix = data.camera.combinedViewMatrix() * modelMatrix;
glm::dmat4 projectionMatrix = glm::dmat4(data.camera.projectionMatrix());
glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
glm::dmat4 modelMatrix = calcModelTransform(data);
glm::dmat4 modelViewProjectionMatrix =
calcModelViewProjectionTransform(data, modelMatrix);
glm::dvec3 cameraViewDirectionWorld = -data.camera.viewDirectionWorldSpace();
glm::dvec3 cameraUpDirectionWorld = data.camera.lookUpVectorWorldSpace();
modules/digitaluniverse/rendering/renderableplanescloud.cpp
+14 -16
View File
@@ -376,8 +376,8 @@ void RenderablePlanesCloud::deinitializeGL() {
}
void RenderablePlanesCloud::renderPlanes(const RenderData&,
const glm::dmat4& modelViewMatrix,
const glm::dmat4& projectionMatrix,
const glm::dmat4& modelViewTransform,
const glm::dmat4& projectionTransform,
const float fadeInVariable)
{
glEnablei(GL_BLEND, 0);
@@ -387,10 +387,11 @@ void RenderablePlanesCloud::renderPlanes(const RenderData&,
_program->activate();
glm::dmat4 modelViewProjectionMatrix = glm::dmat4(projectionMatrix) * modelViewMatrix;
glm::dmat4 modelViewProjectionTransform =
glm::dmat4(projectionTransform) * modelViewTransform;
_program->setUniform(
_uniformCache.modelViewProjectionTransform,
modelViewProjectionMatrix
modelViewProjectionTransform
);
_program->setUniform(_uniformCache.alphaValue, opacity());
_program->setUniform(_uniformCache.fadeInValue, fadeInVariable);
@@ -448,24 +449,21 @@ void RenderablePlanesCloud::render(const RenderData& data, RendererTasks&) {
}
}
const glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewMatrix = data.camera.combinedViewMatrix() * modelMatrix;
const glm::mat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelTransform = calcModelTransform(data);
const glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
const glm::mat4 projectionTransform = data.camera.projectionMatrix();
if (_hasSpeckFile) {
renderPlanes(data, modelViewMatrix, projectionMatrix, fadeInVariable);
renderPlanes(data, modelViewTransform, projectionTransform, fadeInVariable);
}
if (_hasLabels) {
const glm::dmat4 mvpMatrix = glm::dmat4(projectionMatrix) * modelViewMatrix;
const glm::dmat4 modelViewProjectionTransform =
glm::dmat4(projectionTransform) * modelViewTransform;
const glm::dmat4 invMVPParts = glm::inverse(modelMatrix) *
const glm::dmat4 invMVPParts = glm::inverse(modelTransform) *
glm::inverse(data.camera.combinedViewMatrix()) *
glm::inverse(glm::dmat4(projectionMatrix));
glm::inverse(glm::dmat4(projectionTransform));
const glm::dvec3 orthoRight = glm::normalize(
glm::dvec3(invMVPParts * glm::dvec4(1.0, 0.0, 0.0, 0.0))
);
@@ -473,7 +471,7 @@ void RenderablePlanesCloud::render(const RenderData& data, RendererTasks&) {
glm::dvec3(invMVPParts * glm::dvec4(0.0, 1.0, 0.0, 0.0))
);
_labels->render(data, mvpMatrix, orthoRight, orthoUp, fadeInVariable);
_labels->render(data, modelViewProjectionTransform, orthoRight, orthoUp, fadeInVariable);
}
}
modules/digitaluniverse/rendering/renderableplanescloud.h
+2 -2
View File
@@ -80,8 +80,8 @@ private:
void deleteDataGPUAndCPU();
void createPlanes();
void renderPlanes(const RenderData& data, const glm::dmat4& modelViewMatrix,
const glm::dmat4& projectionMatrix, float fadeInVariable);
void renderPlanes(const RenderData& data, const glm::dmat4& modelViewTransform,
const glm::dmat4& projectionTransform, float fadeInVariable);
void loadTextures();
modules/digitaluniverse/rendering/renderablepoints.cpp
+1 -2
View File
@@ -238,8 +238,7 @@ void RenderablePoints::render(const RenderData& data, RendererTasks&) {
_program->setUniform(
_uniformCache.modelViewProjectionTransform,
glm::dmat4(data.camera.projectionMatrix()) *
data.camera.combinedViewMatrix() * glm::dmat4(1.0)
calcModelViewProjectionTransform(data, glm::dmat4(1.0))
);
_program->setUniform(_uniformCache.color, _pointColor);
modules/exoplanets/rendering/renderableorbitdisc.cpp
+1 -8
View File
@@ -185,16 +185,9 @@ void RenderableOrbitDisc::deinitializeGL() {
void RenderableOrbitDisc::render(const RenderData& data, RendererTasks&) {
_shader->activate();
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
_shader->setUniform(
_uniformCache.modelViewProjection,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(calcModelViewProjectionTransform(data))
);
_shader->setUniform(_uniformCache.offset, _offset);
_shader->setUniform(_uniformCache.opacity, opacity());
modules/gaia/rendering/renderablegaiastars.cpp
+2 -4
View File
@@ -962,15 +962,13 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
GLint defaultFbo;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo);
glm::dmat4 model = glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 model = calcModelTransform(data);
float viewScaling = data.camera.scaling();
glm::dmat4 view = data.camera.combinedViewMatrix();
glm::dmat4 projection = data.camera.projectionMatrix();
glm::dmat4 modelViewProjMat = projection * view * model;
glm::dmat4 modelViewProjMat = calcModelViewProjectionTransform(data, model);
glm::vec2 screenSize = glm::vec2(global::renderEngine->renderingResolution());
// Wait until camera has stabilized before we traverse the Octree/stream from files.
modules/galaxy/rendering/renderablegalaxy.cpp
+12 -18
View File
@@ -629,17 +629,14 @@ void RenderableGalaxy::renderPoints(const RenderData& data) {
glm::rotate(glm::dmat4(1.0), 4.45741, glm::dvec3(0.0, 0.0, 1.0)
);
glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) * rotMatrix *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
AlternativeTransform altTransform;
altTransform.rotation = glm::dmat4(data.modelTransform.rotation) * rotMatrix;
glm::dmat4 modelTransform = calcModelTransform(data, altTransform);
glm::dmat4 projectionMatrix = glm::dmat4(data.camera.projectionMatrix());
glm::dmat4 cameraViewProjectionMatrix =
glm::dmat4(data.camera.projectionMatrix()) * data.camera.combinedViewMatrix();
glm::dmat4 cameraViewProjectionMatrix = projectionMatrix *
data.camera.combinedViewMatrix();
_pointsProgram->setUniform(_uniformCachePoints.modelMatrix, modelMatrix);
_pointsProgram->setUniform(_uniformCachePoints.modelMatrix, modelTransform);
_pointsProgram->setUniform(
_uniformCachePoints.cameraViewProjectionMatrix,
cameraViewProjectionMatrix
@@ -682,17 +679,14 @@ void RenderableGalaxy::renderBillboards(const RenderData& data) {
glm::rotate(glm::dmat4(1.0), 4.45741, glm::dvec3(0.0, 0.0, 1.0)
);
glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) * rotMatrix *
glm::scale(glm::dmat4(1.0), data.modelTransform.scale);
AlternativeTransform altTransform;
altTransform.rotation = glm::dmat4(data.modelTransform.rotation) * rotMatrix;
glm::dmat4 modelTransform = calcModelTransform(data, altTransform);
glm::dmat4 projectionMatrix = glm::dmat4(data.camera.projectionMatrix());
glm::dmat4 cameraViewProjectionMatrix =
glm::dmat4(data.camera.projectionMatrix()) * data.camera.combinedViewMatrix();
glm::dmat4 cameraViewProjectionMatrix = projectionMatrix *
data.camera.combinedViewMatrix();
_billboardsProgram->setUniform(_uniformCacheBillboards.modelMatrix, modelMatrix);
_billboardsProgram->setUniform(_uniformCacheBillboards.modelMatrix, modelTransform);
_billboardsProgram->setUniform(
_uniformCacheBillboards.cameraViewProjectionMatrix,
cameraViewProjectionMatrix
modules/skybrowser/src/renderableskytarget.cpp
+4 -12
View File
@@ -241,23 +241,15 @@ void RenderableSkyTarget::render(const RenderData& data, RendererTasks&) {
cameraOrientedRotation :
glm::dmat4(data.modelTransform.rotation);
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
rotationTransform *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
glm::dmat4(1.0);
const glm::dmat4 modelViewTransform =
data.camera.combinedViewMatrix() * modelTransform;
auto [modelTransform, modelViewTransform, modelViewProjectionTransform] =
calcAllTransforms(data, { .rotation = rotationTransform });
_shader->setUniform(
"modelViewProjectionTransform",
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(modelViewProjectionTransform)
);
_shader->setUniform(
"modelViewTransform",
glm::mat4(data.camera.combinedViewMatrix() * glm::dmat4(modelViewTransform))
);
_shader->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
_shader->setUniform("multiplyColor", _multiplyColor);
modules/space/rendering/renderableconstellationbounds.cpp
+1 -5
View File
@@ -186,11 +186,7 @@ void RenderableConstellationBounds::render(const RenderData& data, RendererTasks
_program->setUniform("camrot", glm::mat4(data.camera.viewRotationMatrix()));
_program->setUniform("scaling", glm::vec2(1.f, 0.f));
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelTransform = calcModelTransform(data);
_program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
_program->setUniform("ModelTransform", glm::mat4(modelTransform));
modules/space/rendering/renderableconstellationlines.cpp
+3 -8
View File
@@ -283,16 +283,11 @@ void RenderableConstellationLines::renderConstellations(const RenderData&,
}
void RenderableConstellationLines::render(const RenderData& data, RendererTasks& tasks) {
const glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewMatrix = data.camera.combinedViewMatrix() * modelMatrix;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewTransform = calcModelViewTransform(data);
const glm::dmat4 projectionTransform = data.camera.projectionMatrix();
if (_drawElements) {
renderConstellations(data, modelViewMatrix, projectionMatrix);
renderConstellations(data, modelViewTransform, projectionTransform);
}
RenderableConstellationsBase::render(data, tasks);
modules/space/rendering/renderableconstellationsbase.cpp
+5 -10
View File
@@ -214,21 +214,16 @@ void RenderableConstellationsBase::render(const RenderData& data, RendererTasks&
return;
}
const glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelViewMatrix = data.camera.combinedViewMatrix() * modelMatrix;
const glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
const glm::dmat4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
const glm::dmat4 modelTransform = calcModelTransform(data);
const glm::dmat4 modelViewProjectionTransform =
calcModelViewProjectionTransform(data, modelTransform);
const glm::vec3 lookup = data.camera.lookUpVectorWorldSpace();
const glm::vec3 viewDirection = data.camera.viewDirectionWorldSpace();
glm::vec3 right = glm::cross(viewDirection, lookup);
const glm::vec3 up = glm::cross(right, viewDirection);
const glm::dmat4 worldToModelTransform = glm::inverse(modelMatrix);
const glm::dmat4 worldToModelTransform = glm::inverse(modelTransform);
glm::vec3 orthoRight = glm::normalize(
glm::vec3(worldToModelTransform * glm::vec4(right, 0.f))
);
@@ -244,7 +239,7 @@ void RenderableConstellationsBase::render(const RenderData& data, RendererTasks&
const glm::vec3 orthoUp = glm::normalize(
glm::vec3(worldToModelTransform * glm::dvec4(up, 0.f))
);
_labels->render(data, modelViewProjectionMatrix, orthoRight, orthoUp);
_labels->render(data, modelViewProjectionTransform, orthoRight, orthoUp);
}
} // namespace openspace
modules/space/rendering/renderableeclipsecone.cpp
+3 -6
View File
@@ -277,15 +277,12 @@ void RenderableEclipseCone::render(const RenderData& data, RendererTasks&) {
_shader->activate();
// Model transform and view transform needs to be in double precision
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
const glm::dmat4 modelViewProjectionTransform =
calcModelViewProjectionTransform(data);
_shader->setUniform(
_uniformCache.modelViewProjectionTransform,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(modelViewProjectionTransform)
);
_shader->setUniform(_uniformCache.opacity, opacity());
modules/space/rendering/renderablefluxnodes.cpp
+11 -8
View File
@@ -676,21 +676,24 @@ void RenderableFluxNodes::render(const RenderData& data, RendererTasks&) {
_shaderProgram->activate();
// Calculate Model View MatrixProjection
const glm::dmat4 rotMat = glm::dmat4(data.modelTransform.rotation);
const glm::dmat4 modelMat =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
rotMat * glm::scale(glm::dmat4(1.0), data.modelTransform.scale);
const glm::dmat4 modelViewMat = data.camera.combinedViewMatrix() * modelMat;
const glm::dmat4 rotationTransform = glm::dmat4(data.modelTransform.rotation);
const glm::dmat4 modelTransform = calcModelTransform(
data,
{ .rotation = rotationTransform }
);
_shaderProgram->setUniform("modelViewProjection",
data.camera.sgctInternal.projectionMatrix() * glm::mat4(modelViewMat)
_shaderProgram->setUniform(
"modelViewProjection",
glm::mat4(calcModelViewProjectionTransform(data, modelTransform))
);
SceneGraphNode* earthNode = sceneGraphNode("Earth");
if (!earthNode) {
LWARNING("Could not find scene graph node 'Earth'");
}
glm::vec3 earthPos = earthNode->worldPosition() * data.modelTransform.rotation;
glm::vec3 earthPos = glm::vec3(
earthNode->worldPosition() * data.modelTransform.rotation
);
_shaderProgram->setUniform(_uniformCache.streamColor, _streamColor);
_shaderProgram->setUniform(_uniformCache.nodeSize, _nodeSize);
modules/space/rendering/renderablehabitablezone.cpp
+1 -8
View File
@@ -146,16 +146,9 @@ RenderableHabitableZone::RenderableHabitableZone(const ghoul::Dictionary& dictio
void RenderableHabitableZone::render(const RenderData& data, RendererTasks&) {
_shader->activate();
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
_shader->setUniform(
_uniformCache.modelViewProjection,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(calcModelViewProjectionTransform(data))
);
_shader->setUniform(_uniformCache.width, _width);
_shader->setUniform(_uniformCache.opacity, opacity());
modules/space/rendering/renderableorbitalkepler.cpp
+1 -9
View File
@@ -271,15 +271,7 @@ void RenderableOrbitalKepler::render(const RenderData& data, RendererTasks&) {
_programObject->setUniform(_uniformCache.opacity, opacity());
_programObject->setUniform(_uniformCache.inGameTime, data.time.j2000Seconds());
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
_programObject->setUniform(
_uniformCache.modelView,
data.camera.combinedViewMatrix() * modelTransform
);
_programObject->setUniform(_uniformCache.modelView, calcModelViewTransform(data));
// Because we want the property to work similar to the planet trails
const float fade = pow(_appearance.lineFade.maxValue() - _appearance.lineFade, 2.f);
modules/space/rendering/renderablerings.cpp
+1 -8
View File
@@ -184,16 +184,9 @@ void RenderableRings::deinitializeGL() {
void RenderableRings::render(const RenderData& data, RendererTasks&) {
_shader->activate();
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
_shader->setUniform(
_uniformCache.modelViewProjection,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(calcModelViewProjectionTransform(data))
);
_shader->setUniform(_uniformCache.textureOffset, _offset);
_shader->setUniform(_uniformCache.colorFilterValue, _colorFilter);
modules/space/rendering/renderablestars.cpp
+1 -4
View File
@@ -1047,10 +1047,7 @@ void RenderableStars::render(const RenderData& data, RendererTasks&) {
glm::dvec3 cameraUp = data.camera.lookUpVectorWorldSpace();
_program->setUniform(_uniformCache.cameraUp, cameraUp);
glm::dmat4 modelMatrix =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), data.modelTransform.scale);
glm::dmat4 modelMatrix = calcModelTransform(data);
glm::dmat4 projectionMatrix = glm::dmat4(data.camera.projectionMatrix());
modules/space/rendering/renderabletravelspeed.cpp
+4 -9
View File
@@ -299,15 +299,10 @@ void RenderableTravelSpeed::render(const RenderData& data, RendererTasks&) {
}
_shaderProgram->activate();
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), data.modelTransform.scale);
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
modelTransform;
_shaderProgram->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
_shaderProgram->setUniform(
"modelViewTransform",
glm::mat4(calcModelViewTransform(data))
);
_shaderProgram->setUniform("projectionTransform", data.camera.projectionMatrix());
#ifndef __APPLE__
modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp
+1 -7
View File
@@ -142,13 +142,7 @@ void RenderableCrawlingLine::render(const RenderData& data, RendererTasks&) {
_program->activate();
_frameCounter++;
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewProjectionTransform = data.camera.projectionMatrix() *
glm::mat4(data.camera.combinedViewMatrix() * modelTransform);
glm::dmat4 modelViewProjectionTransform = calcModelViewProjectionTransform(data);
_program->setUniform("modelViewProjection", modelViewProjectionTransform);
modules/spacecraftinstruments/rendering/renderablefov.cpp
+1 -7
View File
@@ -758,14 +758,8 @@ void RenderableFov::render(const RenderData& data, RendererTasks&) {
_program->activate();
// Model transform and view transform needs to be in double precision
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::mat4 modelViewProjectionTransform =
data.camera.projectionMatrix() *
glm::mat4(data.camera.combinedViewMatrix() * modelTransform);
calcModelViewProjectionTransform(data);
_program->setUniform(_uniformCache.modelViewProjection, modelViewProjectionTransform);
modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
+4 -6
View File
@@ -262,12 +262,10 @@ void RenderableModelProjection::render(const RenderData& data, RendererTasks&) {
const glm::vec3 bodyPos = data.modelTransform.translation;
// Model transform and view transform needs to be in double precision
const glm::dmat4 transform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
glm::scale(glm::dmat4(1.0), glm::dvec3(_modelScale));
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * transform;
const glm::dmat4 modelTransform = glm::scale(
calcModelTransform(data), glm::dvec3(_modelScale)
);
const glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
// malej 2023-FEB-23: The light sources should probably not be hard coded
const glm::vec3 directionToSun = glm::normalize(_sunPosition - bodyPos);
modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
+7 -3
View File
@@ -125,10 +125,14 @@ void RenderablePlaneProjection::render(const RenderData& data, RendererTasks&) {
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(_stateMatrix);
glm::mat4 mvp = data.camera.projectionMatrix() *
glm::mat4(data.camera.combinedViewMatrix() * modelTransform);
_shader->setUniform("modelViewProjectionTransform", mvp);
const glm::dmat4 ModelViewProjectionTransform =
calcModelViewProjectionTransform(data, modelTransform);
_shader->setUniform(
"modelViewProjectionTransform",
glm::mat4(ModelViewProjectionTransform)
);
ghoul::opengl::TextureUnit unit;
unit.activate();
modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
+3 -8
View File
@@ -522,17 +522,12 @@ void RenderablePlanetProjection::render(const RenderData& data, RendererTasks&)
_programObject->setUniform(_mainUniformCache.sunPos, static_cast<glm::vec3>(sunPos));
// Model transform and view transform needs to be in double precision
glm::dmat4 trans =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
const glm::dmat4 modelTransform = calcModelTransform(data);
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * trans;
_programObject->setUniform(_mainUniformCache.modelTransform, glm::mat4(trans));
_programObject->setUniform(_mainUniformCache.modelTransform, glm::mat4(modelTransform));
_programObject->setUniform(
_mainUniformCache.modelViewProjectionTransform,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(calcModelViewProjectionTransform(data, modelTransform))
);
_programObject->setUniform(_mainUniformCache.hasBaseMap, _baseTexture != nullptr);
modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
+1 -7
View File
@@ -260,15 +260,9 @@ void RenderableShadowCylinder::render(const RenderData& data, RendererTasks&) {
_shader->activate();
// Model transform and view transform needs to be in double precision
const glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
_shader->setUniform(
_uniformCache.modelViewProjectionTransform,
data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
glm::mat4(calcModelViewProjectionTransform(data))
);
_shader->setUniform(_uniformCache.shadowColor, _shadowColor);
src/rendering/renderable.cpp
+47
View File
@@ -337,4 +337,51 @@ bool Renderable::hasOverrideRenderBin() const noexcept {
return _hasOverrideRenderBin;
}
glm::dmat4 Renderable::calcModelTransform(const RenderData& data,
const AlternativeTransform& altTransform) const
{
glm::dvec3 translation =
altTransform.translation.value_or(data.modelTransform.translation);
glm::dmat3 rotation = altTransform.rotation.value_or(data.modelTransform.rotation);
glm::dvec3 scale = altTransform.scale.value_or(data.modelTransform.scale);
return glm::translate(glm::dmat4(1.0), translation) *
glm::dmat4(rotation) *
glm::scale(glm::dmat4(1.0), scale);
}
glm::dmat4 Renderable::calcModelViewTransform(const RenderData& data,
std::optional<glm::dmat4> modelTransform) const
{
glm::dmat4 modelMatrix = modelTransform.value_or(calcModelTransform(data));
return data.camera.combinedViewMatrix() * modelMatrix;
}
glm::dmat4 Renderable::calcModelViewProjectionTransform(const RenderData& data,
std::optional<glm::dmat4> modelTransform) const
{
glm::dmat4 modelMatrix = modelTransform.value_or(calcModelTransform(data));
glm::dmat4 viewMatrix = data.camera.combinedViewMatrix();
glm::dmat4 projectionMatrix = data.camera.projectionMatrix();
return glm::dmat4(projectionMatrix * viewMatrix * modelMatrix);
}
std::tuple<glm::dmat4, glm::dmat4, glm::dmat4> Renderable::calcAllTransforms(
const RenderData& data,
const AlternativeTransform& altModelTransform) const
{
glm::dmat4 modelTransform = calcModelTransform(data, altModelTransform);
glm::dmat4 modelViewTransform = calcModelViewTransform(data, modelTransform);
glm::dmat4 modelViewProjectionTransform = calcModelViewProjectionTransform(
data,
modelTransform
);
return {
modelTransform,
modelViewTransform,
modelViewProjectionTransform
};
}
} // namespace openspace