Trying to fix the jittering issue, foound an extra matrix inversion that could be the source

libraries/gpu/src/gpu/Context.cpp

@@ -74,9 +74,11 @@ void Context::downloadFramebuffer(const FramebufferPointer& srcFramebuffer, cons
     _backend->downloadFramebuffer(srcFramebuffer, region, destImage);
 }
 
-const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived() const {
+const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const Transform& xformView) const {
     _projectionInverse = glm::inverse(_projection);
-    _viewInverse = glm::inverse(_view);
+   // _viewInverse = glm::inverse(_view);
+    xformView.getMatrix(_viewInverse);
+    _view = glm::inverse(_viewInverse);
 
     Mat4 viewUntranslated = _view;
     viewUntranslated[3] = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
@@ -84,16 +86,18 @@ const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived() con
     return *this;
 }
 
-Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const StereoState& _stereo) const {
+Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const StereoState& _stereo, const Transform& xformView) const {
     TransformCamera result = *this;
+    Transform offsetTransform = xformView;
     if (!_stereo._skybox) {
         result._view = _stereo._eyeViews[eye] * result._view;
+        offsetTransform.postTranslate(-Vec3(_stereo._eyeViews[eye][3]));
     } else {
-        glm::mat4 skyboxView = _stereo._eyeViews[eye];
+      //  glm::mat4 skyboxView = _stereo._eyeViews[eye];
-        skyboxView[3] = vec4(0, 0, 0, 1);
+       // skyboxView[3] = vec4(0, 0, 0, 1);
-        result._view = skyboxView * result._view;
+      //  result._view = skyboxView * result._view;
     }
     result._projection = _stereo._eyeProjections[eye];
-    result.recomputeDerived();
+    result.recomputeDerived(xformView);
     return result;
 }

libraries/gpu/src/gpu/Context.h

@@ -79,15 +79,15 @@ public:
     // UBO class... layout MUST match the layout in TransformCamera.slh
     class TransformCamera {
     public:
-        Mat4 _view;
+        mutable Mat4 _view;
         mutable Mat4 _viewInverse;
         mutable Mat4 _projectionViewUntranslated;
         Mat4 _projection;
         mutable Mat4 _projectionInverse;
         Vec4 _viewport; // Public value is int but float in the shader to stay in floats for all the transform computations.
 
-        const Backend::TransformCamera& recomputeDerived() const;
+        const Backend::TransformCamera& recomputeDerived(const Transform& xformView) const;
-        TransformCamera getEyeCamera(int eye, const StereoState& stereo) const;
+        TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& xformView) const;
     };
 
 

libraries/gpu/src/gpu/GLBackendTransform.cpp

@@ -105,6 +105,7 @@ void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const Stereo
     }
 
     if (_invalidView) {
+        // This is when the _view matrix gets assigned
         _view.getInverseMatrix(_camera._view);
     }
 
@@ -113,11 +114,11 @@ void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const Stereo
         if (stereo._enable) {
             _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
             for (int i = 0; i < 2; ++i) {
-                _cameras.push_back(_camera.getEyeCamera(i, stereo));
+                _cameras.push_back(_camera.getEyeCamera(i, stereo, _view));
             }
         } else {
             _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
-            _cameras.push_back(_camera.recomputeDerived());
+            _cameras.push_back(_camera.recomputeDerived(_view));
         }
     }
 

libraries/gpu/src/gpu/Transform.slh

@@ -76,24 +76,40 @@ TransformObject getTransformObject() {
      <$viewport$> = <$cameraTransform$>._viewport;
 <@endfunc@>
 
-<@func transformModelToClipPos(cameraTransform, objectTransform, modelPos, clipPos)@>
+<@func transformModelToEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWorldAlignedPos)@>
-    <!// Equivalent to the following but hoppefully a tad more accurate
+    <!// Bring the model pos in the world aligned space centered on the eye axis !>
-      //return camera._projection * camera._view * object._model * pos; !>
+    { // _transformModelToEyeWorldAlignedPos
-    { // transformModelToClipPos
+        highp mat4 _mv = <$objectTransform$>._model;
-        vec4 _eyepos = (<$objectTransform$>._model * <$modelPos$>) + vec4(-<$modelPos$>.w * <$cameraTransform$>._viewInverse[3].xyz, 0.0);
+        _mv[3].xyz -= <$cameraTransform$>._viewInverse[3].xyz;
-        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * _eyepos;
+        highp vec4 _eyeWApos = (_mv * <$modelPos$>);
+        <$eyeWorldAlignedPos$> = _eyeWApos;
     }
 <@endfunc@>
 
-<@func $transformModelToEyeAndClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos)@>
+<@func transformModelToClipPos(cameraTransform, objectTransform, modelPos, clipPos)@>
-    <!// Equivalent to the following but hoppefully a tad more accurate
-      //return camera._projection * camera._view * object._model * pos; !>
     { // transformModelToClipPos
-        vec4 _worldpos = (<$objectTransform$>._model * <$modelPos$>);
+        vec4 eyeWAPos;
-        <$eyePos$> = (<$cameraTransform$>._view * _worldpos);
+        <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
-        vec4 _eyepos =(<$objectTransform$>._model * <$modelPos$>) + vec4(-<$modelPos$>.w * <$cameraTransform$>._viewInverse[3].xyz, 0.0);
+
-        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * _eyepos;
+        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos;
-      //  <$eyePos$> = (<$cameraTransform$>._projectionInverse * <$clipPos$>);
+    }
+<@endfunc@>
+
+<@func transformModelToEyeAndClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos)@>
+    { // transformModelToEyeAndClipPos
+        vec4 eyeWAPos;
+        <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
+
+        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos;
+        <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0);
+    }
+<@endfunc@>
+
+<@func transformModelToEyePos(cameraTransform, objectTransform, modelPos, eyePos)@>
+    { // transformModelToEyePos
+        vec4 eyeWAPos;
+        <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
+        <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0);
     }
 <@endfunc@>
 
@@ -103,6 +119,7 @@ TransformObject getTransformObject() {
     }
 <@endfunc@>
 
+
 <@func transformModelToEyeDir(cameraTransform, objectTransform, modelDir, eyeDir)@>
     { // transformModelToEyeDir
         vec3 mr0 = vec3(<$objectTransform$>._modelInverse[0].x, <$objectTransform$>._modelInverse[1].x, <$objectTransform$>._modelInverse[2].x);
@@ -129,15 +146,6 @@ TransformObject getTransformObject() {
     }
 <@endfunc@>
 
-<@func $transformModelToEyePos(cameraTransform, objectTransform, modelPos, eyePos)@>
-    <!// Equivalent to the following but hoppefully a tad more accurate
-    //return camera._view * object._model * pos; !>
-    { // transformModelToEyePos
-        vec4 _worldpos = (<$objectTransform$>._model * vec4(<$modelPos$>.xyz, 1.0));
-        <$eyePos$> = (<$cameraTransform$>._view * _worldpos);
-    }
-<@endfunc@>
-
 <@func transformEyeToClipPos(cameraTransform, eyePos, clipPos)@>
     { // transformEyeToClipPos
         <$clipPos$> = <$cameraTransform$>._projection * vec4(<$eyePos$>.xyz, 1.0);