diff --git a/include/openspace/rendering/renderable.h b/include/openspace/rendering/renderable.h
index 38f94f62a3..71bd6f3c2e 100644
--- a/include/openspace/rendering/renderable.h
+++ b/include/openspace/rendering/renderable.h
@@ -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;
diff --git a/modules/base/rendering/grids/renderableboxgrid.cpp b/modules/base/rendering/grids/renderableboxgrid.cpp
index 2a54b6d064..7af3822024 100644
--- a/modules/base/rendering/grids/renderableboxgrid.cpp
+++ b/modules/base/rendering/grids/renderableboxgrid.cpp
@@ -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);
     }
 }
 
diff --git a/modules/base/rendering/grids/renderablegrid.cpp b/modules/base/rendering/grids/renderablegrid.cpp
index a855a2b441..ceddd1bd0f 100644
--- a/modules/base/rendering/grids/renderablegrid.cpp
+++ b/modules/base/rendering/grids/renderablegrid.cpp
@@ -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))
     );
diff --git a/modules/base/rendering/grids/renderableradialgrid.cpp b/modules/base/rendering/grids/renderableradialgrid.cpp
index fa1f2c4d5e..4f528fd15b 100644
--- a/modules/base/rendering/grids/renderableradialgrid.cpp
+++ b/modules/base/rendering/grids/renderableradialgrid.cpp
@@ -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);
     }
 }
 
diff --git a/modules/base/rendering/grids/renderablesphericalgrid.cpp b/modules/base/rendering/grids/renderablesphericalgrid.cpp
index bc261d6078..b196d5d460 100644
--- a/modules/base/rendering/grids/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/grids/renderablesphericalgrid.cpp
@@ -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);
     }
 }
 
diff --git a/modules/base/rendering/renderablecartesianaxes.cpp b/modules/base/rendering/renderablecartesianaxes.cpp
index e93e18d107..841a6b032e 100644
--- a/modules/base/rendering/renderablecartesianaxes.cpp
+++ b/modules/base/rendering/renderablecartesianaxes.cpp
@@ -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());
diff --git a/modules/base/rendering/renderabledisc.cpp b/modules/base/rendering/renderabledisc.cpp
index f09ae1dbfd..2cb9431ab8 100644
--- a/modules/base/rendering/renderabledisc.cpp
+++ b/modules/base/rendering/renderabledisc.cpp
@@ -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());
diff --git a/modules/base/rendering/renderablelabel.cpp b/modules/base/rendering/renderablelabel.cpp
index f11f5bd89f..54e1bbba80 100644
--- a/modules/base/rendering/renderablelabel.cpp
+++ b/modules/base/rendering/renderablelabel.cpp
@@ -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();
diff --git a/modules/base/rendering/renderablemodel.cpp b/modules/base/rendering/renderablemodel.cpp
index 5b7f5db8aa..e9d9d0d1a9 100644
--- a/modules/base/rendering/renderablemodel.cpp
+++ b/modules/base/rendering/renderablemodel.cpp
@@ -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());
diff --git a/modules/base/rendering/renderablenodeline.cpp b/modules/base/rendering/renderablenodeline.cpp
index a4b922c3f4..b15644c5fa 100644
--- a/modules/base/rendering/renderablenodeline.cpp
+++ b/modules/base/rendering/renderablenodeline.cpp
@@ -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());
diff --git a/modules/base/rendering/renderableplane.cpp b/modules/base/rendering/renderableplane.cpp
index 31de178d52..37e688e08f 100644
--- a/modules/base/rendering/renderableplane.cpp
+++ b/modules/base/rendering/renderableplane.cpp
@@ -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) {
diff --git a/modules/base/rendering/renderableplane.h b/modules/base/rendering/renderableplane.h
index feb6c53782..d6bc9f9b53 100644
--- a/modules/base/rendering/renderableplane.h
+++ b/modules/base/rendering/renderableplane.h
@@ -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
diff --git a/modules/base/rendering/renderableprism.cpp b/modules/base/rendering/renderableprism.cpp
index 04fe0a22ad..b7d3936e14 100644
--- a/modules/base/rendering/renderableprism.cpp
+++ b/modules/base/rendering/renderableprism.cpp
@@ -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
diff --git a/modules/base/rendering/renderablesphere.cpp b/modules/base/rendering/renderablesphere.cpp
index c734654687..2cd9f54ff2 100644
--- a/modules/base/rendering/renderablesphere.cpp
+++ b/modules/base/rendering/renderablesphere.cpp
@@ -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
diff --git a/modules/base/rendering/renderabletrail.cpp b/modules/base/rendering/renderabletrail.cpp
index 31477e4be6..1f0d9f26ba 100644
--- a/modules/base/rendering/renderabletrail.cpp
+++ b/modules/base/rendering/renderabletrail.cpp
@@ -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());
 
