Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-06-05 16:11:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
samcake 2016-03-11 18:52:02 -08:00
parent d1c024fb39
commit 3cf32b17be
4 changed files with 48 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
libraries/gpu/src/gpu/Context.cpp
View file

@ -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];
skyboxView[3] = vec4(0, 0, 0, 1);
result._view = skyboxView * result._view;
// glm::mat4 skyboxView = _stereo._eyeViews[eye];
// skyboxView[3] = vec4(0, 0, 0, 1);
// result._view = skyboxView * result._view;
}
result._projection = _stereo._eyeProjections[eye];
result.recomputeDerived();
result.recomputeDerived(xformView);
return result;
}

6
libraries/gpu/src/gpu/Context.h
View file

@ -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;
};

5
libraries/gpu/src/gpu/GLBackendTransform.cpp
View file

@ -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));
}
}

54
libraries/gpu/src/gpu/Transform.slh
View file

@ -76,24 +76,40 @@ 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 +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);