Merge pull request #7339 from samcake/red

Less jittering at far distance

libraries/entities-renderer/src/textured_particle.slv

@@ -125,7 +125,8 @@ void main(void) {
     vec4 quadPos = radius * UNIT_QUAD[twoTriID];
 
     vec4 anchorPoint;
-    <$transformModelToEyePos(cam, obj, inPosition, anchorPoint)$>
+    vec4 _inPosition = vec4(inPosition, 1.0);
+    <$transformModelToEyePos(cam, obj, _inPosition, anchorPoint)$>
 
     vec4 eyePos = anchorPoint + quadPos;
     <$transformEyeToClipPos(cam, eyePos, gl_Position)$>

libraries/gpu/src/gpu/Context.cpp

@@ -74,9 +74,14 @@ 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);
+
+    // Get the viewEyeToWorld matrix form the transformView as passed to the gpu::Batch
+    // this is the "_viewInverse" fed to the shader
+    // Genetrate the "_view" matrix as well from the xform
+    xformView.getMatrix(_viewInverse);
+    _view = glm::inverse(_viewInverse);
 
     Mat4 viewUntranslated = _view;
     viewUntranslated[3] = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
@@ -84,16 +89,16 @@ 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];
-        skyboxView[3] = vec4(0, 0, 0, 1);
-        result._view = skyboxView * result._view;
+       // FIXME: If "skybox" the ipd is set to 0 for now, let s try to propose a better solution for this in the future
     }
     result._projection = _stereo._eyeProjections[eye];
-    result.recomputeDerived();
+    result.recomputeDerived(offsetTransform);
+ 
     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;
-        TransformCamera getEyeCamera(int eye, const StereoState& stereo) const;
+        const Backend::TransformCamera& recomputeDerived(const Transform& xformView) 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,39 @@ TransformObject getTransformObject() {
      <$viewport$> = <$cameraTransform$>._viewport;
 <@endfunc@>
 
-<@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 _eyepos = (<$objectTransform$>._model * <$modelPos$>) + vec4(-<$modelPos$>.w * <$cameraTransform$>._viewInverse[3].xyz, 0.0);
-        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * _eyepos;
+<@func transformModelToEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWorldAlignedPos)@>
+    <!// Bring the model pos in the world aligned space centered on the eye axis !>
+    { // _transformModelToEyeWorldAlignedPos
+        highp mat4 _mv = <$objectTransform$>._model;
+        _mv[3].xyz -= <$cameraTransform$>._viewInverse[3].xyz;
+        highp vec4 _eyeWApos = (_mv * <$modelPos$>);
+        <$eyeWorldAlignedPos$> = _eyeWApos;
     }
 <@endfunc@>
 
-<@func $transformModelToEyeAndClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos)@>
-    <!// Equivalent to the following but hoppefully a tad more accurate
-      //return camera._projection * camera._view * object._model * pos; !>
+<@func transformModelToClipPos(cameraTransform, objectTransform, modelPos, clipPos)@>
     { // transformModelToClipPos
-        vec4 _worldpos = (<$objectTransform$>._model * <$modelPos$>);
-        <$eyePos$> = (<$cameraTransform$>._view * _worldpos);
-        vec4 _eyepos =(<$objectTransform$>._model * <$modelPos$>) + vec4(-<$modelPos$>.w * <$cameraTransform$>._viewInverse[3].xyz, 0.0);
-        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * _eyepos;
-      //  <$eyePos$> = (<$cameraTransform$>._projectionInverse * <$clipPos$>);
+        vec4 eyeWAPos;
+        <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
+
+        <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos;
+    }
+<@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 +118,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 +145,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);

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -264,7 +264,9 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
                 deferredTransforms[i].projection = projMats[i];
 
                 auto sideViewMat = monoViewMat * glm::inverse(eyeViews[i]);
-                viewTransforms[i].evalFromRawMatrix(sideViewMat);
+              //  viewTransforms[i].evalFromRawMatrix(sideViewMat);
+                viewTransforms[i] = monoViewTransform;
+                viewTransforms[i].postTranslate(-glm::vec3((eyeViews[i][3])));// evalFromRawMatrix(sideViewMat);
                 deferredTransforms[i].viewInverse = sideViewMat;
 
                 deferredTransforms[i].stereoSide = (i == 0 ? -1.0f : 1.0f);