diff --git a/modules/base/shaders/plane_fs.glsl b/modules/base/shaders/plane_fs.glsl
index d3491cd260..11761fdb47 100644
--- a/modules/base/shaders/plane_fs.glsl
+++ b/modules/base/shaders/plane_fs.glsl
@@ -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);
diff --git a/modules/base/shaders/plane_vs.glsl b/modules/base/shaders/plane_vs.glsl
index 83f9720ca7..e1e3bb1f73 100644
--- a/modules/base/shaders/plane_vs.glsl
+++ b/modules/base/shaders/plane_vs.glsl
@@ -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;
diff --git a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
index 2414994f05..3f04668c98 100644
--- a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+++ b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
@@ -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();
diff --git a/modules/digitaluniverse/rendering/renderableplanescloud.cpp b/modules/digitaluniverse/rendering/renderableplanescloud.cpp
index 060023baf9..c599f429fb 100644
--- a/modules/digitaluniverse/rendering/renderableplanescloud.cpp
+++ b/modules/digitaluniverse/rendering/renderableplanescloud.cpp
@@ -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);
     }
 }
 
diff --git a/modules/digitaluniverse/rendering/renderableplanescloud.h b/modules/digitaluniverse/rendering/renderableplanescloud.h
index 4ee824e228..8c8773e70d 100644
--- a/modules/digitaluniverse/rendering/renderableplanescloud.h
+++ b/modules/digitaluniverse/rendering/renderableplanescloud.h
@@ -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();
 
diff --git a/modules/digitaluniverse/rendering/renderablepoints.cpp b/modules/digitaluniverse/rendering/renderablepoints.cpp
index 1a7d76acd5..c104723ffb 100644
--- a/modules/digitaluniverse/rendering/renderablepoints.cpp
+++ b/modules/digitaluniverse/rendering/renderablepoints.cpp
@@ -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);
diff --git a/modules/exoplanets/rendering/renderableorbitdisc.cpp b/modules/exoplanets/rendering/renderableorbitdisc.cpp
index dddb81f391..9fadb165f1 100644
--- a/modules/exoplanets/rendering/renderableorbitdisc.cpp
+++ b/modules/exoplanets/rendering/renderableorbitdisc.cpp
@@ -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());
diff --git a/modules/gaia/rendering/renderablegaiastars.cpp b/modules/gaia/rendering/renderablegaiastars.cpp
index cd2d5baded..f99b1c75aa 100644
--- a/modules/gaia/rendering/renderablegaiastars.cpp
+++ b/modules/gaia/rendering/renderablegaiastars.cpp
@@ -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.
diff --git a/modules/galaxy/rendering/renderablegalaxy.cpp b/modules/galaxy/rendering/renderablegalaxy.cpp
index 164ff7f11c..b77ccf1001 100644
--- a/modules/galaxy/rendering/renderablegalaxy.cpp
+++ b/modules/galaxy/rendering/renderablegalaxy.cpp
@@ -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
diff --git a/modules/skybrowser/src/renderableskytarget.cpp b/modules/skybrowser/src/renderableskytarget.cpp
index 8619ebaed8..429b660d15 100644
--- a/modules/skybrowser/src/renderableskytarget.cpp
+++ b/modules/skybrowser/src/renderableskytarget.cpp
@@ -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);
 
diff --git a/modules/space/rendering/renderableconstellationbounds.cpp b/modules/space/rendering/renderableconstellationbounds.cpp
index 2aa9a6fd81..8e3cb017fa 100644
--- a/modules/space/rendering/renderableconstellationbounds.cpp
+++ b/modules/space/rendering/renderableconstellationbounds.cpp
@@ -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));
diff --git a/modules/space/rendering/renderableconstellationlines.cpp b/modules/space/rendering/renderableconstellationlines.cpp
index cb4f55cfec..01529fad9d 100644
--- a/modules/space/rendering/renderableconstellationlines.cpp
+++ b/modules/space/rendering/renderableconstellationlines.cpp
@@ -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);
diff --git a/modules/space/rendering/renderableconstellationsbase.cpp b/modules/space/rendering/renderableconstellationsbase.cpp
index ad73cffcf9..fd77b5bc64 100644
--- a/modules/space/rendering/renderableconstellationsbase.cpp
+++ b/modules/space/rendering/renderableconstellationsbase.cpp
@@ -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
diff --git a/modules/space/rendering/renderableeclipsecone.cpp b/modules/space/rendering/renderableeclipsecone.cpp
index 1f6c893fc1..a5b22b12cd 100644
--- a/modules/space/rendering/renderableeclipsecone.cpp
+++ b/modules/space/rendering/renderableeclipsecone.cpp
@@ -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());
diff --git a/modules/space/rendering/renderablefluxnodes.cpp b/modules/space/rendering/renderablefluxnodes.cpp
index 7a547ae1b1..cd0ed7b9a5 100644
--- a/modules/space/rendering/renderablefluxnodes.cpp
+++ b/modules/space/rendering/renderablefluxnodes.cpp
@@ -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);
diff --git a/modules/space/rendering/renderablehabitablezone.cpp b/modules/space/rendering/renderablehabitablezone.cpp
index 03b946631c..67caa87580 100644
--- a/modules/space/rendering/renderablehabitablezone.cpp
+++ b/modules/space/rendering/renderablehabitablezone.cpp
@@ -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());
diff --git a/modules/space/rendering/renderableorbitalkepler.cpp b/modules/space/rendering/renderableorbitalkepler.cpp
index 0b5174457c..1baa644886 100644
--- a/modules/space/rendering/renderableorbitalkepler.cpp
+++ b/modules/space/rendering/renderableorbitalkepler.cpp
@@ -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);
diff --git a/modules/space/rendering/renderablerings.cpp b/modules/space/rendering/renderablerings.cpp
index b2e618dd6b..41fe330e8b 100644
--- a/modules/space/rendering/renderablerings.cpp
+++ b/modules/space/rendering/renderablerings.cpp
@@ -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);
diff --git a/modules/space/rendering/renderablestars.cpp b/modules/space/rendering/renderablestars.cpp
index 9309473b57..8207385ad8 100644
--- a/modules/space/rendering/renderablestars.cpp
+++ b/modules/space/rendering/renderablestars.cpp
@@ -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());
 
diff --git a/modules/space/rendering/renderabletravelspeed.cpp b/modules/space/rendering/renderabletravelspeed.cpp
index b495961e39..7b8b354370 100644
--- a/modules/space/rendering/renderabletravelspeed.cpp
+++ b/modules/space/rendering/renderabletravelspeed.cpp
@@ -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__
diff --git a/modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp b/modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp
index 902847649e..31688c56c6 100644
--- a/modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp
+++ b/modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp
@@ -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);
 
diff --git a/modules/spacecraftinstruments/rendering/renderablefov.cpp b/modules/spacecraftinstruments/rendering/renderablefov.cpp
index e29610b013..e25e156eaf 100644
--- a/modules/spacecraftinstruments/rendering/renderablefov.cpp
+++ b/modules/spacecraftinstruments/rendering/renderablefov.cpp
@@ -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);
 
diff --git a/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp b/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
index 3852feda2e..bd88be6f96 100644
--- a/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
@@ -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);
diff --git a/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp b/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
index bf6f4c41a0..9a9ea32360 100644
--- a/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
@@ -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();
diff --git a/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp b/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
index 818c2e0a7d..dd395868f8 100644
--- a/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
@@ -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);
diff --git a/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp b/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
index dc18010b34..f721ea17c7 100644
--- a/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
@@ -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);
diff --git a/src/rendering/renderable.cpp b/src/rendering/renderable.cpp
index 1b35fbb3ff..ec30219e37 100644
--- a/src/rendering/renderable.cpp
+++ b/src/rendering/renderable.cpp
@@ -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