From 07209101aeb726458c78c93cec1c2c12c7ed8cb7 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Wed, 22 Jul 2020 14:11:59 -0700 Subject: [PATCH 01/34] working on bringing back TAA PR --- interface/src/SecondaryCamera.cpp | 2 +- .../scripting/RenderScriptingInterface.cpp | 2 + .../display-plugins/OpenGLDisplayPlugin.cpp | 5 +- .../src/display-plugins/OpenGLDisplayPlugin.h | 1 - .../src/RenderableEntityItem.cpp | 5 + .../src/RenderableEntityItem.h | 1 + .../src/RenderableWebEntityItem.cpp | 4 +- libraries/entities-renderer/src/polyvox.slf | 3 + libraries/entities-renderer/src/polyvox.slv | 3 +- .../gpu-gl-common/src/gpu/gl/GLBackend.cpp | 62 +-- .../gpu-gl-common/src/gpu/gl/GLBackend.h | 115 +++--- .../src/gpu/gl/GLBackendPipeline.cpp | 12 - .../src/gpu/gl/GLBackendTransform.cpp | 135 +++++-- .../gpu-gl-common/src/gpu/gl/GLPipeline.cpp | 5 - .../gpu-gl-common/src/gpu/gl/GLPipeline.h | 3 - libraries/gpu-gl/src/gpu/gl41/GL41Backend.h | 2 + .../src/gpu/gl41/GL41BackendTransform.cpp | 32 ++ libraries/gpu-gl/src/gpu/gl45/GL45Backend.h | 2 + .../src/gpu/gl45/GL45BackendTexture.cpp | 4 +- .../src/gpu/gl45/GL45BackendTransform.cpp | 28 ++ libraries/gpu-gles/src/gpu/gles/GLESBackend.h | 4 + .../src/gpu/gles/GLESBackendTransform.cpp | 32 ++ libraries/gpu/src/gpu/Backend.cpp | 118 ++++++ libraries/gpu/src/gpu/Backend.h | 136 +++++++ libraries/gpu/src/gpu/Batch.cpp | 77 +++- libraries/gpu/src/gpu/Batch.h | 39 +- libraries/gpu/src/gpu/Context.cpp | 68 ---- libraries/gpu/src/gpu/Context.h | 119 +----- libraries/gpu/src/gpu/DrawUnitQuad.slv | 27 ++ libraries/gpu/src/gpu/Query.h | 2 + libraries/gpu/src/gpu/Transform.slh | 158 ++++++-- .../gpu/src/gpu/TransformCamera_shared.slh | 32 +- .../gpu/src/gpu/TransformObject_shared.slh | 19 + libraries/gpu/src/gpu/drawColor.slp | 3 +- libraries/gpu/src/gpu/drawWhite.slp | 2 + libraries/graphics/src/graphics/Skybox.cpp | 8 +- libraries/graphics/src/graphics/Skybox.h | 4 +- libraries/graphics/src/graphics/skybox.slv | 7 +- .../src/procedural/ProceduralSkybox.cpp | 10 +- .../src/procedural/ProceduralSkybox.h | 4 +- .../render-utils/src/AntialiasingEffect.cpp | 371 +++++++----------- .../render-utils/src/AntialiasingEffect.h | 123 +++--- .../render-utils/src/BackgroundStage.cpp | 14 +- libraries/render-utils/src/BackgroundStage.h | 5 +- libraries/render-utils/src/BloomEffect.cpp | 15 +- .../src/BloomThreshold.shared.slh | 2 + libraries/render-utils/src/BloomThreshold.slf | 3 +- .../render-utils/src/DebugDeferredBuffer.cpp | 40 +- .../render-utils/src/DebugDeferredBuffer.h | 9 +- .../render-utils/src/DeferredBufferRead.slh | 24 +- .../render-utils/src/DeferredBufferWrite.slh | 27 +- .../src/DeferredBufferWrite_shared.slh | 12 + .../src/DeferredFrameTransform.cpp | 80 ++-- .../render-utils/src/DeferredFrameTransform.h | 42 +- libraries/render-utils/src/RenderViewTask.cpp | 16 +- libraries/render-utils/src/RenderViewTask.h | 9 +- 56 files changed, 1230 insertions(+), 857 deletions(-) create mode 100644 libraries/gpu/src/gpu/Backend.cpp create mode 100644 libraries/gpu/src/gpu/Backend.h create mode 100644 libraries/gpu/src/gpu/DrawUnitQuad.slv create mode 100644 libraries/gpu/src/gpu/TransformObject_shared.slh create mode 100644 libraries/gpu/src/gpu/drawWhite.slp create mode 100644 libraries/render-utils/src/DeferredBufferWrite_shared.slh diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp index 704d7963e72..b643e566796 100644 --- a/interface/src/SecondaryCamera.cpp +++ b/interface/src/SecondaryCamera.cpp @@ -275,7 +275,7 @@ class EndSecondaryCameraFrame { // Restores renderContext. void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor) { const auto cachedArg = task.addJob("SecondaryCamera"); - task.addJob("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1); + task.addJob("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1, 2); task.addJob("EndSecondaryCamera", cachedArg); } \ No newline at end of file diff --git a/interface/src/scripting/RenderScriptingInterface.cpp b/interface/src/scripting/RenderScriptingInterface.cpp index 12814aa6b6a..654df929f8d 100644 --- a/interface/src/scripting/RenderScriptingInterface.cpp +++ b/interface/src/scripting/RenderScriptingInterface.cpp @@ -191,6 +191,8 @@ void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mo _renderSettingLock.withWriteLock([&] { _antialiasingMode = mode; + // TODO: this may be needed if there are problems with changing antialiasing settings + //auto mainViewAntialiasingSetupConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.AntialiasingSetup"); auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.JitterCam"); auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.Antialiasing"); auto secondViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderSecondView.JitterCam"); diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp index 03a463c82a5..a80018913ec 100644 --- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp +++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp @@ -357,7 +357,7 @@ void OpenGLDisplayPlugin::customizeContext() { auto presentThread = DependencyManager::get(); Q_ASSERT(thread() == presentThread->thread()); - getGLBackend()->setCameraCorrection(mat4(), mat4(), true); + getGLBackend()->updatePresentFrame(mat4(), mat4(), true); for (auto& cursorValue : _cursorsData) { auto& cursorData = cursorValue.second; @@ -701,8 +701,7 @@ void OpenGLDisplayPlugin::present(const std::shared_ptr& if (_currentFrame) { auto correction = getViewCorrection(); - getGLBackend()->setCameraCorrection(correction, _prevRenderView); - _prevRenderView = correction * _currentFrame->view; + getGLBackend()->updatePresentFrame(correction); { withPresentThreadLock([&] { _renderRate.increment(); diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.h b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.h index 15cebf7e3a9..239deb87a8b 100644 --- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.h +++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.h @@ -150,7 +150,6 @@ class OpenGLDisplayPlugin : public DisplayPlugin { gpu::FramePointer _currentFrame; gpu::Frame* _lastFrame{ nullptr }; - mat4 _prevRenderView; gpu::FramebufferPointer _compositeFramebuffer; gpu::PipelinePointer _hudPipeline; gpu::PipelinePointer _mirrorHUDPipeline; diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp index 212baa66340..4c38b993b5c 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp @@ -43,6 +43,10 @@ const Transform& EntityRenderer::getModelTransform() const { return _modelTransform; } +const Transform& EntityRenderer::getPreviousModelTransform() const { + return _prevModelTransform; +} + void EntityRenderer::makeStatusGetters(const EntityItemPointer& entity, Item::Status::Getters& statusGetters) { auto nodeList = DependencyManager::get(); // DANGER: nodeList->getSessionUUID() will return null id when not connected to domain. @@ -414,6 +418,7 @@ void EntityRenderer::updateModelTransformAndBound(const EntityItemPointer& entit bool success = false; auto newModelTransform = getTransformToCenterWithMaybeOnlyLocalRotation(entity, success); if (success) { + _prevModelTransform = _modelTransform; _modelTransform = newModelTransform; } diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index 3caeef07137..fdb342a4429 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/libraries/entities-renderer/src/RenderableEntityItem.h @@ -162,6 +162,7 @@ class EntityRenderer : public QObject, public std::enable_shared_from_this()->bindWebBrowserProgram(batch, transparent, forward); DependencyManager::get()->renderQuad(batch, topLeft, bottomRight, texMin, texMax, color, _geometryId); - batch.popProjectionJitter(); + batch.popProjectionJitterEnabled(); batch.setResourceTexture(0, nullptr); } diff --git a/libraries/entities-renderer/src/polyvox.slf b/libraries/entities-renderer/src/polyvox.slf index 34568230810..dd735ecf168 100644 --- a/libraries/entities-renderer/src/polyvox.slf +++ b/libraries/entities-renderer/src/polyvox.slf @@ -36,6 +36,8 @@ <@if HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; + <@else@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_POSITION_MS) in vec3 _positionMS; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; @@ -88,6 +90,7 @@ void main(void) { <@if not HIFI_USE_FORWARD@> packDeferredFragment( + _prevPositionCS, normalize(_normalWS), 1.0, diffuse, diff --git a/libraries/entities-renderer/src/polyvox.slv b/libraries/entities-renderer/src/polyvox.slv index 34547cef1a6..42ee508bfde 100644 --- a/libraries/entities-renderer/src/polyvox.slv +++ b/libraries/entities-renderer/src/polyvox.slv @@ -23,6 +23,7 @@ layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; <@endif@> layout(location=RENDER_UTILS_ATTR_POSITION_MS) out vec3 _positionMS; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; <@endif@> @@ -34,7 +35,7 @@ void main(void) { <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> <@else@> <@if not HIFI_USE_FORWARD@> - <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <@else@> <$transformModelToEyeAndClipPos(cam, obj, inPosition, _positionES, gl_Position)$> <@endif@> diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index af39458f172..621cd34ac7e 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -50,10 +50,16 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] = (&::gpu::gl::GLBackend::do_setModelTransform), (&::gpu::gl::GLBackend::do_setViewTransform), (&::gpu::gl::GLBackend::do_setProjectionTransform), - (&::gpu::gl::GLBackend::do_setProjectionJitter), + (&::gpu::gl::GLBackend::do_setProjectionJitterEnabled), + (&::gpu::gl::GLBackend::do_setProjectionJitterSequence), + (&::gpu::gl::GLBackend::do_setProjectionJitterScale), (&::gpu::gl::GLBackend::do_setViewportTransform), (&::gpu::gl::GLBackend::do_setDepthRangeTransform), + (&::gpu::gl::GLBackend::do_saveViewProjectionTransform), + (&::gpu::gl::GLBackend::do_setSavedViewProjectionTransform), + (&::gpu::gl::GLBackend::do_copySavedViewProjectionTransformToBuffer), + (&::gpu::gl::GLBackend::do_setPipeline), (&::gpu::gl::GLBackend::do_setStateBlendFactor), (&::gpu::gl::GLBackend::do_setStateScissorRect), @@ -269,12 +275,10 @@ bool GLBackend::availableMemoryKnown() { } GLBackend::GLBackend(bool syncCache) { - _pipeline._cameraCorrectionBuffer._buffer->flush(); initShaderBinaryCache(); } GLBackend::GLBackend() { - _pipeline._cameraCorrectionBuffer._buffer->flush(); initShaderBinaryCache(); } @@ -320,19 +324,7 @@ void GLBackend::renderPassTransfer(const Batch& batch) { case Batch::COMMAND_drawIndexedInstanced: case Batch::COMMAND_multiDrawIndirect: case Batch::COMMAND_multiDrawIndexedIndirect: - { - Vec2u outputSize{ 1,1 }; - - auto framebuffer = acquire(_output._framebuffer); - if (framebuffer) { - outputSize.x = framebuffer->getWidth(); - outputSize.y = framebuffer->getHeight(); - } else if (glm::dot(_transform._projectionJitter, _transform._projectionJitter)>0.0f) { - qCWarning(gpugllogging) << "Jittering needs to have a frame buffer to be set"; - } - - _transform.preUpdate(_commandIndex, _stereo, outputSize); - } + preUpdateTransform(); break; case Batch::COMMAND_disableContextStereo: @@ -343,6 +335,11 @@ void GLBackend::renderPassTransfer(const Batch& batch) { _stereo._contextDisable = false; break; + case Batch::COMMAND_copySavedViewProjectionTransformToBuffer: + // We need to store this transform state in the transform buffer + preUpdateTransform(); + break; + case Batch::COMMAND_setFramebuffer: case Batch::COMMAND_setViewportTransform: case Batch::COMMAND_setViewTransform: @@ -385,6 +382,9 @@ void GLBackend::renderPassDraw(const Batch& batch) { case Batch::COMMAND_setModelTransform: case Batch::COMMAND_setViewTransform: case Batch::COMMAND_setProjectionTransform: + case Batch::COMMAND_saveViewProjectionTransform: + case Batch::COMMAND_setSavedViewProjectionTransform: + case Batch::COMMAND_setProjectionJitterSequence: break; case Batch::COMMAND_draw: @@ -410,7 +410,6 @@ void GLBackend::renderPassDraw(const Batch& batch) { //case Batch::COMMAND_setModelTransform: //case Batch::COMMAND_setViewTransform: //case Batch::COMMAND_setProjectionTransform: - case Batch::COMMAND_setProjectionJitter: case Batch::COMMAND_setViewportTransform: case Batch::COMMAND_setDepthRangeTransform: { @@ -554,7 +553,7 @@ void GLBackend::render(const Batch& batch) { _stereo._enable = false; } // Reset jitter - _transform._projectionJitter = Vec2(0.0f, 0.0f); + _transform._projectionJitter._isEnabled = false; { GL_PROFILE_RANGE(render_gpu_gl_detail, "Transfer"); @@ -578,6 +577,14 @@ void GLBackend::render(const Batch& batch) { // Restore the saved stereo state for the next batch _stereo._enable = savedStereo; + + if (batch._mustUpdatePreviousModels) { + // Update object transform history for when the batch will be reexecuted + for (auto& objectTransform : batch._objects) { + objectTransform._previousModel = objectTransform._model; + } + batch._mustUpdatePreviousModels = false; + } } @@ -997,15 +1004,18 @@ void GLBackend::recycle() const { _textureManagement._transferEngine->manageMemory(); } -void GLBackend::setCameraCorrection(const Mat4& correction, const Mat4& prevRenderView, bool reset) { +void GLBackend::updatePresentFrame(const Mat4& correction, bool reset) { auto invCorrection = glm::inverse(correction); - auto invPrevView = glm::inverse(prevRenderView); - _transform._correction.prevView = (reset ? Mat4() : prevRenderView); - _transform._correction.prevViewInverse = (reset ? Mat4() : invPrevView); - _transform._correction.correction = correction; - _transform._correction.correctionInverse = invCorrection; - _pipeline._cameraCorrectionBuffer._buffer->setSubData(0, _transform._correction); - _pipeline._cameraCorrectionBuffer._buffer->flush(); + _transform._presentFrame.correction = correction; + _transform._presentFrame.correctionInverse = invCorrection; + + auto& projectionJitter = _transform._projectionJitter; + projectionJitter._currentSampleIndex++; + + // Update previous views of saved transforms + for (auto& viewProjState : _transform._savedTransforms) { + viewProjState._state._previousCorrectedView = viewProjState._state._correctedView; + } } void GLBackend::syncProgram(const gpu::ShaderPointer& program) { diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index 2947649ce75..d89adc70ddc 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -26,7 +26,7 @@ #include #include -#include +#include #include "GLShared.h" @@ -121,7 +121,6 @@ class GLBackend : public Backend, public std::enable_shared_from_this // Shutdown rendering and persist any required resources void shutdown() override; - void setCameraCorrection(const Mat4& correction, const Mat4& prevRenderView, bool reset = false) override; void render(const Batch& batch) final override; // This call synchronize the Full Backend cache with the current GLState @@ -177,10 +176,16 @@ class GLBackend : public Backend, public std::enable_shared_from_this virtual void do_setModelTransform(const Batch& batch, size_t paramOffset) final; virtual void do_setViewTransform(const Batch& batch, size_t paramOffset) final; virtual void do_setProjectionTransform(const Batch& batch, size_t paramOffset) final; - virtual void do_setProjectionJitter(const Batch& batch, size_t paramOffset) final; + virtual void do_setProjectionJitterEnabled(const Batch& batch, size_t paramOffset) final; + virtual void do_setProjectionJitterSequence(const Batch& batch, size_t paramOffset) final; + virtual void do_setProjectionJitterScale(const Batch& batch, size_t paramOffset) final; virtual void do_setViewportTransform(const Batch& batch, size_t paramOffset) final; virtual void do_setDepthRangeTransform(const Batch& batch, size_t paramOffset) final; + virtual void do_saveViewProjectionTransform(const Batch& batch, size_t paramOffset) final; + virtual void do_setSavedViewProjectionTransform(const Batch& batch, size_t paramOffset) final; + virtual void do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) = 0; + // Uniform Stage virtual void do_setUniformBuffer(const Batch& batch, size_t paramOffset) final; @@ -300,8 +305,9 @@ class GLBackend : public Backend, public std::enable_shared_from_this virtual bool supportsBindless() const { return false; } static const size_t INVALID_OFFSET = (size_t)-1; - bool _inRenderTransferPass{ false }; - int _currentDraw{ -1 }; + static const uint INVALID_SAVED_CAMERA_SLOT = (uint)-1; + bool _inRenderTransferPass { false }; + int _currentDraw { -1 }; struct FrameTrash { GLsync fence = nullptr; @@ -392,11 +398,9 @@ class GLBackend : public Backend, public std::enable_shared_from_this // between the time when a was recorded and the time(s) when it is // executed // Prev is the previous correction used at previous frame - struct CameraCorrection { + struct PresentFrame { mat4 correction; mat4 correctionInverse; - mat4 prevView; - mat4 prevViewInverse; }; struct TransformStageState { @@ -417,32 +421,60 @@ class GLBackend : public Backend, public std::enable_shared_from_this using CameraBufferElement = TransformCamera; #endif using TransformCameras = std::vector; + + struct ViewProjectionState { + Transform _view; + Transform _correctedView; + Transform _previousCorrectedView; + Mat4 _projection; + bool _viewIsCamera; + + void copyExceptPrevious(const ViewProjectionState& other) { + _view = other._view; + _correctedView = other._correctedView; + _projection = other._projection; + _viewIsCamera = other._viewIsCamera; + } + }; + + struct SaveTransform { + ViewProjectionState _state; + size_t _cameraOffset{ INVALID_OFFSET }; + }; TransformCamera _camera; TransformCameras _cameras; + std::array _savedTransforms; mutable std::map _drawCallInfoOffsets; - GLuint _objectBuffer{ 0 }; - GLuint _cameraBuffer{ 0 }; - GLuint _drawCallInfoBuffer{ 0 }; - GLuint _objectBufferTexture{ 0 }; - size_t _cameraUboSize{ 0 }; - bool _viewIsCamera{ false }; - bool _skybox{ false }; - Transform _view; - CameraCorrection _correction; - bool _viewCorrectionEnabled{ true }; - - Mat4 _projection; - Vec4i _viewport{ 0, 0, 1, 1 }; - Vec2 _depthRange{ 0.0f, 1.0f }; - Vec2 _projectionJitter{ 0.0f, 0.0f }; - bool _invalidView{ false }; - bool _invalidProj{ false }; - bool _invalidViewport{ false }; - - bool _enabledDrawcallInfoBuffer{ false }; + GLuint _objectBuffer { 0 }; + GLuint _cameraBuffer { 0 }; + GLuint _drawCallInfoBuffer { 0 }; + GLuint _objectBufferTexture { 0 }; + size_t _cameraUboSize { 0 }; + ViewProjectionState _viewProjectionState; + uint _currentSavedTransformSlot { INVALID_SAVED_CAMERA_SLOT }; + bool _skybox { false }; + PresentFrame _presentFrame; + bool _viewCorrectionEnabled { true }; + + struct Jitter { + std::vector _offsetSequence; + Vec2 _offset { 0.0f }; + float _scale { 0.f }; + unsigned int _currentSampleIndex { 0 }; + bool _isEnabled { false }; + }; + + Jitter _projectionJitter; + Vec4i _viewport { 0, 0, 1, 1 }; + Vec2 _depthRange { 0.0f, 1.0f }; + bool _invalidView { false }; + bool _invalidProj { false }; + bool _invalidViewport { false }; + + bool _enabledDrawcallInfoBuffer { false }; using Pair = std::pair; using List = std::list; @@ -450,11 +482,13 @@ class GLBackend : public Backend, public std::enable_shared_from_this mutable List::const_iterator _camerasItr; mutable size_t _currentCameraOffset{ INVALID_OFFSET }; - void preUpdate(size_t commandIndex, const StereoState& stereo, Vec2u framebufferSize); + void pushCameraBufferElement(const StereoState& stereo, TransformCameras& cameras) const; + void preUpdate(size_t commandIndex, const StereoState& stereo); void update(size_t commandIndex, const StereoState& stereo) const; void bindCurrentCamera(int stereoSide) const; } _transform; + void preUpdateTransform(); virtual void transferTransformState(const Batch& batch) const = 0; struct UniformStageState { @@ -524,25 +558,16 @@ class GLBackend : public Backend, public std::enable_shared_from_this PipelineReference _pipeline{}; GLuint _program{ 0 }; - bool _cameraCorrection{ false }; - GLShader* _programShader{ nullptr }; - bool _invalidProgram{ false }; + GLShader* _programShader { nullptr }; + bool _invalidProgram { false }; - BufferView _cameraCorrectionBuffer{ gpu::BufferView(std::make_shared(sizeof(CameraCorrection), nullptr)) }; - BufferView _cameraCorrectionBufferIdentity{ gpu::BufferView( - std::make_shared(sizeof(CameraCorrection), nullptr)) }; + State::Data _stateCache { State::DEFAULT }; + State::Signature _stateSignatureCache { 0 }; - State::Data _stateCache{ State::DEFAULT }; - State::Signature _stateSignatureCache{ 0 }; + GLState* _state { nullptr }; + bool _invalidState { false }; - GLState* _state{ nullptr }; - bool _invalidState{ false }; - - PipelineStageState() { - _cameraCorrectionBuffer.edit() = CameraCorrection(); - _cameraCorrectionBufferIdentity.edit() = CameraCorrection(); - _cameraCorrectionBufferIdentity._buffer->flush(); - } + PipelineStageState() {} } _pipeline; // Backend dependent compilation of the shader diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp index e94d2986ee6..45db4ba5fbb 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp @@ -37,7 +37,6 @@ void GLBackend::do_setPipeline(const Batch& batch, size_t paramOffset) { reset(_pipeline._pipeline); _pipeline._program = 0; - _pipeline._cameraCorrection = false; _pipeline._programShader = nullptr; _pipeline._invalidProgram = true; @@ -63,7 +62,6 @@ void GLBackend::do_setPipeline(const Batch& batch, size_t paramOffset) { _pipeline._program = glprogram; _pipeline._programShader = pipelineObject->_program; _pipeline._invalidProgram = true; - _pipeline._cameraCorrection = pipelineObject->_cameraCorrection; } // Now for the state @@ -79,16 +77,6 @@ void GLBackend::do_setPipeline(const Batch& batch, size_t paramOffset) { // THis should be done on Pipeline::update... if (_pipeline._invalidProgram) { glUseProgram(_pipeline._program); - if (_pipeline._cameraCorrection) { - // Invalidate uniform buffer cache slot - _uniform._buffers[gpu::slot::buffer::CameraCorrection].reset(); - auto& cameraCorrectionBuffer = _transform._viewCorrectionEnabled ? - _pipeline._cameraCorrectionBuffer._buffer : - _pipeline._cameraCorrectionBufferIdentity._buffer; - // Because we don't sync Buffers in the bindUniformBuffer, let s force this buffer synced - getBufferID(*cameraCorrectionBuffer); - bindUniformBuffer(gpu::slot::buffer::CameraCorrection, cameraCorrectionBuffer, 0, sizeof(CameraCorrection)); - } (void)CHECK_GL_ERROR(); _pipeline._invalidProgram = false; } diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp index 67ab502b6b8..86f48f792ab 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp @@ -18,20 +18,47 @@ void GLBackend::do_setModelTransform(const Batch& batch, size_t paramOffset) { } void GLBackend::do_setViewTransform(const Batch& batch, size_t paramOffset) { - _transform._view = batch._transforms.get(batch._params[paramOffset]._uint); - _transform._viewIsCamera = batch._params[paramOffset + 1]._uint != 0; + _transform._viewProjectionState._view = batch._transforms.get(batch._params[paramOffset]._uint); + // View history is only supported with saved transforms and if setViewTransform is called (and not setSavedViewProjectionTransform) + // then, in consequence, the view will NOT be corrected in the present thread. In which case + // the previousCorrectedView should be the same as the view. + _transform._viewProjectionState._previousCorrectedView = _transform._viewProjectionState._view; + _transform._viewProjectionState._viewIsCamera = batch._params[paramOffset + 1]._uint != 0; _transform._invalidView = true; + // The current view / proj doesn't correspond to a saved camera slot + _transform._currentSavedTransformSlot = INVALID_SAVED_CAMERA_SLOT; } void GLBackend::do_setProjectionTransform(const Batch& batch, size_t paramOffset) { memcpy(glm::value_ptr(_transform._projection), batch.readData(batch._params[paramOffset]._uint), sizeof(Mat4)); _transform._invalidProj = true; + // The current view / proj doesn't correspond to a saved camera slot + _transform._currentSavedTransformSlot = INVALID_SAVED_CAMERA_SLOT; } -void GLBackend::do_setProjectionJitter(const Batch& batch, size_t paramOffset) { - _transform._projectionJitter.x = batch._params[paramOffset]._float; - _transform._projectionJitter.y = batch._params[paramOffset+1]._float; +void GLBackend::do_setProjectionJitterEnabled(const Batch& batch, size_t paramOffset) { + _transform._projectionJitter._isEnabled = (batch._params[paramOffset]._int & 1) != 0; _transform._invalidProj = true; + // The current view / proj doesn't correspond to a saved camera slot + _transform._currentSavedTransformSlot = INVALID_SAVED_CAMERA_SLOT; +} + +void GLBackend::do_setProjectionJitterSequence(const Batch& batch, size_t paramOffset) { + auto count = batch._params[paramOffset + 0]._uint; + auto& projectionJitter = _transform._projectionJitter; + projectionJitter._offsetSequence.resize(count); + if (count) { + memcpy(projectionJitter._offsetSequence.data(), batch.readData(batch._params[paramOffset + 1]._uint), sizeof(Vec2) * count); + projectionJitter._offset = projectionJitter._offsetSequence[projectionJitter._currentSampleIndex % count]; + } else { + projectionJitter._offset = Vec2(0.0f); + } +} + +void GLBackend::do_setProjectionJitterScale(const Batch& batch, size_t paramOffset) { + // Should be 2 for one pixel amplitude as clip space is between -1 and 1, but lower values give less blur + // but more aliasing... + _transform._projectionJitter._scale = 2.0f * batch._params[paramOffset + 0]._float; } void GLBackend::do_setViewportTransform(const Batch& batch, size_t paramOffset) { @@ -90,55 +117,78 @@ void GLBackend::syncTransformStateCache() { Mat4 modelView; auto modelViewInv = glm::inverse(modelView); - _transform._view.evalFromRawMatrix(modelViewInv); + _transform._viewProjectionState._view.evalFromRawMatrix(modelViewInv); glDisableVertexAttribArray(gpu::Stream::DRAW_CALL_INFO); _transform._enabledDrawcallInfoBuffer = false; } -void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const StereoState& stereo, Vec2u framebufferSize) { +void GLBackend::TransformStageState::pushCameraBufferElement(const StereoState& stereo, TransformCameras& cameras) const { + const float jitterAmplitude = _projectionJitter._scale; + const Vec2 jitterScale = Vec2(jitterAmplitude * float(_projectionJitter._isEnabled & 1)) / Vec2(_viewport.z, _viewport.w); + const Vec2 jitter = jitterScale * _projectionJitter._offset; + + if (stereo.isStereo()) { +#ifdef GPU_STEREO_CAMERA_BUFFER + cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter), + _camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); +#else + cameras.push_back((_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); + cameras.push_back((_camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); +#endif + } else { +#ifdef GPU_STEREO_CAMERA_BUFFER + cameras.push_back(CameraBufferElement( + _camera.getMonoCamera(_skybox, _viewProjectionState._correctedView, _viewProjectionState._previousCorrectedView, jitter))); +#else + cameras.push_back((_camera.getMonoCamera(_skybox, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); +#endif + } +} + +void GLBackend::preUpdateTransform() { + _transform.preUpdate(_commandIndex, _stereo); +} + +void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const StereoState& stereo) { // Check all the dirty flags and update the state accordingly if (_invalidViewport) { _camera._viewport = glm::vec4(_viewport); } if (_invalidProj) { - _camera._projection = _projection; + _camera._projection = _viewProjectionState._projection; } if (_invalidView) { // Apply the correction - if (_viewIsCamera && (_viewCorrectionEnabled && _correction.correction != glm::mat4())) { - // FIXME should I switch to using the camera correction buffer in Transform.slf and leave this out? - Transform result; - _view.mult(result, _view, _correction.correctionInverse); - if (_skybox) { - result.setTranslation(vec3()); - } - _view = result; + if (_viewProjectionState._viewIsCamera && (_viewCorrectionEnabled && _presentFrame.correction != glm::mat4())) { + Transform::mult(_viewProjectionState._correctedView, _viewProjectionState._view, _presentFrame.correctionInverse); + } else { + _viewProjectionState._correctedView = _viewProjectionState._view; + } + + if (_skybox) { + _viewProjectionState._correctedView.setTranslation(vec3()); } // This is when the _view matrix gets assigned - _view.getInverseMatrix(_camera._view); + _viewProjectionState._correctedView.getInverseMatrix(_camera._view); } if (_invalidView || _invalidProj || _invalidViewport) { size_t offset = _cameraUboSize * _cameras.size(); - Vec2 finalJitter = _projectionJitter / Vec2(framebufferSize); _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset)); - if (stereo.isStereo()) { -#ifdef GPU_STEREO_CAMERA_BUFFER - _cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, _view, finalJitter), _camera.getEyeCamera(1, stereo, _view, finalJitter))); -#else - _cameras.push_back((_camera.getEyeCamera(0, stereo, _view, finalJitter))); - _cameras.push_back((_camera.getEyeCamera(1, stereo, _view, finalJitter))); -#endif - } else { -#ifdef GPU_STEREO_CAMERA_BUFFER - _cameras.push_back(CameraBufferElement(_camera.getMonoCamera(_view, finalJitter))); -#else - _cameras.push_back((_camera.getMonoCamera(_view, finalJitter))); -#endif + pushCameraBufferElement(stereo, _cameras); + if (_currentSavedTransformSlot != INVALID_SAVED_CAMERA_SLOT) { + // Save the offset of the saved camera slot in the camera buffer. Can be used to copy + // that data, or (in the future) to reuse the offset. + _savedTransforms[_currentSavedTransformSlot]._cameraOffset = offset; } } @@ -177,3 +227,26 @@ void GLBackend::resetTransformStage() { glDisableVertexAttribArray(gpu::Stream::DRAW_CALL_INFO); _transform._enabledDrawcallInfoBuffer = false; } + +void GLBackend::do_saveViewProjectionTransform(const Batch& batch, size_t paramOffset) { + auto slotId = batch._params[paramOffset + 0]._uint; + slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); + + _transform._savedTransforms[slotId]._cameraOffset = INVALID_OFFSET; + _transform._currentSavedTransformSlot = slotId; + // If we are saving this transform to a save slot, then it means we are tracking the history of the view + // so copy the previous corrected view to the transform state. + _transform._viewProjectionState._previousCorrectedView = _transform._savedTransforms[slotId]._state._previousCorrectedView; + preUpdateTransform(); + _transform._savedTransforms[slotId]._state.copyExceptPrevious(_transform._viewProjectionState); +} + +void GLBackend::do_setSavedViewProjectionTransform(const Batch& batch, size_t paramOffset) { + auto slotId = batch._params[paramOffset + 0]._uint; + slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); + + _transform._viewProjectionState = _transform._savedTransforms[slotId]._state; + _transform._invalidView = true; + _transform._invalidProj = true; + _transform._currentSavedTransformSlot = slotId; +} diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.cpp index 52e10eb417e..d4786a5a8fa 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.cpp @@ -49,11 +49,6 @@ GLPipeline* GLPipeline::sync(GLBackend& backend, const Pipeline& pipeline) { Backend::setGPUObject(pipeline, object); } - // Special case for view correction matrices, any pipeline that declares the correction buffer - // uniform will automatically have it provided without any client code necessary. - // Required for stable lighting in the HMD. - auto reflection = shader->getReflection(backend.getShaderDialect(), backend.getShaderVariant()); - object->_cameraCorrection = reflection.validUniformBuffer(gpu::slot::buffer::CameraCorrection); object->_program = programObject; object->_state = stateObject; diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.h b/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.h index a102e33b149..16344833233 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLPipeline.h @@ -18,9 +18,6 @@ class GLPipeline : public GPUObject { GLShader* _program { nullptr }; GLState* _state { nullptr }; - // Bit of a hack, any pipeline can need the camera correction buffer at execution time, so - // we store whether a given pipeline has declared the uniform buffer for it. - bool _cameraCorrection{ false }; }; } } diff --git a/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h b/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h index 881487c9dbf..49ef58ab00c 100644 --- a/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h +++ b/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h @@ -167,6 +167,8 @@ class GL41Backend : public GLBackend { bool bindResourceBuffer(uint32_t slot, const BufferPointer& buffer) override; void releaseResourceBuffer(uint32_t slot) override; + void do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) override; + // Output stage void do_blit(const Batch& batch, size_t paramOffset) override; diff --git a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp index b11707eba2b..52bfbbf577c 100644 --- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp +++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp @@ -10,6 +10,8 @@ // #include "GL41Backend.h" +#include "gpu/gl/GLBuffer.h" + using namespace gpu; using namespace gpu::gl41; @@ -97,4 +99,34 @@ void GL41Backend::updateTransform(const Batch& batch) { } (void)CHECK_GL_ERROR(); +} + +void GL41Backend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) { + auto slotId = batch._params[paramOffset + 0]._uint; + BufferPointer buffer = batch._buffers.get(batch._params[paramOffset + 1]._uint); + auto dstOffset = batch._params[paramOffset + 2]._uint; + size_t size = _transform._cameraUboSize; + + slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); + const auto& savedTransform = _transform._savedTransforms[slotId]; + + if ((dstOffset + size) > buffer->getBufferCPUMemSize()) { + qCWarning(gpugllogging) << "Copying saved TransformCamera data out of bounds of uniform buffer"; + size = (size_t)std::max((ptrdiff_t)buffer->getBufferCPUMemSize() - (ptrdiff_t)dstOffset, 0); + } + if (savedTransform._cameraOffset == INVALID_OFFSET) { + qCWarning(gpugllogging) << "Saved TransformCamera data has an invalid transform offset. Copy aborted."; + return; + } + + // Sync BufferObject + auto* object = syncGPUObject(*buffer); + if (object) { + glBindBuffer(GL_COPY_READ_BUFFER, _transform._cameraBuffer); + glBindBuffer(GL_COPY_WRITE_BUFFER, object->_buffer); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, savedTransform._cameraOffset, dstOffset, size); + glBindBuffer(GL_COPY_READ_BUFFER, 0); + glBindBuffer(GL_COPY_WRITE_BUFFER, 0); + (void)CHECK_GL_ERROR(); + } } \ No newline at end of file diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h index 3e7392e3668..c8b0a84605a 100644 --- a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h +++ b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h @@ -269,6 +269,8 @@ class GL45Backend : public GLBackend { bool bindResourceBuffer(uint32_t slot, const BufferPointer& buffer) override; void releaseResourceBuffer(uint32_t slot) override; + void do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) override; + // Output stage void do_blit(const Batch& batch, size_t paramOffset) override; diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp index bb31903d8ec..f1fa282720e 100644 --- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp +++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp @@ -167,7 +167,7 @@ class GLSamplerCache { glSamplerParameteri(result, GL_TEXTURE_WRAP_T, GLTexture::WRAP_MODES[sampler.getWrapModeV()]); glSamplerParameteri(result, GL_TEXTURE_WRAP_R, GLTexture::WRAP_MODES[sampler.getWrapModeW()]); - glSamplerParameterf(result, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy()); + glSamplerParameterf(result, GL_TEXTURE_MAX_ANISOTROPY, sampler.getMaxAnisotropy()); glSamplerParameterfv(result, GL_TEXTURE_BORDER_COLOR, (const float*)&sampler.getBorderColor()); glSamplerParameterf(result, GL_TEXTURE_MIN_LOD, sampler.getMinMip()); @@ -314,7 +314,7 @@ void GL45Texture::syncSampler() const { glTextureParameteri(_id, GL_TEXTURE_WRAP_T, WRAP_MODES[sampler.getWrapModeV()]); glTextureParameteri(_id, GL_TEXTURE_WRAP_R, WRAP_MODES[sampler.getWrapModeW()]); - glTextureParameterf(_id, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy()); + glTextureParameterf(_id, GL_TEXTURE_MAX_ANISOTROPY, sampler.getMaxAnisotropy()); glTextureParameterfv(_id, GL_TEXTURE_BORDER_COLOR, (const float*)&sampler.getBorderColor()); glTextureParameterf(_id, GL_TEXTURE_MIN_LOD, sampler.getMinMip()); diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp index f389c5f62c8..ae7170d2822 100644 --- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp +++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp @@ -10,6 +10,8 @@ // #include "GL45Backend.h" +#include "gpu/gl/GLBuffer.h" + using namespace gpu; using namespace gpu::gl45; @@ -101,4 +103,30 @@ void GL45Backend::updateTransform(const Batch& batch) { } (void)CHECK_GL_ERROR(); +} + +void GL45Backend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) { + auto slotId = batch._params[paramOffset + 0]._uint; + BufferPointer buffer = batch._buffers.get(batch._params[paramOffset + 1]._uint); + auto dstOffset = batch._params[paramOffset + 2]._uint; + size_t size = _transform._cameraUboSize; + + slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); + const auto& savedTransform = _transform._savedTransforms[slotId]; + + if ((dstOffset + size) > buffer->getBufferCPUMemSize()) { + qCWarning(gpugllogging) << "Copying saved TransformCamera data out of bounds of uniform buffer"; + size = (size_t)std::max((ptrdiff_t)buffer->getBufferCPUMemSize() - (ptrdiff_t)dstOffset, 0); + } + if (savedTransform._cameraOffset == INVALID_OFFSET) { + qCWarning(gpugllogging) << "Saved TransformCamera data has an invalid transform offset. Copy aborted."; + return; + } + + // Sync BufferObject + auto* object = syncGPUObject(*buffer); + if (object) { + glCopyNamedBufferSubData(_transform._cameraBuffer, object->_buffer, savedTransform._cameraOffset, dstOffset, size); + (void)CHECK_GL_ERROR(); + } } \ No newline at end of file diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h index 636518c85a6..0e636250256 100644 --- a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h +++ b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h @@ -76,6 +76,8 @@ class GLESBackend : public GLBackend { void allocateStorage() const; void syncSampler() const override; const Size _size { 0 }; + + }; class GLESAttachmentTexture : public GLESFixedAllocationTexture { @@ -164,6 +166,8 @@ class GLESBackend : public GLBackend { bool bindResourceBuffer(uint32_t slot, const BufferPointer& buffer) override; void releaseResourceBuffer(uint32_t slot) override; + void do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) override; + // Output stage void do_blit(const Batch& batch, size_t paramOffset) override; diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp b/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp index 7e1ee0da3b0..be5e2a25570 100644 --- a/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp +++ b/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp @@ -10,6 +10,8 @@ // #include "GLESBackend.h" +#include "gpu/gl/GLBuffer.h" + using namespace gpu; using namespace gpu::gles; @@ -99,4 +101,34 @@ void GLESBackend::updateTransform(const Batch& batch) { } (void)CHECK_GL_ERROR(); +} + +void GLESBackend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch, size_t paramOffset) { + auto slotId = batch._params[paramOffset + 0]._uint; + BufferPointer buffer = batch._buffers.get(batch._params[paramOffset + 1]._uint); + auto dstOffset = batch._params[paramOffset + 2]._uint; + size_t size = _transform._cameraUboSize; + + slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); + const auto& savedTransform = _transform._savedTransforms[slotId]; + + if ((dstOffset + size) > buffer->getBufferCPUMemSize()) { + qCWarning(gpugllogging) << "Copying saved TransformCamera data out of bounds of uniform buffer"; + size = (size_t)std::max((ptrdiff_t)buffer->getBufferCPUMemSize() - (ptrdiff_t)dstOffset, 0); + } + if (savedTransform._cameraOffset == INVALID_OFFSET) { + qCWarning(gpugllogging) << "Saved TransformCamera data has an invalid transform offset. Copy aborted."; + return; + } + + // Sync BufferObject + auto* object = syncGPUObject(*buffer); + if (object) { + glBindBuffer(GL_COPY_READ_BUFFER, _transform._cameraBuffer); + glBindBuffer(GL_COPY_WRITE_BUFFER, object->_buffer); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, savedTransform._cameraOffset, dstOffset, size); + glBindBuffer(GL_COPY_READ_BUFFER, 0); + glBindBuffer(GL_COPY_WRITE_BUFFER, 0); + (void)CHECK_GL_ERROR(); + } } \ No newline at end of file diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp new file mode 100644 index 00000000000..3a0b650bece --- /dev/null +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -0,0 +1,118 @@ +// +// Backend.cpp +// interface/src/gpu +// +// Created by Olivier Prat on 05/25/2018. +// Copyright 2018 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// +#include "Backend.h" + +using namespace gpu; + +// Counters for Buffer and Texture usage in GPU/Context + +ContextMetricSize Backend::freeGPUMemSize; + +ContextMetricCount Backend::bufferCount; +ContextMetricSize Backend::bufferGPUMemSize; + +ContextMetricCount Backend::textureResidentCount; +ContextMetricCount Backend::textureFramebufferCount; +ContextMetricCount Backend::textureResourceCount; +ContextMetricCount Backend::textureExternalCount; + +ContextMetricSize Backend::textureResidentGPUMemSize; +ContextMetricSize Backend::textureFramebufferGPUMemSize; +ContextMetricSize Backend::textureResourceGPUMemSize; +ContextMetricSize Backend::textureExternalGPUMemSize; + +ContextMetricCount Backend::texturePendingGPUTransferCount; +ContextMetricSize Backend::texturePendingGPUTransferMemSize; + +ContextMetricSize Backend::textureResourcePopulatedGPUMemSize; +ContextMetricSize Backend::textureResourceIdealGPUMemSize; + +Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, + const StereoState& _stereo, + const Transform& view, + const Transform& previousView, + Vec2 normalizedJitter) const { + TransformCamera result = *this; + Transform eyeView = view; + Transform eyePreviousView = previousView; + if (!_stereo._skybox) { + eyeView.postTranslate(-Vec3(_stereo._eyeViews[eye][3])); + eyePreviousView.postTranslate(-Vec3(_stereo._eyeViews[eye][3])); + } else { + // FIXME: If "skybox" the ipd is set to 0 for now, let s try to propose a better solution for this in the future + eyePreviousView.setTranslation(vec3()); + } + result._projection = _stereo._eyeProjections[eye]; + + // Apply jitter to projections + normalizedJitter.x *= 2.0f; + result._projection[2][0] += normalizedJitter.x; + result._projection[2][1] += normalizedJitter.y; + + result.recomputeDerived(eyeView, eyePreviousView); + + result._stereoInfo = Vec4(1.0f, (float)eye, 1.0f / result._viewport.z, 1.0f / result._viewport.w); + + return result; +} + +Backend::TransformCamera Backend::TransformCamera::getMonoCamera(bool isSkybox, + const Transform& view, + Transform previousView, + Vec2 normalizedJitter) const { + TransformCamera result = *this; + + if (isSkybox) { + previousView.setTranslation(vec3()); + } + result._projection[2][0] += normalizedJitter.x; + result._projection[2][1] += normalizedJitter.y; + result.recomputeDerived(view, previousView); + + result._stereoInfo = Vec4(0.0f, 0.0f, 1.0f / result._viewport.z, 1.0f / result._viewport.w); + return result; +} + +const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const Transform& view, + const Transform& previousView) const { + _projectionInverse = glm::inverse(_projection); + + // 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 + view.getMatrix(_viewInverse); + _view = glm::inverse(_viewInverse); + previousView.getMatrix(_previousViewInverse); + _previousView = glm::inverse(_previousViewInverse); + + Mat4 viewUntranslated = _view; + viewUntranslated[3] = Vec4(0.0f, 0.0f, 0.0f, 1.0f); + _projectionViewUntranslated = _projection * viewUntranslated; + + viewUntranslated = _previousView; + viewUntranslated[3] = Vec4(0.0f, 0.0f, 0.0f, 1.0f); + // We suppose that the projection, including jitter, hasn't changed from previous frame + // This may sound counter-intuitive to use the same jitter value but in fact it is needed. + // Think of it this way: + // If we have no velocity (no camera or object movement) then we wish to reproject to exactly + // the same pixel value. The current pixel UV when computing the motion vectoris trivially computed + // from the fragment coordinates but the previous UV is computed conceptually with an unjittered + // projection * previous view matrix in the vertex shader and sent to the fragment to write in the + // motion vector as an interpolated attribute. But since the current projection * view matrix is + // jittered, the effectively rasterized interpolated previous UV will be slightly offset. That offset + // is exactly the jitter amount. So we add that jitter amount to the projection in the projection * previous + // view matrix computation. Hope this makes sense. + _previousProjectionViewUntranslated = _projection * viewUntranslated; + + _stereoInfo = Vec4(0.0f); + + return *this; +} \ No newline at end of file diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h new file mode 100644 index 00000000000..c0878da3cc9 --- /dev/null +++ b/libraries/gpu/src/gpu/Backend.h @@ -0,0 +1,136 @@ +// +// Backend.h +// interface/src/gpu +// +// Created by Olivier Prat on 05/18/2018. +// Copyright 2018 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// +#ifndef hifi_gpu_Backend_h +#define hifi_gpu_Backend_h + +#include + +#include "Forward.h" +#include "Batch.h" +#include "Buffer.h" +#include "Framebuffer.h" + +class QImage; + +namespace gpu { +class Context; + +struct ContextStats { +public: + int _ISNumFormatChanges = 0; + int _ISNumInputBufferChanges = 0; + int _ISNumIndexBufferChanges = 0; + + int _RSNumResourceBufferBounded = 0; + int _RSNumTextureBounded = 0; + int _RSAmountTextureMemoryBounded = 0; + + int _DSNumAPIDrawcalls = 0; + int _DSNumDrawcalls = 0; + int _DSNumTriangles = 0; + + int _PSNumSetPipelines = 0; + + ContextStats() {} + ContextStats(const ContextStats& stats) = default; + + void evalDelta(const ContextStats& begin, const ContextStats& end); +}; + +class Backend { +public: + virtual ~Backend(){}; + + virtual void shutdown() {} + virtual const std::string& getVersion() const = 0; + + void setStereoState(const StereoState& stereo) { _stereo = stereo; } + + virtual void render(const Batch& batch) = 0; + virtual void syncCache() = 0; + virtual void recycle() const = 0; + virtual void downloadFramebuffer(const FramebufferPointer& srcFramebuffer, const Vec4i& region, QImage& destImage) = 0; + + virtual bool supportedTextureFormat(const gpu::Element& format) = 0; + + // Shared header between C++ and GLSL +#include "TransformCamera_shared.slh" + + class TransformCamera : public _TransformCamera { + public: + const Backend::TransformCamera& recomputeDerived(const Transform& view, const Transform& previousView) const; + // Jitter should be divided by framebuffer size + TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, Vec2 normalizedJitter) const; + // Jitter should be divided by framebuffer size + TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& view, const Transform& previousView, Vec2 normalizedJitter) const; + }; + + template + static void setGPUObject(const U& object, T* gpuObject) { + object.gpuObject.setGPUObject(gpuObject); + } + template + static T* getGPUObject(const U& object) { + return reinterpret_cast(object.gpuObject.getGPUObject()); + } + + void resetStats() const { _stats = ContextStats(); } + void getStats(ContextStats& stats) const { stats = _stats; } + + virtual bool isTextureManagementSparseEnabled() const = 0; + + // These should only be accessed by Backend implementation to report the buffer and texture allocations, + // they are NOT public objects + static ContextMetricSize freeGPUMemSize; + + static ContextMetricCount bufferCount; + static ContextMetricSize bufferGPUMemSize; + + static ContextMetricCount textureResidentCount; + static ContextMetricCount textureFramebufferCount; + static ContextMetricCount textureResourceCount; + static ContextMetricCount textureExternalCount; + + static ContextMetricSize textureResidentGPUMemSize; + static ContextMetricSize textureFramebufferGPUMemSize; + static ContextMetricSize textureResourceGPUMemSize; + static ContextMetricSize textureExternalGPUMemSize; + + static ContextMetricCount texturePendingGPUTransferCount; + static ContextMetricSize texturePendingGPUTransferMemSize; + static ContextMetricSize textureResourcePopulatedGPUMemSize; + static ContextMetricSize textureResourceIdealGPUMemSize; + +protected: + virtual bool isStereo() const { + return _stereo.isStereo(); + } + + void getStereoProjections(mat4* eyeProjections) const { + for (int i = 0; i < 2; ++i) { + eyeProjections[i] = _stereo._eyeProjections[i]; + } + } + + void getStereoViews(mat4* eyeViews) const { + for (int i = 0; i < 2; ++i) { + eyeViews[i] = _stereo._eyeViews[i]; + } + } + + friend class Context; + mutable ContextStats _stats; + StereoState _stereo; +}; + +} + +#endif \ No newline at end of file diff --git a/libraries/gpu/src/gpu/Batch.cpp b/libraries/gpu/src/gpu/Batch.cpp index e6217cc600f..89e63d3325d 100644 --- a/libraries/gpu/src/gpu/Batch.cpp +++ b/libraries/gpu/src/gpu/Batch.cpp @@ -53,6 +53,7 @@ Batch::Batch(const std::string& name) { _data.reserve(_dataMax); _objects.reserve(_objectsMax); _drawCallInfos.reserve(_drawCallInfosMax); + _mustUpdatePreviousModels = true; } Batch::~Batch() { @@ -101,17 +102,18 @@ void Batch::clear() { _currentModel = Transform(); _drawcallUniform = 0; _drawcallUniformReset = 0; - _projectionJitter = glm::vec2(0.0f); _enableStereo = true; _enableSkybox = false; + _mustUpdatePreviousModels = true; } size_t Batch::cacheData(size_t size, const void* data) { size_t offset = _data.size(); size_t numBytes = size; _data.resize(offset + numBytes); - memcpy(_data.data() + offset, data, size); - + if (data) { + memcpy(_data.data() + offset, data, size); + } return offset; } @@ -236,6 +238,15 @@ void Batch::setModelTransform(const Transform& model) { ADD_COMMAND(setModelTransform); _currentModel = model; + _previousModel = model; + _invalidModel = true; +} + +void Batch::setModelTransform(const Transform& model, const Transform& previousModel) { + ADD_COMMAND(setModelTransform); + + _currentModel = model; + _previousModel = previousModel; _invalidModel = true; } @@ -252,20 +263,29 @@ void Batch::setProjectionTransform(const Mat4& proj) { _params.emplace_back(cacheData(sizeof(Mat4), &proj)); } -void Batch::setProjectionJitter(float jx, float jy) { - _projectionJitter.x = jx; - _projectionJitter.y = jy; - pushProjectionJitter(jx, jy); +void Batch::setProjectionJitterEnabled(bool isProjectionEnabled) { + _isJitterOnProjectionEnabled = isProjectionEnabled; + pushProjectionJitterEnabled(_isJitterOnProjectionEnabled); +} + +void Batch::pushProjectionJitterEnabled(bool isProjectionEnabled) { + ADD_COMMAND(setProjectionJitterEnabled); + _params.emplace_back(isProjectionEnabled & 1); +} + +void Batch::popProjectionJitterEnabled() { + pushProjectionJitterEnabled(_isJitterOnProjectionEnabled); } -void Batch::pushProjectionJitter(float jx, float jy) { - ADD_COMMAND(setProjectionJitter); - _params.emplace_back(jx); - _params.emplace_back(jy); +void Batch::setProjectionJitterSequence(const Vec2* sequence, size_t count) { + ADD_COMMAND(setProjectionJitterSequence); + _params.emplace_back((uint)count); + _params.emplace_back(cacheData(sizeof(Vec2) * count, sequence)); } -void Batch::popProjectionJitter() { - pushProjectionJitter(_projectionJitter.x, _projectionJitter.y); +void Batch::setProjectionJitterScale(float scale) { + ADD_COMMAND(setProjectionJitterScale); + _params.emplace_back(scale); } void Batch::setViewportTransform(const Vec4i& viewport) { @@ -281,6 +301,34 @@ void Batch::setDepthRangeTransform(float nearDepth, float farDepth) { _params.emplace_back(nearDepth); } +void Batch::saveViewProjectionTransform(uint32 saveSlot) { + ADD_COMMAND(saveViewProjectionTransform); + if (saveSlot >= MAX_TRANSFORM_SAVE_SLOT_COUNT) { + qCWarning(gpulogging) << "Transform save slot" << saveSlot << "exceeds max save slot count of" << MAX_TRANSFORM_SAVE_SLOT_COUNT; + } + _params.emplace_back(saveSlot); +} + +void Batch::setSavedViewProjectionTransform(uint32 saveSlot) { + ADD_COMMAND(setSavedViewProjectionTransform); + if (saveSlot >= MAX_TRANSFORM_SAVE_SLOT_COUNT) { + qCWarning(gpulogging) << "Transform save slot" << saveSlot << "exceeds max save slot count of" + << MAX_TRANSFORM_SAVE_SLOT_COUNT; + } + _params.emplace_back(saveSlot); +} + +void Batch::copySavedViewProjectionTransformToBuffer(uint32 saveSlot, const BufferPointer& buffer, Offset offset) { + ADD_COMMAND(copySavedViewProjectionTransformToBuffer); + if (saveSlot >= MAX_TRANSFORM_SAVE_SLOT_COUNT) { + qCWarning(gpulogging) << "Transform save slot" << saveSlot << "exceeds max save slot count of" + << MAX_TRANSFORM_SAVE_SLOT_COUNT; + } + _params.emplace_back(saveSlot); + _params.emplace_back(_buffers.cache(buffer)); + _params.emplace_back(offset); +} + void Batch::setPipeline(const PipelinePointer& pipeline) { ADD_COMMAND(setPipeline); @@ -548,12 +596,15 @@ void Batch::captureDrawCallInfoImpl() { if (_invalidModel) { TransformObject object; _currentModel.getMatrix(object._model); + _previousModel.getMatrix(object._previousModel); // FIXME - we don't want to be using glm::inverse() here but it fixes the flickering issue we are // seeing with planky blocks in toybox. Our implementation of getInverseMatrix() is buggy in cases // of non-uniform scale. We need to fix that. In the mean time, glm::inverse() works. //_model.getInverseMatrix(_object._modelInverse); + //_previousModel.getInverseMatrix(_object._previousModelInverse); object._modelInverse = glm::inverse(object._model); + object._previousModelInverse = glm::inverse(object._previousModel); _objects.emplace_back(object); diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h index 0a438ea1484..8f0a61b7f2f 100644 --- a/libraries/gpu/src/gpu/Batch.h +++ b/libraries/gpu/src/gpu/Batch.h @@ -42,6 +42,9 @@ class Batch { public: typedef Stream::Slot Slot; + enum { + MAX_TRANSFORM_SAVE_SLOT_COUNT = 6 + }; class DrawCallInfo { public: @@ -174,17 +177,24 @@ class Batch { // WARNING: ViewTransform transform from eye space to world space, its inverse is composed // with the ModelTransform to create the equivalent of the gl ModelViewMatrix void setModelTransform(const Transform& model); + void setModelTransform(const Transform& model, const Transform& previousModel); void resetViewTransform() { setViewTransform(Transform(), false); } void setViewTransform(const Transform& view, bool camera = true); void setProjectionTransform(const Mat4& proj); - void setProjectionJitter(float jx = 0.0f, float jy = 0.0f); + void setProjectionJitterEnabled(bool isProjectionEnabled); + void setProjectionJitterSequence(const Vec2* sequence, size_t count); + void setProjectionJitterScale(float scale); // Very simple 1 level stack management of jitter. - void pushProjectionJitter(float jx = 0.0f, float jy = 0.0f); - void popProjectionJitter(); + void pushProjectionJitterEnabled(bool isProjectionEnabled); + void popProjectionJitterEnabled(); // Viewport is xy = low left corner in framebuffer, zw = width height of the viewport, expressed in pixels void setViewportTransform(const Vec4i& viewport); void setDepthRangeTransform(float nearDepth, float farDepth); + void saveViewProjectionTransform(uint32 saveSlot); + void setSavedViewProjectionTransform(uint32 saveSlot); + void copySavedViewProjectionTransformToBuffer(uint32 saveSlot, const BufferPointer& buffer, Offset offset); + // Pipeline Stage void setPipeline(const PipelinePointer& pipeline); @@ -309,10 +319,16 @@ class Batch { COMMAND_setModelTransform, COMMAND_setViewTransform, COMMAND_setProjectionTransform, - COMMAND_setProjectionJitter, + COMMAND_setProjectionJitterEnabled, + COMMAND_setProjectionJitterSequence, + COMMAND_setProjectionJitterScale, COMMAND_setViewportTransform, COMMAND_setDepthRangeTransform, + COMMAND_saveViewProjectionTransform, + COMMAND_setSavedViewProjectionTransform, + COMMAND_copySavedViewProjectionTransformToBuffer, + COMMAND_setPipeline, COMMAND_setStateBlendFactor, COMMAND_setStateScissorRect, @@ -496,16 +512,14 @@ class Batch { static size_t _dataMax; // SSBO class... layout MUST match the layout in Transform.slh - class TransformObject { - public: - Mat4 _model; - Mat4 _modelInverse; - }; +#include "TransformObject_shared.slh" using TransformObjects = std::vector; bool _invalidModel { true }; Transform _currentModel; - TransformObjects _objects; + Transform _previousModel; + mutable bool _mustUpdatePreviousModels; + mutable TransformObjects _objects; static size_t _objectsMax; BufferCaches _buffers; @@ -523,10 +537,11 @@ class Batch { NamedBatchDataMap _namedData; + bool _isJitterOnProjectionEnabled{ false }; + uint16_t _drawcallUniform{ 0 }; uint16_t _drawcallUniformReset{ 0 }; - glm::vec2 _projectionJitter{ 0.0f, 0.0f }; bool _enableStereo{ true }; bool _enableSkybox { false }; @@ -556,7 +571,7 @@ class Batch { template size_t Batch::Cache::_max = BATCH_PREALLOCATE_MIN; -} +} // namespace gpu #if defined(NSIGHT_FOUND) diff --git a/libraries/gpu/src/gpu/Context.cpp b/libraries/gpu/src/gpu/Context.cpp index 8dee120555c..7afd4374feb 100644 --- a/libraries/gpu/src/gpu/Context.cpp +++ b/libraries/gpu/src/gpu/Context.cpp @@ -217,74 +217,6 @@ double Context::getFrameTimerBatchAverage() const { return 0.0; } -const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const Transform& xformView) const { - _projectionInverse = glm::inverse(_projection); - - // Get the viewEyeToWorld matrix from 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); - _projectionViewUntranslated = _projection * viewUntranslated; - - _stereoInfo = Vec4(0.0f); - - return *this; -} - -Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const StereoState& _stereo, const Transform& xformView, Vec2 normalizedJitter) const { - TransformCamera result = *this; - Transform offsetTransform = xformView; - if (!_stereo._skybox) { - offsetTransform.postTranslate(-Vec3(_stereo._eyeViews[eye][3])); - } else { - // 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]; - normalizedJitter.x *= 2.0f; - result._projection[2][0] += normalizedJitter.x; - result._projection[2][1] += normalizedJitter.y; - result.recomputeDerived(offsetTransform); - - result._stereoInfo = Vec4(1.0f, (float)eye, 0.0f, 0.0f); - - return result; -} - -Backend::TransformCamera Backend::TransformCamera::getMonoCamera(const Transform& xformView, Vec2 normalizedJitter) const { - TransformCamera result = *this; - result._projection[2][0] += normalizedJitter.x; - result._projection[2][1] += normalizedJitter.y; - result.recomputeDerived(xformView); - return result; -} - -// Counters for Buffer and Texture usage in GPU/Context - -ContextMetricSize Backend::freeGPUMemSize; - -ContextMetricCount Backend::bufferCount; -ContextMetricSize Backend::bufferGPUMemSize; - -ContextMetricCount Backend::textureResidentCount; -ContextMetricCount Backend::textureFramebufferCount; -ContextMetricCount Backend::textureResourceCount; -ContextMetricCount Backend::textureExternalCount; - -ContextMetricSize Backend::textureResidentGPUMemSize; -ContextMetricSize Backend::textureFramebufferGPUMemSize; -ContextMetricSize Backend::textureResourceGPUMemSize; -ContextMetricSize Backend::textureExternalGPUMemSize; - -ContextMetricCount Backend::texturePendingGPUTransferCount; -ContextMetricSize Backend::texturePendingGPUTransferMemSize; - -ContextMetricSize Backend::textureResourcePopulatedGPUMemSize; -ContextMetricSize Backend::textureResourceIdealGPUMemSize; - Size Context::getFreeGPUMemSize() { return Backend::freeGPUMemSize.getValue(); } diff --git a/libraries/gpu/src/gpu/Context.h b/libraries/gpu/src/gpu/Context.h index 1946f447f8f..4e5cab17a82 100644 --- a/libraries/gpu/src/gpu/Context.h +++ b/libraries/gpu/src/gpu/Context.h @@ -15,131 +15,14 @@ #include #include -#include - -#include "Forward.h" -#include "Batch.h" -#include "Buffer.h" #include "Texture.h" #include "Pipeline.h" -#include "Framebuffer.h" #include "Frame.h" #include "PointerStorage.h" - -class QImage; +#include "Backend.h" namespace gpu { -struct ContextStats { -public: - uint32_t _ISNumFormatChanges { 0 }; - uint32_t _ISNumInputBufferChanges { 0 }; - uint32_t _ISNumIndexBufferChanges { 0 }; - - uint32_t _RSNumResourceBufferBounded { 0 }; - uint32_t _RSNumTextureBounded { 0 }; - uint64_t _RSAmountTextureMemoryBounded { 0 }; - - uint32_t _DSNumAPIDrawcalls { 0 }; - uint32_t _DSNumDrawcalls { 0 }; - uint32_t _DSNumTriangles { 0 }; - - uint32_t _PSNumSetPipelines { 0 }; - - ContextStats() {} - ContextStats(const ContextStats& stats) = default; - - void evalDelta(const ContextStats& begin, const ContextStats& end); -}; - -class Backend { -public: - virtual ~Backend(){}; - - virtual void shutdown() {} - virtual const std::string& getVersion() const = 0; - - void setStereoState(const StereoState& stereo) { _stereo = stereo; } - - virtual void render(const Batch& batch) = 0; - virtual void syncCache() = 0; - virtual void syncProgram(const gpu::ShaderPointer& program) = 0; - virtual void recycle() const = 0; - virtual void downloadFramebuffer(const FramebufferPointer& srcFramebuffer, const Vec4i& region, QImage& destImage) = 0; - virtual void setCameraCorrection(const Mat4& correction, const Mat4& prevRenderView, bool reset = false) {} - - virtual bool supportedTextureFormat(const gpu::Element& format) = 0; - - // Shared header between C++ and GLSL -#include "TransformCamera_shared.slh" - - class TransformCamera : public _TransformCamera { - public: - const Backend::TransformCamera& recomputeDerived(const Transform& xformView) const; - // Jitter should be divided by framebuffer size - TransformCamera getMonoCamera(const Transform& xformView, Vec2 normalizedJitter) const; - // Jitter should be divided by framebuffer size - TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& xformView, Vec2 normalizedJitter) const; - }; - - template - static void setGPUObject(const U& object, T* gpuObject) { - object.gpuObject.setGPUObject(gpuObject); - } - template - static T* getGPUObject(const U& object) { - return reinterpret_cast(object.gpuObject.getGPUObject()); - } - - void resetStats() const { _stats = ContextStats(); } - void getStats(ContextStats& stats) const { stats = _stats; } - - virtual bool isTextureManagementSparseEnabled() const = 0; - - // These should only be accessed by Backend implementation to report the buffer and texture allocations, - // they are NOT public objects - static ContextMetricSize freeGPUMemSize; - - static ContextMetricCount bufferCount; - static ContextMetricSize bufferGPUMemSize; - - static ContextMetricCount textureResidentCount; - static ContextMetricCount textureFramebufferCount; - static ContextMetricCount textureResourceCount; - static ContextMetricCount textureExternalCount; - - static ContextMetricSize textureResidentGPUMemSize; - static ContextMetricSize textureFramebufferGPUMemSize; - static ContextMetricSize textureResourceGPUMemSize; - static ContextMetricSize textureExternalGPUMemSize; - - static ContextMetricCount texturePendingGPUTransferCount; - static ContextMetricSize texturePendingGPUTransferMemSize; - static ContextMetricSize textureResourcePopulatedGPUMemSize; - static ContextMetricSize textureResourceIdealGPUMemSize; - - virtual bool isStereo() const { - return _stereo.isStereo(); - } - - void getStereoProjections(mat4* eyeProjections) const { - for (int i = 0; i < 2; ++i) { - eyeProjections[i] = _stereo._eyeProjections[i]; - } - } -protected: - - void getStereoViews(mat4* eyeViews) const { - for (int i = 0; i < 2; ++i) { - eyeViews[i] = _stereo._eyeViews[i]; - } - } - - friend class Context; - mutable ContextStats _stats; - StereoState _stereo; -}; - class Context { public: using Size = Resource::Size; diff --git a/libraries/gpu/src/gpu/DrawUnitQuad.slv b/libraries/gpu/src/gpu/DrawUnitQuad.slv new file mode 100644 index 00000000000..7fcc7f97382 --- /dev/null +++ b/libraries/gpu/src/gpu/DrawUnitQuad.slv @@ -0,0 +1,27 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// <$_SCRIBE_FILENAME$> +// Generated on <$_SCRIBE_DATE$> +// Draw the unit quad [-1,-1 -> 1,1]. +// Not transform used. +// Simply draw a Triangle_strip of 2 triangles, no input buffers or index buffer needed +// +// Created by Olivier Prat on 10/22/2018 +// Copyright 2018 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +void main(void) { + const float depth = 1.0; + const vec4 UNIT_QUAD[4] = vec4[4]( + vec4(-1.0, -1.0, depth, 1.0), + vec4(1.0, -1.0, depth, 1.0), + vec4(-1.0, 1.0, depth, 1.0), + vec4(1.0, 1.0, depth, 1.0) + ); + vec4 pos = UNIT_QUAD[gl_VertexID]; + + gl_Position = pos; +} \ No newline at end of file diff --git a/libraries/gpu/src/gpu/Query.h b/libraries/gpu/src/gpu/Query.h index 912901951ce..acec5500b2f 100644 --- a/libraries/gpu/src/gpu/Query.h +++ b/libraries/gpu/src/gpu/Query.h @@ -66,6 +66,8 @@ namespace gpu { double getGPUAverage() const; double getBatchAverage() const; + const std::string& name() const { return _name; } + protected: static const int QUERY_QUEUE_SIZE { 4 }; diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index 3015de7e0e8..d7f617d7f99 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -10,8 +10,8 @@ <@if not GPU_TRANSFORM_STATE_SLH@> <@def GPU_TRANSFORM_STATE_SLH@> -<@include gpu/ShaderConstants.h@> <@func declareStandardCameraTransform()@> +<@include gpu/ShaderConstants.h@> <@include gpu/TransformCamera_shared.slh@> #define TransformCamera _TransformCamera @@ -90,32 +90,21 @@ vec3 getEyeWorldPos() { } bool cam_isStereo() { -#ifdef GPU_TRANSFORM_IS_STEREO return getTransformCamera()._stereoInfo.x > 0.0; -#else - return _cameraBlock._camera._stereoInfo.x > 0.0; -#endif } float cam_getStereoSide() { -#ifdef GPU_TRANSFORM_IS_STEREO -#ifdef GPU_TRANSFORM_STEREO_CAMERA return getTransformCamera()._stereoInfo.y; -#else - return _cameraBlock._camera._stereoInfo.y; -#endif -#else - return _cameraBlock._camera._stereoInfo.y; -#endif +} + +vec2 cam_getInvWidthHeight() { + return getTransformCamera()._stereoInfo.zw; } <@endfunc@> <@func declareStandardObjectTransform()@> -struct TransformObject { - mat4 _model; - mat4 _modelInverse; -}; +<@include gpu/TransformObject_shared.slh@> layout(location=GPU_ATTR_DRAW_CALL_INFO) in ivec2 _drawCallInfo; @@ -159,7 +148,7 @@ TransformObject getTransformObject() { <$viewport$> = <$cameraTransform$>._viewport; <@endfunc@> -<@func transformStereoClipsSpace(cameraTransform, clipPos)@> +<@func transformStereoClipSpace(clipPos)@> { #ifdef GPU_TRANSFORM_IS_STEREO @@ -190,6 +179,28 @@ TransformObject getTransformObject() { } <@endfunc@> +<@func transformModelToPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWorldAlignedPos)@> + + { // transformModelToPrevEyeWorldAlignedPos + highp mat4 _mv = <$objectTransform$>._previousModel; + _mv[3].xyz -= <$cameraTransform$>._previousViewInverse[3].xyz; + highp vec4 _eyeWApos = (_mv * <$modelPos$>); + <$eyeWorldAlignedPos$> = _eyeWApos; + } +<@endfunc@> + +<@func transformModelToEyeAndPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWAPos, prevEyeWAPos)@> + + { // transformModelToEyeAndPrevEyeWorldAlignedPos + highp mat4 _mv = <$objectTransform$>._model; + highp mat4 _pmv = <$objectTransform$>._previousModel; + _mv[3].xyz -= <$cameraTransform$>._viewInverse[3].xyz; + _pmv[3].xyz -= <$cameraTransform$>._previousViewInverse[3].xyz; + <$eyeWAPos$> = (_mv * <$modelPos$>); + <$prevEyeWAPos$> = (_pmv * <$modelPos$>); + } +<@endfunc@> + <@func transformModelToMonoClipPos(cameraTransform, objectTransform, modelPos, clipPos)@> { // transformModelToMonoClipPos vec4 eyeWAPos; @@ -201,7 +212,7 @@ TransformObject getTransformObject() { <@func transformModelToClipPos(cameraTransform, objectTransform, modelPos, clipPos)@> { // transformModelToClipPos <$transformModelToMonoClipPos($cameraTransform$, $objectTransform$, $modelPos$, $clipPos$)$> - <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$> + <$transformStereoClipSpace($clipPos$)$> } <@endfunc@> @@ -212,19 +223,74 @@ TransformObject getTransformObject() { <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); - <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$> + <$transformStereoClipSpace($clipPos$)$> + } +<@endfunc@> + +<@func transformModelToEyeClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos, prevClipPos)@> + { // transformModelToEyeClipPosAndPrevClipPos + vec4 eyeWAPos; + vec4 prevEyeWAPos; + <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> + <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); + <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; + <$transformStereoClipSpace($clipPos$)$> + + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * prevEyeWAPos; + // Prev clip pos is in mono clip space + } +<@endfunc@> + +<@func transformModelToEyeMonoClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos, monoClipPos, prevClipPos)@> + { // transformModelToEyeMonoClipPosAndPrevClipPos + vec4 eyeWAPos; + vec4 prevEyeWAPos; + <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> + <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); + <$monoClipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; + <$clipPos$> = <$monoClipPos$>; + <$transformStereoClipSpace($clipPos$)$> + + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * prevEyeWAPos; + // Prev clip pos is in mono clip space + } +<@endfunc@> + +<@func transformModelToClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, clipPos, prevClipPos)@> + { // transformModelToClipPosAndPrevClipPos + vec4 eyeWAPos; + vec4 prevEyeWAPos; + <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> + <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; + <$transformStereoClipSpace($clipPos$)$> + + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * prevEyeWAPos; + // Prev clip pos is in mono clip space } <@endfunc@> <@func transformModelToWorldAndEyeAndClipPos(cameraTransform, objectTransform, modelPos, worldPos, eyePos, clipPos)@> - { // transformModelToEyeAndClipPos + { // transformModelToWorldAndEyeAndClipPos vec4 eyeWAPos; <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$> <$worldPos$> = vec4(eyeWAPos.xyz + <$cameraTransform$>._viewInverse[3].xyz, 1.0); <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); - <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$> + <$transformStereoClipSpace($clipPos$)$> + } +<@endfunc@> + +<@func transformModelToWorldEyeClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, worldPos, eyePos, clipPos, prevClipPos)@> + { // transformModelToWorldEyeClipPosAndPrevClipPos + vec4 eyeWAPos; + vec4 prevEyeWAPos; + <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> + <$worldPos$> = vec4(eyeWAPos.xyz + <$cameraTransform$>._viewInverse[3].xyz, 1.0); + <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; + <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * prevEyeWAPos; + <$transformStereoClipSpace($clipPos$)$> } <@endfunc@> @@ -236,13 +302,22 @@ TransformObject getTransformObject() { } <@endfunc@> +<@func transformModelToEyePosAndPrevEyePos(cameraTransform, objectTransform, modelPos, eyePos, prevEyePos)@> + { // transformModelToEyePosAndPrevEyePos + vec4 eyeWAPos; + vec4 prevEyeWAPos; + <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> + <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); + <$prevEyePos$> = vec4((<$cameraTransform$>._previousView * vec4(prevEyeWAPos.xyz, 0.0)).xyz, 1.0); + } +<@endfunc@> <@func transformWorldToClipPos(cameraTransform, worldPos, clipPos)@> { // transformWorldToClipPos vec4 eyeWAPos = <$worldPos$> - vec4(<$cameraTransform$>._viewInverse[3].xyz, 0.0); <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; - <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$> + <$transformStereoClipSpace($clipPos$)$> } <@endfunc@> @@ -275,12 +350,40 @@ TransformObject getTransformObject() { } <@endfunc@> +<@func transformModelToPrevEyeDir(cameraTransform, objectTransform, modelDir, prevEyeDir)@> + { // transformModelToPrevEyeDir + vec3 mr0 = vec3(<$objectTransform$>._previousModelInverse[0].x, <$objectTransform$>._previousModelInverse[1].x, <$objectTransform$>._previousModelInverse[2].x); + vec3 mr1 = vec3(<$objectTransform$>._previousModelInverse[0].y, <$objectTransform$>._previousModelInverse[1].y, <$objectTransform$>._previousModelInverse[2].y); + vec3 mr2 = vec3(<$objectTransform$>._previousModelInverse[0].z, <$objectTransform$>._previousModelInverse[1].z, <$objectTransform$>._previousModelInverse[2].z); + + vec3 mvc0 = vec3(dot(<$cameraTransform$>._previousViewInverse[0].xyz, mr0), dot(<$cameraTransform$>._previousViewInverse[0].xyz, mr1), dot(<$cameraTransform$>._previousViewInverse[0].xyz, mr2)); + vec3 mvc1 = vec3(dot(<$cameraTransform$>._previousViewInverse[1].xyz, mr0), dot(<$cameraTransform$>._previousViewInverse[1].xyz, mr1), dot(<$cameraTransform$>._previousViewInverse[1].xyz, mr2)); + vec3 mvc2 = vec3(dot(<$cameraTransform$>._previousViewInverse[2].xyz, mr0), dot(<$cameraTransform$>._previousViewInverse[2].xyz, mr1), dot(<$cameraTransform$>._previousViewInverse[2].xyz, mr2)); + + <$prevEyeDir$> = vec3(dot(mvc0, <$modelDir$>), dot(mvc1, <$modelDir$>), dot(mvc2, <$modelDir$>)); + } +<@endfunc@> + <@func transformEyeToWorldDir(cameraTransform, eyeDir, worldDir)@> { // transformEyeToWorldDir <$worldDir$> = vec3(<$cameraTransform$>._viewInverse * vec4(<$eyeDir$>.xyz, 0.0)); } <@endfunc@> +<@func transformEyeToPrevWorldDir(cameraTransform, eyeDir, prevWorldDir)@> + { // transformEyeToPrevWorldDir + <$prevWorldDir$> = vec3(<$cameraTransform$>._previousViewInverse * vec4(<$eyeDir$>.xyz, 0.0)); + } +<@endfunc@> + +<@func transformEyeToWorldDirAndPrevClipPos(cameraTransform, eyeDir, worldDir, prevClipPos)@> + { // transformEyeToWorldDirAndPrevClipPos + vec4 worldVec = <$cameraTransform$>._viewInverse * vec4(<$eyeDir$>.xyz, 0.0); + <$worldDir$> = worldVec.xyz; + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * worldVec; + } +<@endfunc@> + <@func transformClipToEyeDir(cameraTransform, clipPos, eyeDir)@> { // transformClipToEyeDir <$eyeDir$> = vec3(<$cameraTransform$>._projectionInverse * vec4(<$clipPos$>.xyz, 1.0)); // Must be 1.0 here @@ -291,7 +394,14 @@ TransformObject getTransformObject() { { // transformEyeToClipPos <$clipPos$> = <$cameraTransform$>._projection * vec4(<$eyePos$>.xyz, 1.0); - <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$> + <$transformStereoClipSpace($clipPos$)$> + } +<@endfunc@> + +<@func transformPrevEyeToPrevClipPos(cameraTransform, prevEyePos, prevClipPos)@> + { // transformPrevEyeToPrevClipPos + <$prevClipPos$> = <$cameraTransform$>._previousViewInverse * vec4(<$prevEyePos$>.xyz, 1.0) - vec4(<$cameraTransform$>._previousViewInverse[3].xyz, 0.0); + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * <$prevClipPos$>; } <@endfunc@> diff --git a/libraries/gpu/src/gpu/TransformCamera_shared.slh b/libraries/gpu/src/gpu/TransformCamera_shared.slh index e4a0f8c2cc6..a7d8f58590f 100644 --- a/libraries/gpu/src/gpu/TransformCamera_shared.slh +++ b/libraries/gpu/src/gpu/TransformCamera_shared.slh @@ -1,22 +1,26 @@ -// glsl / C++ compatible source as interface for FadeEffect +// glsl / C++ compatible source as interface for TransformCamera #ifdef __cplusplus -# define _MAT4 Mat4 -# define _VEC4 Vec4 -# define _MUTABLE mutable +# define TC_MAT4 gpu::Mat4 +# define TC_VEC4 gpu::Vec4 +# define TC_MUTABLE mutable #else -# define _MAT4 mat4 -# define _VEC4 vec4 -# define _MUTABLE +# define TC_MAT4 mat4 +# define TC_VEC4 vec4 +# define TC_MUTABLE #endif struct _TransformCamera { - _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. - _MUTABLE _VEC4 _stereoInfo; + TC_MUTABLE TC_MAT4 _view; + TC_MUTABLE TC_MAT4 _viewInverse; + TC_MUTABLE TC_MAT4 _previousView; + TC_MUTABLE TC_MAT4 _previousViewInverse; + TC_MAT4 _projection; + TC_MUTABLE TC_MAT4 _projectionInverse; + TC_MUTABLE TC_MAT4 _projectionViewUntranslated; + // Previous projection view untranslated AND jittered with current jitter + TC_MUTABLE TC_MAT4 _previousProjectionViewUntranslated; + TC_VEC4 _viewport; // Public value is int but float in the shader to stay in floats for all the transform computations. + TC_MUTABLE TC_VEC4 _stereoInfo; }; // <@if 1@> diff --git a/libraries/gpu/src/gpu/TransformObject_shared.slh b/libraries/gpu/src/gpu/TransformObject_shared.slh new file mode 100644 index 00000000000..dce87c9e0b9 --- /dev/null +++ b/libraries/gpu/src/gpu/TransformObject_shared.slh @@ -0,0 +1,19 @@ +// glsl / C++ compatible source as interface for TransformCamera +#ifdef __cplusplus +# define TO_MAT4 Mat4 +#else +# define TO_MAT4 mat4 +#endif + +struct TransformObject { + TO_MAT4 _model; + TO_MAT4 _modelInverse; + TO_MAT4 _previousModel; + TO_MAT4 _previousModelInverse; +}; + + // <@if 1@> + // Trigger Scribe include + // <@endif@> +// + diff --git a/libraries/gpu/src/gpu/drawColor.slp b/libraries/gpu/src/gpu/drawColor.slp index 1c81242fed5..8289f465502 100644 --- a/libraries/gpu/src/gpu/drawColor.slp +++ b/libraries/gpu/src/gpu/drawColor.slp @@ -1,3 +1,2 @@ -VERTEX DrawTransformVertexPosition +VERTEX DrawUnitQuad FRAGMENT DrawColor -r diff --git a/libraries/gpu/src/gpu/drawWhite.slp b/libraries/gpu/src/gpu/drawWhite.slp new file mode 100644 index 00000000000..c3e7ec1121d --- /dev/null +++ b/libraries/gpu/src/gpu/drawWhite.slp @@ -0,0 +1,2 @@ +VERTEX DrawUnitQuad +FRAGMENT DrawWhite diff --git a/libraries/graphics/src/graphics/Skybox.cpp b/libraries/graphics/src/graphics/Skybox.cpp index 7d7fd35018b..e0134c337b4 100644 --- a/libraries/graphics/src/graphics/Skybox.cpp +++ b/libraries/graphics/src/graphics/Skybox.cpp @@ -73,14 +73,14 @@ void Skybox::prepare(gpu::Batch& batch) const { } } -void Skybox::render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward) const { +void Skybox::render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward, uint transformSlot) const { updateSchemaBuffer(); - Skybox::render(batch, frustum, (*this), forward); + Skybox::render(batch, frustum, (*this), forward, transformSlot); } static std::map _pipelines; -void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Skybox& skybox, bool forward) { +void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Skybox& skybox, bool forward, uint transformSlot) { if (_pipelines.empty()) { static const std::vector> keys = { std::make_tuple(false, shader::graphics::program::skybox), @@ -109,6 +109,8 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky batch.setProjectionTransform(projMat); batch.setViewTransform(viewTransform); + // This is needed if we want to have motion vectors on the sky + batch.saveViewProjectionTransform(transformSlot); batch.setModelTransform(Transform()); // only for Mac batch.setPipeline(_pipelines[forward]); diff --git a/libraries/graphics/src/graphics/Skybox.h b/libraries/graphics/src/graphics/Skybox.h index 5668604c8b8..94b12cf1abc 100644 --- a/libraries/graphics/src/graphics/Skybox.h +++ b/libraries/graphics/src/graphics/Skybox.h @@ -44,9 +44,9 @@ class Skybox { virtual void clear(); void prepare(gpu::Batch& batch) const; - virtual void render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward) const; + virtual void render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward, uint transformSlot) const; - static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox, bool forward); + static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox, bool forward, uint transformSlot); const UniformBufferView& getSchemaBuffer() const { return _schemaBuffer; } diff --git a/libraries/graphics/src/graphics/skybox.slv b/libraries/graphics/src/graphics/skybox.slv index a6e6930d22d..91f5e1dcd96 100755 --- a/libraries/graphics/src/graphics/skybox.slv +++ b/libraries/graphics/src/graphics/skybox.slv @@ -23,17 +23,16 @@ void main(void) { vec4(-1.0, 1.0, depth, 1.0), vec4(1.0, 1.0, depth, 1.0) ); - vec4 inPosition = UNIT_QUAD[gl_VertexID]; // standard transform TransformCamera cam = getTransformCamera(); - vec3 clipDir = vec3(inPosition.xy, 0.0); + vec3 clipDir = UNIT_QUAD[gl_VertexID].xyz; vec3 eyeDir; <$transformClipToEyeDir(cam, clipDir, eyeDir)$> <$transformEyeToWorldDir(cam, eyeDir, _normal)$> // Position is supposed to come in clip space - gl_Position = vec4(inPosition.xy, 0.0, 1.0); + gl_Position = vec4(clipDir, 1.0); - <$transformStereoClipsSpace(cam, gl_Position)$> + <$transformStereoClipSpace(gl_Position)$> } diff --git a/libraries/procedural/src/procedural/ProceduralSkybox.cpp b/libraries/procedural/src/procedural/ProceduralSkybox.cpp index 432e02fe101..f96dd7f4ed4 100644 --- a/libraries/procedural/src/procedural/ProceduralSkybox.cpp +++ b/libraries/procedural/src/procedural/ProceduralSkybox.cpp @@ -43,15 +43,15 @@ void ProceduralSkybox::clear() { Skybox::clear(); } -void ProceduralSkybox::render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward) const { +void ProceduralSkybox::render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward, uint transformSlot) const { if (_procedural.isReady()) { - ProceduralSkybox::render(batch, frustum, (*this), forward); + ProceduralSkybox::render(batch, frustum, (*this), forward, transformSlot); } else { - Skybox::render(batch, frustum, forward); + Skybox::render(batch, frustum, forward, transformSlot); } } -void ProceduralSkybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const ProceduralSkybox& skybox, bool forward) { +void ProceduralSkybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const ProceduralSkybox& skybox, bool forward, uint transformSlot) { glm::mat4 projMat; viewFrustum.evalProjectionMatrix(projMat); @@ -59,6 +59,8 @@ void ProceduralSkybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, viewFrustum.evalViewTransform(viewTransform); batch.setProjectionTransform(projMat); batch.setViewTransform(viewTransform); + // This is needed if we want to have motion vectors on the sky + batch.saveViewProjectionTransform(transformSlot); batch.setModelTransform(Transform()); // only for Mac auto& procedural = skybox._procedural; diff --git a/libraries/procedural/src/procedural/ProceduralSkybox.h b/libraries/procedural/src/procedural/ProceduralSkybox.h index 983b4320893..122eeafbf92 100644 --- a/libraries/procedural/src/procedural/ProceduralSkybox.h +++ b/libraries/procedural/src/procedural/ProceduralSkybox.h @@ -26,8 +26,8 @@ class ProceduralSkybox: public graphics::Skybox { bool empty() override; void clear() override; - void render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward) const override; - static void render(gpu::Batch& batch, const ViewFrustum& frustum, const ProceduralSkybox& skybox, bool forward); + void render(gpu::Batch& batch, const ViewFrustum& frustum, bool forward, uint transformSlot) const override; + static void render(gpu::Batch& batch, const ViewFrustum& frustum, const ProceduralSkybox& skybox, bool forward, uint transformSlot); uint64_t getCreated() const { return _created; } diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index ac0eed9417b..d4debab45bc 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -13,7 +13,6 @@ #include -#include #include #include #include @@ -21,11 +20,6 @@ #include "render-utils/ShaderConstants.h" #include "StencilMaskPass.h" -#include "TextureCache.h" -#include "DependencyManager.h" -#include "ViewFrustum.h" -#include "GeometryCache.h" -#include "FramebufferCache.h" #include "RandomAndNoise.h" namespace ru { @@ -38,110 +32,107 @@ namespace gr { using graphics::slot::buffer::Buffer; } -#if !ANTIALIASING_USE_TAA +gpu::PipelinePointer Antialiasing::_antialiasingPipeline; +gpu::PipelinePointer Antialiasing::_intensityPipeline; +gpu::PipelinePointer Antialiasing::_blendPipeline; +gpu::PipelinePointer Antialiasing::_debugBlendPipeline; -Antialiasing::Antialiasing() { - _geometryId = DependencyManager::get()->allocateID(); + #define TAA_JITTER_SEQUENCE_LENGTH 16 + +void AntialiasingSetupConfig::setIndex(int current) { + _index = (current) % TAA_JITTER_SEQUENCE_LENGTH; + emit dirty(); } -Antialiasing::~Antialiasing() { - auto geometryCache = DependencyManager::get(); - if (geometryCache) { - geometryCache->releaseID(_geometryId); +int AntialiasingSetupConfig::cycleStopPauseRun() { + _state = (_state + 1) % 3; + switch (_state) { + case 0: { + return none(); + break; + } + case 1: { + return pause(); + break; + } + case 2: + default: { + return play(); + break; + } } + return _state; } -const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() { - if (!_antialiasingPipeline) { - gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::fxaa); - gpu::StatePointer state = std::make_shared(); +int AntialiasingSetupConfig::prev() { + setIndex(_index - 1); + return _index; +} - state->setDepthTest(false, false, gpu::LESS_EQUAL); - PrepareStencil::testNoAA(*state); +int AntialiasingSetupConfig::next() { + setIndex(_index + 1); + return _index; +} - // Good to go add the brand new pipeline - _antialiasingPipeline = gpu::Pipeline::create(program, state); - } +int AntialiasingSetupConfig::none() { + _state = 0; + stop = true; + freeze = false; + setIndex(-1); + return _state; +} - return _antialiasingPipeline; +int AntialiasingSetupConfig::pause() { + _state = 1; + stop = false; + freeze = true; + setIndex(0); + return _state; } -const gpu::PipelinePointer& Antialiasing::getBlendPipeline() { - if (!_blendPipeline) { - gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::fxaa_blend); - gpu::StatePointer state = std::make_shared(); - state->setDepthTest(false, false, gpu::LESS_EQUAL); - PrepareStencil::testNoAA(*state); +int AntialiasingSetupConfig::play() { + _state = 2; + stop = false; + freeze = false; + setIndex(0); + return _state; +} - // Good to go add the brand new pipeline - _blendPipeline = gpu::Pipeline::create(program, state); +AntialiasingSetup::AntialiasingSetup() { + _sampleSequence.reserve(TAA_JITTER_SEQUENCE_LENGTH + 1); + // Fill in with jitter samples + for (int i = 0; i < TAA_JITTER_SEQUENCE_LENGTH; i++) { + _sampleSequence.emplace_back(glm::vec2(evaluateHalton<2>(i), evaluateHalton<3>(i)) - vec2(0.5f)); } return _blendPipeline; } -void Antialiasing::run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceBuffer) { - assert(renderContext->args); - assert(renderContext->args->hasViewFrustum()); - - RenderArgs* args = renderContext->args; - - gpu::doInBatch("Antialiasing::run", args->_context, [&](gpu::Batch& batch) { - batch.enableStereo(false); - batch.setViewportTransform(args->_viewport); - - if (!_paramsBuffer) { - _paramsBuffer = std::make_shared(sizeof(glm::vec4), nullptr); - } - - { - int width = args->_viewport.z; - int height = args->_viewport.w; - if (_antialiasingBuffer && _antialiasingBuffer->getSize() != uvec2(width, height)) { - _antialiasingBuffer.reset(); - } - - if (!_antialiasingBuffer) { - // Link the antialiasing FBO to texture - _antialiasingBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("antialiasing")); - auto format = gpu::Element::COLOR_SRGBA_32; - auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT); - _antialiasingTexture = gpu::Texture::createRenderBuffer(format, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); - _antialiasingBuffer->setRenderBuffer(0, _antialiasingTexture); - glm::vec2 fbExtent { args->_viewport.z, args->_viewport.w }; - glm::vec2 inverseFbExtent = 1.0f / fbExtent; - _paramsBuffer->setSubData(0, glm::vec4(inverseFbExtent, 0.0, 0.0)); - } - } - - - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); - batch.setModelTransform(Transform()); - - // FXAA step - auto pipeline = getAntialiasingPipeline(); - batch.setResourceTexture(0, sourceBuffer->getRenderBuffer(0)); - batch.setFramebuffer(_antialiasingBuffer); - batch.setPipeline(pipeline); - batch.setUniformBuffer(0, _paramsBuffer); - batch.draw(gpu::TRIANGLE_STRIP, 4); +void AntialiasingSetup::configure(const Config& config) { + _isStopped = config.stop; + _isFrozen = config.freeze; - // Blend step - batch.setResourceTexture(0, _antialiasingTexture); - batch.setFramebuffer(sourceBuffer); - batch.setPipeline(getBlendPipeline()); - batch.draw(gpu::TRIANGLE_STRIP, 4); - }); + if (config.freeze) { + _freezedSampleIndex = config.getIndex(); + } + _scale = config.scale; } -#else -void AntialiasingConfig::setAAMode(int mode) { - _mode = std::min((int)AntialiasingConfig::MODE_COUNT, std::max(0, mode)); // Just use unsigned? - emit dirty(); +void AntialiasingSetup::run(const render::RenderContextPointer& renderContext) { + assert(renderContext->args); + if (!_isStopped) { + RenderArgs* args = renderContext->args; + + gpu::doInBatch("AntialiasingSetup::run", args->_context, [&](gpu::Batch& batch) { + auto offset = 0; + auto count = _sampleSequence.size(); + if (_isFrozen) { + count = 1; + offset = _freezedSampleIndex; + } + batch.setProjectionJitterSequence(_sampleSequence.data() + offset, count); + batch.setProjectionJitterScale(_scale); + }); + } } Antialiasing::Antialiasing(bool isSharpenEnabled) : @@ -154,13 +145,10 @@ Antialiasing::~Antialiasing() { _antialiasingTextures[1].reset(); } -const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline(const render::RenderContextPointer& renderContext) { - +const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() { if (!_antialiasingPipeline) { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::taa); gpu::StatePointer state = std::make_shared(); - - PrepareStencil::testNoAA(*state); // Good to go add the brand new pipeline _antialiasingPipeline = gpu::Pipeline::create(program, state); @@ -169,11 +157,24 @@ const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline(const render:: return _antialiasingPipeline; } +const gpu::PipelinePointer& Antialiasing::getIntensityPipeline() { + if (!_intensityPipeline) { + gpu::ShaderPointer program = gpu::Shader::createProgram(shader::gpu::program::drawWhite); + gpu::StatePointer state = std::make_shared(); + + PrepareStencil::testNoAA(*state); + + // Good to go add the brand new pipeline + _intensityPipeline = gpu::Pipeline::create(program, state); + } + + return _intensityPipeline; +} + const gpu::PipelinePointer& Antialiasing::getBlendPipeline() { if (!_blendPipeline) { - gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::fxaa_blend); + gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::aa_blend); gpu::StatePointer state = std::make_shared(); - PrepareStencil::testNoAA(*state); // Good to go add the brand new pipeline _blendPipeline = gpu::Pipeline::create(program, state); } @@ -200,6 +201,7 @@ void Antialiasing::configure(const Config& config) { if (!_isSharpenEnabled) { _sharpen = 0.0f; } + _params.edit().setSharpenedOutput(_sharpen > 0.0f); _params.edit().blend = config.blend * config.blend; _params.edit().covarianceGamma = config.covarianceGamma; @@ -211,6 +213,8 @@ void Antialiasing::configure(const Config& config) { _params.edit().regionInfo.x = config.debugX; _params.edit().regionInfo.z = config.debugFXAAX; + _params.edit().setBicubicHistoryFetch(config.bicubicHistoryFetch); + _params.edit().setDebug(config.debug); _params.edit().setShowDebugCursor(config.showCursorPixel); _params.edit().setDebugCursor(config.debugCursorTexcoord); @@ -220,16 +224,16 @@ void Antialiasing::configure(const Config& config) { } -void Antialiasing::run(const render::RenderContextPointer& renderContext, const Inputs& inputs) { +void Antialiasing::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& output) { assert(renderContext->args); - assert(renderContext->args->hasViewFrustum()); RenderArgs* args = renderContext->args; auto& deferredFrameTransform = inputs.get0(); - auto& sourceBuffer = inputs.get1(); - auto& linearDepthBuffer = inputs.get2(); - auto& velocityBuffer = inputs.get3(); + const auto& deferredFrameBuffer = inputs.get1(); + const auto& sourceBuffer = deferredFrameBuffer->getLightingFramebuffer(); + const auto& linearDepthBuffer = inputs.get2(); + const auto& velocityTexture = deferredFrameBuffer->getDeferredVelocityTexture(); int width = sourceBuffer->getWidth(); int height = sourceBuffer->getHeight(); @@ -240,12 +244,9 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const _antialiasingTextures[1].reset(); } - - if (!_antialiasingBuffers) { - std::vector antiAliasingBuffers; + if (!_antialiasingBuffers || !_intensityFramebuffer) { std::vector antiAliasingBuffers; // Link the antialiasing FBO to texture - auto format = sourceBuffer->getRenderBuffer(0)->getTexelFormat(); - auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR, gpu::Sampler::WRAP_CLAMP); + auto format = gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA); auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR, gpu::Sampler::WRAP_CLAMP); for (int i = 0; i < 2; i++) { antiAliasingBuffers.emplace_back(gpu::Framebuffer::create("antialiasing")); const auto& antiAliasingBuffer = antiAliasingBuffers.back(); @@ -253,25 +254,47 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const antiAliasingBuffer->setRenderBuffer(0, _antialiasingTextures[i]); } _antialiasingBuffers = std::make_shared(antiAliasingBuffers); + + _intensityTexture = gpu::Texture::createRenderBuffer(gpu::Element::COLOR_R_8, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); + _intensityFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("taaIntensity")); + _intensityFramebuffer->setRenderBuffer(0, _intensityTexture); + _intensityFramebuffer->setStencilBuffer(deferredFrameBuffer->getDeferredFramebuffer()->getDepthStencilBuffer(), deferredFrameBuffer->getDeferredFramebuffer()->getDepthStencilBufferFormat()); } - + + outputs = _intensityTexture; + gpu::doInBatch("Antialiasing::run", args->_context, [&](gpu::Batch& batch) { + PROFILE_RANGE_BATCH(batch, "TAA"); + batch.enableStereo(false); batch.setViewportTransform(args->_viewport); + // Set the intensity buffer to 1 except when the stencil is masked as NoAA, where it should be 0 + // This is a bit of a hack as it is not possible and not portable to use the stencil value directly + // as a texture + batch.setFramebuffer(_intensityFramebuffer); + batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, gpu::Vec4(0.0f)); + batch.setResourceTexture(0, nullptr); + batch.setPipeline(getIntensityPipeline()); + batch.draw(gpu::TRIANGLE_STRIP, 4); + // TAA step - getAntialiasingPipeline(renderContext); - batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaHistory, _antialiasingBuffers, 0); - batch.setResourceTexture(ru::Texture::TaaSource, sourceBuffer->getRenderBuffer(0)); - batch.setResourceTexture(ru::Texture::TaaVelocity, velocityBuffer->getVelocityTexture()); - // This is only used during debug + if (!_params->isFXAAEnabled()) { + batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaHistory, _antialiasingBuffers, 0); + batch.setResourceTexture(ru::Texture::TaaVelocity, velocityTexture); + } else { + batch.setResourceTexture(ru::Texture::TaaHistory, nullptr); + batch.setResourceTexture(ru::Texture::TaaVelocity, nullptr); + } + + // This is only used during debug batch.setResourceTexture(ru::Texture::TaaDepth, linearDepthBuffer->getLinearDepthTexture()); batch.setUniformBuffer(ru::Buffer::TaaParams, _params); batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredFrameTransform->getFrameTransformBuffer()); - + batch.setFramebufferSwapChain(_antialiasingBuffers, 1); - batch.setPipeline(getAntialiasingPipeline(renderContext)); + batch.setPipeline(getAntialiasingPipeline()); batch.draw(gpu::TRIANGLE_STRIP, 4); // Blend step @@ -281,9 +304,9 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const if (_params->isDebug()) { batch.setPipeline(getDebugBlendPipeline()); batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaNext, _antialiasingBuffers, 1); - } else { + } else { batch.setPipeline(getBlendPipeline()); - // Must match the bindg point in the fxaa_blend.slf shader + // Must match the binding point in the aa_blend.slf shader batch.setResourceFramebufferSwapChainTexture(0, _antialiasingBuffers, 1); // Disable sharpen if FXAA if (!_blendParamsBuffer) { @@ -294,7 +317,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const } batch.draw(gpu::TRIANGLE_STRIP, 4); batch.advance(_antialiasingBuffers); - + batch.setUniformBuffer(ru::Buffer::TaaParams, nullptr); batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, nullptr); @@ -302,114 +325,8 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const batch.setResourceTexture(ru::Texture::TaaHistory, nullptr); batch.setResourceTexture(ru::Texture::TaaVelocity, nullptr); batch.setResourceTexture(ru::Texture::TaaNext, nullptr); - }); -} - -void JitterSampleConfig::setIndex(int current) { - _index = (current) % JitterSample::SEQUENCE_LENGTH; - emit dirty(); -} - -void JitterSampleConfig::setState(int state) { - _state = (state) % 3; - switch (_state) { - case 0: { - none(); - break; - } - case 1: { - pause(); - break; - } - case 2: - default: { - play(); - break; - } - } - emit dirty(); -} - -int JitterSampleConfig::cycleStopPauseRun() { - setState((_state + 1) % 3); - return _state; -} - -int JitterSampleConfig::prev() { - setIndex(_index - 1); - return _index; -} - -int JitterSampleConfig::next() { - setIndex(_index + 1); - return _index; -} - -int JitterSampleConfig::none() { - _state = 0; - stop = true; - freeze = false; - setIndex(-1); - return _state; -} - -int JitterSampleConfig::pause() { - _state = 1; - stop = false; - freeze = true; - setIndex(0); - return _state; -} - - -int JitterSampleConfig::play() { - _state = 2; - stop = false; - freeze = false; - setIndex(0); - return _state; -} - -JitterSample::SampleSequence::SampleSequence(){ - // Halton sequence (2,3) - - for (int i = 0; i < SEQUENCE_LENGTH; i++) { - offsets[i] = glm::vec2(halton::evaluate<2>(i), halton::evaluate<3>(i)); - offsets[i] -= vec2(0.5f); - } - offsets[SEQUENCE_LENGTH] = glm::vec2(0.0f); -} - -void JitterSample::configure(const Config& config) { - _freeze = config.stop || config.freeze; - if (config.freeze) { - auto pausedIndex = config.getIndex(); - if (_sampleSequence.currentIndex != pausedIndex) { - _sampleSequence.currentIndex = pausedIndex; - } - } else if (config.stop) { - _sampleSequence.currentIndex = -1; - } else { - _sampleSequence.currentIndex = config.getIndex(); - } - _scale = config.scale; -} - -void JitterSample::run(const render::RenderContextPointer& renderContext, Output& jitter) { - auto& current = _sampleSequence.currentIndex; - if (!_freeze) { - if (current >= 0) { - current = (current + 1) % SEQUENCE_LENGTH; - } else { - current = -1; - } - } - if (current >= 0) { - jitter = _sampleSequence.offsets[current]; - } else { - jitter = glm::vec2(0.0f); - } + // Reset jitter sequence + batch.setProjectionJitterSequence(nullptr, 0); + }); } - -#endif diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 540810bbc3e..4d24fe3a258 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -18,10 +18,10 @@ #include "render/DrawTask.h" #include "DeferredFrameTransform.h" -#include "VelocityBufferPass.h" +#include "DeferredFramebuffer.h" +#include "SurfaceGeometryPass.h" - -class JitterSampleConfig : public render::Job::Config { +class AntialiasingSetupConfig : public render::Job::Config { Q_OBJECT Q_PROPERTY(float scale MEMBER scale NOTIFY dirty) Q_PROPERTY(bool freeze MEMBER freeze NOTIFY dirty) @@ -29,9 +29,9 @@ class JitterSampleConfig : public render::Job::Config { Q_PROPERTY(int index READ getIndex NOTIFY dirty) Q_PROPERTY(int state READ getState WRITE setState NOTIFY dirty) public: - JitterSampleConfig() : render::Job::Config(true) {} + AntialiasingSetupConfig() : render::Job::Config(true) {} - float scale{ 0.5f }; + float scale{ 1.0f }; bool stop{ false }; bool freeze{ false }; @@ -57,34 +57,22 @@ public slots: }; - -class JitterSample { +class AntialiasingSetup { public: - enum { - SEQUENCE_LENGTH = 64 - }; - - using Config = JitterSampleConfig; - using Output = glm::vec2; - using JobModel = render::Job::ModelO; + using Config = AntialiasingSetupConfig; + using JobModel = render::Job::Model; void configure(const Config& config); - void run(const render::RenderContextPointer& renderContext, Output& jitter); + void run(const render::RenderContextPointer& renderContext); private: - struct SampleSequence { - SampleSequence(); - - glm::vec2 offsets[SEQUENCE_LENGTH + 1]; - int sequenceLength{ SEQUENCE_LENGTH }; - int currentIndex{ 0 }; - }; - - SampleSequence _sampleSequence; - float _scale{ 1.0 }; - bool _freeze{ false }; + std::vector _sampleSequence; + float _scale { 1.0f }; + int _freezedSampleIndex { 0 }; + bool _isStopped { false }; + bool _isFrozen { false }; }; @@ -97,6 +85,7 @@ class AntialiasingConfig : public render::Job::Config { Q_PROPERTY(bool constrainColor MEMBER constrainColor NOTIFY dirty) Q_PROPERTY(bool feedbackColor MEMBER feedbackColor NOTIFY dirty) + Q_PROPERTY(bool bicubicHistoryFetch MEMBER bicubicHistoryFetch NOTIFY dirty) Q_PROPERTY(bool debug MEMBER debug NOTIFY dirty) Q_PROPERTY(float debugX MEMBER debugX NOTIFY dirty) @@ -141,12 +130,13 @@ class AntialiasingConfig : public render::Job::Config { int _mode{ TAA }; // '_' prefix but not private? - float blend{ 0.25f }; - float sharpen{ 0.05f }; + float blend { 0.2f }; + float sharpen { 0.0f }; - bool constrainColor{ true }; - float covarianceGamma{ 0.65f }; - bool feedbackColor{ false }; + bool constrainColor { true }; + float covarianceGamma { 1.15f }; + bool feedbackColor { false }; + bool bicubicHistoryFetch { true }; float debugX{ 0.0f }; float debugFXAAX{ 1.0f }; @@ -165,15 +155,11 @@ class AntialiasingConfig : public render::Job::Config { #define SET_BIT(bitfield, bitIndex, value) bitfield = ((bitfield) & ~(1 << (bitIndex))) | ((value) << (bitIndex)) #define GET_BIT(bitfield, bitIndex) ((bitfield) & (1 << (bitIndex))) -#define ANTIALIASING_USE_TAA 1 - -#if ANTIALIASING_USE_TAA - struct TAAParams { - float nope{ 0.0f }; - float blend{ 0.15f }; - float covarianceGamma{ 1.0f }; - float debugShowVelocityThreshold{ 1.0f }; + float nope { 0.0f }; + float blend { 0.15f }; + float covarianceGamma { 0.9f }; + float debugShowVelocityThreshold { 1.0f }; glm::ivec4 flags{ 0 }; glm::vec4 pixelInfo{ 0.5f, 0.5f, 2.0f, 0.0f }; @@ -185,6 +171,12 @@ struct TAAParams { void setFeedbackColor(bool enabled) { SET_BIT(flags.y, 4, enabled); } bool isFeedbackColor() const { return (bool)GET_BIT(flags.y, 4); } + void setBicubicHistoryFetch(bool enabled) { SET_BIT(flags.y, 0, enabled); } + bool isBicubicHistoryFetch() const { return (bool)GET_BIT(flags.y, 0); } + + void setSharpenedOutput(bool enabled) { SET_BIT(flags.y, 2, enabled); } + bool isSharpenedOutput() const { return (bool)GET_BIT(flags.y, 2); } + void setDebug(bool enabled) { SET_BIT(flags.x, 0, enabled); } bool isDebug() const { return (bool) GET_BIT(flags.x, 0); } @@ -199,21 +191,24 @@ struct TAAParams { void setShowClosestFragment(bool enabled) { SET_BIT(flags.x, 3, enabled); } + bool isFXAAEnabled() const { return regionInfo.z == 0.0f; } }; using TAAParamsBuffer = gpu::StructBuffer; class Antialiasing { public: - using Inputs = render::VaryingSet4 < DeferredFrameTransformPointer, gpu::FramebufferPointer, LinearDepthFramebufferPointer, VelocityFramebufferPointer > ; + using Inputs = render::VaryingSet3; + using Outputs = gpu::TexturePointer; using Config = AntialiasingConfig; - using JobModel = render::Job::ModelI; + using JobModel = render::Job::ModelIO; Antialiasing(bool isSharpenEnabled = true); ~Antialiasing(); void configure(const Config& config); - void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); + void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs); - const gpu::PipelinePointer& getAntialiasingPipeline(const render::RenderContextPointer& renderContext); + const gpu::PipelinePointer& getAntialiasingPipeline(); + const gpu::PipelinePointer& getIntensityPipeline(); const gpu::PipelinePointer& getBlendPipeline(); const gpu::PipelinePointer& getDebugBlendPipeline(); @@ -221,10 +216,16 @@ class Antialiasing { gpu::FramebufferSwapChainPointer _antialiasingBuffers; gpu::TexturePointer _antialiasingTextures[2]; + gpu::FramebufferPointer _intensityFramebuffer; + gpu::TexturePointer _intensityTexture; gpu::BufferPointer _blendParamsBuffer; gpu::PipelinePointer _antialiasingPipeline; gpu::PipelinePointer _blendPipeline; - gpu::PipelinePointer _debugBlendPipeline; + + static gpu::PipelinePointer _antialiasingPipeline; + static gpu::PipelinePointer _intensityPipeline; + static gpu::PipelinePointer _blendPipeline; + static gpu::PipelinePointer _debugBlendPipeline; TAAParamsBuffer _params; AntialiasingConfig::Mode _mode{ AntialiasingConfig::TAA }; @@ -232,38 +233,4 @@ class Antialiasing { bool _isSharpenEnabled{ true }; }; - -#else // User setting for antialias mode will probably be broken. -class AntiAliasingConfig : public render::Job::Config { // Not to be confused with AntialiasingConfig... - Q_OBJECT - Q_PROPERTY(bool enabled MEMBER enabled) -public: - AntiAliasingConfig() : render::Job::Config(true) {} -}; - -class Antialiasing { -public: - using Config = AntiAliasingConfig; - using JobModel = render::Job::ModelI; - - Antialiasing(); - ~Antialiasing(); - void configure(const Config& config) {} - void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceBuffer); - - const gpu::PipelinePointer& getAntialiasingPipeline(); - const gpu::PipelinePointer& getBlendPipeline(); - -private: - gpu::FramebufferPointer _antialiasingBuffer; - - gpu::TexturePointer _antialiasingTexture; - gpu::BufferPointer _paramsBuffer; - - gpu::PipelinePointer _antialiasingPipeline; - gpu::PipelinePointer _blendPipeline; - int _geometryId { 0 }; -}; -#endif - #endif // hifi_AntialiasingEffect_h diff --git a/libraries/render-utils/src/BackgroundStage.cpp b/libraries/render-utils/src/BackgroundStage.cpp index 91b766d90be..12e78de7877 100644 --- a/libraries/render-utils/src/BackgroundStage.cpp +++ b/libraries/render-utils/src/BackgroundStage.cpp @@ -80,6 +80,7 @@ void DrawBackgroundStage::run(const render::RenderContextPointer& renderContext, auto args = renderContext->args; gpu::doInBatch("DrawBackgroundStage::run", args->_context, [&](gpu::Batch& batch) { + PROFILE_RANGE_BATCH(batch, "Background"); args->_batch = &batch; batch.enableSkybox(true); @@ -87,16 +88,11 @@ void DrawBackgroundStage::run(const render::RenderContextPointer& renderContext, batch.setViewportTransform(args->_viewport); batch.setStateScissorRect(args->_viewport); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat); + bool forward = args->_renderMethod == render::Args::RenderMethod::FORWARD; + batch.setProjectionJitterEnabled(forward); // If we're using forward rendering, we need to calculate haze - if (args->_renderMethod == render::Args::RenderMethod::FORWARD) { + if (forward) { const auto& hazeStage = args->_scene->getStage(); if (hazeStage && hazeFrame->_hazes.size() > 0) { const auto& hazePointer = hazeStage->getHaze(hazeFrame->_hazes.front()); @@ -106,7 +102,7 @@ void DrawBackgroundStage::run(const render::RenderContextPointer& renderContext, } } - skybox->render(batch, args->getViewFrustum(), args->_renderMethod == render::Args::RenderMethod::FORWARD); + skybox->render(batch, args->getViewFrustum(), forward, _transformSlot); }); args->_batch = nullptr; } diff --git a/libraries/render-utils/src/BackgroundStage.h b/libraries/render-utils/src/BackgroundStage.h index 3015b721b19..6406cf78bb9 100644 --- a/libraries/render-utils/src/BackgroundStage.h +++ b/libraries/render-utils/src/BackgroundStage.h @@ -85,9 +85,12 @@ class DrawBackgroundStage { using Inputs = render::VaryingSet3; using JobModel = render::Job::ModelI; - DrawBackgroundStage() {} + DrawBackgroundStage(unsigned int transformSlot) : _transformSlot(transformSlot) {} void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); + +private: + unsigned int _transformSlot; }; #endif diff --git a/libraries/render-utils/src/BloomEffect.cpp b/libraries/render-utils/src/BloomEffect.cpp index 5cb2f060210..ef59b1b0dc6 100644 --- a/libraries/render-utils/src/BloomEffect.cpp +++ b/libraries/render-utils/src/BloomEffect.cpp @@ -16,12 +16,15 @@ #include #include "render-utils/ShaderConstants.h" +#include "StencilMaskPass.h" #define BLOOM_BLUR_LEVEL_COUNT 3 BloomThreshold::BloomThreshold(unsigned int downsamplingFactor) { assert(downsamplingFactor > 0); - _parameters.edit()._sampleCount = downsamplingFactor; + auto& params = _parameters.edit(); + params._sampleCount = downsamplingFactor; + params._offset = (1.0f - downsamplingFactor) * 0.5f; } void BloomThreshold::configure(const Config& config) {} @@ -50,11 +53,6 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons auto inputBuffer = inputFrameBuffer->getRenderBuffer(0); auto bufferSize = gpu::Vec2u(inputBuffer->getDimensions()); - const auto downSamplingFactor = _parameters.get()._sampleCount; - - // Downsample resolution - bufferSize.x /= downSamplingFactor; - bufferSize.y /= downSamplingFactor; if (!_outputBuffer || _outputBuffer->getSize() != bufferSize) { auto colorTexture = gpu::TexturePointer(gpu::Texture::createRenderBuffer(inputBuffer->getTexelFormat(), bufferSize.x, bufferSize.y, @@ -62,6 +60,7 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons _outputBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("BloomThreshold")); _outputBuffer->setRenderBuffer(0, colorTexture); + _outputBuffer->setStencilBuffer(inputFrameBuffer->getDepthStencilBuffer(), inputFrameBuffer->getDepthStencilBufferFormat()); _parameters.edit()._deltaUV = { 1.0f / bufferSize.x, 1.0f / bufferSize.y }; } @@ -69,6 +68,7 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons if (!_pipeline) { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::bloomThreshold); gpu::StatePointer state = std::make_shared(); + PrepareStencil::testNoBloom(*state); _pipeline = gpu::Pipeline::create(program, state); } @@ -79,6 +79,9 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons gpu::doInBatch("BloomThreshold::run", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); + // We need to clear in case there are zones of the buffer that are stencil tagged as "No Bloom" + batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, gpu::Vec4(0.0f)); + batch.setViewportTransform(viewport); batch.setProjectionTransform(glm::mat4()); batch.resetViewTransform(); diff --git a/libraries/render-utils/src/BloomThreshold.shared.slh b/libraries/render-utils/src/BloomThreshold.shared.slh index 5ad490a1ca2..e1bcae11ea5 100644 --- a/libraries/render-utils/src/BloomThreshold.shared.slh +++ b/libraries/render-utils/src/BloomThreshold.shared.slh @@ -8,8 +8,10 @@ struct Parameters { BT_VEC2 _deltaUV; + float _offset; float _threshold; int _sampleCount; + float _padding[3]; }; // <@if 1@> diff --git a/libraries/render-utils/src/BloomThreshold.slf b/libraries/render-utils/src/BloomThreshold.slf index bbf863994fc..1a12f070ba5 100644 --- a/libraries/render-utils/src/BloomThreshold.slf +++ b/libraries/render-utils/src/BloomThreshold.slf @@ -17,11 +17,10 @@ LAYOUT_STD140(binding=RENDER_UTILS_BUFFER_BLOOM_PARAMS) uniform parametersBuffer Parameters parameters; }; -layout(location=0) in vec2 varTexCoord0; layout(location=0) out vec4 outFragColor; void main(void) { - vec2 startUv = varTexCoord0; + vec2 startUv = (vec2(gl_FragCoord.xy) + vec2(parameters._offset)) * parameters._deltaUV; vec4 maskedColor = vec4(0,0,0,0); for (int y=0 ; y 1e-4 ? velColor : vec4(0f, 0f, 1f, 0f);" + "}" +}; + +static const std::string DEFAULT_ANTIALIASING_INTENSITY_SHADER{ + "vec4 getFragmentColor() {" + " return vec4(texture(debugTexture0, uv).rrr, 1.0);" " }" }; @@ -251,7 +258,7 @@ static std::string getFileContent(const std::string& fileName, const std::string } #include // TODO REMOVE: Temporary until UI -DebugDeferredBuffer::DebugDeferredBuffer() { +DebugDeferredBuffer::DebugDeferredBuffer(uint transformSlot) : _transformSlot(transformSlot) { // TODO REMOVE: Temporary until UI static const auto DESKTOP_PATH = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation); static const auto CUSTOM_FILE = DESKTOP_PATH.toStdString() + "/custom.slh"; @@ -325,6 +332,8 @@ std::string DebugDeferredBuffer::getShaderSourceCode(Mode mode, const std::strin return DEFAULT_HALF_NORMAL_SHADER; case VelocityMode: return DEFAULT_VELOCITY_SHADER; + case AntialiasingIntensityMode: + return DEFAULT_ANTIALIASING_INTENSITY_SHADER; case CustomMode: return getFileContent(customFile, DEFAULT_CUSTOM_SHADER); default: @@ -401,9 +410,9 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I auto& linearDepthTarget = inputs.get1(); auto& surfaceGeometryFramebuffer = inputs.get2(); auto& ambientOcclusionFramebuffer = inputs.get3(); - auto& velocityFramebuffer = inputs.get4(); - auto& frameTransform = inputs.get5(); - auto& shadowFrame = inputs.get6(); + auto& frameTransform = inputs.get4(); + auto& lightFrame = inputs.get5(); + const auto& antialiasingIntensityTexture = inputs.get6(); gpu::doInBatch("DebugDeferredBuffer::run", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); @@ -412,12 +421,7 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I const auto geometryBuffer = DependencyManager::get(); const auto textureCache = DependencyManager::get(); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); using Textures = render_utils::slot::texture::Texture; @@ -435,8 +439,8 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I batch.setResourceTexture(Textures::DeferredDepth, deferredFramebuffer->getPrimaryDepthTexture()); batch.setResourceTexture(Textures::DeferredLighting, deferredFramebuffer->getLightingTexture()); } - if (velocityFramebuffer && _mode == VelocityMode) { - batch.setResourceTexture(Textures::DebugTexture0, velocityFramebuffer->getVelocityTexture()); + if (_mode == VelocityMode) { + batch.setResourceTexture(Textures::DebugTexture0, deferredFramebuffer->getDeferredVelocityTexture()); } if (!shadowFrame->_objects.empty()) { @@ -472,6 +476,10 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I batch.setResourceTexture(Textures::DebugTexture0, ambientOcclusionFramebuffer->getNormalTexture()); } } + if (antialiasingIntensityTexture && _mode == AntialiasingIntensityMode) { + batch.setResourceTexture(Textures::DebugTexture0, antialiasingIntensityTexture); + } + const glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f); const glm::vec2 bottomLeft(_size.x, _size.y); const glm::vec2 topRight(_size.z, _size.w); diff --git a/libraries/render-utils/src/DebugDeferredBuffer.h b/libraries/render-utils/src/DebugDeferredBuffer.h index 5ff3ab28c99..fc3b5ccbffe 100644 --- a/libraries/render-utils/src/DebugDeferredBuffer.h +++ b/libraries/render-utils/src/DebugDeferredBuffer.h @@ -19,7 +19,6 @@ #include "DeferredFramebuffer.h" #include "SurfaceGeometryPass.h" #include "AmbientOcclusionEffect.h" -#include "VelocityBufferPass.h" #include "LightStage.h" @@ -44,13 +43,13 @@ class DebugDeferredBuffer { LinearDepthFramebufferPointer, SurfaceGeometryFramebufferPointer, AmbientOcclusionFramebufferPointer, - VelocityFramebufferPointer, DeferredFrameTransformPointer, - LightStage::ShadowFramePointer>; + LightStage::FramePointer, + gpu::TexturePointer>; using Config = DebugDeferredBufferConfig; using JobModel = render::Job::ModelI; - DebugDeferredBuffer(); + DebugDeferredBuffer(uint transformSlot); ~DebugDeferredBuffer(); void configure(const Config& config); @@ -92,6 +91,7 @@ class DebugDeferredBuffer { AmbientOcclusionBlurredMode, AmbientOcclusionNormalMode, VelocityMode, + AntialiasingIntensityMode, CustomMode, // Needs to stay last NumModes, @@ -100,6 +100,7 @@ class DebugDeferredBuffer { private: Mode _mode{ Off }; glm::vec4 _size; + uint _transformSlot; #include "debug_deferred_buffer_shared.slh" diff --git a/libraries/render-utils/src/DeferredBufferRead.slh b/libraries/render-utils/src/DeferredBufferRead.slh index 868b93ff915..31985948250 100644 --- a/libraries/render-utils/src/DeferredBufferRead.slh +++ b/libraries/render-utils/src/DeferredBufferRead.slh @@ -45,6 +45,7 @@ struct DeferredFragment { vec3 fresnel; float roughness; int mode; + int side; float scattering; float depthVal; }; @@ -58,6 +59,9 @@ vec3 getFresnelF0(float metallic, vec3 metalF0) { } <@endif@> +<@include DeferredTransform.slh@> +<$declareDeferredFrameTransform()$> + DeferredFragment unpackDeferredFragmentNoPosition(vec2 texcoord) { vec4 normalVal; vec4 diffuseVal; @@ -82,6 +86,8 @@ DeferredFragment unpackDeferredFragmentNoPosition(vec2 texcoord) { frag.scattering = float(frag.mode == FRAG_MODE_SCATTERING) * specularVal.x; frag.fresnel = getFresnelF0(frag.metallic, diffuseVal.xyz); + frag.side = getStereoSideFromUV(texcoord.x); + return frag; } @@ -109,18 +115,14 @@ DeferredFragment unpackDeferredFragmentNoPositionNoAmbient(vec2 texcoord) { frag.fresnel = getFresnelF0(frag.metallic, diffuseVal.xyz); + frag.side = getStereoSideFromUV(texcoord.x); + return frag; } - -<@include DeferredTransform.slh@> -<$declareDeferredFrameTransform()$> - -vec4 unpackDeferredPosition(float depthValue, vec2 texcoord) { +vec4 unpackDeferredPosition(int side, float depthValue, vec2 texcoord) { float check = float(isStereo()); - float check2 = check * float(texcoord.x > 0.5); - texcoord.x -= check2 * 0.5; - int side = int(check2); + texcoord.x -= check * 0.5 * float(side); texcoord.x *= 1.0 + check; return vec4(evalEyePositionFromZdb(side, depthValue, texcoord), 1.0); @@ -129,7 +131,7 @@ vec4 unpackDeferredPosition(float depthValue, vec2 texcoord) { // This method to unpack position is fastesst vec4 unpackDeferredPositionFromZdb(vec2 texcoord) { float Zdb = texture(depthMap, texcoord).x; - return unpackDeferredPosition(Zdb, texcoord); + return unpackDeferredPosition(getStereoSideFromUV(texcoord.x), Zdb, texcoord); } vec4 unpackDeferredPositionFromZeye(vec2 texcoord) { @@ -144,13 +146,13 @@ vec4 unpackDeferredPositionFromZeye(vec2 texcoord) { return vec4(evalEyePositionFromZeye(side, Zeye, texcoord), 1.0); } -DeferredFragment unpackDeferredFragment(DeferredFrameTransform deferredTransform, vec2 texcoord) { +DeferredFragment unpackDeferredFragment(vec2 texcoord) { float depthValue = texture(depthMap, texcoord).r; DeferredFragment frag = unpackDeferredFragmentNoPosition(texcoord); frag.depthVal = depthValue; - frag.position = unpackDeferredPosition(frag.depthVal, texcoord); + frag.position = unpackDeferredPosition(frag.side, frag.depthVal, texcoord); return frag; } diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index de3d0a3087c..6c69fdbc276 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -12,12 +12,13 @@ <@def DEFERRED_BUFFER_WRITE_SLH@> <@include DeferredBuffer.slh@> +<@include DeferredBufferWrite_shared.slh@> - -layout(location=0) out vec4 _fragColor0; // albedo / metallic -layout(location=1) out vec4 _fragColor1; // Normal -layout(location=2) out vec4 _fragColor2; // scattering / emissive / occlusion -layout(location=3) out vec4 _fragColor3; // emissive +layout(location = DEFERRED_COLOR_SLOT) out vec4 _fragColor0; // albedo / metallic +layout(location = DEFERRED_NORMAL_SLOT) out vec4 _fragColor1; // Normal +layout(location = DEFERRED_SPECULAR_SLOT) out vec4 _fragColor2; // scattering / emissive / occlusion +layout(location = DEFERRED_VELOCITY_SLOT) out vec4 _velocity; // velocity +layout(location = DEFERRED_LIGHTING_SLOT) out vec4 _lighting; // emissive // the alpha threshold const float alphaThreshold = 0.5; @@ -25,10 +26,11 @@ float evalOpaqueFinalAlpha(float alpha, float mapAlpha) { return mix(alpha, 1.0 - alpha, step(mapAlpha, alphaThreshold)); } +<@include VelocityWrite.slh@> <@include DefaultMaterials.slh@> <@include LightingModel.slh@> -void packDeferredFragment(vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 emissive, float occlusion, float scattering) { +void packDeferredFragment(vec4 prevPositionCS, vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 emissive, float occlusion, float scattering) { if (alpha < 1.0) { discard; } @@ -37,10 +39,11 @@ void packDeferredFragment(vec3 normal, float alpha, vec3 albedo, float roughness _fragColor0 = vec4(albedo, mix(packShadedMetallic(metallic), packScatteringMetallic(metallic), check)); _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); _fragColor2 = vec4(mix(emissive, vec3(scattering), check), occlusion); - _fragColor3 = vec4(isEmissiveEnabled() * emissive, 1.0); + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(isEmissiveEnabled() * emissive, 1.0); } -void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 lightmap) { +void packDeferredFragmentLightmap(vec4 prevPositionCS, vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 lightmap) { if (alpha < 1.0) { discard; } @@ -48,10 +51,11 @@ void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 albedo, float r _fragColor0 = vec4(albedo, packLightmappedMetallic(metallic)); _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); _fragColor2 = vec4(isLightmapEnabled() * lightmap, 1.0); - _fragColor3 = vec4(isLightmapEnabled() * lightmap * albedo, 1.0); + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(isLightmapEnabled() * lightmap * albedo, 1.0); } -void packDeferredFragmentUnlit(vec3 normal, float alpha, vec3 color) { +void packDeferredFragmentUnlit(vec4 prevPositionCS, vec3 normal, float alpha, vec3 color) { // to reduce texel flickering for floating point error we discard when alpha is "almost one" if (alpha < 0.999999) { discard; @@ -59,7 +63,8 @@ void packDeferredFragmentUnlit(vec3 normal, float alpha, vec3 color) { _fragColor0 = vec4(color, packUnlit()); _fragColor1 = vec4(packNormal(normal), 1.0); _fragColor2 = vec4(vec3(0.0), 1.0); - _fragColor3 = vec4(color, 1.0); + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(color, 1.0); } void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 albedo, float roughness) { diff --git a/libraries/render-utils/src/DeferredBufferWrite_shared.slh b/libraries/render-utils/src/DeferredBufferWrite_shared.slh new file mode 100644 index 00000000000..b579925728d --- /dev/null +++ b/libraries/render-utils/src/DeferredBufferWrite_shared.slh @@ -0,0 +1,12 @@ +// glsl / C++ compatible source as interface for DeferredBuffer layout + +#define DEFERRED_COLOR_SLOT 0 +#define DEFERRED_NORMAL_SLOT 1 +#define DEFERRED_SPECULAR_SLOT 2 +#define DEFERRED_VELOCITY_SLOT 3 +#define DEFERRED_LIGHTING_SLOT 4 + + // <@if 1@> + // Trigger Scribe include + // <@endif@> +// \ No newline at end of file diff --git a/libraries/render-utils/src/DeferredFrameTransform.cpp b/libraries/render-utils/src/DeferredFrameTransform.cpp index 21d5b120d65..80ac8e357a1 100644 --- a/libraries/render-utils/src/DeferredFrameTransform.cpp +++ b/libraries/render-utils/src/DeferredFrameTransform.cpp @@ -18,73 +18,51 @@ DeferredFrameTransform::DeferredFrameTransform() { _frameTransformBuffer = gpu::BufferView(std::make_shared(sizeof(FrameTransform), (const gpu::Byte*) &frameTransform)); } -void DeferredFrameTransform::update(RenderArgs* args, glm::vec2 jitter) { +void DeferredFrameTransform::update(RenderArgs* args) { // Update the depth info with near and far (same for stereo) auto nearZ = args->getViewFrustum().getNearClip(); auto farZ = args->getViewFrustum().getFarClip(); auto& frameTransformBuffer = _frameTransformBuffer.edit(); - frameTransformBuffer.depthInfo = glm::vec4(nearZ*farZ, farZ - nearZ, -farZ, 0.0f); + frameTransformBuffer.infos.depthInfo = glm::vec4(nearZ*farZ, farZ - nearZ, -farZ, 0.0f); + frameTransformBuffer.infos.pixelInfo = args->_viewport; - frameTransformBuffer.pixelInfo = args->_viewport; - - //_parametersBuffer.edit()._ditheringInfo.y += 0.25f; - - Transform cameraTransform; - args->getViewFrustum().evalViewTransform(cameraTransform); - cameraTransform.getMatrix(frameTransformBuffer.invView); - cameraTransform.getInverseMatrix(frameTransformBuffer.view); - - args->getViewFrustum().evalProjectionMatrix(frameTransformBuffer.projectionMono); - - // There may be some sort of mismatch here if the viewport size isn't the same as the frame buffer size as - // jitter is normalized by frame buffer size in TransformCamera. But we should be safe. - jitter.x /= args->_viewport.z; - jitter.y /= args->_viewport.w; + args->getViewFrustum().evalProjectionMatrix(frameTransformBuffer.infos.projectionMono); // Running in stereo ? bool isStereo = args->isStereo(); if (!isStereo) { - frameTransformBuffer.projectionUnjittered[0] = frameTransformBuffer.projectionMono; - frameTransformBuffer.invProjectionUnjittered[0] = glm::inverse(frameTransformBuffer.projectionUnjittered[0]); - - frameTransformBuffer.stereoInfo = glm::vec4(0.0f, (float)args->_viewport.z, 0.0f, 0.0f); - frameTransformBuffer.invpixelInfo = glm::vec4(1.0f / args->_viewport.z, 1.0f / args->_viewport.w, 0.0f, 0.0f); - - frameTransformBuffer.projection[0] = frameTransformBuffer.projectionUnjittered[0]; - frameTransformBuffer.projection[0][2][0] += jitter.x; - frameTransformBuffer.projection[0][2][1] += jitter.y; - frameTransformBuffer.invProjection[0] = glm::inverse(frameTransformBuffer.projection[0]); + frameTransformBuffer.infos.stereoInfo = glm::vec4(0.0f, (float)args->_viewport.z, 0.0f, 0.0f); + frameTransformBuffer.infos.invPixelInfo = glm::vec4(1.0f / args->_viewport.z, 1.0f / args->_viewport.w, 0.0f, 0.0f); } else { - - mat4 projMats[2]; - mat4 eyeViews[2]; - args->_context->getStereoProjections(projMats); - args->_context->getStereoViews(eyeViews); - - jitter.x *= 2.0f; - - for (int i = 0; i < 2; i++) { - // Compose the mono Eye space to Stereo clip space Projection Matrix - auto sideViewMat = projMats[i] * eyeViews[i]; - frameTransformBuffer.projectionUnjittered[i] = sideViewMat; - frameTransformBuffer.invProjectionUnjittered[i] = glm::inverse(sideViewMat); - - frameTransformBuffer.projection[i] = frameTransformBuffer.projectionUnjittered[i]; - frameTransformBuffer.projection[i][2][0] += jitter.x; - frameTransformBuffer.projection[i][2][1] += jitter.y; - frameTransformBuffer.invProjection[i] = glm::inverse(frameTransformBuffer.projection[i]); - } - - frameTransformBuffer.stereoInfo = glm::vec4(1.0f, (float)(args->_viewport.z >> 1), 0.0f, 1.0f); - frameTransformBuffer.invpixelInfo = glm::vec4(1.0f / (float)(args->_viewport.z >> 1), 1.0f / args->_viewport.w, 0.0f, 0.0f); + frameTransformBuffer.infos.pixelInfo.z *= 0.5f; + frameTransformBuffer.infos.stereoInfo = glm::vec4(1.0f, (float)(args->_viewport.z >> 1), 0.0f, 1.0f); + frameTransformBuffer.infos.invPixelInfo = glm::vec4(2.0f / (float)(args->_viewport.z), 1.0f / args->_viewport.w, 0.0f, 0.0f); } } -void GenerateDeferredFrameTransform::run(const render::RenderContextPointer& renderContext, const Input& jitter, Output& frameTransform) { +void GenerateDeferredFrameTransform::run(const render::RenderContextPointer& renderContext, Output& frameTransform) { if (!frameTransform) { frameTransform = std::make_shared(); } - frameTransform->update(renderContext->args, jitter); + + RenderArgs* args = renderContext->args; + frameTransform->update(args); + + gpu::doInBatch("GenerateDeferredFrameTransform::run", args->_context, [&](gpu::Batch& batch) { + args->_batch = &batch; + + glm::mat4 projMat; + Transform viewMat; + args->getViewFrustum().evalProjectionMatrix(projMat); + args->getViewFrustum().evalViewTransform(viewMat); + batch.setProjectionTransform(projMat); + batch.setViewTransform(viewMat); + // This is the main view / projection transform that will be reused later on + batch.saveViewProjectionTransform(_transformSlot); + // Copy it to the deferred transform for the lighting pass + batch.copySavedViewProjectionTransformToBuffer(_transformSlot, frameTransform->getFrameTransformBuffer()._buffer, + sizeof(DeferredFrameTransform::DeferredFrameInfo)); + }); } diff --git a/libraries/render-utils/src/DeferredFrameTransform.h b/libraries/render-utils/src/DeferredFrameTransform.h index f7700cb2dcc..9029d81786d 100644 --- a/libraries/render-utils/src/DeferredFrameTransform.h +++ b/libraries/render-utils/src/DeferredFrameTransform.h @@ -20,12 +20,13 @@ // DeferredFrameTransform is a helper class gathering in one place the needed camera transform // and frame resolution needed for all the deferred rendering passes taking advantage of the Deferred buffers class DeferredFrameTransform { + friend class GenerateDeferredFrameTransform; public: using UniformBufferView = gpu::BufferView; DeferredFrameTransform(); - void update(RenderArgs* args, glm::vec2 jitter); + void update(RenderArgs* args); UniformBufferView getFrameTransformBuffer() const { return _frameTransformBuffer; } @@ -34,54 +35,31 @@ class DeferredFrameTransform { // Class describing the uniform buffer with the transform info common to the AO shaders // It s changing every frame - class FrameTransform { +#include "DeferredTransform_shared.slh" + class FrameTransform : public _DeferredFrameTransform { public: - // Pixel info is { viewport width height} - glm::vec4 pixelInfo; - glm::vec4 invpixelInfo; - // Depth info is { n.f, f - n, -f} - glm::vec4 depthInfo; - // Stereo info is { isStereoFrame, halfWidth } - glm::vec4 stereoInfo{ 0.0 }; - // Mono proj matrix or Left and Right proj matrix going from Mono Eye space to side clip space - glm::mat4 projection[2]; - // Inverse proj matrix or Left and Right proj matrix going from Mono Eye space to side clip space - glm::mat4 invProjection[2]; - // THe mono projection for sure - glm::mat4 projectionMono; - // Inv View matrix from eye space (mono) to world space - glm::mat4 invView; - // View matrix from world space to eye space (mono) - glm::mat4 view; - // Mono proj matrix or Left and Right proj matrix going from Mono Eye space to side clip space without jittering - glm::mat4 projectionUnjittered[2]; - // Inverse proj matrix or Left and Right proj matrix going from Mono Eye space to side clip space without jittering - glm::mat4 invProjectionUnjittered[2]; - - FrameTransform() {} + FrameTransform() { infos.stereoInfo = glm::vec4(0.0f); } }; - UniformBufferView _frameTransformBuffer; - + UniformBufferView _frameTransformBuffer; }; using DeferredFrameTransformPointer = std::shared_ptr; - - class GenerateDeferredFrameTransform { public: using Input = glm::vec2; using Output = DeferredFrameTransformPointer; - using JobModel = render::Job::ModelIO; + using JobModel = render::Job::ModelO; - GenerateDeferredFrameTransform() {} + GenerateDeferredFrameTransform(unsigned int transformSlot) : _transformSlot{ transformSlot } {} - void run(const render::RenderContextPointer& renderContext, const Input& jitter, Output& frameTransform); + void run(const render::RenderContextPointer& renderContext, Output& frameTransform); private: + unsigned int _transformSlot; }; #endif // hifi_DeferredFrameTransform_h diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp index 93a3ff2d670..ae84d320d86 100644 --- a/libraries/render-utils/src/RenderViewTask.cpp +++ b/libraries/render-utils/src/RenderViewTask.cpp @@ -15,7 +15,7 @@ #include "RenderDeferredTask.h" #include "RenderForwardTask.h" -void RenderShadowsAndDeferredTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask) { +void RenderShadowsAndDeferredTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset) { task.addJob("SetRenderMethodTask", render::Args::DEFERRED); const auto items = input.getN(0); @@ -28,16 +28,16 @@ void RenderShadowsAndDeferredTask::build(JobModel& task, const render::Varying& const auto shadowTaskOut = task.addJob("RenderShadowTask", shadowTaskIn, cullFunctor, tagBits, tagMask); const auto renderDeferredInput = RenderDeferredTask::Input(items, lightingModel, lightingStageFramesAndZones, shadowTaskOut).asVarying(); - task.addJob("RenderDeferredTask", renderDeferredInput); + task.addJob("RenderDeferredTask", renderDeferredInput, transformOffset); } -void DeferredForwardSwitchJob::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask) { - task.addBranch("RenderShadowsAndDeferredTask", 0, input, cullFunctor, tagBits, tagMask); +void DeferredForwardSwitchJob::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset) { + task.addBranch("RenderShadowsAndDeferredTask", 0, input, cullFunctor, tagBits, tagMask, transformOffset); - task.addBranch("RenderForwardTask", 1, input); + task.addBranch("RenderForwardTask", 1, input, transformOffset); } -void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask) { +void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset) { const auto items = task.addJob("FetchCullSort", cullFunctor, tagBits, tagMask); // Issue the lighting model, aka the big global settings for the view @@ -48,9 +48,9 @@ void RenderViewTask::build(JobModel& task, const render::Varying& input, render: #ifndef Q_OS_ANDROID const auto deferredForwardIn = DeferredForwardSwitchJob::Input(items, lightingModel, lightingStageFramesAndZones).asVarying(); - task.addJob("DeferredForwardSwitch", deferredForwardIn, cullFunctor, tagBits, tagMask); + task.addJob("DeferredForwardSwitch", deferredForwardIn, cullFunctor, tagBits, tagMask, transformOffset); #else const auto renderInput = RenderForwardTask::Input(items, lightingModel, lightingStageFramesAndZones).asVarying(); - task.addJob("RenderForwardTask", renderInput); + task.addJob("RenderForwardTask", renderInput, transformOffset); #endif } diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h index cdb56a21893..1cc57113824 100644 --- a/libraries/render-utils/src/RenderViewTask.h +++ b/libraries/render-utils/src/RenderViewTask.h @@ -24,7 +24,8 @@ class RenderShadowsAndDeferredTask { RenderShadowsAndDeferredTask() {} - void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask); + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, + uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset); }; @@ -36,7 +37,8 @@ class DeferredForwardSwitchJob { DeferredForwardSwitchJob() {} void configure(const render::SwitchConfig& config) {} - void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask); + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, + uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset); }; @@ -47,7 +49,8 @@ class RenderViewTask { RenderViewTask() {} - void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t tagBits = 0x00, uint8_t tagMask = 0x00); + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, + uint8_t tagBits = 0x00, uint8_t tagMask = 0x00, uint8_t transformOffset = 0); }; From 9cc6f11d2bac1da5eb0e8550a1f44d2eafda2ee5 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Fri, 24 Jul 2020 12:12:52 -0700 Subject: [PATCH 02/34] wip finish transfering original PR --- .../render-utils/src/AntialiasingEffect.cpp | 3 +- libraries/render-utils/src/BackgroundStage.h | 4 +- libraries/render-utils/src/BloomEffect.cpp | 1 - .../render-utils/src/DeferredFramebuffer.cpp | 64 +++- .../render-utils/src/DeferredFramebuffer.h | 28 ++ .../src/DeferredLightingEffect.cpp | 6 +- .../render-utils/src/DeferredLightingEffect.h | 3 +- .../render-utils/src/DeferredTransform.slh | 128 +++---- .../src/DeferredTransform_shared.slh | 33 ++ libraries/render-utils/src/GeometryCache.cpp | 9 +- libraries/render-utils/src/Haze.slf | 9 +- .../render-utils/src/HighlightEffect.cpp | 48 +-- libraries/render-utils/src/HighlightEffect.h | 23 +- .../render-utils/src/Highlight_aabox.slv | 8 +- libraries/render-utils/src/LightClusters.cpp | 12 +- libraries/render-utils/src/LightClusters.h | 3 +- .../render-utils/src/MeshPartPayload.cpp | 3 +- .../render-utils/src/RenderCommonTask.cpp | 43 ++- libraries/render-utils/src/RenderCommonTask.h | 14 +- .../render-utils/src/RenderDeferredTask.cpp | 178 +++++----- .../render-utils/src/RenderDeferredTask.h | 20 +- .../render-utils/src/RenderForwardTask.cpp | 40 ++- .../render-utils/src/RenderForwardTask.h | 6 +- .../render-utils/src/RenderHUDLayerTask.cpp | 32 +- .../render-utils/src/RenderHUDLayerTask.h | 9 +- .../render-utils/src/RenderPipelines.cpp | 2 +- .../render-utils/src/StencilMaskPass.cpp | 6 + libraries/render-utils/src/StencilMaskPass.h | 1 + .../render-utils/src/VelocityBufferPass.cpp | 165 --------- .../render-utils/src/VelocityBufferPass.h | 89 ----- libraries/render-utils/src/VelocityWrite.slh | 57 ++++ libraries/render-utils/src/ZoneRenderer.cpp | 6 +- libraries/render-utils/src/aa_blend.slf | 52 +++ .../src/deferred_light_limited.slv | 3 +- .../src/directional_skybox_light.slf | 9 +- .../render-utils/src/drawWorkloadProxy.slf | 2 + .../render-utils/src/drawWorkloadProxy.slv | 24 +- .../render-utils/src/drawWorkloadView.slf | 2 + .../render-utils/src/drawWorkloadView.slv | 19 +- .../src/lightClusters_drawClusterContent.slf | 2 +- .../lightClusters_drawClusterFromDepth.slf | 2 +- .../src/local_lights_drawOutline.slf | 2 +- .../render-utils/src/local_lights_shading.slf | 5 +- libraries/render-utils/src/model.slf | 3 + libraries/render-utils/src/model.slv | 3 +- libraries/render-utils/src/parabola.slf | 7 +- libraries/render-utils/src/parabola.slv | 9 +- .../src/render-utils/ShaderConstants.h | 11 +- .../{fxaa_blend.slp => aa_blend.slp} | 0 .../velocityBuffer_cameraMotion.slp | 1 - libraries/render-utils/src/sdf_text3D.slf | 4 + libraries/render-utils/src/sdf_text3D.slh | 19 +- libraries/render-utils/src/sdf_text3D.slv | 4 +- libraries/render-utils/src/simple.slf | 7 +- libraries/render-utils/src/simple.slv | 9 +- .../render-utils/src/simple_procedural.slf | 3 + .../render-utils/src/simple_procedural.slv | 3 +- .../src/surfaceGeometry_makeCurvature.slf | 10 +- libraries/render-utils/src/taa.slf | 37 +- libraries/render-utils/src/taa.slh | 322 +++++++++++------- libraries/render-utils/src/taa_blend.slf | 1 - .../src/velocityBuffer_cameraMotion.slf | 43 --- libraries/render-utils/src/web_browser.slf | 3 +- libraries/render-utils/src/web_browser.slv | 3 +- .../render-utils/src/zone_drawAmbient.slf | 2 +- .../render-utils/src/zone_drawKeyLight.slf | 5 +- .../render-utils/src/zone_drawSkybox.slf | 2 +- .../render/src/render/DrawSceneOctree.cpp | 16 +- libraries/render/src/render/DrawSceneOctree.h | 10 +- libraries/render/src/render/DrawStatus.cpp | 14 +- libraries/render/src/render/DrawStatus.h | 2 +- libraries/render/src/render/DrawTask.cpp | 7 +- libraries/render/src/render/DrawTask.h | 3 + libraries/render/src/render/Engine.h | 5 + libraries/render/src/render/ShapePipeline.cpp | 1 + libraries/render/src/render/ShapePipeline.h | 1 + .../utilities/render/luci/Antialiasing.qml | 39 ++- .../utilities/render/luci/Framebuffer.qml | 1 + tests-manual/gpu/src/TestWindow.cpp | 4 +- 79 files changed, 907 insertions(+), 882 deletions(-) create mode 100644 libraries/render-utils/src/DeferredTransform_shared.slh delete mode 100644 libraries/render-utils/src/VelocityBufferPass.cpp delete mode 100644 libraries/render-utils/src/VelocityBufferPass.h create mode 100644 libraries/render-utils/src/VelocityWrite.slh create mode 100644 libraries/render-utils/src/aa_blend.slf rename libraries/render-utils/src/render-utils/{fxaa_blend.slp => aa_blend.slp} (100%) delete mode 100644 libraries/render-utils/src/render-utils/velocityBuffer_cameraMotion.slp delete mode 100644 libraries/render-utils/src/velocityBuffer_cameraMotion.slf diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index d4debab45bc..af569a72a5b 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -102,9 +102,8 @@ AntialiasingSetup::AntialiasingSetup() { _sampleSequence.reserve(TAA_JITTER_SEQUENCE_LENGTH + 1); // Fill in with jitter samples for (int i = 0; i < TAA_JITTER_SEQUENCE_LENGTH; i++) { - _sampleSequence.emplace_back(glm::vec2(evaluateHalton<2>(i), evaluateHalton<3>(i)) - vec2(0.5f)); + _sampleSequence.emplace_back(glm::vec2(halton::evaluate<2>(i), halton::evaluate<3>(i)) - vec2(0.5f)); } - return _blendPipeline; } void AntialiasingSetup::configure(const Config& config) { diff --git a/libraries/render-utils/src/BackgroundStage.h b/libraries/render-utils/src/BackgroundStage.h index 6406cf78bb9..9a43b069df1 100644 --- a/libraries/render-utils/src/BackgroundStage.h +++ b/libraries/render-utils/src/BackgroundStage.h @@ -85,12 +85,12 @@ class DrawBackgroundStage { using Inputs = render::VaryingSet3; using JobModel = render::Job::ModelI; - DrawBackgroundStage(unsigned int transformSlot) : _transformSlot(transformSlot) {} + DrawBackgroundStage(uint transformSlot) : _transformSlot(transformSlot) {} void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); private: - unsigned int _transformSlot; + uint _transformSlot; }; #endif diff --git a/libraries/render-utils/src/BloomEffect.cpp b/libraries/render-utils/src/BloomEffect.cpp index ef59b1b0dc6..206d1cacf70 100644 --- a/libraries/render-utils/src/BloomEffect.cpp +++ b/libraries/render-utils/src/BloomEffect.cpp @@ -68,7 +68,6 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons if (!_pipeline) { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::bloomThreshold); gpu::StatePointer state = std::make_shared(); - PrepareStencil::testNoBloom(*state); _pipeline = gpu::Pipeline::create(program, state); } diff --git a/libraries/render-utils/src/DeferredFramebuffer.cpp b/libraries/render-utils/src/DeferredFramebuffer.cpp index 1906375654e..679ae375194 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.cpp +++ b/libraries/render-utils/src/DeferredFramebuffer.cpp @@ -10,6 +10,11 @@ // #include "DeferredFramebuffer.h" +#include "DeferredBufferWrite_shared.slh" + +#include "gpu/Batch.h" +#include "gpu/Context.h" + DeferredFramebuffer::DeferredFramebuffer() { } @@ -36,8 +41,10 @@ void DeferredFramebuffer::updatePrimaryDepth(const gpu::TexturePointer& depthBuf _deferredColorTexture.reset(); _deferredNormalTexture.reset(); _deferredSpecularTexture.reset(); + _deferredVelocityTexture.reset(); _lightingTexture.reset(); _lightingFramebuffer.reset(); + _lightingWithVelocityFramebuffer.reset(); } } @@ -46,8 +53,9 @@ void DeferredFramebuffer::allocate() { _deferredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("deferred")); _deferredFramebufferDepthColor = gpu::FramebufferPointer(gpu::Framebuffer::create("deferredDepthColor")); - auto colorFormat = gpu::Element::COLOR_SRGBA_32; - auto linearFormat = gpu::Element::COLOR_RGBA_32; + const auto colorFormat = gpu::Element::COLOR_SRGBA_32; + const auto linearFormat = gpu::Element::COLOR_RGBA_32; + const auto halfFormat = gpu::Element(gpu::VEC2, gpu::HALF, gpu::XY); auto width = _frameSize.x; auto height = _frameSize.y; @@ -56,10 +64,12 @@ void DeferredFramebuffer::allocate() { _deferredColorTexture = gpu::Texture::createRenderBuffer(colorFormat, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); _deferredNormalTexture = gpu::Texture::createRenderBuffer(linearFormat, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); _deferredSpecularTexture = gpu::Texture::createRenderBuffer(linearFormat, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); + _deferredVelocityTexture = gpu::Texture::createRenderBuffer(halfFormat, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); - _deferredFramebuffer->setRenderBuffer(0, _deferredColorTexture); - _deferredFramebuffer->setRenderBuffer(1, _deferredNormalTexture); - _deferredFramebuffer->setRenderBuffer(2, _deferredSpecularTexture); + _deferredFramebuffer->setRenderBuffer(DEFERRED_COLOR_SLOT, _deferredColorTexture); + _deferredFramebuffer->setRenderBuffer(DEFERRED_NORMAL_SLOT, _deferredNormalTexture); + _deferredFramebuffer->setRenderBuffer(DEFERRED_SPECULAR_SLOT, _deferredSpecularTexture); + _deferredFramebuffer->setRenderBuffer(DEFERRED_VELOCITY_SLOT, _deferredVelocityTexture); _deferredFramebufferDepthColor->setRenderBuffer(0, _deferredColorTexture); @@ -80,8 +90,12 @@ void DeferredFramebuffer::allocate() { _lightingFramebuffer->setRenderBuffer(0, _lightingTexture); _lightingFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat); - _deferredFramebuffer->setRenderBuffer(3, _lightingTexture); + _lightingWithVelocityFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("lighting_velocity")); + _lightingWithVelocityFramebuffer->setRenderBuffer(0, _lightingTexture); + _lightingWithVelocityFramebuffer->setRenderBuffer(1, _deferredVelocityTexture); + _lightingWithVelocityFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat); + _deferredFramebuffer->setRenderBuffer(DEFERRED_LIGHTING_SLOT, _lightingTexture); } @@ -92,6 +106,19 @@ gpu::TexturePointer DeferredFramebuffer::getPrimaryDepthTexture() { return _primaryDepthTexture; } +gpu::FramebufferPointer DeferredFramebuffer::getFramebuffer(Type type) { + switch (type) { + default: + return getDeferredFramebuffer(); + case COLOR_DEPTH: + return getDeferredFramebufferDepthColor(); + case LIGHTING: + return getLightingFramebuffer(); + case LIGHTING_VELOCITY: + return getLightingWithVelocityFramebuffer(); + }; +} + gpu::FramebufferPointer DeferredFramebuffer::getDeferredFramebuffer() { if (!_deferredFramebuffer) { allocate(); @@ -127,6 +154,13 @@ gpu::TexturePointer DeferredFramebuffer::getDeferredSpecularTexture() { return _deferredSpecularTexture; } +gpu::TexturePointer DeferredFramebuffer::getDeferredVelocityTexture() { + if (!_deferredVelocityTexture) { + allocate(); + } + return _deferredVelocityTexture; +} + gpu::FramebufferPointer DeferredFramebuffer::getLightingFramebuffer() { if (!_lightingFramebuffer) { allocate(); @@ -134,9 +168,27 @@ gpu::FramebufferPointer DeferredFramebuffer::getLightingFramebuffer() { return _lightingFramebuffer; } +gpu::FramebufferPointer DeferredFramebuffer::getLightingWithVelocityFramebuffer() { + if (!_lightingWithVelocityFramebuffer) { + allocate(); + } + return _lightingWithVelocityFramebuffer; +} + gpu::TexturePointer DeferredFramebuffer::getLightingTexture() { if (!_lightingTexture) { allocate(); } return _lightingTexture; } + +void SetDeferredFramebuffer::run(const render::RenderContextPointer& renderContext, const DeferredFramebufferPointer& framebuffer) { + assert(renderContext->args); + RenderArgs* args = renderContext->args; + + gpu::doInBatch("SetDeferredFramebuffer::run", args->_context, [&](gpu::Batch& batch) { + args->_batch = &batch; + batch.setFramebuffer(framebuffer->getFramebuffer(_type)); + args->_batch = nullptr; + }); +} \ No newline at end of file diff --git a/libraries/render-utils/src/DeferredFramebuffer.h b/libraries/render-utils/src/DeferredFramebuffer.h index 6002bf6494c..f3cbdf59336 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.h +++ b/libraries/render-utils/src/DeferredFramebuffer.h @@ -15,20 +15,34 @@ #include "gpu/Resource.h" #include "gpu/Framebuffer.h" + #include "render/Engine.h" // DeferredFramebuffer is a helper class gathering in one place the GBuffer (Framebuffer) and lighting framebuffer class DeferredFramebuffer { public: + enum Type { + FULL = 0, + COLOR_DEPTH, + LIGHTING, + LIGHTING_VELOCITY, + + MAX_TYPE + }; + DeferredFramebuffer(); + gpu::FramebufferPointer getFramebuffer(Type type); + gpu::FramebufferPointer getDeferredFramebuffer(); gpu::FramebufferPointer getDeferredFramebufferDepthColor(); gpu::TexturePointer getDeferredColorTexture(); gpu::TexturePointer getDeferredNormalTexture(); gpu::TexturePointer getDeferredSpecularTexture(); + gpu::TexturePointer getDeferredVelocityTexture(); gpu::FramebufferPointer getLightingFramebuffer(); + gpu::FramebufferPointer getLightingWithVelocityFramebuffer(); gpu::TexturePointer getLightingTexture(); // Update the depth buffer which will drive the allocation of all the other resources according to its size. @@ -47,13 +61,27 @@ class DeferredFramebuffer { gpu::TexturePointer _deferredColorTexture; gpu::TexturePointer _deferredNormalTexture; gpu::TexturePointer _deferredSpecularTexture; + gpu::TexturePointer _deferredVelocityTexture; gpu::TexturePointer _lightingTexture; gpu::FramebufferPointer _lightingFramebuffer; + gpu::FramebufferPointer _lightingWithVelocityFramebuffer; glm::ivec2 _frameSize; }; using DeferredFramebufferPointer = std::shared_ptr; +class SetDeferredFramebuffer { +public: + using JobModel = render::Job::ModelI; + + SetDeferredFramebuffer(DeferredFramebuffer::Type type) : _type(type) {} + + void run(const render::RenderContextPointer& renderContext, const DeferredFramebufferPointer& framebuffer); + +protected: + DeferredFramebuffer::Type _type{ DeferredFramebuffer::FULL }; +}; + #endif // hifi_DeferredFramebuffer_h \ No newline at end of file diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp index 8d7fc345ac9..aa2b0a8e7cd 100644 --- a/libraries/render-utils/src/DeferredLightingEffect.cpp +++ b/libraries/render-utils/src/DeferredLightingEffect.cpp @@ -286,6 +286,7 @@ void PrepareDeferred::run(const RenderContextPointer& renderContext, const Input outputs.edit0() = _deferredFramebuffer; outputs.edit1() = _deferredFramebuffer->getLightingFramebuffer(); + outputs.edit2() = _deferredFramebuffer->getLightingWithVelocityFramebuffer(); gpu::doInBatch("PrepareDeferred::run", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); @@ -298,8 +299,9 @@ void PrepareDeferred::run(const RenderContextPointer& renderContext, const Input // Clear Color, Depth and Stencil for deferred buffer batch.clearFramebuffer( - gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 | gpu::Framebuffer::BUFFER_COLOR3 | - gpu::Framebuffer::BUFFER_DEPTH | + gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | + gpu::Framebuffer::BUFFER_COLOR2 | gpu::Framebuffer::BUFFER_COLOR3 | + gpu::Framebuffer::BUFFER_COLOR4 | gpu::Framebuffer::BUFFER_DEPTH | gpu::Framebuffer::BUFFER_STENCIL, vec4(vec3(0), 0), 1.0, 0, true); diff --git a/libraries/render-utils/src/DeferredLightingEffect.h b/libraries/render-utils/src/DeferredLightingEffect.h index 47793764106..a83be6e5d2d 100644 --- a/libraries/render-utils/src/DeferredLightingEffect.h +++ b/libraries/render-utils/src/DeferredLightingEffect.h @@ -78,8 +78,7 @@ class PrepareDeferred { public: // Inputs: primaryFramebuffer and lightingModel using Inputs = render::VaryingSet2 ; - // Output: DeferredFramebuffer, LightingFramebuffer - using Outputs = render::VaryingSet2; + using Outputs = render::VaryingSet3; using JobModel = render::Job::ModelIO; diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index 93a3e61c517..0729258dc1b 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -16,111 +16,104 @@ <@func declareDeferredFrameTransform()@> -struct CameraCorrection { - mat4 _correction; - mat4 _correctionInverse; - - mat4 _prevView; - mat4 _prevViewInverse; -}; - -LAYOUT(binding=GPU_BUFFER_CAMERA_CORRECTION) uniform cameraCorrectionBuffer { - CameraCorrection cameraCorrection; -}; +<@include DeferredTransform_shared.slh@> -struct DeferredFrameTransform { - vec4 _pixelInfo; - vec4 _invPixelInfo; - vec4 _depthInfo; - vec4 _stereoInfo; - mat4 _projection[2]; - mat4 _invProjection[2]; - mat4 _projectionMono; - mat4 _viewInverse; - mat4 _view; - mat4 _projectionUnJittered[2]; - mat4 _invProjectionUnJittered[2]; -}; +#define DeferredFrameTransform _DeferredFrameTransform +#define TransformCamera _TransformCamera -LAYOUT(binding=RENDER_UTILS_BUFFER_DEFERRED_FRAME_TRANSFORM) uniform deferredFrameTransformBuffer { +LAYOUT_STD140(binding=RENDER_UTILS_BUFFER_DEFERRED_FRAME_TRANSFORM) uniform deferredFrameTransformBuffer { DeferredFrameTransform frameTransform; }; vec2 getWidthHeight(int resolutionLevel) { - return vec2(ivec2(frameTransform._pixelInfo.zw) >> resolutionLevel); + return vec2(ivec2(frameTransform.infos._pixelInfo.zw) >> resolutionLevel); } vec2 getInvWidthHeight() { - return frameTransform._invPixelInfo.xy; + return frameTransform.infos.invPixelInfo.xy; +} + +mat4 getProjection(int side) { + return frameTransform.cameras[side]._projection; +} + +mat4 getProjectionInverse(int side) { + return frameTransform.cameras[side]._projectionInverse; } float getProjScaleEye() { - return frameTransform._projection[0][1][1]; + return getProjection(0)[1][1]; } float getProjScale(int resolutionLevel) { - return getWidthHeight(resolutionLevel).y * frameTransform._projection[0][1][1] * 0.5; -} -mat4 getProjection(int side) { - return frameTransform._projection[side]; + return getWidthHeight(resolutionLevel).y * getProjScaleEye() * 0.5; } + mat4 getProjectionMono() { - return frameTransform._projectionMono; -} -mat4 getUnjitteredProjection(int side) { - return frameTransform._projectionUnJittered[side]; -} -mat4 getUnjitteredInvProjection(int side) { - return frameTransform._invProjectionUnJittered[side]; + return frameTransform.infos.projectionMono; } // positive near distance of the projection float getProjectionNear() { - float planeC = frameTransform._projection[0][2][3] + frameTransform._projection[0][2][2]; - float planeD = frameTransform._projection[0][3][2]; + mat4 projection = getProjection(0); + float planeC = projection[2][3] + projection[2][2]; + float planeD = projection[3][2]; return planeD / planeC; } // positive far distance of the projection float getPosLinearDepthFar() { - return -frameTransform._depthInfo.z; -} - -mat4 getViewInverse() { - return frameTransform._viewInverse * cameraCorrection._correctionInverse; + return -frameTransform.infos._depthInfo.z; } -mat4 getView() { - return cameraCorrection._correction * frameTransform._view; +mat4 getViewInverse(int side) { + frameTransform.cameras[side]._viewInverse } -mat4 getPreviousView() { - return cameraCorrection._prevView; +mat4 getView(int side) { + return frameTransform.cameras[side]._view; } -mat4 getPreviousViewInverse() { - return cameraCorrection._prevViewInverse; +mat4 getPreviousView(int side) { + return frameTransform.cameras[side]._previousView; } -DeferredFrameTransform getDeferredFrameTransform() { - DeferredFrameTransform result = frameTransform; - result._view = getView(); - result._viewInverse = getViewInverse(); - return result; +mat4 getPreviousViewInverse(int side) { + return frameTransform.cameras[side]._previousViewInverse; } bool isStereo() { - return frameTransform._stereoInfo.x > 0.0f; + return frameTransform.infos._stereoInfo.x > 0.0f; } float getStereoSideWidth(int resolutionLevel) { - return float(int(frameTransform._stereoInfo.y) >> resolutionLevel); + return float(int(frameTransform.infos._stereoInfo.y) >> resolutionLevel); } float getStereoSideHeight(int resolutionLevel) { - return float(int(frameTransform._pixelInfo.w) >> resolutionLevel); + return float(int(frameTransform.infos.pixelInfo.w) >> resolutionLevel); } +vec2 getSideImageSize(int resolutionLevel) { + return vec2(float(int(frameTransform.infos.stereoInfo.y) >> resolutionLevel), float(int(frameTransform.infos.pixelInfo.w) >> resolutionLevel)); +} + +int getStereoSideFromPixel(int xPos, int resolutionLevel) { + int sideWidth = int(getStereoSideWidth(resolutionLevel)); + return int(xPos >= sideWidth && isStereo()); +} + +int getStereoSideFromPixel(int xPos) { + return getStereoSideFromPixel(xPos, 0); +} + +int getStereoSideFromFragCoord() { + return getStereoSideFromPixel(int(gl_FragCoord.x), 0); +} + +int getStereoSideFromUV(float uPos) { + return int(uPos >= 0.5 && isStereo());} + vec2 getStereoSideSize(int resolutionLevel) { return vec2(getStereoSideWidth(resolutionLevel), getStereoSideHeight(resolutionLevel)); } @@ -134,17 +127,16 @@ ivec4 getStereoSideInfo(int xPos, int resolutionLevel) { return getStereoSideInfoFromWidth(xPos, sideWidth); } - int getStereoSide(ivec4 sideInfo) { return sideInfo.x; } float evalZeyeFromZdb(float depth) { - return frameTransform._depthInfo.x / (depth * frameTransform._depthInfo.y + frameTransform._depthInfo.z); + return frameTransform.infos._depthInfo.x / (depth * frameTransform.infos._depthInfo.y + frameTransform.infos._depthInfo.z); } float evalZdbFromZeye(float Zeye) { - return (frameTransform._depthInfo.x - Zeye * frameTransform._depthInfo.z) / (Zeye * frameTransform._depthInfo.y); + return (frameTransform.infos._depthInfo.x - Zeye * frameTransform.infos._depthInfo.z) / (Zeye * frameTransform.infos._depthInfo.y); } vec3 evalEyeNormal(vec3 C) { @@ -155,15 +147,7 @@ vec3 evalEyePositionFromZdb(int side, float Zdb, vec2 texcoord) { // compute the view space position using the depth vec3 clipPos; clipPos.xyz = vec3(texcoord.xy, Zdb) * 2.0 - 1.0; - vec4 eyePos = frameTransform._invProjection[side] * vec4(clipPos.xyz, 1.0); - return eyePos.xyz / eyePos.w; -} - -vec3 evalUnjitteredEyePositionFromZdb(int side, float Zdb, vec2 texcoord) { - // compute the view space position using the depth - vec3 clipPos; - clipPos.xyz = vec3(texcoord.xy, Zdb) * 2.0 - 1.0; - vec4 eyePos = frameTransform._invProjectionUnJittered[side] * vec4(clipPos.xyz, 1.0); + vec4 eyePos = getProjectionInverse(side) * vec4(clipPos.xyz, 1.0); return eyePos.xyz / eyePos.w; } diff --git a/libraries/render-utils/src/DeferredTransform_shared.slh b/libraries/render-utils/src/DeferredTransform_shared.slh new file mode 100644 index 00000000000..7e574f0715c --- /dev/null +++ b/libraries/render-utils/src/DeferredTransform_shared.slh @@ -0,0 +1,33 @@ +// glsl / C++ compatible source as interface for DeferredFrameTransform layout +#ifdef __cplusplus +# define DFT_VEC4 glm::vec4 +# define DFT_MAT4 glm::mat4 +#include "gpu/TransformCamera_shared.slh" +#else +# define DFT_VEC4 vec4 +# define DFT_MAT4 mat4 +<@include gpu/TransformCamera_shared.slh@> +#endif + +struct DeferredFrameInfo { + // Pixel info is { viewport width height} + DFT_VEC4 pixelInfo; + DFT_VEC4 invPixelInfo; + // Depth info is { n.f, f - n, -f} + DFT_VEC4 depthInfo; + // Stereo info is { isStereoFrame, halfWidth } + DFT_VEC4 stereoInfo; + // The mono projection for sure + DFT_MAT4 projectionMono; +}; + +struct _DeferredFrameTransform { + DeferredFrameInfo infos; + // The camera transforms for the two eyes (or only first one if mono, of course) + _TransformCamera cameras[2]; +}; + + // <@if 1@> + // Trigger Scribe include + // <@endif@> +// \ No newline at end of file diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp index 4ac097e31d7..c1cbdbe5e41 100644 --- a/libraries/render-utils/src/GeometryCache.cpp +++ b/libraries/render-utils/src/GeometryCache.cpp @@ -799,7 +799,7 @@ render::ShapePipelinePointer GeometryCache::getFadingShapePipeline(bool textured graphics::MaterialKey::CullFaceMode cullFaceMode) { auto fadeEffect = DependencyManager::get(); auto fadeBatchSetter = fadeEffect->getBatchSetter(); - auto fadeItemSetter = fadeEffect->getItemUniformSetter(); + auto fadeItemSetter = fadeEffect->getItemStoredSetter(); return std::make_shared(getSimplePipeline(textured, transparent, unlit, depthBias, true, true, forward, cullFaceMode), nullptr, [fadeBatchSetter, fadeItemSetter](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args* args) { batch.setResourceTexture(gr::Texture::MaterialAlbedo, DependencyManager::get()->getWhiteTexture()); @@ -1995,7 +1995,7 @@ void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch, bool noBlend) { // enable decal blend state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA); - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); _standardDrawPipeline = gpu::Pipeline::create(program, state); @@ -2027,7 +2027,7 @@ void GeometryCache::useGridPipeline(gpu::Batch& batch, GridBuffer gridBuffer, bo gpu::StatePointer state = std::make_shared(); state->setDepthTest(true, !std::get<0>(key), gpu::LESS_EQUAL); if (std::get<0>(key)) { - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); } else { PrepareStencil::testMaskDrawShape(*state); } @@ -2134,7 +2134,6 @@ gpu::PipelinePointer GeometryCache::getWebBrowserProgram(bool transparent, bool gpu::StatePointer state = std::make_shared(); state->setDepthTest(true, !transparent, gpu::LESS_EQUAL); - // FIXME: do we need a testMaskDrawNoAA? PrepareStencil::testMaskDrawShapeNoAA(*state); state->setBlendFunction(transparent, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA, @@ -2215,7 +2214,7 @@ gpu::PipelinePointer GeometryCache::getSimplePipeline(bool textured, bool transp gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE); if (config.isAntiAliased()) { - config.isTransparent() ? PrepareStencil::testMask(*state) : PrepareStencil::testMaskDrawShape(*state); + config.isTransparent() ? PrepareStencil::testMaskResetNoAA(*state) : PrepareStencil::testMaskDrawShape(*state); } else { PrepareStencil::testMaskDrawShapeNoAA(*state); } diff --git a/libraries/render-utils/src/Haze.slf b/libraries/render-utils/src/Haze.slf index 899f36b8ebf..69f38c56f14 100644 --- a/libraries/render-utils/src/Haze.slf +++ b/libraries/render-utils/src/Haze.slf @@ -23,13 +23,13 @@ LAYOUT(binding=RENDER_UTILS_TEXTURE_HAZE_LINEAR_DEPTH) uniform sampler2D linearDepthMap; -vec4 unpackPositionFromZeye(vec2 texcoord) { +vec4 unpackPositionFromZeyeAndGetSide(vec2 texcoord, out int side) { float Zeye = -texture(linearDepthMap, texcoord).x; float check = float(isStereo()); float check2 = check * float(texcoord.x > 0.5); texcoord.x -= check2 * 0.5; - int side = int(check2); + side = int(check2); texcoord.x *= 1.0 + check; return vec4(evalEyePositionFromZeye(side, Zeye, texcoord), 1.0); @@ -43,9 +43,10 @@ void main(void) { discard; } - vec4 fragPositionES = unpackPositionFromZeye(varTexCoord0); + int side; + vec4 fragPositionES = unpackPositionFromZeyeAndGetSide(varTexCoord0, side); - mat4 viewInverse = getViewInverse(); + mat4 viewInverse = getViewInverse(side); vec4 fragPositionWS = viewInverse * fragPositionES; vec4 eyePositionWS = viewInverse[3]; diff --git a/libraries/render-utils/src/HighlightEffect.cpp b/libraries/render-utils/src/HighlightEffect.cpp index 5a8b09b018a..db8b4ff02d1 100644 --- a/libraries/render-utils/src/HighlightEffect.cpp +++ b/libraries/render-utils/src/HighlightEffect.cpp @@ -118,7 +118,8 @@ gpu::PipelinePointer DrawHighlightMask::_stencilMaskPipeline; gpu::PipelinePointer DrawHighlightMask::_stencilMaskFillPipeline; DrawHighlightMask::DrawHighlightMask(unsigned int highlightIndex, render::ShapePlumberPointer shapePlumber, - HighlightSharedParametersPointer parameters) : _highlightPassIndex(highlightIndex), _shapePlumber(shapePlumber), _sharedParameters(parameters) {} + HighlightSharedParametersPointer parameters, uint transformSlot) : + _highlightPassIndex(highlightIndex), _shapePlumber(shapePlumber), _sharedParameters(parameters), _transformSlot(transformSlot) {} void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) { assert(renderContext->args); @@ -171,8 +172,6 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c batch.clearDepthStencilFramebuffer(1.0f, 0); }); - const auto jitter = inputs.get2(); - render::ItemBounds itemBounds; gpu::doInBatch("DrawHighlightMask::run", args->_context, [&](gpu::Batch& batch) { @@ -184,9 +183,8 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c args->getViewFrustum().evalProjectionMatrix(projMat); args->getViewFrustum().evalViewTransform(viewMat); batch.setViewportTransform(args->_viewport); - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat); + batch.setProjectionJitterEnabled(true); + batch.setSavedViewProjectionTransform(_transformSlot); const std::vector keys = { ShapeKey::Builder(), ShapeKey::Builder().withFade(), @@ -257,6 +255,11 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c } gpu::doInBatch("DrawHighlightMask::run::end", args->_context, [&](gpu::Batch& batch) { + // Setup camera, projection and viewport for all items + batch.setViewportTransform(args->_viewport); + batch.setProjectionJitterEnabled(true); + batch.setSavedViewProjectionTransform(_transformSlot); + // Draw stencil mask with object bounding boxes auto stencilPipeline = highlight._style.isFilled() ? _stencilMaskFillPipeline : _stencilMaskPipeline; batch.setPipeline(stencilPipeline); @@ -317,7 +320,6 @@ void DrawHighlight::run(const render::RenderContextPointer& renderContext, const shaderParameters._size.y = size; } - auto primaryFramebuffer = inputs.get4(); gpu::doInBatch("DrawHighlight::run", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); batch.setFramebuffer(destinationFrameBuffer); @@ -333,9 +335,6 @@ void DrawHighlight::run(const render::RenderContextPointer& renderContext, const batch.setResourceTexture(ru::Texture::HighlightSceneDepth, sceneDepthBuffer->getPrimaryDepthTexture()); batch.setResourceTexture(ru::Texture::HighlightDepth, highlightedDepthTexture); batch.draw(gpu::TRIANGLE_STRIP, 4); - - // Reset the framebuffer for overlay drawing - batch.setFramebuffer(primaryFramebuffer); }); } } @@ -359,7 +358,7 @@ const gpu::PipelinePointer& DrawHighlight::getPipeline(const render::HighlightSt return style.isFilled() ? _pipelineFilled : _pipeline; } -DebugHighlight::DebugHighlight() { +DebugHighlight::DebugHighlight(uint transformSlot) : _transformSlot(transformSlot) { _geometryDepthId = DependencyManager::get()->allocateID(); } @@ -382,22 +381,15 @@ void DebugHighlight::run(const render::RenderContextPointer& renderContext, cons assert(renderContext->args); assert(renderContext->args->hasViewFrustum()); RenderArgs* args = renderContext->args; - const auto jitter = input.get2(); - auto primaryFramebuffer = input.get3(); gpu::doInBatch("DebugHighlight::run", args->_context, [&](gpu::Batch& batch) { batch.setViewportTransform(args->_viewport); batch.setFramebuffer(highlightResources->getColorFramebuffer()); const auto geometryBuffer = DependencyManager::get(); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat); + batch.setProjectionJitterEnabled(true); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); const glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f); @@ -409,9 +401,6 @@ void DebugHighlight::run(const render::RenderContextPointer& renderContext, cons geometryBuffer->renderQuad(batch, bottomLeft, topRight, color, _geometryDepthId); batch.setResourceTexture(0, nullptr); - - // Reset the framebuffer for overlay drawing - batch.setFramebuffer(primaryFramebuffer); }); } } @@ -498,12 +487,11 @@ void DrawHighlightTask::configure(const Config& config) { } -void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs) { +void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, uint transformSlot) { const auto items = inputs.getN(0).get(); const auto sceneFrameBuffer = inputs.getN(1); const auto primaryFramebuffer = inputs.getN(2); const auto deferredFrameTransform = inputs.getN(3); - const auto jitter = inputs.getN(4); // Prepare the ShapePipeline auto shapePlumber = std::make_shared(); @@ -541,8 +529,8 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren stream << "HighlightMask" << i; name = stream.str(); } - const auto drawMaskInputs = DrawHighlightMask::Inputs(sortedBounds, highlightResources, jitter).asVarying(); - const auto highlightedRect = task.addJob(name, drawMaskInputs, i, shapePlumber, sharedParameters); + const auto drawMaskInputs = DrawHighlightMask::Inputs(sortedBounds, highlightResources).asVarying(); + const auto highlightedRect = task.addJob(name, drawMaskInputs, i, shapePlumber, sharedParameters, transformSlot); if (i == 0) { highlight0Rect = highlightedRect; } @@ -553,13 +541,13 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren stream << "HighlightEffect" << i; name = stream.str(); } - const auto drawHighlightInputs = DrawHighlight::Inputs(deferredFrameTransform, highlightResources, sceneFrameBuffer, highlightedRect, primaryFramebuffer).asVarying(); + const auto drawHighlightInputs = DrawHighlight::Inputs(deferredFrameTransform, highlightResources, sceneFrameBuffer, highlightedRect).asVarying(); task.addJob(name, drawHighlightInputs, i, sharedParameters); } // Debug highlight - const auto debugInputs = DebugHighlight::Inputs(highlightResources, const_cast(highlight0Rect), jitter, primaryFramebuffer).asVarying(); - task.addJob("HighlightDebug", debugInputs); + const auto debugInputs = DebugHighlight::Inputs(highlightResources, const_cast(highlight0Rect)).asVarying(); + task.addJob("HighlightDebug", debugInputs, transformSlot); } const render::Varying DrawHighlightTask::addSelectItemJobs(JobModel& task, const render::Varying& selectionName, diff --git a/libraries/render-utils/src/HighlightEffect.h b/libraries/render-utils/src/HighlightEffect.h index 933503fdb54..4d5eba4f525 100644 --- a/libraries/render-utils/src/HighlightEffect.h +++ b/libraries/render-utils/src/HighlightEffect.h @@ -112,11 +112,10 @@ class ExtractSelectionName { class DrawHighlightMask { public: - using Inputs = render::VaryingSet3; - using Outputs = glm::ivec4; + using Inputs = render::VaryingSet2; using Outputs = glm::ivec4; using JobModel = render::Job::ModelIO; - DrawHighlightMask(unsigned int highlightIndex, render::ShapePlumberPointer shapePlumber, HighlightSharedParametersPointer parameters); + DrawHighlightMask(unsigned int highlightIndex, render::ShapePlumberPointer shapePlumber, HighlightSharedParametersPointer parameters, uint transformSlot); void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs); @@ -126,6 +125,7 @@ class DrawHighlightMask { HighlightSharedParametersPointer _sharedParameters; gpu::BufferPointer _boundsBuffer; gpu::StructBuffer _outlineWidth; + uint _transformSlot; static gpu::PipelinePointer _stencilMaskPipeline; static gpu::PipelinePointer _stencilMaskFillPipeline; @@ -134,7 +134,7 @@ class DrawHighlightMask { class DrawHighlight { public: - using Inputs = render::VaryingSet5; + using Inputs = render::VaryingSet4; using Config = render::Job::Config; using JobModel = render::Job::ModelI; @@ -172,11 +172,10 @@ class DebugHighlightConfig : public render::Job::Config { class DebugHighlight { public: - using Inputs = render::VaryingSet4; - using Config = DebugHighlightConfig; + using Inputs = render::VaryingSet2; using Config = DebugHighlightConfig; using JobModel = render::Job::ModelI; - DebugHighlight(); + DebugHighlight(uint transformSlot); ~DebugHighlight(); void configure(const Config& config); @@ -185,8 +184,9 @@ class DebugHighlight { private: gpu::PipelinePointer _depthPipeline; - int _geometryDepthId{ 0 }; - bool _isDisplayEnabled{ false }; + int _geometryDepthId { 0 }; + bool _isDisplayEnabled { false }; + uint transformSlot; const gpu::PipelinePointer& getDepthPipeline(); void initializePipelines(); @@ -195,14 +195,13 @@ class DebugHighlight { class DrawHighlightTask { public: - using Inputs = render::VaryingSet5; - using Config = render::Task::Config; + using Inputs = render::VaryingSet4; using Config = render::Task::Config; using JobModel = render::Task::ModelI; DrawHighlightTask(); void configure(const Config& config); - void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs); + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, uint transformSlot); private: static const render::Varying addSelectItemJobs(JobModel& task, const render::Varying& selectionName, const RenderFetchCullSortTask::BucketList& items); diff --git a/libraries/render-utils/src/Highlight_aabox.slv b/libraries/render-utils/src/Highlight_aabox.slv index 65b98355ae2..e75694d910e 100644 --- a/libraries/render-utils/src/Highlight_aabox.slv +++ b/libraries/render-utils/src/Highlight_aabox.slv @@ -1,7 +1,7 @@ <@include gpu/Config.slh@> <$VERSION_HEADER$> -// Generated on <$_SCRIBE_DATE$> -// +// <$_SCRIBE_FILENAME$> +// Generated on <$_SCRIBE_DATE$> // Draw and transform the fed vertex position with the standard MVP stack // and offset the vertices by a certain amount in the vertex direction // @@ -12,9 +12,7 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // -<@include gpu/ShaderConstants.h@> <@include gpu/Transform.slh@> - <$declareStandardTransform()$> struct ItemBound { @@ -107,5 +105,5 @@ void main(void) { vec4 offsetPosition; <$transformModelToMonoClipPos(cam, obj, pos, offsetPosition)$> gl_Position.xy += normalize(offsetPosition.xy-gl_Position.xy) * _parameters.outlineWidth * gl_Position.w; - <$transformStereoClipsSpace(cam, gl_Position)$> + <$transformStereoClipSpace(gl_Position)$> } diff --git a/libraries/render-utils/src/LightClusters.cpp b/libraries/render-utils/src/LightClusters.cpp index 3dc826d56c8..a1bd4001fcb 100644 --- a/libraries/render-utils/src/LightClusters.cpp +++ b/libraries/render-utils/src/LightClusters.cpp @@ -575,7 +575,7 @@ void LightClusteringPass::run(const render::RenderContextPointer& renderContext, config->setNumClusteredLightReferences(clusteringStats.z); } -DebugLightClusters::DebugLightClusters() { +DebugLightClusters::DebugLightClusters(uint transformSlot) : _transformSlot(transformSlot) { } @@ -650,13 +650,7 @@ void DebugLightClusters::run(const render::RenderContextPointer& renderContext, // Assign the camera transform batch.setViewportTransform(args->_viewport); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); - + batch.setSavedViewProjectionTransform(_transformSlot); // Then the actual ClusterGrid attributes batch.setModelTransform(Transform()); @@ -668,8 +662,6 @@ void DebugLightClusters::run(const render::RenderContextPointer& renderContext, batch.setUniformBuffer(ru::Buffer::LightClusterGrid, lightClusters->_clusterGridBuffer); batch.setUniformBuffer(ru::Buffer::LightClusterContent, lightClusters->_clusterContentBuffer); - - if (doDrawClusterFromDepth) { batch.setPipeline(getDrawClusterFromDepthPipeline()); batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredTransform->getFrameTransformBuffer()); diff --git a/libraries/render-utils/src/LightClusters.h b/libraries/render-utils/src/LightClusters.h index 60978e76e89..be39e8ffc1e 100644 --- a/libraries/render-utils/src/LightClusters.h +++ b/libraries/render-utils/src/LightClusters.h @@ -217,7 +217,7 @@ class DebugLightClusters { using Config = DebugLightClustersConfig; using JobModel = render::Job::ModelI; - DebugLightClusters(); + DebugLightClusters(uint transformSlot); void configure(const Config& config); @@ -228,6 +228,7 @@ class DebugLightClusters { gpu::PipelinePointer _drawClusterGrid; gpu::PipelinePointer _drawClusterFromDepth; gpu::PipelinePointer _drawClusterContent; + uint _transformSlot; const gpu::PipelinePointer getDrawClusterGridPipeline(); const gpu::PipelinePointer getDrawClusterFromDepthPipeline(); const gpu::PipelinePointer getDrawClusterContentPipeline(); diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp index 8ba5be54e6d..e1d7d4afda0 100644 --- a/libraries/render-utils/src/MeshPartPayload.cpp +++ b/libraries/render-utils/src/MeshPartPayload.cpp @@ -162,6 +162,7 @@ void ModelMeshPartPayload::computeAdjustedLocalBound(const std::vectorargs->_context, [&](gpu::Batch& batch) { _gpuTimer->begin(batch); + batch.pushProfileRange(timer->name().c_str()); }); } void EndGPURangeTimer::run(const render::RenderContextPointer& renderContext, const gpu::RangeTimerPointer& timer) { gpu::doInBatch("EndGPURangeTimer", renderContext->args->_context, [&](gpu::Batch& batch) { + batch.popProfileRange(); timer->end(batch); }); @@ -45,10 +46,22 @@ void EndGPURangeTimer::run(const render::RenderContextPointer& renderContext, co config->setGPUBatchRunTime(timer->getGPUAverage(), timer->getBatchAverage()); } -DrawLayered3D::DrawLayered3D(bool opaque) : - _shapePlumber(std::make_shared()), - _opaquePass(opaque) { - initForwardPipelines(*_shapePlumber); +void SetFramebuffer::run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& framebuffer) { + assert(renderContext->args); + RenderArgs* args = renderContext->args; + + gpu::doInBatch("SetFramebuffer::run", args->_context, [&](gpu::Batch& batch) { + args->_batch = &batch; + batch.setFramebuffer(framebuffer); + args->_batch = nullptr; + }); +} + +DrawLayered3D::DrawLayered3D(const render::ShapePlumberPointer& shapePlumber, bool opaque, bool jitter, unsigned int transformSlot) : + _shapePlumber(shapePlumber), + _transformSlot(transformSlot), + _opaquePass(opaque), + _isJitterEnabled(jitter) { } void DrawLayered3D::run(const RenderContextPointer& renderContext, const Inputs& inputs) { @@ -58,9 +71,9 @@ void DrawLayered3D::run(const RenderContextPointer& renderContext, const Inputs& auto config = std::static_pointer_cast(renderContext->jobConfig); const auto& inItems = inputs.get0(); - const auto& lightingModel = inputs.get1(); - const auto& hazeFrame = inputs.get2(); - const auto jitter = inputs.get3(); + const auto& frameTransform = inputs.get1() + const auto& lightingModel = inputs.get2(); + const auto& hazeFrame = inputs.get3(); config->setNumDrawn((int)inItems.size()); emit config->numDrawnChanged(); @@ -80,29 +93,25 @@ void DrawLayered3D::run(const RenderContextPointer& renderContext, const Inputs& if (_opaquePass) { gpu::doInBatch("DrawLayered3D::run::clear", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); - batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0, false); + batch.clearDepthFramebuffer(true, false); }); } if (!inItems.empty()) { // Render the items gpu::doInBatch("DrawLayered3D::main", args->_context, [&](gpu::Batch& batch) { + PROFILE_RANGE_BATCH(batch, "DrawLayered3D::main"); args->_batch = &batch; batch.setViewportTransform(args->_viewport); batch.setStateScissorRect(args->_viewport); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat); + batch.setProjectionJitterEnabled(_isJitterEnabled); + batch.setSavedViewProjectionTransform(_transformSlot); // Setup lighting model for all items; batch.setUniformBuffer(ru::Buffer::LightModel, lightingModel->getParametersBuffer()); batch.setResourceTexture(ru::Texture::AmbientFresnel, lightingModel->getAmbientFresnelLUT()); + batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, frameTransform->getFrameTransformBuffer()); if (haze) { batch.setUniformBuffer(graphics::slot::buffer::Buffer::HazeParams, haze->getHazeParametersBuffer()); diff --git a/libraries/render-utils/src/RenderCommonTask.h b/libraries/render-utils/src/RenderCommonTask.h index 15d6ff98955..550d330b50b 100644 --- a/libraries/render-utils/src/RenderCommonTask.h +++ b/libraries/render-utils/src/RenderCommonTask.h @@ -13,6 +13,7 @@ #include "LightStage.h" #include "HazeStage.h" #include "LightingModel.h" +#include "DeferredFrameTransform.h" class BeginGPURangeTimer { public: @@ -61,11 +62,11 @@ class DrawLayered3DConfig : public render::Job::Config { class DrawLayered3D { public: - using Inputs = render::VaryingSet4; + using Inputs = render::VaryingSet4; using Config = DrawLayered3DConfig; using JobModel = render::Job::ModelI; - DrawLayered3D(bool opaque); + DrawLayered3D(const render::ShapePlumberPointer& shapePlumber, bool opaque, bool jitter, unsigned int transformSlot); void configure(const Config& config) { _maxDrawn = config.maxDrawn; } void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); @@ -73,7 +74,16 @@ class DrawLayered3D { protected: render::ShapePlumberPointer _shapePlumber; int _maxDrawn; // initialized by Config + uint _transformSlot; bool _opaquePass { true }; + bool _isJitterEnabled { false }; +}; + +class SetFramebuffer { +public: + using JobModel = render::Job::ModelI; + + void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& framebuffer); }; class Blit { diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index c506f22bc71..e3a65386433 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -39,7 +40,6 @@ #include "DeferredFramebuffer.h" #include "DeferredLightingEffect.h" #include "SurfaceGeometryPass.h" -#include "VelocityBufferPass.h" #include "FramebufferCache.h" #include "TextureCache.h" #include "ZoneRenderer.h" @@ -60,6 +60,7 @@ using namespace render; extern void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePipeline::BatchSetter& batchSetter, const render::ShapePipeline::ItemSetter& itemSetter); +extern void initForwardPipelines(render::ShapePlumber& plumber); namespace ru { using render_utils::slot::texture::Texture; @@ -74,25 +75,17 @@ namespace gr { class RenderDeferredTaskDebug { public: - using ExtraBuffers = render::VaryingSet6; + using ExtraBuffers = render::VaryingSet5; using Input = render::VaryingSet9; + LightingModel, Antialiasing::Outputs>; using JobModel = render::Task::ModelI; - RenderDeferredTaskDebug(); - - void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs); -private: + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, uint mainViewTransformSlot); }; - -RenderDeferredTask::RenderDeferredTask() -{ -} - void RenderDeferredTask::configure(const Config& config) { // Propagate resolution scale to sub jobs who need it auto preparePrimaryBufferConfig = config.getConfig("PreparePrimaryBufferDeferred"); @@ -100,11 +93,16 @@ void RenderDeferredTask::configure(const Config& config) { preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale); } -void RenderDeferredTask::build(JobModel& task, const render::Varying& input, render::Varying& output) { +void RenderDeferredTask::build(JobModel& task, const render::Varying& input, render::Varying& output, uint8_t transformOffset) { auto fadeEffect = DependencyManager::get(); // Prepare the ShapePipelines - ShapePlumberPointer shapePlumber = std::make_shared(); - initDeferredPipelines(*shapePlumber, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter()); + ShapePlumberPointer shapePlumberDeferred = std::make_shared(); + initDeferredPipelines(*shapePlumberDeferred, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter()); + ShapePlumberPointer shapePlumberForward = std::make_shared(); + initForwardPipelines(*shapePlumberForward); + + uint backgroundViewTransformSlot = render::RenderEngine::TS_BACKGROUND_VIEW + transformOffset; + uint mainViewTransformSlot = render::RenderEngine::TS_MAIN_VIEW + transformOffset; const auto& inputs = input.get(); @@ -142,25 +140,26 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren fadeEffect->build(task, opaques); - const auto jitter = task.addJob("JitterCam"); + task.addJob("AntialiasingSetup"); // GPU jobs: Start preparing the primary, deferred and lighting buffer const auto scaledPrimaryFramebuffer = task.addJob("PreparePrimaryBufferDeferred"); // Prepare deferred, generate the shared Deferred Frame Transform. Only valid with the scaled frame buffer - const auto deferredFrameTransform = task.addJob("DeferredFrameTransform", jitter); + const auto deferredFrameTransform = task.addJob("DeferredFrameTransform", mainViewTransformSlot); const auto prepareDeferredInputs = PrepareDeferred::Inputs(scaledPrimaryFramebuffer, lightingModel).asVarying(); const auto prepareDeferredOutputs = task.addJob("PrepareDeferred", prepareDeferredInputs); const auto deferredFramebuffer = prepareDeferredOutputs.getN(0); const auto lightingFramebuffer = prepareDeferredOutputs.getN(1); + const auto lightingWithVelocityFramebuffer = prepareDeferredOutputs.getN(2); // draw a stencil mask in hidden regions of the framebuffer. task.addJob("PrepareStencil", scaledPrimaryFramebuffer); // Render opaque objects in DeferredBuffer - const auto opaqueInputs = DrawStateSortDeferred::Inputs(opaques, lightingModel, jitter).asVarying(); - task.addJob("DrawOpaqueDeferred", opaqueInputs, shapePlumber); + const auto opaqueInputs = DrawStateSortDeferred::Inputs(opaques, lightingModel, deferredFrameTransform).asVarying(); + task.addJob("DrawOpaqueDeferred", opaqueInputs, shapePlumberDeferred, mainViewTransformSlot); // Opaque all rendered @@ -186,11 +185,6 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren const auto ambientOcclusionFramebuffer = ambientOcclusionOutputs.getN(0); const auto ambientOcclusionUniforms = ambientOcclusionOutputs.getN(1); - // Velocity - const auto velocityBufferInputs = VelocityBufferPass::Inputs(deferredFrameTransform, deferredFramebuffer).asVarying(); - const auto velocityBufferOutputs = task.addJob("VelocityBuffer", velocityBufferInputs); - const auto velocityBuffer = velocityBufferOutputs.getN(0); - // Light Clustering // Create the cluster grid of lights, cpu job for now const auto lightClusteringPassInputs = LightClusteringPass::Input(deferredFrameTransform, lightingModel, lightFrame, linearDepthTarget).asVarying(); @@ -201,30 +195,34 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren const auto deferredLightingInputs = RenderDeferred::Inputs(deferredFrameTransform, deferredFramebuffer, extraDeferredBuffer, lightingModel, lightClusters, lightFrame, shadowFrame, hazeFrame).asVarying(); task.addJob("RenderDeferred", deferredLightingInputs); + task.addJob("SetDeferredFramebufferBackground", deferredFramebuffer, DeferredFramebuffer::FULL); // Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying(); - task.addJob("DrawBackgroundDeferred", backgroundInputs); + task.addJob("DrawBackgroundDeferred", backgroundInputs, backgroundViewTransformSlot); + task.addJob("SetDeferredFramebufferHaze", deferredFramebuffer, DeferredFramebuffer::LIGHTING); const auto drawHazeInputs = render::Varying(DrawHaze::Inputs(hazeFrame, lightingFramebuffer, linearDepthTarget, deferredFrameTransform, lightingModel, lightFrame)); task.addJob("DrawHazeDeferred", drawHazeInputs); // Render transparent objects forward in LightingBuffer - const auto transparentsInputs = RenderTransparentDeferred::Inputs(transparents, hazeFrame, lightFrame, lightingModel, lightClusters, shadowFrame, jitter).asVarying(); - task.addJob("DrawTransparentDeferred", transparentsInputs, shapePlumber); + const auto transparentsInputs = RenderTransparentDeferred::Inputs(transparents, hazeFrame, lightFrame, lightingModel, lightClusters, shadowFrame, deferredFrameTransform).asVarying(); + task.addJob("DrawTransparentDeferred", transparentsInputs, shapePlumberDeferred, mainViewTransformSlot); // Highlight - const auto outlineInputs = DrawHighlightTask::Inputs(items, deferredFramebuffer, lightingFramebuffer, deferredFrameTransform, jitter).asVarying(); - task.addJob("DrawHighlight", outlineInputs); + const auto outlineInputs = DrawHighlightTask::Inputs(items, deferredFramebuffer, lightingFramebuffer, deferredFrameTransform).asVarying(); + task.addJob("DrawHighlight", outlineInputs, mainViewTransformSlot); // Layered Over (in front) - const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, jitter).asVarying(); - const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, jitter).asVarying(); - task.addJob("DrawInFrontOpaque", inFrontOpaquesInputs, true); - task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, false); + task.addJob("SetOpaqueLayeredFramebuffer", deferredFramebuffer, DeferredFramebuffer::LIGHTING_VELOCITY); + const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + task.addJob("DrawInFrontOpaque", inFrontOpaquesInputs, shapePlumberForward, true, true, mainViewTransformSlot); + task.addJob("SetTransparentLayeredFramebuffer", deferredFramebuffer, DeferredFramebuffer::LIGHTING); + const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, shapePlumberForward, false, true, mainViewTransformSlot); // AA job before bloom to limit flickering - const auto antialiasingInputs = Antialiasing::Inputs(deferredFrameTransform, lightingFramebuffer, linearDepthTarget, velocityBuffer).asVarying(); - task.addJob("Antialiasing", antialiasingInputs); + const auto antialiasingInputs = Antialiasing::Inputs(deferredFrameTransform, deferredFramebuffer, linearDepthTarget).asVarying(); + const auto antialiasingIntensityTexture = task.addJob("Antialiasing", antialiasingInputs); // Add bloom const auto bloomInputs = BloomEffect::Inputs(deferredFrameTransform, lightingFramebuffer, bloomFrame, lightingModel).asVarying(); @@ -238,21 +236,18 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren // Debugging task is happening in the "over" layer after tone mapping and just before HUD { // Debug the bounds of the rendered items, still look at the zbuffer - const auto extraDebugBuffers = RenderDeferredTaskDebug::ExtraBuffers(linearDepthTarget, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, ambientOcclusionUniforms, scatteringResource, velocityBuffer); + const auto extraDebugBuffers = RenderDeferredTaskDebug::ExtraBuffers(linearDepthTarget, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, ambientOcclusionUniforms, scatteringResource); const auto debugInputs = RenderDeferredTaskDebug::Input(fetchedItems, shadowTaskOutputs, lightingStageInputs, lightClusters, prepareDeferredOutputs, extraDebugBuffers, - deferredFrameTransform, jitter, lightingModel).asVarying(); - task.addJob("DebugRenderDeferredTask", debugInputs); + deferredFrameTransform, lightingModel, antialiasingIntensityTexture).asVarying(); + task.addJob("DebugRenderDeferredTask", debugInputs, mainViewTransformSlot); } // HUD Layer - const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying(); - task.addJob("RenderHUDLayer", renderHUDLayerInputs); + const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame, deferredFrameTransform).asVarying(); + task.addJob("RenderHUDLayer", renderHUDLayerInputs, shapePlumberForward, mainViewTransformSlot); } -RenderDeferredTaskDebug::RenderDeferredTaskDebug() { -} - -void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input, render::Varying& outputs) { +void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input, render::Varying& outputs, uint mainViewTransformSlot) { const auto& inputs = input.get(); @@ -274,63 +269,59 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input // RenderShadowTask out const auto& shadowOut = inputs.get1(); - - const auto& renderShadowTaskOut = shadowOut[0]; - const auto& shadowFrame = shadowOut[1]; + const auto& renderShadowTaskOut = shadowOut[0]; + const auto& shadowFrame = shadowOut.get1(); // Extract the Lighting Stages Current frame ( and zones) const auto lightingStageInputs = inputs.get2(); // Fetch the current frame stacks from all the stages const auto stageCurrentFrames = lightingStageInputs.get0(); - const auto lightFrame = stageCurrentFrames[0]; - const auto backgroundFrame = stageCurrentFrames[1]; - const auto hazeFrame = stageCurrentFrames[2]; - const auto bloomFrame = stageCurrentFrames[3]; + const auto lightFrame = stageCurrentFrames.get0(); + const auto backgroundFrame = stageCurrentFrames.get1(); + const auto hazeFrame = stageCurrentFrames.get2(); + const auto bloomFrame = stageCurrentFrames.get3(); // Zones - const auto& zones = lightingStageInputs[1]; + const auto& zones = lightingStageInputs.get1(); // Light CLuster - const auto& lightClusters = inputs[3]; + const auto& lightClusters = inputs.get3(); // PrepareDeferred out const auto& prepareDeferredOutputs = inputs.get4(); - const auto& deferredFramebuffer = prepareDeferredOutputs[0]; + const auto& deferredFramebuffer = prepareDeferredOutputs.get0(); // extraDeferredBuffer const auto& extraDeferredBuffer = inputs.get5(); - const auto& linearDepthTarget = extraDeferredBuffer[0]; - const auto& surfaceGeometryFramebuffer = extraDeferredBuffer[1]; - const auto& ambientOcclusionFramebuffer = extraDeferredBuffer[2]; - const auto& ambientOcclusionUniforms = extraDeferredBuffer[3]; - const auto& scatteringResource = extraDeferredBuffer[4]; - const auto& velocityBuffer = extraDeferredBuffer[5]; + const auto& linearDepthTarget = extraDeferredBuffer.get0(); + const auto& surfaceGeometryFramebuffer = extraDeferredBuffer.get1(); + const auto& ambientOcclusionFramebuffer = extraDeferredBuffer.get2(); + const auto& ambientOcclusionUniforms = extraDeferredBuffer.get3(); + const auto& scatteringResource = extraDeferredBuffer.get4(); // GenerateDeferredFrameTransform out - const auto& deferredFrameTransform = inputs[6]; - - // Jitter out - const auto& jitter = inputs[7]; + const auto& deferredFrameTransform = inputs.get6(); // Lighting Model out - const auto& lightingModel = inputs[8]; - + const auto& lightingModel = inputs.get7(); + // Antialiasing out + const auto& antialiasingIntensityTexture = inputs.get8(); // Light Cluster Grid Debuging job { const auto debugLightClustersInputs = DebugLightClusters::Inputs(deferredFrameTransform, lightingModel, linearDepthTarget, lightClusters).asVarying(); - task.addJob("DebugLightClusters", debugLightClustersInputs); + task.addJob("DebugLightClusters", debugLightClustersInputs, mainViewTransformSlot); } { // Debug the bounds of the rendered items, still look at the zbuffer - task.addJob("DrawMetaBounds", metas); - task.addJob("DrawOpaqueBounds", opaques); - task.addJob("DrawTransparentBounds", transparents); + task.addJob("DrawMetaBounds", metas, mainViewTransformSlot); + task.addJob("DrawOpaqueBounds", opaques, mainViewTransformSlot); + task.addJob("DrawTransparentBounds", transparents, mainViewTransformSlot); - task.addJob("DrawLightBounds", lights); - task.addJob("DrawZones", zones); + task.addJob("DrawLightBounds", lights, mainViewTransformSlot); + task.addJob("DrawZones", zones, mainViewTransformSlot); const auto frustums = task.addJob("ExtractFrustums", shadowFrame); const auto viewFrustum = frustums.getN(ExtractFrustums::VIEW_FRUSTUM); task.addJob("DrawViewFrustum", viewFrustum, glm::vec3(0.0f, 1.0f, 0.0f)); @@ -362,12 +353,12 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input const auto selectedItems = task.addJob("TransparentSelection", selectItemInput, selectionBaseName); // Render.getConfig("RenderMainView.DrawSelectionBounds").enabled = true - task.addJob("DrawSelectionBounds", selectedItems); + task.addJob("DrawSelectionBounds", selectedItems, mainViewTransformSlot); } { // Debug the bounds of the layered objects, still look at the zbuffer - task.addJob("DrawInFrontOpaqueBounds", inFrontOpaque); - task.addJob("DrawInFrontTransparentBounds", inFrontTransparent); + task.addJob("DrawInFrontOpaqueBounds", inFrontOpaque, mainViewTransformSlot); + task.addJob("DrawInFrontTransparentBounds", inFrontTransparent, mainViewTransformSlot); } { // Debug the bounds of the layered objects, still look at the zbuffer @@ -379,8 +370,8 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input { // Debugging Deferred buffer job - const auto debugFramebuffers = DebugDeferredBuffer::Inputs(deferredFramebuffer, linearDepthTarget, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, velocityBuffer, deferredFrameTransform, shadowFrame).asVarying(); - task.addJob("DebugDeferredBuffer", debugFramebuffers); + const auto debugFramebuffers = DebugDeferredBuffer::Inputs(deferredFramebuffer, linearDepthTarget, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, deferredFrameTransform, shadowFrame, antialiasingIntensityTexture).asVarying(); + task.addJob("DebugDeferredBuffer", debugFramebuffers, mainViewTransformSlot); const auto debugSubsurfaceScatteringInputs = DebugSubsurfaceScattering::Inputs(deferredFrameTransform, deferredFramebuffer, lightingModel, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, scatteringResource).asVarying(); @@ -391,8 +382,8 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input // Scene Octree Debugging job { - task.addJob("DrawSceneOctree", spatialSelection); - task.addJob("DrawItemSelection", spatialSelection); + task.addJob("DrawSceneOctree", spatialSelection, mainViewTransformSlot); + task.addJob("DrawItemSelection", spatialSelection, mainViewTransformSlot); } // Status icon rendering job @@ -400,8 +391,7 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input // Grab a texture map representing the different status icons and assign that to the drawStatusJob auto iconMapPath = PathUtils::resourcesPath() + "icons/statusIconAtlas.svg"; auto statusIconMap = DependencyManager::get()->getImageTexture(iconMapPath, image::TextureUsage::STRICT_TEXTURE); - const auto drawStatusInputs = DrawStatus::Input(opaques, jitter).asVarying(); - task.addJob("DrawStatus", drawStatusInputs, DrawStatus(statusIconMap)); + task.addJob("DrawStatus", opaques, DrawStatus(statusIconMap)); } const auto debugZoneInputs = DebugZoneLighting::Inputs(deferredFrameTransform, lightFrame, backgroundFrame).asVarying(); @@ -462,7 +452,7 @@ void RenderTransparentDeferred::run(const RenderContextPointer& renderContext, c const auto& lightingModel = inputs.get3(); const auto& lightClusters = inputs.get4(); // Not needed yet: const auto& shadowFrame = inputs.get5(); - const auto jitter = inputs.get6(); + const auto& deferredFrameTransform = inputs.get6(); auto deferredLightingEffect = DependencyManager::get(); RenderArgs* args = renderContext->args; @@ -474,18 +464,13 @@ void RenderTransparentDeferred::run(const RenderContextPointer& renderContext, c batch.setViewportTransform(args->_viewport); batch.setStateScissorRect(args->_viewport); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat); + batch.setProjectionJitterEnabled(true); + batch.setSavedViewProjectionTransform(_transformSlot); // Setup lighting model for all items; batch.setUniformBuffer(ru::Buffer::LightModel, lightingModel->getParametersBuffer()); batch.setResourceTexture(ru::Texture::AmbientFresnel, lightingModel->getAmbientFresnelLUT()); + batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredFrameTransform->getFrameTransformBuffer()); // Set the light deferredLightingEffect->setupKeyLightBatch(args, batch, *lightFrame); @@ -529,7 +514,7 @@ void DrawStateSortDeferred::run(const RenderContextPointer& renderContext, const const auto& inItems = inputs.get0(); const auto& lightingModel = inputs.get1(); - const auto jitter = inputs.get2(); + const auto deferredFrameTransform = inputs.get2(); RenderArgs* args = renderContext->args; @@ -540,18 +525,13 @@ void DrawStateSortDeferred::run(const RenderContextPointer& renderContext, const batch.setViewportTransform(args->_viewport); batch.setStateScissorRect(args->_viewport); - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat); + batch.setProjectionJitterEnabled(true); + batch.setSavedViewProjectionTransform(_transformSlot); // Setup lighting model for all items; batch.setUniformBuffer(ru::Buffer::LightModel, lightingModel->getParametersBuffer()); batch.setResourceTexture(ru::Texture::AmbientFresnel, lightingModel->getAmbientFresnelLUT()); + batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredFrameTransform->getFrameTransformBuffer()); // From the lighting model define a global shapeKey ORED with individiual keys ShapeKey::Builder keyBuilder; diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h index 969094488e8..ce4348f257c 100644 --- a/libraries/render-utils/src/RenderDeferredTask.h +++ b/libraries/render-utils/src/RenderDeferredTask.h @@ -43,18 +43,19 @@ class RenderTransparentDeferredConfig : public render::Job::Config { class RenderTransparentDeferred { public: - using Inputs = render::VaryingSet7; + using Inputs = render::VaryingSet7; using Config = RenderTransparentDeferredConfig; using JobModel = render::Job::ModelI; - RenderTransparentDeferred(render::ShapePlumberPointer shapePlumber) - : _shapePlumber{ shapePlumber } {} + RenderTransparentDeferred(render::ShapePlumberPointer shapePlumber, uint transformSlot) + : _shapePlumber(shapePlumber), _transformSlot(transformSlot) {} void configure(const Config& config) { _maxDrawn = config.maxDrawn; } void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); protected: render::ShapePlumberPointer _shapePlumber; + uint _transformSlot; int _maxDrawn; // initialized by Config }; @@ -83,13 +84,13 @@ class DrawStateSortConfig : public render::Job::Config { class DrawStateSortDeferred { public: - using Inputs = render::VaryingSet3; + using Inputs = render::VaryingSet3; using Config = DrawStateSortConfig; using JobModel = render::Job::ModelI; - DrawStateSortDeferred(render::ShapePlumberPointer shapePlumber) - : _shapePlumber{ shapePlumber } { + DrawStateSortDeferred(render::ShapePlumberPointer shapePlumber, uint transformSlot) + : _shapePlumber(shapePlumber), _transformSlot(transformSlot) { } void configure(const Config& config) { @@ -100,6 +101,7 @@ class DrawStateSortDeferred { protected: render::ShapePlumberPointer _shapePlumber; + uint _transformSlot; int _maxDrawn; // initialized by Config bool _stateSort; }; @@ -141,12 +143,8 @@ class RenderDeferredTask { using Config = RenderDeferredTaskConfig; using JobModel = render::Task::ModelI; - RenderDeferredTask(); - void configure(const Config& config); - void build(JobModel& task, const render::Varying& input, render::Varying& output); - -private: + void build(JobModel& task, const render::Varying& input, render::Varying& output, uint8_t transformOffset); }; diff --git a/libraries/render-utils/src/RenderForwardTask.cpp b/libraries/render-utils/src/RenderForwardTask.cpp index e34db755b70..fe774a100ea 100644 --- a/libraries/render-utils/src/RenderForwardTask.cpp +++ b/libraries/render-utils/src/RenderForwardTask.cpp @@ -66,7 +66,7 @@ void RenderForwardTask::configure(const Config& config) { preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale); } -void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output) { +void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output, uint8_t transformOffset) { task.addJob("SetRenderMethodTask", render::Args::FORWARD); // Prepare the ShapePipelines @@ -74,6 +74,9 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend ShapePlumberPointer shapePlumber = std::make_shared(); initForwardPipelines(*shapePlumber); + uint backgroundViewTransformSlot = render::RenderEngine::TS_BACKGROUND_VIEW + transformOffset; + uint mainViewTransformSlot = render::RenderEngine::TS_MAIN_VIEW + transformOffset; + // Unpack inputs const auto& inputs = input.get(); @@ -112,7 +115,7 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend const auto scaledPrimaryFramebuffer = task.addJob("PreparePrimaryBufferForward"); // Prepare deferred, generate the shared Deferred Frame Transform. Only valid with the scaled frame buffer - const auto deferredFrameTransform = task.addJob("DeferredFrameTransform"); + const auto deferredFrameTransform = task.addJob("DeferredFrameTransform", mainViewTransformSlot); // Prepare Forward Framebuffer pass const auto prepareForwardInputs = PrepareForward::Inputs(scaledPrimaryFramebuffer, lightFrame).asVarying(); @@ -123,30 +126,30 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend // Draw opaques forward const auto opaqueInputs = DrawForward::Inputs(opaques, lightingModel, hazeFrame).asVarying(); - task.addJob("DrawOpaques", opaqueInputs, shapePlumber, true); + task.addJob("DrawOpaques", opaqueInputs, shapePlumber, true, mainViewTransformSlot); // Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying(); - task.addJob("DrawBackgroundForward", backgroundInputs); + task.addJob("DrawBackgroundForward", backgroundInputs, backgroundViewTransformSlot); // Draw transparent objects forward const auto transparentInputs = DrawForward::Inputs(transparents, lightingModel, hazeFrame).asVarying(); - task.addJob("DrawTransparents", transparentInputs, shapePlumber, false); + task.addJob("DrawTransparents", transparentInputs, shapePlumber, false, mainViewTransformSlot); // Layered const auto nullJitter = Varying(glm::vec2(0.0f, 0.0f)); - const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, nullJitter).asVarying(); - const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, nullJitter).asVarying(); - task.addJob("DrawInFrontOpaque", inFrontOpaquesInputs, true); - task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, false); + const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + task.addJob("DrawInFrontOpaque", inFrontOpaquesInputs, shapePlumber, true, false, mainViewTransformSlot); + task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, shapePlumber, false, false, mainViewTransformSlot); { // Debug the bounds of the rendered items, still look at the zbuffer - task.addJob("DrawMetaBounds", metas); - task.addJob("DrawBounds", opaques); - task.addJob("DrawTransparentBounds", transparents); + task.addJob("DrawMetaBounds", metas, mainViewTransformSlot); + task.addJob("DrawBounds", opaques, mainViewTransformSlot); + task.addJob("DrawTransparentBounds", transparents, mainViewTransformSlot); - task.addJob("DrawZones", zones); + task.addJob("DrawZones", zones, mainViewTransformSlot); const auto debugZoneInputs = DebugZoneLighting::Inputs(deferredFrameTransform, lightFrame, backgroundFrame).asVarying(); task.addJob("DrawZoneStack", debugZoneInputs); } @@ -161,8 +164,8 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend const auto toneMappingInputs = ToneMapAndResample::Input(resolvedFramebuffer, destFramebuffer).asVarying(); const auto toneMappedBuffer = task.addJob("ToneMapping", toneMappingInputs); // HUD Layer - const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying(); - task.addJob("RenderHUDLayer", renderHUDLayerInputs); + const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame, deferredFrameTransform).asVarying(); + task.addJob("RenderHUDLayer", renderHUDLayerInputs, shapePlumber, mainViewTransformSlot); } gpu::FramebufferPointer PreparePrimaryFramebufferMSAA::createFramebuffer(const char* name, const glm::uvec2& frameSize, int numSamples) { @@ -264,12 +267,7 @@ void DrawForward::run(const RenderContextPointer& renderContext, const Inputs& i args->_batch = &batch; // Setup projection - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); // Setup lighting model for all items; diff --git a/libraries/render-utils/src/RenderForwardTask.h b/libraries/render-utils/src/RenderForwardTask.h index 6833e424496..c3deb002b65 100644 --- a/libraries/render-utils/src/RenderForwardTask.h +++ b/libraries/render-utils/src/RenderForwardTask.h @@ -36,7 +36,7 @@ class RenderForwardTask { RenderForwardTask() {} void configure(const Config& config); - void build(JobModel& task, const render::Varying& input, render::Varying& output); + void build(JobModel& task, const render::Varying& input, render::Varying& output, uint8_t transformOffset); }; @@ -93,13 +93,15 @@ class DrawForward{ using Inputs = render::VaryingSet3; using JobModel = render::Job::ModelI; - DrawForward(const render::ShapePlumberPointer& shapePlumber, bool opaquePass) : _shapePlumber(shapePlumber), _opaquePass(opaquePass) {} + DrawForward(const render::ShapePlumberPointer& shapePlumber, bool opaquePass, uint transformSlot) : + _shapePlumber(shapePlumber), _opaquePass(opaquePass), _transformSlot(transformSlot) {} void run(const render::RenderContextPointer& renderContext, const Inputs& inputs); private: render::ShapePlumberPointer _shapePlumber; bool _opaquePass; + uint _transformSlot; }; #endif // hifi_RenderForwardTask_h diff --git a/libraries/render-utils/src/RenderHUDLayerTask.cpp b/libraries/render-utils/src/RenderHUDLayerTask.cpp index 743e59eebc5..1a75fce29de 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.cpp +++ b/libraries/render-utils/src/RenderHUDLayerTask.cpp @@ -24,12 +24,8 @@ void CompositeHUD::run(const RenderContextPointer& renderContext, const gpu::Fra // Grab the HUD texture #if !defined(DISABLE_QML) gpu::doInBatch("CompositeHUD", renderContext->args->_context, [&](gpu::Batch& batch) { - glm::mat4 projMat; - Transform viewMat; - renderContext->args->getViewFrustum().evalProjectionMatrix(projMat); - renderContext->args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); + PROFILE_RANGE_BATCH(batch, "HUD"); + batch.setSavedViewProjectionTransform(_transformSlot); if (inputs) { batch.setFramebuffer(inputs); } @@ -40,22 +36,24 @@ void CompositeHUD::run(const RenderContextPointer& renderContext, const gpu::Fra #endif } -void RenderHUDLayerTask::build(JobModel& task, const render::Varying& input, render::Varying& output) { +void RenderHUDLayerTask::build(JobModel& task, const render::Varying& input, render::Varying& output, + render::ShapePlumberPointer shapePlumber, uint transformSlot) { const auto& inputs = input.get(); - const auto& primaryFramebuffer = inputs[0]; - const auto& lightingModel = inputs[1]; - const auto& hudOpaque = inputs[2]; - const auto& hudTransparent = inputs[3]; - const auto& hazeFrame = inputs[4]; + const auto& primaryFramebuffer = inputs.get0(); + const auto& lightingModel = inputs.get1(); + const auto& hudOpaque = inputs.get2(); + const auto& hudTransparent = inputs.get3(); + const auto& hazeFrame = inputs.get4(); + const auto& deferredFrameTransform = inputs.get5(); // Composite the HUD and HUD overlays - task.addJob("HUD", primaryFramebuffer); + task.addJob("HUD", primaryFramebuffer, transformSlot); // And HUD Layer objects const auto nullJitter = Varying(glm::vec2(0.0f, 0.0f)); - const auto hudOpaquesInputs = DrawLayered3D::Inputs(hudOpaque, lightingModel, hazeFrame, nullJitter).asVarying(); - const auto hudTransparentsInputs = DrawLayered3D::Inputs(hudTransparent, lightingModel, hazeFrame, nullJitter).asVarying(); - task.addJob("DrawHUDOpaque", hudOpaquesInputs, true); - task.addJob("DrawHUDTransparent", hudTransparentsInputs, false); + const auto hudOpaquesInputs = DrawLayered3D::Inputs(hudOpaque, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + const auto hudTransparentsInputs = DrawLayered3D::Inputs(hudTransparent, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); + task.addJob("DrawHUDOpaque", hudOpaquesInputs, shapePlumber, true, false, transformSlot); + task.addJob("DrawHUDTransparent", hudTransparentsInputs, shapePlumber, false, false, transformSlot); } diff --git a/libraries/render-utils/src/RenderHUDLayerTask.h b/libraries/render-utils/src/RenderHUDLayerTask.h index c30b0498a85..a0b0d26b854 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.h +++ b/libraries/render-utils/src/RenderHUDLayerTask.h @@ -19,16 +19,21 @@ class CompositeHUD { //using Inputs = gpu::FramebufferPointer; using JobModel = render::Job::ModelI; + CompositeHUD(uint transformSlot) : _transformSlot(transformSlot) {} + void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& inputs); + +private: + uint _transformSlot; }; class RenderHUDLayerTask { public: // Framebuffer where to draw, lighting model, opaque items, transparent items - using Input = render::VaryingSet5; + using Input = render::VaryingSet6; using JobModel = render::Task::ModelI; - void build(JobModel& task, const render::Varying& input, render::Varying& output); + void build(JobModel& task, const render::Varying& input, render::Varying& output, render::ShapePlumberPointer shapePlumber, uint transformSlot); }; #endif // hifi_RenderHUDLayerTask_h \ No newline at end of file diff --git a/libraries/render-utils/src/RenderPipelines.cpp b/libraries/render-utils/src/RenderPipelines.cpp index ed9fb326c4f..34d2d5f6391 100644 --- a/libraries/render-utils/src/RenderPipelines.cpp +++ b/libraries/render-utils/src/RenderPipelines.cpp @@ -265,7 +265,7 @@ void addPlumberPipeline(ShapePlumber& plumber, bool isWireframed = (i & 2); for (int cullFaceMode = graphics::MaterialKey::CullFaceMode::CULL_NONE; cullFaceMode < graphics::MaterialKey::CullFaceMode::NUM_CULL_FACE_MODES; cullFaceMode++) { auto state = std::make_shared(); - key.isTranslucent() ? PrepareStencil::testMask(*state) : PrepareStencil::testMaskDrawShape(*state); + key.isTranslucent() ? PrepareStencil::testMaskResetNoAA(*state) : PrepareStencil::testMaskDrawShape(*state); // Depth test depends on transparency state->setDepthTest(true, !key.isTranslucent(), gpu::LESS_EQUAL); diff --git a/libraries/render-utils/src/StencilMaskPass.cpp b/libraries/render-utils/src/StencilMaskPass.cpp index 7c89e6b6011..76ee597592b 100644 --- a/libraries/render-utils/src/StencilMaskPass.cpp +++ b/libraries/render-utils/src/StencilMaskPass.cpp @@ -122,6 +122,12 @@ void PrepareStencil::testMask(gpu::State& state) { gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP)); } +// Pass if this area has NOT been marked as MASK or anything containing MASK and reset NO_AA if it passes +void PrepareStencil::testMaskResetNoAA(gpu::State& state) { + state.setStencilTest(true, STENCIL_NO_AA, gpu::State::StencilTest(STENCIL_MASK, STENCIL_MASK, gpu::NOT_EQUAL, + gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_REPLACE)); +} + // Pass if this area has NOT been marked as NO_AA or anything containing NO_AA void PrepareStencil::testNoAA(gpu::State& state) { state.setStencilTest(true, 0x00, gpu::State::StencilTest(STENCIL_NO_AA, STENCIL_NO_AA, gpu::NOT_EQUAL, diff --git a/libraries/render-utils/src/StencilMaskPass.h b/libraries/render-utils/src/StencilMaskPass.h index bca2ef17a58..5599d792bac 100644 --- a/libraries/render-utils/src/StencilMaskPass.h +++ b/libraries/render-utils/src/StencilMaskPass.h @@ -52,6 +52,7 @@ class PrepareStencil { static void drawMask(gpu::State& state); static void drawBackground(gpu::State& state); static void testMask(gpu::State& state); + static void testMaskResetNoAA(gpu::State& state); static void testNoAA(gpu::State& state); static void testBackground(gpu::State& state); static void testShape(gpu::State& state); diff --git a/libraries/render-utils/src/VelocityBufferPass.cpp b/libraries/render-utils/src/VelocityBufferPass.cpp deleted file mode 100644 index 9437ead3b25..00000000000 --- a/libraries/render-utils/src/VelocityBufferPass.cpp +++ /dev/null @@ -1,165 +0,0 @@ -// -// VelocityBufferPass.cpp -// libraries/render-utils/src/ -// -// Created by Sam Gateau 8/15/2017. -// Copyright 2017 High Fidelity, Inc. -// -// Distributed under the Apache License, Version 2.0. -// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html -// -#include "VelocityBufferPass.h" - -#include - -#include -#include - -#include "StencilMaskPass.h" -#include "render-utils/ShaderConstants.h" - -namespace ru { - using render_utils::slot::texture::Texture; - using render_utils::slot::buffer::Buffer; -} - -VelocityFramebuffer::VelocityFramebuffer() { -} - - -void VelocityFramebuffer::updatePrimaryDepth(const gpu::TexturePointer& depthBuffer) { - //If the depth buffer or size changed, we need to delete our FBOs - bool reset = false; - if ((_primaryDepthTexture != depthBuffer)) { - _primaryDepthTexture = depthBuffer; - reset = true; - } - if (_primaryDepthTexture) { - auto newFrameSize = glm::ivec2(_primaryDepthTexture->getDimensions()); - if (_frameSize != newFrameSize) { - _frameSize = newFrameSize; - _halfFrameSize = newFrameSize >> 1; - - reset = true; - } - } - - if (reset) { - clear(); - } -} - -void VelocityFramebuffer::clear() { - _velocityFramebuffer.reset(); - _velocityTexture.reset(); -} - -void VelocityFramebuffer::allocate() { - - auto width = _frameSize.x; - auto height = _frameSize.y; - - // For Velocity Buffer: - _velocityTexture = gpu::Texture::createRenderBuffer(gpu::Element(gpu::VEC2, gpu::HALF, gpu::RGB), width, height, gpu::Texture::SINGLE_MIP, - gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR)); - _velocityFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("velocity")); - _velocityFramebuffer->setRenderBuffer(0, _velocityTexture); - _velocityFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, _primaryDepthTexture->getTexelFormat()); -} - -gpu::FramebufferPointer VelocityFramebuffer::getVelocityFramebuffer() { - if (!_velocityFramebuffer) { - allocate(); - } - return _velocityFramebuffer; -} - -gpu::TexturePointer VelocityFramebuffer::getVelocityTexture() { - if (!_velocityTexture) { - allocate(); - } - return _velocityTexture; -} - -VelocityBufferPass::VelocityBufferPass() { -} - -void VelocityBufferPass::configure(const Config& config) { -} - -void VelocityBufferPass::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) { - assert(renderContext->args); - assert(renderContext->args->hasViewFrustum()); - - RenderArgs* args = renderContext->args; - - const auto& frameTransform = inputs.get0(); - const auto& deferredFramebuffer = inputs.get1(); - - if (!_gpuTimer) { - _gpuTimer = std::make_shared < gpu::RangeTimer>(__FUNCTION__); - } - - if (!_velocityFramebuffer) { - _velocityFramebuffer = std::make_shared(); - } - _velocityFramebuffer->updatePrimaryDepth(deferredFramebuffer->getPrimaryDepthTexture()); - - auto depthBuffer = deferredFramebuffer->getPrimaryDepthTexture(); - - auto velocityFBO = _velocityFramebuffer->getVelocityFramebuffer(); - auto velocityTexture = _velocityFramebuffer->getVelocityTexture(); - - outputs.edit0() = _velocityFramebuffer; - outputs.edit1() = velocityFBO; - outputs.edit2() = velocityTexture; - - auto cameraMotionPipeline = getCameraMotionPipeline(renderContext); - - auto fullViewport = args->_viewport; - - gpu::doInBatch("VelocityBufferPass::run", args->_context, [=](gpu::Batch& batch) { - _gpuTimer->begin(batch); - batch.enableStereo(false); - - batch.setViewportTransform(fullViewport); - batch.setProjectionTransform(glm::mat4()); - batch.resetViewTransform(); - batch.setModelTransform(gpu::Framebuffer::evalSubregionTexcoordTransform(_velocityFramebuffer->getDepthFrameSize(), fullViewport)); - - batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, frameTransform->getFrameTransformBuffer()); - - // Velocity buffer camera motion - batch.setFramebuffer(velocityFBO); - batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(0.0f, 0.0f, 0.0f, 0.0f)); - batch.setPipeline(cameraMotionPipeline); - batch.setResourceTexture(ru::Texture::TaaDepth, depthBuffer); - batch.draw(gpu::TRIANGLE_STRIP, 4); - - _gpuTimer->end(batch); - }); - - auto config = std::static_pointer_cast(renderContext->jobConfig); - config->setGPUBatchRunTime(_gpuTimer->getGPUAverage(), _gpuTimer->getBatchAverage()); -} - - -const gpu::PipelinePointer& VelocityBufferPass::getCameraMotionPipeline(const render::RenderContextPointer& renderContext) { - if (!_cameraMotionPipeline) { - gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::velocityBuffer_cameraMotion); - gpu::StatePointer state = std::make_shared(); - - // Stencil test the curvature pass for objects pixels only, not the background - // PrepareStencil::testShape(*state); - - state->setColorWriteMask(true, true, false, false); - - // Good to go add the brand new pipeline - _cameraMotionPipeline = gpu::Pipeline::create(program, state); - } - - return _cameraMotionPipeline; -} - - - diff --git a/libraries/render-utils/src/VelocityBufferPass.h b/libraries/render-utils/src/VelocityBufferPass.h deleted file mode 100644 index 50b994f6db1..00000000000 --- a/libraries/render-utils/src/VelocityBufferPass.h +++ /dev/null @@ -1,89 +0,0 @@ -// -// VelocityBufferPass.h -// libraries/render-utils/src/ -// -// Created by Sam Gateau 8/15/2017. -// Copyright 2017 High Fidelity, Inc. -// -// Distributed under the Apache License, Version 2.0. -// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html -// - -#ifndef hifi_VelocityBufferPass_h -#define hifi_VelocityBufferPass_h - -#include "SurfaceGeometryPass.h" - - -// VelocityFramebuffer is a helper class gathering in one place theframebuffers and targets describing the surface geometry linear depth -// from a z buffer -class VelocityFramebuffer { -public: - VelocityFramebuffer(); - - gpu::FramebufferPointer getVelocityFramebuffer(); - gpu::TexturePointer getVelocityTexture(); - - // Update the depth buffer which will drive the allocation of all the other resources according to its size. - void updatePrimaryDepth(const gpu::TexturePointer& depthBuffer); - - gpu::TexturePointer getPrimaryDepthTexture(); - const glm::ivec2& getDepthFrameSize() const { return _frameSize; } - - void setResolutionLevel(int level); - int getResolutionLevel() const { return _resolutionLevel; } - -protected: - void clear(); - void allocate(); - - gpu::TexturePointer _primaryDepthTexture; - - gpu::FramebufferPointer _velocityFramebuffer; - gpu::TexturePointer _velocityTexture; - - glm::ivec2 _frameSize; - glm::ivec2 _halfFrameSize; - int _resolutionLevel{ 0 }; -}; - -using VelocityFramebufferPointer = std::shared_ptr; - -class VelocityBufferPassConfig : public render::GPUJobConfig { - Q_OBJECT - Q_PROPERTY(float depthThreshold MEMBER depthThreshold NOTIFY dirty) - -public: - VelocityBufferPassConfig() : render::GPUJobConfig(true) {} - - float depthThreshold{ 5.0f }; - -signals: - void dirty(); -}; - -class VelocityBufferPass { -public: - using Inputs = render::VaryingSet2; - using Outputs = render::VaryingSet3; - using Config = VelocityBufferPassConfig; - using JobModel = render::Job::ModelIO; - - VelocityBufferPass(); - - void configure(const Config& config); - void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs); - -private: - typedef gpu::BufferView UniformBufferView; - - VelocityFramebufferPointer _velocityFramebuffer; - - const gpu::PipelinePointer& getCameraMotionPipeline(const render::RenderContextPointer& renderContext); - gpu::PipelinePointer _cameraMotionPipeline; - - gpu::RangeTimerPointer _gpuTimer; -}; - - -#endif // hifi_VelocityBufferPass_h diff --git a/libraries/render-utils/src/VelocityWrite.slh b/libraries/render-utils/src/VelocityWrite.slh new file mode 100644 index 00000000000..0ca60c7a1ac --- /dev/null +++ b/libraries/render-utils/src/VelocityWrite.slh @@ -0,0 +1,57 @@ + +<@if not VELOCITY_WRITE_SLH@> +<@def VELOCITY_WRITE_SLH@> + +<@include gpu/Transform.slh@> +<$declareStandardCameraTransform()$> + +vec2 getEyeTexcoordPos() { + // No need to add 0.5 as, by default, frag coords are pixel centered at (0.5, 0.5) + vec2 texCoordPos = gl_FragCoord.xy; + texCoordPos *= cam_getInvWidthHeight(); + texCoordPos.x -= cam_getStereoSide(); + return texCoordPos; +} + +vec2 packVelocity(vec4 prevPositionCS) { + vec2 uv = getEyeTexcoordPos(); + vec2 prevUV = (prevPositionCS.xy / prevPositionCS.w) * 0.5 + 0.5; + vec2 deltaUV = uv - prevUV; + // Velocity should be computed without any jitter inside. + return deltaUV; +} + +vec2 packVelocity(vec4 positionCS, vec4 prevPositionCS) { + vec2 uv = positionCS.xy / positionCS.w; + vec2 prevUV = prevPositionCS.xy / prevPositionCS.w; + vec2 deltaUV = (uv - prevUV) * 0.5; + // Velocity should be computed without any jitter inside. + return deltaUV; +} + +void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color) { + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(color, 1.0); +} + +void packDeferredFragmentLighting(vec4 prevPositionCS, vec4 color) { + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = color; +} + +// Use this version when your shader can possibly be used to rasterize GL_LINES +void packDeferredFragmentLighting(vec4 positionCS, vec4 prevPositionCS, vec4 color) { + _velocity = vec4(packVelocity(positionCS, prevPositionCS), 0.0, 0.0); + _lighting = color; +} + +<@endif@> \ No newline at end of file diff --git a/libraries/render-utils/src/ZoneRenderer.cpp b/libraries/render-utils/src/ZoneRenderer.cpp index 5332e138162..5e8a8df9d33 100644 --- a/libraries/render-utils/src/ZoneRenderer.cpp +++ b/libraries/render-utils/src/ZoneRenderer.cpp @@ -87,7 +87,7 @@ const gpu::PipelinePointer& DebugZoneLighting::getKeyLightPipeline() { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::zone_drawKeyLight); gpu::StatePointer state = std::make_shared(); - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA); _keyLightPipeline = gpu::Pipeline::create(program, state); } @@ -99,7 +99,7 @@ const gpu::PipelinePointer& DebugZoneLighting::getAmbientPipeline() { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::zone_drawAmbient); gpu::StatePointer state = std::make_shared(); - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA); _ambientPipeline = gpu::Pipeline::create(program, state); } @@ -110,7 +110,7 @@ const gpu::PipelinePointer& DebugZoneLighting::getBackgroundPipeline() { gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::zone_drawSkybox); gpu::StatePointer state = std::make_shared(); - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA); _backgroundPipeline = gpu::Pipeline::create(program, state); } diff --git a/libraries/render-utils/src/aa_blend.slf b/libraries/render-utils/src/aa_blend.slf new file mode 100644 index 00000000000..cc23b3b088b --- /dev/null +++ b/libraries/render-utils/src/aa_blend.slf @@ -0,0 +1,52 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// <$_SCRIBE_FILENAME$> +// Generated on <$_SCRIBE_DATE$> +// +// Created by Raffi Bedikian on 8/30/15 +// Copyright 2015 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +<@include gpu/ShaderConstants.h@> + +layout(location=0) in vec2 varTexCoord0; +layout(location=0) out vec4 outFragColor; + +layout(binding=0) uniform sampler2D colorTexture; + +struct aaBlendParams { + vec4 sharpenIntensity; +}; + +layout(binding=0) uniform aaBlendParamsBuffer { + aaBlendParams params; +}; + +void main(void) { + if (params.sharpenIntensity.x > 0.0) { + vec4 pixels[9]; + vec4 sharpenedPixel; + pixels[0] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(-1,-1), 0); + pixels[1] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(0,-1), 0); + pixels[2] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(1,-1), 0); + + pixels[3] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(-1,0), 0); + pixels[4] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy), 0); + pixels[5] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(1,0), 0); + + pixels[6] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(-1,1), 0); + pixels[7] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(0,1), 0); + pixels[8] = texelFetch(colorTexture, ivec2(gl_FragCoord.xy) + ivec2(1,1), 0); + + sharpenedPixel = pixels[4] * 6.8 - (pixels[1] + pixels[3] + pixels[5] + pixels[7]) - (pixels[0] + pixels[2] + pixels[6] + pixels[8]) *0.7; + + vec4 minColor = max(vec4(0), pixels[4] - vec4(0.5)); + vec4 maxColor = pixels[4] + vec4(0.5); + outFragColor = clamp(pixels[4] + sharpenedPixel * params.sharpenIntensity.x, minColor, maxColor); + } else { + outFragColor = texelFetch(colorTexture, ivec2(gl_FragCoord.xy), 0); + } +} \ No newline at end of file diff --git a/libraries/render-utils/src/deferred_light_limited.slv b/libraries/render-utils/src/deferred_light_limited.slv index 0126d546640..5757e99f78b 100644 --- a/libraries/render-utils/src/deferred_light_limited.slv +++ b/libraries/render-utils/src/deferred_light_limited.slv @@ -54,8 +54,7 @@ void main(void) { #ifdef GPU_TRANSFORM_IS_STEREO #ifdef GPU_TRANSFORM_STEREO_SPLIT_SCREEN - TransformCamera cam = getTransformCamera(); - <$transformStereoClipsSpace(cam, pos)$> + <$transformStereoClipSpace(pos)$> #endif #endif diff --git a/libraries/render-utils/src/directional_skybox_light.slf b/libraries/render-utils/src/directional_skybox_light.slf index 20026283be8..77935c3e192 100644 --- a/libraries/render-utils/src/directional_skybox_light.slf +++ b/libraries/render-utils/src/directional_skybox_light.slf @@ -30,12 +30,11 @@ layout(location=RENDER_UTILS_ATTR_TEXCOORD01) in vec4 _texCoord01; layout(location=0) out vec4 _fragColor; void main(void) { - DeferredFrameTransform deferredTransform = getDeferredFrameTransform(); - DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); + DeferredFragment frag = unpackDeferredFragment(_texCoord0); <@if HIFI_USE_SHADOW@> vec4 viewPos = vec4(frag.position.xyz, 1.0); - vec4 worldPos = getViewInverse() * viewPos; + vec4 worldPos = getViewInverse(frag.side) * viewPos; Light shadowLight = getKeyLight(); vec3 worldLightDirection = getLightDirection(shadowLight); float shadowAttenuation = evalShadowAttenuation(worldLightDirection, worldPos, -viewPos.z, frag.normal); @@ -55,7 +54,7 @@ void main(void) { <@if HIFI_USE_AMBIENT@> vec3 color = evalAmbientSphereGlobalColor( - getViewInverse(), + getViewInverse(frag.side), shadowAttenuation, frag.obscurance, frag.position.xyz, @@ -69,7 +68,7 @@ void main(void) { lowNormalCurvature); <@else@> vec3 color = evalSkyboxGlobalColor( - getViewInverse(), + getViewInverse(frag.side), shadowAttenuation, frag.obscurance, frag.position.xyz, diff --git a/libraries/render-utils/src/drawWorkloadProxy.slf b/libraries/render-utils/src/drawWorkloadProxy.slf index f0bd9d474ca..107d1a6c4b3 100644 --- a/libraries/render-utils/src/drawWorkloadProxy.slf +++ b/libraries/render-utils/src/drawWorkloadProxy.slf @@ -16,6 +16,7 @@ layout(location=0) in vec4 varColor; layout(location=1) in vec3 varTexcoord; layout(location=2) in vec3 varEyePos; +layout(location=3) in vec4 _prevPositionCS; void main(void) { if (varColor.w > 0.0) { @@ -28,6 +29,7 @@ void main(void) { } packDeferredFragmentUnlit( + _prevPositionCS, vec3(0.0, 1.0, 0.0), 1.0, varColor.rgb); diff --git a/libraries/render-utils/src/drawWorkloadProxy.slv b/libraries/render-utils/src/drawWorkloadProxy.slv index e485f14a935..f728f94afcb 100644 --- a/libraries/render-utils/src/drawWorkloadProxy.slv +++ b/libraries/render-utils/src/drawWorkloadProxy.slv @@ -22,6 +22,15 @@ layout(location=0) out vec4 varColor; layout(location=1) out vec3 varTexcoord; layout(location=2) out vec3 varEyePos; +layout(location=3) out vec4 _prevPositionCS; + +vec4 getPosition(WorkloadProxy proxy, vec4 spriteVert, vec4 proxyPosEye) { + vec3 dirZ = -normalize(proxyPosEye.xyz); + vec3 dirX = normalize(cross(vec3(0.0, 1.0, 0.0), dirZ)); + vec3 dirY = vec3(0.0, 1.0, 0.0); + + return vec4(proxyPosEye.xyz + proxy.sphere.w * (dirX * spriteVert.x + dirY * spriteVert.y /* + dirZ * spriteVert.z*/), 1.0); +} void main(void) { const vec4 UNIT_SPRITE[3] = vec4[3]( @@ -44,22 +53,17 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); vec4 proxyPosEye; - <$transformModelToEyePos(cam, obj, proxyPosWorld, proxyPosEye)$> + vec4 prevProxyPosEye; + <$transformModelToEyePosAndPrevEyePos(cam, obj, proxyPosWorld, proxyPosEye, prevProxyPosEye)$> // Define the billboarded space - vec3 dirZ = -normalize(proxyPosEye.xyz); - vec3 dirX = normalize(cross(vec3(0.0, 1.0, 0.0), dirZ)); - vec3 dirY = vec3(0.0, 1.0, 0.0); + vec4 pos = getPosition(proxy, spriteVert, proxyPosEye); + vec4 prevPos = getPosition(proxy, spriteVert, prevProxyPosEye); - //vec4 pos = vec4(proxyPosEye.xyz + proxy.sphere.w * ( dirX * spriteVert.x + dirY * spriteVert.y + dirZ * spriteVert.z), 1.0); - //Nvidia driver workaround - vec4 pos = vec4(1.0, 1.0, 1.0, 1.0); - pos.x = proxyPosEye.x + proxy.sphere.w * ( dirX.x * spriteVert.x + dirY.x * spriteVert.y + dirZ.x * spriteVert.z); - pos.y = proxyPosEye.y + proxy.sphere.w * ( dirX.y * spriteVert.x + dirY.y * spriteVert.y + dirZ.y * spriteVert.z); - pos.z = proxyPosEye.z + proxy.sphere.w * ( dirX.z * spriteVert.x + dirY.z * spriteVert.y + dirZ.z * spriteVert.z); varEyePos = pos.xyz; varTexcoord = spriteVert.xyz; <$transformEyeToClipPos(cam, pos, gl_Position)$> + <$transformPrevEyeToPrevClipPos(cam, prevPos, _prevPositionCS)$>; // Convert region to color int region = floatBitsToInt(proxy.region.x); diff --git a/libraries/render-utils/src/drawWorkloadView.slf b/libraries/render-utils/src/drawWorkloadView.slf index b638824204e..c838a2f1c89 100644 --- a/libraries/render-utils/src/drawWorkloadView.slf +++ b/libraries/render-utils/src/drawWorkloadView.slf @@ -17,6 +17,7 @@ layout(location=0) in vec4 varColor; layout(location=1) in vec3 varTexcoord; layout(location=2) in vec3 varEyePos; +layout(location=3) in vec4 _prevPositionCS; void main(void) { if (varColor.w > 0.0) { @@ -29,6 +30,7 @@ void main(void) { } packDeferredFragmentUnlit( + _prevPositionCS, vec3(0.0, 1.0, 0.0), 1.0, varColor.rgb); diff --git a/libraries/render-utils/src/drawWorkloadView.slv b/libraries/render-utils/src/drawWorkloadView.slv index 2fdf3d773e9..fe7c3f66928 100644 --- a/libraries/render-utils/src/drawWorkloadView.slv +++ b/libraries/render-utils/src/drawWorkloadView.slv @@ -21,6 +21,7 @@ layout(location=0) out vec4 varColor; layout(location=1) out vec3 varTexcoord; layout(location=2) out vec3 varEyePos; +layout(location=3) out vec4 _prevPositionCS; const int NUM_VERTICES_PER_SEGMENT = 2; const int NUM_SEGMENT_PER_VIEW_REGION = 65; @@ -36,6 +37,12 @@ LAYOUT_STD140(binding=0) uniform DrawMeshBuffer { DrawMesh _drawMeshBuffer; }; +vec4 getPosition(int regionID, int segmentVertexID, vec4 posEye, vec3 tanEye) { + vec3 lateralDir = normalize(cross(vec3(0.0, 0.0, 1.0), normalize(tanEye))); + posEye.xyz += (0.005 * abs(posEye.z) * float(regionID + 1)) * (-1.0 + 2.0 * float(segmentVertexID)) * lateralDir; + return posEye; +} + void main(void) { int viewID = gl_VertexID / NUM_VERTICES_PER_VIEW; int viewVertexID = gl_VertexID - viewID * NUM_VERTICES_PER_VIEW; @@ -51,8 +58,6 @@ void main(void) { vec4 spriteVert = vec4(segment.y, 0.0, segment.x, 1.0); vec3 spriteTan = vec3(segment.x, 0.0, -segment.y); - vec3 lateralDir = vec3(0.0, -1.0 + 2.0 * float(segmentVertexID), 0.0); - WorkloadView view = getWorkloadView(viewID); vec4 region = view.regions[regionID]; vec4 proxyPosWorld = vec4(region.xyz, 1.0); @@ -74,15 +79,19 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); vec4 posEye; - <$transformModelToEyePos(cam, obj, pos, posEye)$> + vec4 prevPosEye; + <$transformModelToEyePosAndPrevEyePos(cam, obj, pos, posEye, prevPosEye)$> vec3 tanEye; + vec3 prevTanEye; <$transformModelToEyeDir(cam, obj, originSpaceTan, tanEye)$> + <$transformModelToPrevEyeDir(cam, obj, originSpaceTan, prevTanEye)$> - lateralDir = normalize(cross(vec3(0.0, 0.0, 1.0), normalize(tanEye))); - posEye.xyz += (0.005 * abs(posEye.z) * float(regionID + 1)) * (-1.0 + 2.0 * float(segmentVertexID)) * lateralDir; + posEye = getPosition(regionID, segmentVertexID, posEye, tanEye); + prevPosEye = getPosition(regionID, segmentVertexID, prevPosEye, prevTanEye); varEyePos = posEye.xyz; <$transformEyeToClipPos(cam, posEye, gl_Position)$> + <$transformPrevEyeToPrevClipPos(cam, prevPosEye, _prevPositionCS)$>; varTexcoord = spriteVert.xyz; diff --git a/libraries/render-utils/src/lightClusters_drawClusterContent.slf b/libraries/render-utils/src/lightClusters_drawClusterContent.slf index 80013bc3cc5..b3b81544a7f 100644 --- a/libraries/render-utils/src/lightClusters_drawClusterContent.slf +++ b/libraries/render-utils/src/lightClusters_drawClusterContent.slf @@ -33,7 +33,7 @@ void main(void) { vec2 texCoord = varTexCoord0.st; vec4 fragEyePos = unpackDeferredPositionFromZdb(texCoord); - vec4 fragWorldPos = getViewInverse() * fragEyePos; + vec4 fragWorldPos = getViewInverse(getStereoSideFromUV(texCoord.x)) * fragEyePos; // From frag world pos find the cluster vec4 clusterEyePos = frustumGrid_worldToEye(fragWorldPos); diff --git a/libraries/render-utils/src/lightClusters_drawClusterFromDepth.slf b/libraries/render-utils/src/lightClusters_drawClusterFromDepth.slf index 0e3f8a5ea56..5e3714abeed 100644 --- a/libraries/render-utils/src/lightClusters_drawClusterFromDepth.slf +++ b/libraries/render-utils/src/lightClusters_drawClusterFromDepth.slf @@ -30,7 +30,7 @@ void main(void) { vec2 texCoord = varTexCoord0.st; vec4 fragEyePos = unpackDeferredPositionFromZdb(texCoord); - vec4 fragWorldPos = getViewInverse() * fragEyePos; + vec4 fragWorldPos = getViewInverse(getStereoSideFromUV(texCoord.x)) * fragEyePos; // From frag world pos find the cluster vec4 clusterEyePos = frustumGrid_worldToEye(fragWorldPos); diff --git a/libraries/render-utils/src/local_lights_drawOutline.slf b/libraries/render-utils/src/local_lights_drawOutline.slf index a2b4cc1d101..f9f78aabb5d 100644 --- a/libraries/render-utils/src/local_lights_drawOutline.slf +++ b/libraries/render-utils/src/local_lights_drawOutline.slf @@ -54,7 +54,7 @@ void main(void) { // Frag pos in world - mat4 invViewMat = getViewInverse(); + mat4 invViewMat = getViewInverse(frag.side); vec4 fragPos = invViewMat * fragPosition; <$fetchClusterInfo(fragPos)$>; diff --git a/libraries/render-utils/src/local_lights_shading.slf b/libraries/render-utils/src/local_lights_shading.slf index 538bdacc99f..9339d6b7ca8 100644 --- a/libraries/render-utils/src/local_lights_shading.slf +++ b/libraries/render-utils/src/local_lights_shading.slf @@ -32,8 +32,7 @@ void main(void) { // Grab the fragment data from the uv vec2 texCoord = _texCoord0.st; - DeferredFrameTransform deferredTransform = getDeferredFrameTransform(); - DeferredFragment frag = unpackDeferredFragment(deferredTransform, texCoord); + DeferredFragment frag = unpackDeferredFragment(texCoord); vec4 fragPosition = frag.position; if (frag.mode == FRAG_MODE_UNLIT) { @@ -41,7 +40,7 @@ void main(void) { } // Frag pos in world - mat4 invViewMat = getViewInverse(); + mat4 invViewMat = getViewInverse(frag.side); vec4 fragWorldPos = invViewMat * fragPosition; <$fetchClusterInfo(fragWorldPos)$>; diff --git a/libraries/render-utils/src/model.slf b/libraries/render-utils/src/model.slf index 98abc29d8c9..dddcd530022 100644 --- a/libraries/render-utils/src/model.slf +++ b/libraries/render-utils/src/model.slf @@ -79,6 +79,7 @@ layout(location=RENDER_UTILS_ATTR_TEXCOORD01) in vec4 _texCoord01; layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_COLOR) in vec4 _color; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@if HIFI_USE_NORMALMAP@> layout(location=RENDER_UTILS_ATTR_TANGENT_WS) in vec3 _tangentWS; <@endif@> @@ -255,6 +256,7 @@ void main(void) { <@if not HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_LIGHTMAP@> packDeferredFragment( + _prevPositionCS, fragNormalWS, opacity, albedo, @@ -269,6 +271,7 @@ void main(void) { scattering); <@else@> packDeferredFragmentLightmap( + _prevPositionCS, fragNormalWS, evalOpaqueFinalAlpha(getMaterialOpacity(mat), opacity), albedo, diff --git a/libraries/render-utils/src/model.slv b/libraries/render-utils/src/model.slv index 319711eac2f..60deb4e28d4 100644 --- a/libraries/render-utils/src/model.slv +++ b/libraries/render-utils/src/model.slv @@ -48,6 +48,7 @@ layout(location=RENDER_UTILS_ATTR_TEXCOORD01) out vec4 _texCoord01; layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_COLOR) out vec4 _color; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@if HIFI_USE_NORMALMAP@> layout(location=RENDER_UTILS_ATTR_TANGENT_WS) out vec3 _tangentWS; <@endif@> @@ -73,7 +74,7 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); <@if not HIFI_USE_SHADOW@> - <$transformModelToWorldAndEyeAndClipPos(cam, obj, positionMS, _positionWS, _positionES, gl_Position)$> + <$transformModelToWorldAndEyeAndClipPosAndPrevClipPos(cam, obj, positionMS, _positionWS, _positionES, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, normalMS, _normalWS)$> <@else@> <$transformModelToClipPos(cam, obj, positionMS, gl_Position)$> diff --git a/libraries/render-utils/src/parabola.slf b/libraries/render-utils/src/parabola.slf index f19f82ec596..e6b754c33de 100644 --- a/libraries/render-utils/src/parabola.slf +++ b/libraries/render-utils/src/parabola.slf @@ -10,18 +10,19 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // +layout(location=0) in vec4 _color; + <@if not HIFI_USE_FORWARD@> <@include DeferredBufferWrite.slh@> + layout(location=1) in vec4 _prevPositionCS; <@else@> layout(location=0) out vec4 _fragColor0; <@endif@> -layout(location=0) in vec4 _color; - void main(void) { <@if not HIFI_USE_FORWARD@> <@if not HIFI_USE_TRANSLUCENT@> - packDeferredFragmentUnlit(vec3(1.0, 0.0, 0.0), 1.0, _color.rgb); + packDeferredFragmentUnlit(_prevPositionCS, vec3(1.0, 0.0, 0.0), 1.0, _color.rgb); <@else@> packDeferredFragmentTranslucent(vec3(1.0, 0.0, 0.0), _color.a, _color.rgb, DEFAULT_ROUGHNESS); <@endif@> diff --git a/libraries/render-utils/src/parabola.slv b/libraries/render-utils/src/parabola.slv index 6032452d1d4..731c14f1220 100644 --- a/libraries/render-utils/src/parabola.slv +++ b/libraries/render-utils/src/parabola.slv @@ -27,6 +27,9 @@ LAYOUT_STD140(binding=0) uniform parabolaData { }; layout(location=0) out vec4 _color; +<@if not HIFI_USE_FORWARD@> + layout(location=1) out vec4 _prevPositionCS; +<@endif@> void main(void) { _color = _parabolaData.color; @@ -51,5 +54,9 @@ void main(void) { pos += 0.5 * _parabolaData.width * normal * (-1.0 + 2.0 * float(gl_VertexID % 2 == 0)); - <$transformModelToClipPos(cam, obj, pos, gl_Position)$> + <@if HIFI_USE_FORWARD@> + <$transformModelToClipPos(cam, obj, pos, gl_Position)$> + <@else@> + <$transformModelToClipPosAndPrevClipPos(cam, obj, pos, gl_Position, _prevPositionCS)$> + <@endif@> } diff --git a/libraries/render-utils/src/render-utils/ShaderConstants.h b/libraries/render-utils/src/render-utils/ShaderConstants.h index 19eb4dd249d..5d00736a29e 100644 --- a/libraries/render-utils/src/render-utils/ShaderConstants.h +++ b/libraries/render-utils/src/render-utils/ShaderConstants.h @@ -36,10 +36,13 @@ // don't conflict with GPU_ATTR_V2F_STEREO_SIDE in the GPU shader constants #define RENDER_UTILS_ATTR_DO_NOT_USE 8 +// Clip space +#define RENDER_UTILS_ATTR_PREV_POSITION_CS 9 + // Fade -#define RENDER_UTILS_ATTR_FADE1 9 -#define RENDER_UTILS_ATTR_FADE2 10 -#define RENDER_UTILS_ATTR_FADE3 11 +#define RENDER_UTILS_ATTR_FADE1 10 +#define RENDER_UTILS_ATTR_FADE2 11 +#define RENDER_UTILS_ATTR_FADE3 12 #define RENDER_UTILS_BUFFER_DEFERRED_FRAME_TRANSFORM 0 @@ -103,6 +106,7 @@ #define RENDER_UTILS_TEXTURE_TAA_VELOCITY 2 #define RENDER_UTILS_TEXTURE_TAA_DEPTH 3 #define RENDER_UTILS_TEXTURE_TAA_NEXT 4 +#define RENDER_UTILS_TEXTURE_TAA_INTENSITY 5 // Surface Geometry #define RENDER_UTILS_BUFFER_SG_PARAMS 1 @@ -189,6 +193,7 @@ enum Texture { TaaVelocity = RENDER_UTILS_TEXTURE_TAA_VELOCITY, TaaDepth = RENDER_UTILS_TEXTURE_TAA_DEPTH, TaaNext = RENDER_UTILS_TEXTURE_TAA_NEXT, + TaaIntensity = RENDER_UTILS_TEXTURE_TAA_INTENSITY, SsaoOcclusion = RENDER_UTILS_TEXTURE_SSAO_OCCLUSION, SsaoDepth = RENDER_UTILS_TEXTURE_SSAO_DEPTH, SsaoNormal = RENDER_UTILS_TEXTURE_SSAO_NORMAL, diff --git a/libraries/render-utils/src/render-utils/fxaa_blend.slp b/libraries/render-utils/src/render-utils/aa_blend.slp similarity index 100% rename from libraries/render-utils/src/render-utils/fxaa_blend.slp rename to libraries/render-utils/src/render-utils/aa_blend.slp diff --git a/libraries/render-utils/src/render-utils/velocityBuffer_cameraMotion.slp b/libraries/render-utils/src/render-utils/velocityBuffer_cameraMotion.slp deleted file mode 100644 index d4d8ec4b01e..00000000000 --- a/libraries/render-utils/src/render-utils/velocityBuffer_cameraMotion.slp +++ /dev/null @@ -1 +0,0 @@ -VERTEX gpu::vertex::DrawViewportQuadTransformTexcoord diff --git a/libraries/render-utils/src/sdf_text3D.slf b/libraries/render-utils/src/sdf_text3D.slf index c5bed1ecabc..9996dc58eff 100644 --- a/libraries/render-utils/src/sdf_text3D.slf +++ b/libraries/render-utils/src/sdf_text3D.slf @@ -34,6 +34,8 @@ <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; +<@else@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_TEXCOORD01) in vec4 _texCoord01; @@ -56,6 +58,7 @@ void main() { _fragColor0 = vec4(color.rgb * isUnlitEnabled(), color.a); <@else@> packDeferredFragmentUnlit( + _prevPositionCS, normalize(_normalWS), color.a, color.rgb); @@ -93,6 +96,7 @@ void main() { <@endif@> <@else@> packDeferredFragment( + _prevPositionCS, normalize(_normalWS), color.a, color.rgb, diff --git a/libraries/render-utils/src/sdf_text3D.slh b/libraries/render-utils/src/sdf_text3D.slh index 76ace991821..cbcfd4826c3 100644 --- a/libraries/render-utils/src/sdf_text3D.slh +++ b/libraries/render-utils/src/sdf_text3D.slh @@ -35,6 +35,7 @@ LAYOUT(binding=0) uniform textParamsBuffer { #define TAA_TEXTURE_LOD_BIAS -3.0 const float interiorCutoff = 0.5; +const float smoothStrength = 4.0; const float taaBias = pow(2.0, TAA_TEXTURE_LOD_BIAS); vec4 evalSDF(vec2 texCoord, vec4 glyphBounds) { @@ -73,18 +74,16 @@ vec4 evalSDF(vec2 texCoord, vec4 glyphBounds) { } vec4 evalSDFSuperSampled(vec2 texCoord, vec4 glyphBounds) { - vec2 dxTexCoord = dFdx(texCoord) * 0.5 * taaBias; - vec2 dyTexCoord = dFdy(texCoord) * 0.5 * taaBias; + vec4 color = evalSDF(texCoord, glyphBounds); - // Perform 4x supersampling for anisotropic filtering - vec4 color; - color = evalSDF(texCoord, glyphBounds); - color += evalSDF(texCoord + dxTexCoord, glyphBounds); - color += evalSDF(texCoord + dyTexCoord, glyphBounds); - color += evalSDF(texCoord + dxTexCoord + dyTexCoord, glyphBounds); - color *= 0.25; + // Rely on TAA for anti-aliasing but smooth transition when minification + // to help filtering + float uvFootprint = length(fwidth(texCoord) * smoothStrength); + float smoothStart = max(0.0, 0.5 - uvFootprint); + float smoothEnd = min(1.0, 0.5 + uvFootprint); + float alpha = max(smoothstep(smoothStart, smoothEnd, color.a), step(interiorCutoff, color.a)); - return vec4(color.rgb, step(interiorCutoff, color.a)); + return vec4(color.rgb, alpha); } <@endfunc@> diff --git a/libraries/render-utils/src/sdf_text3D.slv b/libraries/render-utils/src/sdf_text3D.slv index 9ac3b871f96..a9436fd7da6 100644 --- a/libraries/render-utils/src/sdf_text3D.slv +++ b/libraries/render-utils/src/sdf_text3D.slv @@ -21,6 +21,8 @@ <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; +<@else@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_TEXCOORD01) out vec4 _texCoord01; @@ -44,7 +46,7 @@ void main() { <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> <$transformModelToEyeAndClipPos(cam, obj, position, _positionES, gl_Position)$> <@else@> - <$transformModelToClipPos(cam, obj, position, gl_Position)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, position, gl_Position, _prevPositionCS)$> <@endif@> const vec3 normal = vec3(0, 0, 1); diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index fabe85cb4f5..768ed223ac3 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -49,8 +49,9 @@ <$declareFadeFragmentInstanced()$> <@endif@> -<@if not HIFI_USE_UNLIT@> - <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> +<@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; + <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; <@endif@> <@endif@> @@ -120,6 +121,7 @@ void main(void) { texel.a); <@else@> packDeferredFragment( + _prevPositionCS, evalFrontOrBackFaceNormal(normalize(_normalWS)), 1.0, texel.rgb, @@ -142,6 +144,7 @@ void main(void) { , texel.a); <@else@> packDeferredFragmentUnlit( + _prevPositionCS, evalFrontOrBackFaceNormal(normalize(_normalWS)), 1.0, texel.rgb diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index e47af5d23fc..174af0b120a 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -24,8 +24,9 @@ layout(location=RENDER_UTILS_ATTR_POSITION_WS) out vec4 _positionWS; <@endif@> -<@if not HIFI_USE_UNLIT@> - <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> +<@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; + <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; <@endif@> <@endif@> @@ -43,10 +44,10 @@ void main(void) { <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <$transformModelToEyeAndClipPos(cam, obj, inPosition, _positionES, gl_Position)$> <@else@> - <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <@endif@> <@else@> - <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <@endif@> <@if HIFI_USE_FADE@> diff --git a/libraries/render-utils/src/simple_procedural.slf b/libraries/render-utils/src/simple_procedural.slf index cc8edbb4158..de41a380653 100644 --- a/libraries/render-utils/src/simple_procedural.slf +++ b/libraries/render-utils/src/simple_procedural.slf @@ -29,6 +29,7 @@ layout(location=RENDER_UTILS_ATTR_POSITION_MS) in vec4 _positionMS; layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; +layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; layout(location=RENDER_UTILS_ATTR_NORMAL_MS) in vec3 _normalMS; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_COLOR) in vec4 _color; @@ -147,6 +148,7 @@ void main(void) { <@if not HIFI_USE_TRANSLUCENT@> if (emissiveAmount > 0.0) { packDeferredFragmentLightmap( + _prevPositionCS, normal, 1.0, diffuse, @@ -155,6 +157,7 @@ void main(void) { emissive); } else { packDeferredFragment( + _prevPositionCS, normal, 1.0, diffuse, diff --git a/libraries/render-utils/src/simple_procedural.slv b/libraries/render-utils/src/simple_procedural.slv index 70bce451d3a..7c7544fe3d3 100644 --- a/libraries/render-utils/src/simple_procedural.slv +++ b/libraries/render-utils/src/simple_procedural.slv @@ -29,6 +29,7 @@ layout(location=RENDER_UTILS_ATTR_POSITION_MS) out vec4 _positionMS; layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; +layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; layout(location=RENDER_UTILS_ATTR_NORMAL_MS) out vec3 _normalMS; layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_COLOR) out vec4 _color; @@ -84,6 +85,6 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); - <$transformModelToEyeAndClipPos(cam, obj, positionMS, _positionES, gl_Position)$> + <$transformModelToEyeClipPosAndPrevClipPos(cam, obj, positionMS, _positionES, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, normalMS, _normalWS)$> } \ No newline at end of file diff --git a/libraries/render-utils/src/surfaceGeometry_makeCurvature.slf b/libraries/render-utils/src/surfaceGeometry_makeCurvature.slf index dd9b98b5e58..47bb66b5e35 100644 --- a/libraries/render-utils/src/surfaceGeometry_makeCurvature.slf +++ b/libraries/render-utils/src/surfaceGeometry_makeCurvature.slf @@ -108,7 +108,6 @@ void main(void) { // The position of the pixel fragment in Eye space then in world space vec3 eyePos = evalEyePositionFromZeye(stereoSide.x, Zeye, texcoordPos); - // vec3 worldPos = (frameTransform._viewInverse * vec4(eyePos, 1.0)).xyz; /* if (texcoordPos.y > 0.5) { outFragColor = vec4(fract(10.0 * worldPos.xyz), 1.0); @@ -138,9 +137,10 @@ void main(void) { // Eval px, py, pz world positions of the basis centered on the world pos of the fragment float axeLength = nearPlaneScale; - vec3 ax = (frameTransform._view[0].xyz * axeLength); - vec3 ay = (frameTransform._view[1].xyz * axeLength); - vec3 az = (frameTransform._view[2].xyz * axeLength); + mat4 view = getView(stereoSide.x); + vec3 ax = (view[0].xyz * axeLength); + vec3 ay = (view[1].xyz * axeLength); + vec3 az = (view[2].xyz * axeLength); vec4 px = vec4(eyePos + ax, 0.0); vec4 py = vec4(eyePos + ay, 0.0); @@ -184,7 +184,7 @@ void main(void) { vec2 nclipPos = (texcoordPos - 0.5) * 2.0; - //vec4 clipPos = frameTransform._projection[stereoSide.x] * vec4(eyePos, 1.0); + //vec4 clipPos = getProjection(stereoSide.x) * vec4(eyePos, 1.0); vec4 clipPos = getProjectionMono() * vec4(eyePos, 1.0); nclipPos = clipPos.xy / clipPos.w; diff --git a/libraries/render-utils/src/taa.slf b/libraries/render-utils/src/taa.slf index 25320179f5b..0e2c7e2ecd1 100644 --- a/libraries/render-utils/src/taa.slf +++ b/libraries/render-utils/src/taa.slf @@ -1,9 +1,7 @@ <@include gpu/Config.slh@> <$VERSION_HEADER$> -// Generated on <$_SCRIBE_DATE$> -// -// taa.frag -// fragment shader +// <$_SCRIBE_FILENAME$> +// Generated on <$_SCRIBE_DATE$> // // Created by Sam Gateau on 8/14/2017 // Copyright 2017 High Fidelity, Inc. @@ -28,18 +26,29 @@ void main() { return; } - vec2 fragVel = taa_fetchVelocityMapBest(fragUV).xy; - - vec3 sourceColor; - vec3 historyColor; - vec2 prevFragUV = taa_fetchSourceAndHistory(fragUV, fragVel, sourceColor, historyColor); + nextColor = mix(mix(historyColor, sourceColor, params.blend), taa_evalFeedbackColor(sourceColor, historyColor, params.blend), float(taa_feedbackColor())); - vec3 nextColor = sourceColor; + outFragColor = vec4(taa_resolveColor(nextColor), 1.0); - // clamp history to neighbourhood of current sample - historyColor = mix(historyColor, taa_evalConstrainColor(sourceColor, fragUV, fragVel, historyColor), float(taa_constrainColor())); + vec4 sourceColor; + vec4 historyColor; + vec4 nextColor; - nextColor = mix(mix(historyColor, sourceColor, params.blend), taa_evalFeedbackColor(sourceColor, historyColor, params.blend), float(taa_feedbackColor())); + vec2 fragVel = taa_fetchVelocityMapBest(fragUV).xy; + bool needsTAA = taa_fetchSourceAndHistory(fragUV, fragVel, sourceColor, historyColor); + vec4 nextColor = sourceColor; + if (needsTAA) { + // clamp history to neighbourhood of current sample + historyColor.rgb = mix(historyColor.rgb, taa_evalConstrainColor(sourceColor, fragUV, fragVel, historyColor).rgb, float(taa_constrainColor())); + + if (taa_feedbackColor()) { + nextColor = taa_evalFeedbackColor(sourceColor, historyColor, params.blend); + } else { + nextColor = mix(historyColor, sourceColor, params.blend); + } + + nextColor.rgb = taa_resolveColor(mix(sourceColor.rgb, nextColor.rgb, nextColor.a)); + } - outFragColor = vec4(taa_resolveColor(nextColor), 1.0); + outFragColor = nextColor; } diff --git a/libraries/render-utils/src/taa.slh b/libraries/render-utils/src/taa.slh index ed9162516e4..64b034a4c6b 100644 --- a/libraries/render-utils/src/taa.slh +++ b/libraries/render-utils/src/taa.slh @@ -10,6 +10,7 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // +<@include DeferredBuffer.slh@> <@include DeferredTransform.slh@> <$declareDeferredFrameTransform()$> @@ -21,6 +22,7 @@ LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_SOURCE) uniform sampler2D sourceMap; LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_VELOCITY) uniform sampler2D velocityMap; LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_DEPTH) uniform sampler2D depthMap; LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_NEXT) uniform sampler2D nextMap; +LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_INTENSITY) uniform sampler2D intensityMap; struct TAAParams { @@ -51,10 +53,18 @@ bool taa_showClosestFragment() { return GET_BIT(params.flags.x, 3); } +bool taa_bicubicHistoryFetch() { + return GET_BIT(params.flags.y, 0); +} + bool taa_constrainColor() { return GET_BIT(params.flags.y, 1); } +bool taa_sharpenOutput() { + return GET_BIT(params.flags.y, 2); +} + bool taa_feedbackColor() { return GET_BIT(params.flags.y, 4); } @@ -76,12 +86,23 @@ vec2 taa_getRegionFXAA() { } #define USE_YCOCG 1 -vec4 taa_fetchColor(sampler2D map, vec2 uv) { - vec4 c = texture(map, uv); +vec2 taa_getImageSize() { + vec2 imageSize = getWidthHeight(0); + imageSize.x *= 1.0 + float(isStereo()); + return imageSize; +} + +vec2 taa_getTexelSize() { + vec2 texelSize = getInvWidthHeight(); + texelSize.x *= 1.0 - 0.5 * float(isStereo()); + return texelSize; +} + +vec4 taa_transformColor(vec4 c) { // Apply rapid pseudo tonemapping as TAA is applied to a tonemapped image, using luminance as weight, as proposed in // https://de45xmedrsdbp.cloudfront.net/Resources/files/TemporalAA_small-59732822.pdf - float lum = dot(vec3(0.3,0.5,0.2),c.rgb); - c.rgb = c.rgb / (1.0+lum); + float lum = dot(vec3(0.3, 0.5, 0.2), c.rgb); + c.rgb = c.rgb / (1.0 + lum); #if USE_YCOCG return vec4(color_LinearToYCoCg(c.rgb), c.a); #else @@ -89,23 +110,76 @@ vec4 taa_fetchColor(sampler2D map, vec2 uv) { #endif } +vec4 taa_fetchColor(sampler2D map, vec2 uv) { + vec4 c = texture(map, uv); + return taa_transformColor(c); +} + vec3 taa_resolveColor(vec3 color) { #if USE_YCOCG color = max(vec3(0), color_YCoCgToUnclampedLinear(color)); #endif // Apply rapid inverse tonemapping, using luminance as weight, as proposed in // https://de45xmedrsdbp.cloudfront.net/Resources/files/TemporalAA_small-59732822.pdf - float lum = dot(vec3(0.3,0.5,0.2),color.rgb); - color = color / (1.0-lum); + float lum = dot(vec3(0.3, 0.5, 0.2),color.rgb); + color = color / (1.0 - lum); return color; } vec4 taa_fetchSourceMap(vec2 uv) { - return taa_fetchColor(sourceMap, uv); + vec4 source = taa_fetchColor(sourceMap, uv); + // Store AA intensity in alpha + source.a = texture(intensityMap, uv).r; + return source; } vec4 taa_fetchHistoryMap(vec2 uv) { - return taa_fetchColor(historyMap, uv); + vec4 result; + + if (taa_bicubicHistoryFetch()) { + // Perform a Catmull-Rom interpolation for a (possibly) sharper result. + // Optimized 9-tap fetch based on http://vec3.ca/bicubic-filtering-in-fewer-taps/ + vec2 samplePixelPos = uv * taa_getImageSize() - 0.5; + vec2 samplePixelIntPos = floor(samplePixelPos); + + vec2 samplePixelFracPos = samplePixelPos - samplePixelIntPos; + vec2 samplePixelFracPos2 = samplePixelFracPos * samplePixelFracPos; + + // Catmull-Rom interpolation weights + vec2 w0 = samplePixelFracPos * (samplePixelFracPos * (1.0 - 0.5*samplePixelFracPos) - 0.5); + vec2 w1 = 1.0 + samplePixelFracPos2 * (1.5*samplePixelFracPos - 2.5); + vec2 w2 = samplePixelFracPos * (samplePixelFracPos * (2.0 - 1.5*samplePixelFracPos) + 0.5); + vec2 w3 = samplePixelFracPos2 * (0.5 * samplePixelFracPos - 0.5); + + vec2 w12 = w1 + w2; + vec2 offset12 = w2 / (w1 + w2); + + vec2 sampleUV0 = samplePixelIntPos - vec2(1.0); + vec2 sampleUV3 = samplePixelIntPos + vec2(2.0); + vec2 sampleUV12 = samplePixelIntPos + offset12; + + vec2 texelSize = taa_getTexelSize(); + sampleUV0 = (sampleUV0 + 0.5) * texelSize; + sampleUV3 = (sampleUV3 + 0.5) * texelSize; + sampleUV12 = (sampleUV12 + 0.5) * texelSize; + + result = texture(historyMap, vec2(sampleUV0.x, sampleUV0.y)) * w0.x * w0.y; + result += texture(historyMap, vec2(sampleUV12.x, sampleUV0.y)) * w12.x * w0.y; + result += texture(historyMap, vec2(sampleUV3.x, sampleUV0.y)) * w3.x * w0.y; + + result += texture(historyMap, vec2(sampleUV0.x, sampleUV12.y)) * w0.x * w12.y; + result += texture(historyMap, vec2(sampleUV12.x, sampleUV12.y)) * w12.x * w12.y; + result += texture(historyMap, vec2(sampleUV3.x, sampleUV12.y)) * w3.x * w12.y; + + result += texture(historyMap, vec2(sampleUV0.x, sampleUV3.y)) * w0.x * w3.y; + result += texture(historyMap, vec2(sampleUV12.x, sampleUV3.y)) * w12.x * w3.y; + result += texture(historyMap, vec2(sampleUV3.x, sampleUV3.y)) * w3.x * w3.y; + + result.a = clamp(result.a, 0.0, 1.0); + } else { + result = texture(historyMap, uv); + } + return taa_transformColor(result); } vec4 taa_fetchNextMap(vec2 uv) { @@ -123,35 +197,23 @@ float taa_fetchDepth(vec2 uv) { #define ZCMP_GT(a, b) float(a > b) -vec2 taa_getImageSize() { - vec2 imageSize = getWidthHeight(0); - imageSize.x *= 1.0 + float(isStereo()); - return imageSize; -} - -vec2 taa_getTexelSize() { - vec2 texelSize = getInvWidthHeight(); - texelSize.x *= 1.0 - 0.5 * float(isStereo()); - return texelSize; -} - vec3 taa_findClosestFragment3x3(vec2 uv) { - vec2 dd = abs(taa_getTexelSize()); + vec2 dd = taa_getTexelSize(); vec2 du = vec2(dd.x, 0.0); vec2 dv = vec2(0.0, dd.y); - vec3 dtl = vec3(-1, -1, taa_fetchDepth(uv - dv - du)); + vec3 dtl = vec3(-1, -1, taa_fetchDepth(uv - dd)); vec3 dtc = vec3( 0, -1, taa_fetchDepth(uv - dv)); - vec3 dtr = vec3( 1, -1, taa_fetchDepth(uv - dv + du)); + vec3 dtr = vec3( 1, -1, taa_fetchDepth(uv - dm)); vec3 dml = vec3(-1, 0, taa_fetchDepth(uv - du)); vec3 dmc = vec3( 0, 0, taa_fetchDepth(uv)); vec3 dmr = vec3( 1, 0, taa_fetchDepth(uv + du)); - vec3 dbl = vec3(-1, 1, taa_fetchDepth(uv + dv - du)); + vec3 dbl = vec3(-1, 1, taa_fetchDepth(uv + dm)); vec3 dbc = vec3( 0, 1, taa_fetchDepth(uv + dv)); - vec3 dbr = vec3( 1, 1, taa_fetchDepth(uv + dv + du)); + vec3 dbr = vec3( 1, 1, taa_fetchDepth(uv + dd)); vec3 dmin = dtl; dmin = mix(dmin, dtc, ZCMP_GT(dmin.z, dtc.z)); @@ -169,21 +231,21 @@ vec3 taa_findClosestFragment3x3(vec2 uv) } vec2 taa_fetchVelocityMapBest(vec2 uv) { - vec2 dd = abs(taa_getTexelSize()); + vec2 dd = taa_getTexelSize(); vec2 du = vec2(dd.x, 0.0); vec2 dv = vec2(0.0, dd.y); - vec2 dtl = taa_fetchVelocityMap(uv - dv - du); + vec2 dtl = taa_fetchVelocityMap(uv - dd); vec2 dtc = taa_fetchVelocityMap(uv - dv); - vec2 dtr = taa_fetchVelocityMap(uv - dv + du); + vec2 dtr = taa_fetchVelocityMap(uv - dm); vec2 dml = taa_fetchVelocityMap(uv - du); vec2 dmc = taa_fetchVelocityMap(uv); vec2 dmr = taa_fetchVelocityMap(uv + du); - vec2 dbl = taa_fetchVelocityMap(uv + dv - du); + vec2 dbl = taa_fetchVelocityMap(uv + dm); vec2 dbc = taa_fetchVelocityMap(uv + dv); - vec2 dbr = taa_fetchVelocityMap(uv + dv + du); + vec2 dbr = taa_fetchVelocityMap(uv + dd); vec3 best = vec3(dtl, dot(dtl, dtl)); @@ -223,8 +285,8 @@ vec2 taa_fromFragUVToEyeUVAndSide(vec2 fragUV, out int stereoSide) { vec2 taa_fromEyeUVToFragUV(vec2 eyeUV, int stereoSide) { vec2 fragUV = eyeUV; float check = float(isStereo()); + fragUV.x += check * float(stereoSide); fragUV.x *= 1.0 - 0.5 * check; - fragUV.x += check * float(stereoSide) * 0.5; return fragUV; } @@ -236,13 +298,21 @@ vec2 taa_computePrevFragAndEyeUV(vec2 fragUV, vec2 fragVelocity, out vec2 prevEy } vec2 taa_fetchSourceAndHistory(vec2 fragUV, vec2 fragVelocity, out vec3 sourceColor, out vec3 historyColor) { - vec2 prevEyeUV; - vec2 prevFragUV = taa_computePrevFragAndEyeUV(fragUV, fragVelocity, prevEyeUV); - sourceColor = taa_fetchSourceMap(fragUV).xyz; - - historyColor = mix(sourceColor, taa_fetchHistoryMap(prevFragUV).xyz, float(!(any(lessThan(prevEyeUV, vec2(0.0))) || any(greaterThan(prevEyeUV, vec2(1.0)))))); - - return prevFragUV; + sourceColor.rgb = texture(sourceMap, fragUV).rgb; + // Store AA intensity in alpha + sourceColor.a = texture(intensityMap, fragUV).r; + + // If velocity is 0 then don't fetch history, just return the source. This means there is no jitter on this pixel + if (any(notEqual(fragVelocity, vec2(0.0)))) { + vec2 prevEyeUV; + vec2 prevFragUV = taa_computePrevFragAndEyeUV(fragUV, fragVelocity, prevEyeUV); + sourceColor = taa_transformColor(sourceColor); + historyColor = mix(sourceColor, taa_fetchHistoryMap(prevFragUV).xyz, float(!(any(lessThan(prevEyeUV, vec2(0.0))) || any(greaterThan(prevEyeUV, vec2(1.0)))))); + return true; + } else { + historyColor = sourceColor; + return false; + } } float Luminance(vec3 rgb) { @@ -253,12 +323,13 @@ float Luminance(vec3 rgb) { mat3 taa_evalNeighbourColorVariance(vec3 sourceColor, vec2 fragUV, vec2 fragVelocity) { vec2 texelSize = taa_getTexelSize(); - - vec2 du = vec2(texelSize.x, 0.0); - vec2 dv = vec2(0.0, texelSize.y); + vec2 dd = texelSize; + vec2 du = vec2(dd.x, 0.0); + vec2 dv = vec2(0.0, dd.y); + vec2 dm = vec2(dd.x, -dd.y); - vec3 sampleColor = taa_fetchSourceMap(fragUV - dv - du).rgb; + vec3 sampleColor = taa_fetchSourceMap(fragUV - dd).rgb; vec3 sumSamples = sampleColor; vec3 sumSamples2 = sampleColor * sampleColor; @@ -266,7 +337,7 @@ mat3 taa_evalNeighbourColorVariance(vec3 sourceColor, vec2 fragUV, vec2 fragVelo sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; - sampleColor = taa_fetchSourceMap(fragUV - dv + du).rgb; + sampleColor = taa_fetchSourceMap(fragUV - dm).rgb; sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; @@ -282,27 +353,27 @@ mat3 taa_evalNeighbourColorVariance(vec3 sourceColor, vec2 fragUV, vec2 fragVelo sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; - sampleColor = taa_fetchSourceMap(fragUV + dv - du).rgb; + sampleColor = taa_fetchSourceMap(fragUV + dm).rgb; sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; sampleColor = taa_fetchSourceMap(fragUV + dv).rgb; sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; - - sampleColor = taa_fetchSourceMap(fragUV + dv + du).rgb; + + sampleColor = taa_fetchSourceMap(fragUV + dd).rgb; sumSamples += sampleColor; sumSamples2 += sampleColor * sampleColor; - + vec3 mu = sumSamples / vec3(9.0); vec3 sigma = sqrt(max(sumSamples2 / vec3(9.0) - mu * mu, vec3(0.0))); - - float gamma = params.covarianceGamma; - vec3 cmin = mu - gamma * sigma; - vec3 cmax = mu + gamma * sigma; - return mat3(cmin, cmax, mu); + sigma *= params.covarianceGamma; + vec3 cmin = mu - sigma; + vec3 cmax = mu + sigma; + + return mat3(cmin, cmax, mu); } mat3 taa_evalNeighbourColorRegion(vec3 sourceColor, vec2 fragUV, vec2 fragVelocity, float fragZe) { @@ -310,73 +381,73 @@ mat3 taa_evalNeighbourColorRegion(vec3 sourceColor, vec2 fragUV, vec2 fragVeloci vec2 texelSize = taa_getTexelSize(); vec3 cmin, cmax, cavg; - #if MINMAX_3X3_ROUNDED - vec2 du = vec2(texelSize.x, 0.0); - vec2 dv = vec2(0.0, texelSize.y); - - vec3 ctl = taa_fetchSourceMap(fragUV - dv - du).rgb; - vec3 ctc = taa_fetchSourceMap(fragUV - dv).rgb; - vec3 ctr = taa_fetchSourceMap(fragUV - dv + du).rgb; - vec3 cml = taa_fetchSourceMap(fragUV - du).rgb; - vec3 cmc = sourceColor; //taa_fetchSourceMap(fragUV).rgb; // could resuse the same osurce sample isn't it ? - vec3 cmr = taa_fetchSourceMap(fragUV + du).rgb; - vec3 cbl = taa_fetchSourceMap(fragUV + dv - du).rgb; - vec3 cbc = taa_fetchSourceMap(fragUV + dv).rgb; - vec3 cbr = taa_fetchSourceMap(fragUV + dv + du).rgb; - - cmin = min(ctl, min(ctc, min(ctr, min(cml, min(cmc, min(cmr, min(cbl, min(cbc, cbr)))))))); - cmax = max(ctl, max(ctc, max(ctr, max(cml, max(cmc, max(cmr, max(cbl, max(cbc, cbr)))))))); - - #if MINMAX_3X3_ROUNDED || USE_YCOCG || USE_CLIPPING - cavg = (ctl + ctc + ctr + cml + cmc + cmr + cbl + cbc + cbr) / 9.0; - #elif - cavg = (cmin + cmax ) * 0.5; - #endif - - #if MINMAX_3X3_ROUNDED - vec3 cmin5 = min(ctc, min(cml, min(cmc, min(cmr, cbc)))); - vec3 cmax5 = max(ctc, max(cml, max(cmc, max(cmr, cbc)))); - vec3 cavg5 = (ctc + cml + cmc + cmr + cbc) / 5.0; - cmin = 0.5 * (cmin + cmin5); - cmax = 0.5 * (cmax + cmax5); - cavg = 0.5 * (cavg + cavg5); - #endif - #else - const float _SubpixelThreshold = 0.5; - const float _GatherBase = 0.5; - const float _GatherSubpixelMotion = 0.1666; - - vec2 texel_vel = fragVelocity * imageSize; - float texel_vel_mag = length(texel_vel) * -fragZe; - float k_subpixel_motion = clamp(_SubpixelThreshold / (0.0001 + texel_vel_mag), 0.0, 1.0); - float k_min_max_support = _GatherBase + _GatherSubpixelMotion * k_subpixel_motion; - - vec2 ss_offset01 = k_min_max_support * vec2(-texelSize.x, texelSize.y); - vec2 ss_offset11 = k_min_max_support * vec2(texelSize.x, texelSize.y); - vec3 c00 = taa_fetchSourceMap(fragUV - ss_offset11).rgb; - vec3 c10 = taa_fetchSourceMap(fragUV - ss_offset01).rgb; - vec3 c01 = taa_fetchSourceMap(fragUV + ss_offset01).rgb; - vec3 c11 = taa_fetchSourceMap(fragUV + ss_offset11).rgb; - - cmin = min(c00, min(c10, min(c01, c11))); - cmax = max(c00, max(c10, max(c01, c11))); - cavg = (cmin + cmax ) * 0.5; +#if MINMAX_3X3_ROUNDED + vec2 du = vec2(texelSize.x, 0.0); + vec2 dv = vec2(0.0, texelSize.y); - #if USE_YCOCG || USE_CLIPPING - cavg = (c00 + c10 + c01 + c11) / 4.0; - #elif - cavg = (cmin + cmax ) * 0.5; - #endif + vec3 ctl = taa_fetchSourceMap(fragUV - dv - du).rgb; + vec3 ctc = taa_fetchSourceMap(fragUV - dv).rgb; + vec3 ctr = taa_fetchSourceMap(fragUV - dv + du).rgb; + vec3 cml = taa_fetchSourceMap(fragUV - du).rgb; + vec3 cmc = sourceColor; //taa_fetchSourceMap(fragUV).rgb; // could resuse the same osurce sample isn't it ? + vec3 cmr = taa_fetchSourceMap(fragUV + du).rgb; + vec3 cbl = taa_fetchSourceMap(fragUV + dv - du).rgb; + vec3 cbc = taa_fetchSourceMap(fragUV + dv).rgb; + vec3 cbr = taa_fetchSourceMap(fragUV + dv + du).rgb; + + cmin = min(ctl, min(ctc, min(ctr, min(cml, min(cmc, min(cmr, min(cbl, min(cbc, cbr)))))))); + cmax = max(ctl, max(ctc, max(ctr, max(cml, max(cmc, max(cmr, max(cbl, max(cbc, cbr)))))))); + + #if MINMAX_3X3_ROUNDED || USE_YCOCG || USE_CLIPPING + cavg = (ctl + ctc + ctr + cml + cmc + cmr + cbl + cbc + cbr) / 9.0; + #elif + cavg = (cmin + cmax ) * 0.5; #endif - // shrink chroma min-max - #if USE_YCOCG - vec2 chroma_extent = vec2(0.25 * 0.5 * (cmax.r - cmin.r)); - vec2 chroma_center = sourceColor.gb; - cmin.yz = chroma_center - chroma_extent; - cmax.yz = chroma_center + chroma_extent; - cavg.yz = chroma_center; + #if MINMAX_3X3_ROUNDED + vec3 cmin5 = min(ctc, min(cml, min(cmc, min(cmr, cbc)))); + vec3 cmax5 = max(ctc, max(cml, max(cmc, max(cmr, cbc)))); + vec3 cavg5 = (ctc + cml + cmc + cmr + cbc) / 5.0; + cmin = 0.5 * (cmin + cmin5); + cmax = 0.5 * (cmax + cmax5); + cavg = 0.5 * (cavg + cavg5); + #endif +#else + const float _SubpixelThreshold = 0.5; + const float _GatherBase = 0.5; + const float _GatherSubpixelMotion = 0.1666; + + vec2 texel_vel = fragVelocity * imageSize; + float texel_vel_mag = length(texel_vel) * -fragZe; + float k_subpixel_motion = clamp(_SubpixelThreshold / (0.0001 + texel_vel_mag), 0.0, 1.0); + float k_min_max_support = _GatherBase + _GatherSubpixelMotion * k_subpixel_motion; + + vec2 ss_offset01 = k_min_max_support * vec2(-texelSize.x, texelSize.y); + vec2 ss_offset11 = k_min_max_support * vec2(texelSize.x, texelSize.y); + vec3 c00 = taa_fetchSourceMap(fragUV - ss_offset11).rgb; + vec3 c10 = taa_fetchSourceMap(fragUV - ss_offset01).rgb; + vec3 c01 = taa_fetchSourceMap(fragUV + ss_offset01).rgb; + vec3 c11 = taa_fetchSourceMap(fragUV + ss_offset11).rgb; + + cmin = min(c00, min(c10, min(c01, c11))); + cmax = max(c00, max(c10, max(c01, c11))); + cavg = (cmin + cmax ) * 0.5; + + #if USE_YCOCG || USE_CLIPPING + cavg = (c00 + c10 + c01 + c11) / 4.0; + #elif + cavg = (cmin + cmax ) * 0.5; #endif +#endif + + // shrink chroma min-max +#if USE_YCOCG + vec2 chroma_extent = vec2(0.25 * 0.5 * (cmax.r - cmin.r)); + vec2 chroma_center = sourceColor.gb; + cmin.yz = chroma_center - chroma_extent; + cmax.yz = chroma_center + chroma_extent; + cavg.yz = chroma_center; +#endif return mat3(cmin, cmax, cavg); } @@ -412,24 +483,23 @@ vec3 taa_evalConstrainColor(vec3 sourceColor, vec2 sourceUV, vec2 sourceVel, vec return taa_clampColor(colorMinMaxAvg[0], colorMinMaxAvg[1], sourceColor, candidateColor); } -vec3 taa_evalFeedbackColor(vec3 sourceColor, vec3 historyColor, float blendFactor) { +vec3 taa_evalFeedbackColor(vec4 sourceColor, vec4 historyColor, float blendFactor) { const float _FeedbackMin = 0.1; const float _FeedbackMax = 0.9; // feedback weight from unbiased luminance diff (t.lottes) - #if USE_YCOCG - float lum0 = sourceColor.r; - float lum1 = historyColor.r; - #else - float lum0 = Luminance(sourceColor.rgb); - float lum1 = Luminance(historyColor.rgb); - #endif +#if USE_YCOCG + float lum0 = sourceColor.r; + float lum1 = historyColor.r; +#else + float lum0 = Luminance(sourceColor.rgb); + float lum1 = Luminance(historyColor.rgb); +#endif float unbiased_diff = abs(lum0 - lum1) / max(lum0, max(lum1, 0.2)); float unbiased_weight = 1.0 - unbiased_diff; float unbiased_weight_sqr = unbiased_weight * unbiased_weight; float k_feedback = mix(_FeedbackMin, _FeedbackMax, unbiased_weight_sqr); - - vec3 nextColor = mix(historyColor, sourceColor, k_feedback * blendFactor).xyz; + vec4 nextColor = mix(historyColor, sourceColor, k_feedback * blendFactor); return nextColor; } @@ -447,7 +517,7 @@ vec3 taa_getVelocityColorAboveThreshold(float velocityPixLength) { vec3 taa_evalFXAA(vec2 fragUV) { - // vec2 texelSize = getInvWidthHeight(); + // vec2 texelSize = getInvWidthHeight(); vec2 texelSize = taa_getTexelSize(); // filter width limit for dependent "two-tap" texture samples diff --git a/libraries/render-utils/src/taa_blend.slf b/libraries/render-utils/src/taa_blend.slf index 0999b2482f0..0779109cd99 100644 --- a/libraries/render-utils/src/taa_blend.slf +++ b/libraries/render-utils/src/taa_blend.slf @@ -21,7 +21,6 @@ void main(void) { vec3 nextColor = texture(nextMap, varTexCoord0).xyz; outFragColor = vec4(nextColor, 1.0); - // Pixel being shaded vec3 sourceColor = texture(sourceMap, varTexCoord0).xyz; diff --git a/libraries/render-utils/src/velocityBuffer_cameraMotion.slf b/libraries/render-utils/src/velocityBuffer_cameraMotion.slf deleted file mode 100644 index 0ec63a7b1d3..00000000000 --- a/libraries/render-utils/src/velocityBuffer_cameraMotion.slf +++ /dev/null @@ -1,43 +0,0 @@ -<@include gpu/Config.slh@> -<$VERSION_HEADER$> -// Generated on <$_SCRIBE_DATE$> -// -// velocityBuffer_cameraMotion.frag -// -// Created by Sam Gateau on 6/3/16. -// Copyright 2016 High Fidelity, Inc. -// -// Distributed under the Apache License, Version 2.0. -// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html -// - -<@include DeferredTransform.slh@> -<$declareDeferredFrameTransform()$> - -layout(location=0) in vec2 varTexCoord0; -layout(location=0) out vec4 outFragColor; - -LAYOUT(binding=RENDER_UTILS_TEXTURE_TAA_DEPTH) uniform sampler2D depthMap; - - -void main(void) { - // Pixel being shaded - ivec2 pixelPos; - vec2 texcoordPos; - ivec4 stereoSide; - ivec2 framePixelPos = getPixelPosTexcoordPosAndSide(gl_FragCoord.xy, pixelPos, texcoordPos, stereoSide); - - float Zdb = texelFetch(depthMap, ivec2(gl_FragCoord.xy), 0).x; - - // The position of the pixel fragment in Eye space then in world space - vec3 eyePos = evalUnjitteredEyePositionFromZdb(stereoSide.x, Zdb, texcoordPos); - vec3 worldPos = (getViewInverse() * vec4(eyePos, 1.0)).xyz; - - vec3 prevEyePos = (getPreviousView() * vec4(worldPos, 1.0)).xyz; - vec4 prevClipPos = (getUnjitteredProjection(stereoSide.x) * vec4(prevEyePos, 1.0)); - vec2 prevUV = 0.5 * (prevClipPos.xy / prevClipPos.w) + vec2(0.5); - - //vec2 imageSize = getWidthHeight(0); - vec2 imageSize = vec2(1.0, 1.0); - outFragColor = vec4( ((texcoordPos - prevUV) * imageSize), 0.0, 0.0); -} diff --git a/libraries/render-utils/src/web_browser.slf b/libraries/render-utils/src/web_browser.slf index f746916d3d4..2dc71f12dd4 100644 --- a/libraries/render-utils/src/web_browser.slf +++ b/libraries/render-utils/src/web_browser.slf @@ -35,6 +35,7 @@ LAYOUT(binding=0) uniform sampler2D webTexture; layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; <@else@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_COLOR) in vec4 _color; layout(location=RENDER_UTILS_ATTR_TEXCOORD01) in vec4 _texCoord01; @@ -69,6 +70,6 @@ void main(void) { } } <@else@> - packDeferredFragmentUnlit(normalize(_normalWS), 1.0, texel.rgb); + packDeferredFragmentUnlit(_prevPositionCS, normalize(_normalWS), 1.0, texel.rgb); <@endif@> } diff --git a/libraries/render-utils/src/web_browser.slv b/libraries/render-utils/src/web_browser.slv index 07b4d7d3d7c..157f4a3cd24 100644 --- a/libraries/render-utils/src/web_browser.slv +++ b/libraries/render-utils/src/web_browser.slv @@ -22,6 +22,7 @@ layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; <@else@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_COLOR) out vec4 _color; layout(location=RENDER_UTILS_ATTR_TEXCOORD01) out vec4 _texCoord01; @@ -35,7 +36,7 @@ void main(void) { <@if HIFI_USE_FORWARD@> <$transformModelToWorldAndEyeAndClipPos(cam, obj, inPosition, _positionWS, _positionES, gl_Position)$> <@else@> - <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> + <$transformModelToClipPosAndPrevClip(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, inNormal.xyz, _normalWS)$> <@endif@> } \ No newline at end of file diff --git a/libraries/render-utils/src/zone_drawAmbient.slf b/libraries/render-utils/src/zone_drawAmbient.slf index d780fd0de21..1792407f3e4 100644 --- a/libraries/render-utils/src/zone_drawAmbient.slf +++ b/libraries/render-utils/src/zone_drawAmbient.slf @@ -29,7 +29,7 @@ void main(void) { vec3 spherePos = normalize(vec3(sphereUV, sqrt(1.0 - sphereR2))); - vec3 fragNormal = vec3(getViewInverse() * vec4(spherePos, 0.0)); + vec3 fragNormal = vec3(getViewInverse(getStereoSideFromFragCoord()) * vec4(spherePos, 0.0)); LightAmbient lightAmbient = getLightAmbient(); diff --git a/libraries/render-utils/src/zone_drawKeyLight.slf b/libraries/render-utils/src/zone_drawKeyLight.slf index 7174914ed87..ddd1b1e9c95 100644 --- a/libraries/render-utils/src/zone_drawKeyLight.slf +++ b/libraries/render-utils/src/zone_drawKeyLight.slf @@ -33,8 +33,9 @@ void main(void) { const float INOUT_RATIO = 0.4; const float SUN_THRESHOLD = 0.99; + mat4 viewInverse = getViewInverse(getStereoSideFromFragCoord()); vec3 outSpherePos = normalize(vec3(sphereUV, -sqrt(1.0 - sphereR2))); - vec3 outNormal = vec3(getViewInverse() * vec4(outSpherePos, 0.0)); + vec3 outNormal = vec3(viewInverse * vec4(outSpherePos, 0.0)); float val = step(SUN_THRESHOLD, dot(-lightDirection, outNormal)); @@ -43,7 +44,7 @@ void main(void) { if (sphereR2 < INOUT_RATIO * INOUT_RATIO * SCOPE_RADIUS2) { vec2 inSphereUV = sphereUV / INOUT_RATIO; vec3 inSpherePos = normalize(vec3(inSphereUV, sqrt(1.0 - dot(inSphereUV.xy, inSphereUV.xy)))); - vec3 inNormal = vec3(getViewInverse() * vec4(inSpherePos, 0.0)); + vec3 inNormal = vec3(viewInverse * vec4(inSpherePos, 0.0)); vec3 marbleColor = max(lightIrradiance * vec3(dot(-lightDirection, inNormal)), vec3(0.01)); color += marbleColor; diff --git a/libraries/render-utils/src/zone_drawSkybox.slf b/libraries/render-utils/src/zone_drawSkybox.slf index 743b48d0bf1..d6d4bedeb40 100644 --- a/libraries/render-utils/src/zone_drawSkybox.slf +++ b/libraries/render-utils/src/zone_drawSkybox.slf @@ -30,7 +30,7 @@ void main(void) { vec3 spherePos = normalize(vec3(sphereUV, -sqrt(1.0 - sphereR2))); - vec3 direction = vec3(getViewInverse() * vec4(spherePos, 0.0)); + vec3 direction = vec3(getViewInverse(getStereoSideFromFragCoord()) * vec4(spherePos, 0.0)); vec3 color = skybox.color.rgb; diff --git a/libraries/render/src/render/DrawSceneOctree.cpp b/libraries/render/src/render/DrawSceneOctree.cpp index 44d54c3c289..145c6c681b9 100644 --- a/libraries/render/src/render/DrawSceneOctree.cpp +++ b/libraries/render/src/render/DrawSceneOctree.cpp @@ -73,14 +73,8 @@ void DrawSceneOctree::run(const RenderContextPointer& renderContext, const ItemS std::static_pointer_cast(renderContext->jobConfig)->numFreeCells = (int)scene->getSpatialTree().getNumFreeCells(); gpu::doInBatch("DrawSceneOctree::run", args->_context, [&](gpu::Batch& batch) { - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); batch.setViewportTransform(args->_viewport); - - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); // bind the one gpu::Pipeline we need @@ -177,14 +171,8 @@ void DrawItemSelection::run(const RenderContextPointer& renderContext, const Ite } gpu::doInBatch("DrawItemSelection::run", args->_context, [&](gpu::Batch& batch) { - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); batch.setViewportTransform(args->_viewport); - - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat, true); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); // bind the one gpu::Pipeline we need diff --git a/libraries/render/src/render/DrawSceneOctree.h b/libraries/render/src/render/DrawSceneOctree.h index 0c7441404ae..eddac42d4d9 100644 --- a/libraries/render/src/render/DrawSceneOctree.h +++ b/libraries/render/src/render/DrawSceneOctree.h @@ -63,7 +63,7 @@ namespace render { using Config = DrawSceneOctreeConfig; using JobModel = Job::ModelI; - DrawSceneOctree() {} + DrawSceneOctree(uint transformSlot) : _transformSlot(transformSlot) {} void configure(const Config& config); void run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& selection); @@ -71,6 +71,9 @@ namespace render { const gpu::PipelinePointer getDrawCellBoundsPipeline(); const gpu::PipelinePointer getDrawLODReticlePipeline(); const gpu::PipelinePointer getDrawItemBoundPipeline(); + + private: + uint _transformSlot; }; @@ -120,12 +123,15 @@ namespace render { using Config = DrawItemSelectionConfig; using JobModel = Job::ModelI; - DrawItemSelection() {} + DrawItemSelection(uint transformSlot) : _transformSlot(transformSlot) {} void configure(const Config& config); void run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& selection); const gpu::PipelinePointer getDrawItemBoundPipeline(); + + private: + uint _transformSlot; }; } diff --git a/libraries/render/src/render/DrawStatus.cpp b/libraries/render/src/render/DrawStatus.cpp index d010929e7a1..5ca49e64c89 100644 --- a/libraries/render/src/render/DrawStatus.cpp +++ b/libraries/render/src/render/DrawStatus.cpp @@ -84,7 +84,7 @@ void DrawStatus::configure(const Config& config) { _showFade = config.showFade; } -void DrawStatus::run(const RenderContextPointer& renderContext, const Input& input) { +void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inItems) { assert(renderContext->args); assert(renderContext->args->hasViewFrustum()); RenderArgs* args = renderContext->args; @@ -92,9 +92,6 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inp const int NUM_STATUS_VEC4_PER_ITEM = 2; const int VEC4_LENGTH = 4; - const auto& inItems = input.get0(); - const auto jitter = input.get1(); - // First thing, we collect the bound and the status for all the items we want to render int nbItems = 0; render::ItemBounds itemBounds; @@ -208,15 +205,8 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inp // Alright, something to render let's do it gpu::doInBatch("DrawStatus::run", args->_context, [&](gpu::Batch& batch) { - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); batch.setViewportTransform(args->_viewport); - - batch.setProjectionTransform(projMat); - batch.setProjectionJitter(jitter.x, jitter.y); - batch.setViewTransform(viewMat, true); + batch.setSavedViewProjectionTransform(render::RenderEngine::TS_MAIN_VIEW); batch.setModelTransform(Transform()); // bind the one gpu::Pipeline we need diff --git a/libraries/render/src/render/DrawStatus.h b/libraries/render/src/render/DrawStatus.h index 8f61af1f958..166144d90d6 100644 --- a/libraries/render/src/render/DrawStatus.h +++ b/libraries/render/src/render/DrawStatus.h @@ -43,7 +43,7 @@ namespace render { class DrawStatus { public: using Config = DrawStatusConfig; - using Input = VaryingSet2; + using Input = ItemBounds; using JobModel = Job::ModelI; DrawStatus() {} diff --git a/libraries/render/src/render/DrawTask.cpp b/libraries/render/src/render/DrawTask.cpp index 68a87ca53cf..2b5f4c88466 100644 --- a/libraries/render/src/render/DrawTask.cpp +++ b/libraries/render/src/render/DrawTask.cpp @@ -194,12 +194,7 @@ void DrawBounds::run(const RenderContextPointer& renderContext, args->_batch = &batch; // Setup projection - glm::mat4 projMat; - Transform viewMat; - args->getViewFrustum().evalProjectionMatrix(projMat); - args->getViewFrustum().evalViewTransform(viewMat); - batch.setProjectionTransform(projMat); - batch.setViewTransform(viewMat); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); // Bind program diff --git a/libraries/render/src/render/DrawTask.h b/libraries/render/src/render/DrawTask.h index 1ef4b8caf17..f948dce1b29 100644 --- a/libraries/render/src/render/DrawTask.h +++ b/libraries/render/src/render/DrawTask.h @@ -58,6 +58,8 @@ class DrawBounds { using Inputs = render::ItemBounds; using JobModel = render::Job::ModelI; + DrawBounds(uint transformSlot) : _transformSlot(transformSlot) {} + void configure(const Config& configuration) {} void run(const render::RenderContextPointer& renderContext, const Inputs& items); @@ -67,6 +69,7 @@ class DrawBounds { gpu::PipelinePointer _boundsPipeline; gpu::BufferPointer _drawBuffer; gpu::BufferPointer _paramsBuffer; + uint _transformSlot; }; class DrawQuadVolumeConfig : public render::JobConfig { diff --git a/libraries/render/src/render/Engine.h b/libraries/render/src/render/Engine.h index f1d59727d33..6de0727a3ae 100644 --- a/libraries/render/src/render/Engine.h +++ b/libraries/render/src/render/Engine.h @@ -85,6 +85,11 @@ namespace render { class RenderEngine : public Engine { public: + enum TransformSlot { + TS_MAIN_VIEW = 0, + TS_BACKGROUND_VIEW + }; + RenderEngine(); ~RenderEngine() = default; diff --git a/libraries/render/src/render/ShapePipeline.cpp b/libraries/render/src/render/ShapePipeline.cpp index 048e08e959f..467abd9f9a4 100644 --- a/libraries/render/src/render/ShapePipeline.cpp +++ b/libraries/render/src/render/ShapePipeline.cpp @@ -101,6 +101,7 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p locations->lightBufferUnit = reflection.validUniformBuffer(graphics::slot::buffer::Light); locations->lightAmbientBufferUnit = reflection.validUniformBuffer(graphics::slot::buffer::AmbientLight); locations->lightAmbientMapUnit = reflection.validTexture(graphics::slot::texture::Skybox); + locations->deferredFrameTransformBufferUnit = reflection.validUniformBuffer(render_utils::slot::buffer::DeferredFrameTransform); locations->fadeMaskTextureUnit = reflection.validTexture(render_utils::slot::texture::FadeMask); locations->fadeParameterBufferUnit = reflection.validUniformBuffer(render_utils::slot::buffer::FadeParameters); locations->fadeObjectParameterBufferUnit = reflection.validUniformBuffer(render_utils::slot::buffer::FadeObjectParameters); diff --git a/libraries/render/src/render/ShapePipeline.h b/libraries/render/src/render/ShapePipeline.h index 04b9919140a..2c40162881f 100644 --- a/libraries/render/src/render/ShapePipeline.h +++ b/libraries/render/src/render/ShapePipeline.h @@ -277,6 +277,7 @@ class ShapePipeline { bool lightBufferUnit{ false }; bool lightAmbientBufferUnit{ false }; bool lightAmbientMapUnit{ false }; + bool deferredFrameTransformBufferUnit{ false }; bool fadeMaskTextureUnit{ false }; bool fadeParameterBufferUnit{ false }; bool fadeObjectParameterBufferUnit{ false }; diff --git a/scripts/developer/utilities/render/luci/Antialiasing.qml b/scripts/developer/utilities/render/luci/Antialiasing.qml index 2a52dfed46b..5a494a12e17 100644 --- a/scripts/developer/utilities/render/luci/Antialiasing.qml +++ b/scripts/developer/utilities/render/luci/Antialiasing.qml @@ -49,7 +49,7 @@ Column{ Prop.PropEnum { id: jitter label: "Jitter" - object: Render.getConfig("RenderMainView.JitterCam") + object: Render.getConfig("RenderMainView.AntialiasingSetup") property: "state" enums: [ "Off", @@ -60,9 +60,9 @@ Column{ Separator {} Prop.PropScalar { - visible: (Render.getConfig("RenderMainView.JitterCam").state == 2) + visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 2) label: "Sample Index" - object: Render.getConfig("RenderMainView.JitterCam") + object: Render.getConfig("RenderMainView.AntialiasingSetup") property: "index" // min: -1 // max: 32 @@ -70,18 +70,27 @@ Column{ integral: true } Row { - visible: (Render.getConfig("RenderMainView.JitterCam").state == 2) + visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 2) spacing: 10 HifiControls.Button { text: "<" - onClicked: { Render.getConfig("RenderMainView.JitterCam").prev(); } + onClicked: { Render.getConfig("RenderMainView.AntialiasingSetup").prev(); } } HifiControls.Button { text: ">" - onClicked: { Render.getConfig("RenderMainView.JitterCam").next(); } + onClicked: { Render.getConfig("RenderMainView.AntialiasingSetup").next(); } } } + ConfigSlider { + label: qsTr("Jitter scale") + integral: false + config: Render.getConfig("RenderMainView.AntialiasingSetup") + property: "scale" + max: 2.0 + min: 0.25 + height: 38 + } Separator {} Prop.PropBool { label: "Constrain color" @@ -96,11 +105,19 @@ Column{ min: 0.5 } Separator {} - Prop.PropBool { - label: "Feedback history color" - object: Render.getConfig("RenderMainView.Antialiasing") - property: "feedbackColor" - } + Row { + spacing: 10 + Prop.PropBool { + label: "Feedback history color" + object: Render.getConfig("RenderMainView.Antialiasing") + property: "feedbackColor" + } + Prop.PropBool { + label: "History bicubic fetch" + object: Render.getConfig("RenderMainView.Antialiasing") + property: "bicubicHistoryFetch" + } + } Prop.PropScalar { label: "Source blend" object: Render.getConfig("RenderMainView.Antialiasing") diff --git a/scripts/developer/utilities/render/luci/Framebuffer.qml b/scripts/developer/utilities/render/luci/Framebuffer.qml index dd2b57d085e..5e0fee02689 100644 --- a/scripts/developer/utilities/render/luci/Framebuffer.qml +++ b/scripts/developer/utilities/render/luci/Framebuffer.qml @@ -61,6 +61,7 @@ Column { "Ambient Occlusion Blurred", "Ambient Occlusion Normal", "Velocity", + "Antialiasing Intensity", "Custom", ] diff --git a/tests-manual/gpu/src/TestWindow.cpp b/tests-manual/gpu/src/TestWindow.cpp index f667f20f2b1..af8c6af243f 100644 --- a/tests-manual/gpu/src/TestWindow.cpp +++ b/tests-manual/gpu/src/TestWindow.cpp @@ -28,7 +28,7 @@ extern void initDeferredPipelines(render::ShapePlumber& plumber, const render::S extern void initStencilPipeline(gpu::PipelinePointer& pipeline); #endif -TestWindow::TestWindow() { +TestWindow::TestWindow() : _generateDeferredFrameTransform(render::RenderEngine::TS_MAIN_VIEW) { setSurfaceType(QSurface::OpenGLSurface); @@ -98,7 +98,7 @@ void TestWindow::beginFrame() { _preparePrimaryFramebuffer.run(_renderContext, primaryFramebuffer); DeferredFrameTransformPointer frameTransform; - _generateDeferredFrameTransform.run(_renderContext, glm::vec2(0.0f, 0.0f), frameTransform); + _generateDeferredFrameTransform.run(_renderContext, frameTransform); LightingModelPointer lightingModel; _generateLightingModel.run(_renderContext, lightingModel); From eb20147a67e6a196f7a382655f9a490e0638c417 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Fri, 24 Jul 2020 13:17:55 -0700 Subject: [PATCH 03/34] working on building --- interface/src/graphics/GraphicsEngine.cpp | 2 +- .../src/display-plugins/OpenGLDisplayPlugin.cpp | 2 +- libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp | 1 - libraries/gpu-gl-common/src/gpu/gl/GLBackend.h | 2 ++ libraries/gpu/src/gpu/Batch.h | 2 +- libraries/gpu/src/gpu/FrameIOKeys.h | 10 ++++++++-- libraries/gpu/src/gpu/FrameReader.cpp | 2 +- libraries/gpu/src/gpu/FrameWriter.cpp | 4 ++-- libraries/render-utils/src/AntialiasingEffect.cpp | 2 +- libraries/render-utils/src/AntialiasingEffect.h | 2 -- libraries/render-utils/src/DebugDeferredBuffer.cpp | 2 +- libraries/render-utils/src/DeferredTransform.slh | 2 +- .../render-utils/src/DeferredTransform_shared.slh | 2 +- libraries/render-utils/src/HighlightEffect.h | 2 +- libraries/render-utils/src/RenderCommonTask.cpp | 2 +- libraries/render-utils/src/simple.slf | 3 ++- libraries/render-utils/src/simple.slv | 3 ++- tools/gpu-frame-player/src/RenderThread.cpp | 3 +-- 18 files changed, 27 insertions(+), 21 deletions(-) diff --git a/interface/src/graphics/GraphicsEngine.cpp b/interface/src/graphics/GraphicsEngine.cpp index bf69efd23e8..727fd3c8449 100644 --- a/interface/src/graphics/GraphicsEngine.cpp +++ b/interface/src/graphics/GraphicsEngine.cpp @@ -262,7 +262,7 @@ void GraphicsEngine::render_performFrame() { batch.enableStereo(isStereo); batch.clearDepthStencilFramebuffer(1.0, 0); batch.setViewportTransform({ 0, 0, finalFramebuffer->getSize() }); - _splashScreen->render(batch, viewFrustum, renderArgs._renderMethod == RenderArgs::RenderMethod::FORWARD); + _splashScreen->render(batch, viewFrustum, renderArgs._renderMethod == RenderArgs::RenderMethod::FORWARD, render::RenderEngine::TS_BACKGROUND_VIEW); }); } else { { diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp index a80018913ec..bfd21be9890 100644 --- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp +++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp @@ -357,7 +357,7 @@ void OpenGLDisplayPlugin::customizeContext() { auto presentThread = DependencyManager::get(); Q_ASSERT(thread() == presentThread->thread()); - getGLBackend()->updatePresentFrame(mat4(), mat4(), true); + getGLBackend()->updatePresentFrame(mat4(), true); for (auto& cursorValue : _cursorsData) { auto& cursorData = cursorValue.second; diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index 621cd34ac7e..daa3486b13a 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -344,7 +344,6 @@ void GLBackend::renderPassTransfer(const Batch& batch) { case Batch::COMMAND_setViewportTransform: case Batch::COMMAND_setViewTransform: case Batch::COMMAND_setProjectionTransform: - case Batch::COMMAND_setProjectionJitter: { CommandCall call = _commandCalls[(*command)]; (this->*(call))(batch, *offset); diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index d89adc70ddc..710f4649df7 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -121,6 +121,8 @@ class GLBackend : public Backend, public std::enable_shared_from_this // Shutdown rendering and persist any required resources void shutdown() override; + void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false); + void render(const Batch& batch) final override; // This call synchronize the Full Backend cache with the current GLState diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h index 8f0a61b7f2f..7a551af0023 100644 --- a/libraries/gpu/src/gpu/Batch.h +++ b/libraries/gpu/src/gpu/Batch.h @@ -537,7 +537,7 @@ class Batch { NamedBatchDataMap _namedData; - bool _isJitterOnProjectionEnabled{ false }; + bool _isJitterOnProjectionEnabled { false }; uint16_t _drawcallUniform{ 0 }; uint16_t _drawcallUniformReset{ 0 }; diff --git a/libraries/gpu/src/gpu/FrameIOKeys.h b/libraries/gpu/src/gpu/FrameIOKeys.h index 1a98d0decd4..6a5b7a3e461 100644 --- a/libraries/gpu/src/gpu/FrameIOKeys.h +++ b/libraries/gpu/src/gpu/FrameIOKeys.h @@ -80,7 +80,7 @@ constexpr const char* pose = "pose"; constexpr const char* profileRanges = "profileRanges"; constexpr const char* program = "program"; constexpr const char* programs = "programs"; -constexpr const char* projectionJitter = "projectionJitter"; +constexpr const char* isJitterOnProjectionEnabled = "isJitterOnProjectionEnabled"; constexpr const char* queries = "queries"; constexpr const char* sampleCount = "sampleCount"; constexpr const char* sampleMask = "sampleMask"; @@ -150,10 +150,16 @@ constexpr const char* COMMAND_NAMES[] = { "setModelTransform", "setViewTransform", "setProjectionTransform", - "setProjectionJitter", + "setProjectionJitterEnabled", + "setProjectionJitterSequence", + "setProjectionJitterScale", "setViewportTransform", "setDepthRangeTransform", + "saveViewProjectionTransform", + "setSavedViewProjectionTransform", + "copySavedViewProjectionTransformToBuffer", + "setPipeline", "setStateBlendFactor", "setStateScissorRect", diff --git a/libraries/gpu/src/gpu/FrameReader.cpp b/libraries/gpu/src/gpu/FrameReader.cpp index 96f6b99f7a6..e7e75ad0b96 100644 --- a/libraries/gpu/src/gpu/FrameReader.cpp +++ b/libraries/gpu/src/gpu/FrameReader.cpp @@ -740,7 +740,7 @@ BatchPointer Deserializer::readBatch(const json& node) { auto& batch = *result; readOptional(batch._enableStereo, node, keys::stereo); readOptional(batch._enableSkybox, node, keys::skybox); - readOptionalTransformed(batch._projectionJitter, node, keys::projectionJitter, &readVec2); + readOptional(batch._isJitterOnProjectionEnabled, node, keys::isJitterOnProjectionEnabled); readOptional(batch._drawcallUniform, node, keys::drawcallUniform); readOptional(batch._drawcallUniformReset, node, keys::drawcallUniformReset); readPointerCache(batch._textures, node, keys::textures, textures); diff --git a/libraries/gpu/src/gpu/FrameWriter.cpp b/libraries/gpu/src/gpu/FrameWriter.cpp index 761f37a620f..d2258a5382b 100644 --- a/libraries/gpu/src/gpu/FrameWriter.cpp +++ b/libraries/gpu/src/gpu/FrameWriter.cpp @@ -220,8 +220,8 @@ json Serializer::writeBatch(const Batch& batch) { if (batch._enableStereo != DEFAULT_BATCH._enableStereo) { batchNode[keys::stereo] = batch._enableStereo; } - if (batch._projectionJitter != DEFAULT_BATCH._projectionJitter) { - batchNode[keys::projectionJitter] = writeVec2(batch._projectionJitter); + if (batch._isJitterOnProjectionEnabled != DEFAULT_BATCH._isJitterOnProjectionEnabled) { + batchNode[keys::isJitterOnProjectionEnabled] = batch._isJitterOnProjectionEnabled; } if (batch._drawcallUniform != DEFAULT_BATCH._drawcallUniform) { batchNode[keys::drawcallUniform] = batch._drawcallUniform; diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index af569a72a5b..41ec9a6f65b 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -260,7 +260,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const _intensityFramebuffer->setStencilBuffer(deferredFrameBuffer->getDeferredFramebuffer()->getDepthStencilBuffer(), deferredFrameBuffer->getDeferredFramebuffer()->getDepthStencilBufferFormat()); } - outputs = _intensityTexture; + output = _intensityTexture; gpu::doInBatch("Antialiasing::run", args->_context, [&](gpu::Batch& batch) { PROFILE_RANGE_BATCH(batch, "TAA"); diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 4d24fe3a258..6be6f3a9bdf 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -219,8 +219,6 @@ class Antialiasing { gpu::FramebufferPointer _intensityFramebuffer; gpu::TexturePointer _intensityTexture; gpu::BufferPointer _blendParamsBuffer; - gpu::PipelinePointer _antialiasingPipeline; - gpu::PipelinePointer _blendPipeline; static gpu::PipelinePointer _antialiasingPipeline; static gpu::PipelinePointer _intensityPipeline; diff --git a/libraries/render-utils/src/DebugDeferredBuffer.cpp b/libraries/render-utils/src/DebugDeferredBuffer.cpp index 38db7574367..6531be84c63 100644 --- a/libraries/render-utils/src/DebugDeferredBuffer.cpp +++ b/libraries/render-utils/src/DebugDeferredBuffer.cpp @@ -411,7 +411,7 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I auto& surfaceGeometryFramebuffer = inputs.get2(); auto& ambientOcclusionFramebuffer = inputs.get3(); auto& frameTransform = inputs.get4(); - auto& lightFrame = inputs.get5(); + auto& shadowFrame = inputs.get5(); const auto& antialiasingIntensityTexture = inputs.get6(); gpu::doInBatch("DebugDeferredBuffer::run", args->_context, [&](gpu::Batch& batch) { diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index 0729258dc1b..8f77869db51 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -26,7 +26,7 @@ LAYOUT_STD140(binding=RENDER_UTILS_BUFFER_DEFERRED_FRAME_TRANSFORM) uniform defe }; vec2 getWidthHeight(int resolutionLevel) { - return vec2(ivec2(frameTransform.infos._pixelInfo.zw) >> resolutionLevel); + return vec2(ivec2(frameTransform.infos.pixelInfo.zw) >> resolutionLevel); } vec2 getInvWidthHeight() { diff --git a/libraries/render-utils/src/DeferredTransform_shared.slh b/libraries/render-utils/src/DeferredTransform_shared.slh index 7e574f0715c..2973b627ce9 100644 --- a/libraries/render-utils/src/DeferredTransform_shared.slh +++ b/libraries/render-utils/src/DeferredTransform_shared.slh @@ -30,4 +30,4 @@ struct _DeferredFrameTransform { // <@if 1@> // Trigger Scribe include // <@endif@> -// \ No newline at end of file +// diff --git a/libraries/render-utils/src/HighlightEffect.h b/libraries/render-utils/src/HighlightEffect.h index 4d5eba4f525..fd2ebc63a42 100644 --- a/libraries/render-utils/src/HighlightEffect.h +++ b/libraries/render-utils/src/HighlightEffect.h @@ -186,7 +186,7 @@ class DebugHighlight { gpu::PipelinePointer _depthPipeline; int _geometryDepthId { 0 }; bool _isDisplayEnabled { false }; - uint transformSlot; + uint _transformSlot; const gpu::PipelinePointer& getDepthPipeline(); void initializePipelines(); diff --git a/libraries/render-utils/src/RenderCommonTask.cpp b/libraries/render-utils/src/RenderCommonTask.cpp index d5775a2bf0c..4348c63dbe3 100644 --- a/libraries/render-utils/src/RenderCommonTask.cpp +++ b/libraries/render-utils/src/RenderCommonTask.cpp @@ -71,7 +71,7 @@ void DrawLayered3D::run(const RenderContextPointer& renderContext, const Inputs& auto config = std::static_pointer_cast(renderContext->jobConfig); const auto& inItems = inputs.get0(); - const auto& frameTransform = inputs.get1() + const auto& frameTransform = inputs.get1(); const auto& lightingModel = inputs.get2(); const auto& hazeFrame = inputs.get3(); diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index 768ed223ac3..6be2fc60d06 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -50,10 +50,11 @@ <@endif@> <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> - layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; <@endif@> +<@else@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> <@if HIFI_USE_FADE@> layout(location=RENDER_UTILS_ATTR_POSITION_WS) in vec4 _positionWS; diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index 174af0b120a..84caadb582b 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -25,10 +25,11 @@ <@endif@> <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> - layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; <@endif@> +<@else@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; layout(location=RENDER_UTILS_ATTR_COLOR) out vec4 _color; diff --git a/tools/gpu-frame-player/src/RenderThread.cpp b/tools/gpu-frame-player/src/RenderThread.cpp index 0089c1577bb..446200fefa6 100644 --- a/tools/gpu-frame-player/src/RenderThread.cpp +++ b/tools/gpu-frame-player/src/RenderThread.cpp @@ -122,8 +122,7 @@ void RenderThread::renderFrame(gpu::FramePointer& frame) { if (_correction != glm::mat4()) { std::unique_lock lock(_frameLock); if (_correction != glm::mat4()) { - _backend->setCameraCorrection(_correction, _activeFrame->view); - //_prevRenderView = _correction * _activeFrame->view; + _backend->updatePresentFrame(_correction, true); } } _backend->recycle(); From 49630dfbd9e7f6297719506a360769758b0ce5af Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Mon, 27 Jul 2020 13:50:36 -0700 Subject: [PATCH 04/34] it builds! --- .../src/RenderableEntityItem.cpp | 2 +- .../src/RenderableEntityItem.h | 1 + .../entities-renderer/src/paintStroke.slf | 13 ++++--- .../entities-renderer/src/paintStroke.slv | 22 ++++++++---- .../gpu-gl-common/src/gpu/gl/GLBackend.h | 2 +- libraries/gpu/src/gpu/Backend.h | 2 ++ libraries/gpu/src/gpu/Transform.slh | 6 ++++ .../render-utils/src/AntialiasingEffect.cpp | 5 ++- .../render-utils/src/AntialiasingEffect.h | 13 +++---- .../render-utils/src/DebugDeferredBuffer.h | 2 +- .../render-utils/src/DeferredBufferWrite.slh | 3 +- .../src/DeferredBufferWrite_shared.slh | 2 +- .../render-utils/src/DeferredTransform.slh | 12 +++---- .../render-utils/src/RenderDeferredTask.cpp | 30 ++++++++-------- .../render-utils/src/RenderHUDLayerTask.cpp | 12 +++---- .../render-utils/src/RenderHUDLayerTask.h | 1 + libraries/render-utils/src/grid.slf | 3 +- libraries/render-utils/src/grid.slv | 36 +++++++++++++++++++ libraries/render-utils/src/model.slf | 1 + .../render-utils/src/render-utils/grid.slp | 1 - libraries/render-utils/src/simple.slv | 6 ++-- libraries/render-utils/src/taa.slf | 7 +--- libraries/render-utils/src/taa.slh | 8 +++-- tools/gpu-frame-player/src/RenderThread.cpp | 2 +- 24 files changed, 123 insertions(+), 69 deletions(-) create mode 100644 libraries/render-utils/src/grid.slv diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp index 4c38b993b5c..f34e93eb20f 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp @@ -43,7 +43,7 @@ const Transform& EntityRenderer::getModelTransform() const { return _modelTransform; } -const Transform& EntityRenderer::getPreviousModelTransform() const { +const Transform& EntityRenderer::getPrevModelTransform() const { return _prevModelTransform; } diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index fdb342a4429..17967badefd 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/libraries/entities-renderer/src/RenderableEntityItem.h @@ -122,6 +122,7 @@ class EntityRenderer : public QObject, public std::enable_shared_from_this + <@if not HIFI_USE_FORWARD@> - layout(location=0) in vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> -layout(location=1) in vec2 _texCoord; -layout(location=2) in vec4 _color; -layout(location=3) in float _distanceFromCenter; +layout(location=RENDER_UTILS_ATTR_TEXCOORD01) in vec2 _texCoord; +layout(location=RENDER_UTILS_ATTR_COLOR) in vec4 _color; +layout(location=2) in float _distanceFromCenter; void main(void) { vec4 texel = texture(_texture, _texCoord); @@ -39,7 +42,7 @@ void main(void) { <@if HIFI_USE_TRANSLUCENT@> packDeferredFragmentTranslucent(evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb, DEFAULT_ROUGHNESS); <@else@> - packDeferredFragmentUnlit(evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb); + packDeferredFragmentUnlit(_prevPositionCS, evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb); <@endif@> <@else@> _fragColor0 = texel; diff --git a/libraries/entities-renderer/src/paintStroke.slv b/libraries/entities-renderer/src/paintStroke.slv index cf914387469..bee8e2ed9d7 100644 --- a/libraries/entities-renderer/src/paintStroke.slv +++ b/libraries/entities-renderer/src/paintStroke.slv @@ -12,18 +12,22 @@ <@include gpu/Inputs.slh@> <@include gpu/Color.slh@> + <@include gpu/Transform.slh@> <$declareStandardTransform()$> <@include paintStroke.slh@> <$declarePolyLineBuffers()$> +<@include render-utils/ShaderConstants.h@> + <@if not HIFI_USE_FORWARD@> - layout(location=0) out vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> -layout(location=1) out vec2 _texCoord; -layout(location=2) out vec4 _color; -layout(location=3) out float _distanceFromCenter; +layout(location=RENDER_UTILS_ATTR_TEXCOORD01) out vec2 _texCoord; +layout(location=RENDER_UTILS_ATTR_COLOR) out vec4 _color; +layout(location=2) out float _distanceFromCenter; void main(void) { PolylineVertex vertex = getPolylineVertex(gl_VertexID / 2); @@ -52,16 +56,20 @@ void main(void) { posEye.x += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.x; posEye.y += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.y; posEye.z += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.z; +<@if HIFI_USE_FORWARD@> <$transformEyeToClipPos(cam, posEye, gl_Position)$> -<@if not HIFI_USE_FORWARD@> +<@else@> + <$transformEyeToClipPosAndPrevClipPos(cam, posEye, gl_Position, _prevPositionCS)$> <$transformEyeToWorldDir(cam, normalEye, _normalWS)$> <@endif@> } else { vec3 normal = vertex.normal.xyz; position.xyz += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormal; +<@if HIFI_USE_FORWARD@> <$transformModelToClipPos(cam, obj, position, gl_Position)$> -<@if not HIFI_USE_FORWARD@> +<@else@> + <$transformModelToClipPosAndPrevClipPos(cam, obj, position, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, normal, _normalWS)$> <@endif@> } -} \ No newline at end of file +} diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index 710f4649df7..0fc7dc8d574 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -121,7 +121,7 @@ class GLBackend : public Backend, public std::enable_shared_from_this // Shutdown rendering and persist any required resources void shutdown() override; - void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false); + void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false) override; void render(const Batch& batch) final override; diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index c0878da3cc9..39bec795cfc 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -56,8 +56,10 @@ class Backend { virtual void render(const Batch& batch) = 0; virtual void syncCache() = 0; + virtual void syncProgram(const gpu::ShaderPointer& program) = 0; virtual void recycle() const = 0; virtual void downloadFramebuffer(const FramebufferPointer& srcFramebuffer, const Vec4i& region, QImage& destImage) = 0; + virtual void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false) = 0; virtual bool supportedTextureFormat(const gpu::Element& format) = 0; diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index d7f617d7f99..3f22fb80463 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -11,6 +11,10 @@ <@def GPU_TRANSFORM_STATE_SLH@> <@func declareStandardCameraTransform()@> + +#ifndef STANDARD_TRANSFORM_CAMERA +#define STANDARD_TRANSFORM_CAMERA + <@include gpu/ShaderConstants.h@> <@include gpu/TransformCamera_shared.slh@> @@ -101,6 +105,8 @@ vec2 cam_getInvWidthHeight() { return getTransformCamera()._stereoInfo.zw; } +#endif // STANDARD_TRANSFORM_CAMERA + <@endfunc@> <@func declareStandardObjectTransform()@> diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index 41ec9a6f65b..120439684c6 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -194,8 +194,6 @@ const gpu::PipelinePointer& Antialiasing::getDebugBlendPipeline() { } void Antialiasing::configure(const Config& config) { - _mode = (AntialiasingConfig::Mode) config.getAAMode(); - _sharpen = config.sharpen * 0.25f; if (!_isSharpenEnabled) { _sharpen = 0.0f; @@ -243,7 +241,8 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const _antialiasingTextures[1].reset(); } - if (!_antialiasingBuffers || !_intensityFramebuffer) { std::vector antiAliasingBuffers; + if (!_antialiasingBuffers || !_intensityFramebuffer) { + std::vector antiAliasingBuffers; // Link the antialiasing FBO to texture auto format = gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA); auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR, gpu::Sampler::WRAP_CLAMP); for (int i = 0; i < 2; i++) { diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 6be6f3a9bdf..5237f77723c 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -23,11 +23,10 @@ class AntialiasingSetupConfig : public render::Job::Config { Q_OBJECT - Q_PROPERTY(float scale MEMBER scale NOTIFY dirty) - Q_PROPERTY(bool freeze MEMBER freeze NOTIFY dirty) - Q_PROPERTY(bool stop MEMBER stop NOTIFY dirty) - Q_PROPERTY(int index READ getIndex NOTIFY dirty) - Q_PROPERTY(int state READ getState WRITE setState NOTIFY dirty) + Q_PROPERTY(float scale MEMBER scale NOTIFY dirty) + Q_PROPERTY(bool freeze MEMBER freeze NOTIFY dirty) + Q_PROPERTY(bool stop MEMBER stop NOTIFY dirty) + Q_PROPERTY(int index READ getIndex NOTIFY dirty) public: AntialiasingSetupConfig() : render::Job::Config(true) {} @@ -63,6 +62,8 @@ class AntialiasingSetup { using Config = AntialiasingSetupConfig; using JobModel = render::Job::Model; + AntialiasingSetup(); + void configure(const Config& config); void run(const render::RenderContextPointer& renderContext); @@ -78,7 +79,6 @@ class AntialiasingSetup { class AntialiasingConfig : public render::Job::Config { Q_OBJECT - Q_PROPERTY(int mode READ getAAMode WRITE setAAMode NOTIFY dirty) Q_PROPERTY(float blend MEMBER blend NOTIFY dirty) Q_PROPERTY(float sharpen MEMBER sharpen NOTIFY dirty) Q_PROPERTY(float covarianceGamma MEMBER covarianceGamma NOTIFY dirty) @@ -226,6 +226,7 @@ class Antialiasing { static gpu::PipelinePointer _debugBlendPipeline; TAAParamsBuffer _params; + //TODO: check if it's used AntialiasingConfig::Mode _mode{ AntialiasingConfig::TAA }; float _sharpen{ 0.15f }; bool _isSharpenEnabled{ true }; diff --git a/libraries/render-utils/src/DebugDeferredBuffer.h b/libraries/render-utils/src/DebugDeferredBuffer.h index fc3b5ccbffe..4e4104f221e 100644 --- a/libraries/render-utils/src/DebugDeferredBuffer.h +++ b/libraries/render-utils/src/DebugDeferredBuffer.h @@ -44,7 +44,7 @@ class DebugDeferredBuffer { SurfaceGeometryFramebufferPointer, AmbientOcclusionFramebufferPointer, DeferredFrameTransformPointer, - LightStage::FramePointer, + LightStage::ShadowFramePointer, gpu::TexturePointer>; using Config = DebugDeferredBufferConfig; using JobModel = render::Job::ModelI; diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index 6c69fdbc276..6f57c3fc123 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -74,7 +74,8 @@ void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 albedo, floa _fragColor0 = vec4(albedo.rgb, alpha); _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); _fragColor2 = vec4(vec3(0.0), 1.0); - _fragColor3 = vec4(0.0); + _velocity = vec4(0.0); + _lighting = vec4(0.0); } <@endif@> diff --git a/libraries/render-utils/src/DeferredBufferWrite_shared.slh b/libraries/render-utils/src/DeferredBufferWrite_shared.slh index b579925728d..a1954d10625 100644 --- a/libraries/render-utils/src/DeferredBufferWrite_shared.slh +++ b/libraries/render-utils/src/DeferredBufferWrite_shared.slh @@ -9,4 +9,4 @@ // <@if 1@> // Trigger Scribe include // <@endif@> -// \ No newline at end of file +// diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index 8f77869db51..1e21f877b98 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -63,11 +63,11 @@ float getProjectionNear() { // positive far distance of the projection float getPosLinearDepthFar() { - return -frameTransform.infos._depthInfo.z; + return -frameTransform.infos.depthInfo.z; } mat4 getViewInverse(int side) { - frameTransform.cameras[side]._viewInverse + return frameTransform.cameras[side]._viewInverse; } mat4 getView(int side) { @@ -83,11 +83,11 @@ mat4 getPreviousViewInverse(int side) { } bool isStereo() { - return frameTransform.infos._stereoInfo.x > 0.0f; + return frameTransform.infos.stereoInfo.x > 0.0f; } float getStereoSideWidth(int resolutionLevel) { - return float(int(frameTransform.infos._stereoInfo.y) >> resolutionLevel); + return float(int(frameTransform.infos.stereoInfo.y) >> resolutionLevel); } float getStereoSideHeight(int resolutionLevel) { @@ -132,11 +132,11 @@ int getStereoSide(ivec4 sideInfo) { } float evalZeyeFromZdb(float depth) { - return frameTransform.infos._depthInfo.x / (depth * frameTransform.infos._depthInfo.y + frameTransform.infos._depthInfo.z); + return frameTransform.infos.depthInfo.x / (depth * frameTransform.infos.depthInfo.y + frameTransform.infos.depthInfo.z); } float evalZdbFromZeye(float Zeye) { - return (frameTransform.infos._depthInfo.x - Zeye * frameTransform.infos._depthInfo.z) / (Zeye * frameTransform.infos._depthInfo.y); + return (frameTransform.infos.depthInfo.x - Zeye * frameTransform.infos.depthInfo.z) / (Zeye * frameTransform.infos.depthInfo.y); } vec3 evalEyeNormal(vec3 C) { diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index e3a65386433..0ce00a7a5f7 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -270,34 +270,34 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input // RenderShadowTask out const auto& shadowOut = inputs.get1(); const auto& renderShadowTaskOut = shadowOut[0]; - const auto& shadowFrame = shadowOut.get1(); + const auto& shadowFrame = shadowOut[1]; // Extract the Lighting Stages Current frame ( and zones) const auto lightingStageInputs = inputs.get2(); // Fetch the current frame stacks from all the stages - const auto stageCurrentFrames = lightingStageInputs.get0(); - const auto lightFrame = stageCurrentFrames.get0(); - const auto backgroundFrame = stageCurrentFrames.get1(); - const auto hazeFrame = stageCurrentFrames.get2(); - const auto bloomFrame = stageCurrentFrames.get3(); + const auto stageCurrentFrames = lightingStageInputs[0]; + const auto lightFrame = stageCurrentFrames[0]; + const auto backgroundFrame = stageCurrentFrames[1]; + const auto hazeFrame = stageCurrentFrames[2]; + const auto bloomFrame = stageCurrentFrames[3]; // Zones - const auto& zones = lightingStageInputs.get1(); + const auto& zones = lightingStageInputs[1]; // Light CLuster const auto& lightClusters = inputs.get3(); // PrepareDeferred out const auto& prepareDeferredOutputs = inputs.get4(); - const auto& deferredFramebuffer = prepareDeferredOutputs.get0(); + const auto& deferredFramebuffer = prepareDeferredOutputs[0]; // extraDeferredBuffer const auto& extraDeferredBuffer = inputs.get5(); - const auto& linearDepthTarget = extraDeferredBuffer.get0(); - const auto& surfaceGeometryFramebuffer = extraDeferredBuffer.get1(); - const auto& ambientOcclusionFramebuffer = extraDeferredBuffer.get2(); - const auto& ambientOcclusionUniforms = extraDeferredBuffer.get3(); - const auto& scatteringResource = extraDeferredBuffer.get4(); + const auto& linearDepthTarget = extraDeferredBuffer[0]; + const auto& surfaceGeometryFramebuffer = extraDeferredBuffer[1]; + const auto& ambientOcclusionFramebuffer = extraDeferredBuffer[2]; + const auto& ambientOcclusionUniforms = extraDeferredBuffer[3]; + const auto& scatteringResource = extraDeferredBuffer[4]; // GenerateDeferredFrameTransform out const auto& deferredFrameTransform = inputs.get6(); @@ -362,8 +362,8 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input } { // Debug the bounds of the layered objects, still look at the zbuffer - task.addJob("DrawHUDOpaqueBounds", hudOpaque); - task.addJob("DrawHUDTransparentBounds", hudTransparent); + task.addJob("DrawHUDOpaqueBounds", hudOpaque, mainViewTransformSlot); + task.addJob("DrawHUDTransparentBounds", hudTransparent, mainViewTransformSlot); } // Debugging stages diff --git a/libraries/render-utils/src/RenderHUDLayerTask.cpp b/libraries/render-utils/src/RenderHUDLayerTask.cpp index 1a75fce29de..8c2ac35c4cf 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.cpp +++ b/libraries/render-utils/src/RenderHUDLayerTask.cpp @@ -40,12 +40,12 @@ void RenderHUDLayerTask::build(JobModel& task, const render::Varying& input, ren render::ShapePlumberPointer shapePlumber, uint transformSlot) { const auto& inputs = input.get(); - const auto& primaryFramebuffer = inputs.get0(); - const auto& lightingModel = inputs.get1(); - const auto& hudOpaque = inputs.get2(); - const auto& hudTransparent = inputs.get3(); - const auto& hazeFrame = inputs.get4(); - const auto& deferredFrameTransform = inputs.get5(); + const auto& primaryFramebuffer = inputs[0]; + const auto& lightingModel = inputs[1]; + const auto& hudOpaque = inputs[2]; + const auto& hudTransparent = inputs[3]; + const auto& hazeFrame = inputs[4]; + const auto& deferredFrameTransform = inputs[5]; // Composite the HUD and HUD overlays task.addJob("HUD", primaryFramebuffer, transformSlot); diff --git a/libraries/render-utils/src/RenderHUDLayerTask.h b/libraries/render-utils/src/RenderHUDLayerTask.h index a0b0d26b854..263b3cce004 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.h +++ b/libraries/render-utils/src/RenderHUDLayerTask.h @@ -11,6 +11,7 @@ #include "LightingModel.h" #include "HazeStage.h" +#include "DeferredFrameTransform.h" class CompositeHUD { public: diff --git a/libraries/render-utils/src/grid.slf b/libraries/render-utils/src/grid.slf index 8d54dfef4a2..519506ea54f 100644 --- a/libraries/render-utils/src/grid.slf +++ b/libraries/render-utils/src/grid.slf @@ -15,6 +15,7 @@ <@if not HIFI_USE_FORWARD@> <@include DeferredBufferWrite.slh@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@else@> layout(location=0) out vec4 _fragColor0; <@endif@> @@ -43,7 +44,7 @@ void main(void) { <@if not HIFI_USE_FORWARD@> vec3 NORMAL = vec3(1.0, 0.0, 0.0); <@if not HIFI_USE_TRANSLUCENT@> - packDeferredFragmentUnlit(NORMAL, 1.0, varColor.rgb); + packDeferredFragmentUnlit(_prevPositionCS, NORMAL, 1.0, varColor.rgb); <@else@> packDeferredFragmentTranslucent(NORMAL, varColor.a, varColor.rgb, DEFAULT_ROUGHNESS); <@endif@> diff --git a/libraries/render-utils/src/grid.slv b/libraries/render-utils/src/grid.slv new file mode 100644 index 00000000000..8cca8467d89 --- /dev/null +++ b/libraries/render-utils/src/grid.slv @@ -0,0 +1,36 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// <$_SCRIBE_FILENAME$> +// Generated on <$_SCRIBE_DATE$> +// +// Created by HifiExperiments on 7/24/2020 +// Copyright 2020 Vircadia +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +<@include gpu/Inputs.slh@> +<@include gpu/Color.slh@> +<@include render-utils/ShaderConstants.h@> + +<@include gpu/Transform.slh@> +<$declareStandardTransform()$> + +layout(location=GPU_ATTR_POSITION) out vec3 varPosition; +layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; +layout(location=GPU_ATTR_NORMAL) out vec3 varNormal; +layout(location=GPU_ATTR_TEXCOORD0) out vec2 varTexCoord0; +layout(location=GPU_ATTR_COLOR) out vec4 varColor; + +void main(void) { + varTexCoord0 = inTexCoord0.st; + varColor = color_sRGBAToLinear(inColor); + + // standard transform + TransformCamera cam = getTransformCamera(); + TransformObject obj = getTransformObject(); + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> + <$transformModelToWorldDir(cam, obj, inNormal.xyz, varNormal)$> + varPosition = inPosition.xyz; +} \ No newline at end of file diff --git a/libraries/render-utils/src/model.slf b/libraries/render-utils/src/model.slf index dddcd530022..09e7c2ab7f7 100644 --- a/libraries/render-utils/src/model.slf +++ b/libraries/render-utils/src/model.slf @@ -131,6 +131,7 @@ void main(void) { _fragColor0 = vec4(albedo * isUnlitEnabled(), opacity); <@else@> packDeferredFragmentUnlit( + _prevPositionCS, evalFrontOrBackFaceNormal(normalize(_normalWS)), opacity, albedo * isUnlitEnabled()); diff --git a/libraries/render-utils/src/render-utils/grid.slp b/libraries/render-utils/src/render-utils/grid.slp index 5cf10ff6743..e5119c55e48 100644 --- a/libraries/render-utils/src/render-utils/grid.slp +++ b/libraries/render-utils/src/render-utils/grid.slp @@ -1,2 +1 @@ -VERTEX standardTransformPNTC DEFINES translucent:f forward:f \ No newline at end of file diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index 84caadb582b..c3bf87564e5 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -41,11 +41,9 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); -<@if not HIFI_USE_UNLIT@> - <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> +<@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> + <@if not HIFI_USE_UNLIT@> <$transformModelToEyeAndClipPos(cam, obj, inPosition, _positionES, gl_Position)$> - <@else@> - <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <@endif@> <@else@> <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> diff --git a/libraries/render-utils/src/taa.slf b/libraries/render-utils/src/taa.slf index 0e2c7e2ecd1..881b35074e5 100644 --- a/libraries/render-utils/src/taa.slf +++ b/libraries/render-utils/src/taa.slf @@ -26,20 +26,15 @@ void main() { return; } - nextColor = mix(mix(historyColor, sourceColor, params.blend), taa_evalFeedbackColor(sourceColor, historyColor, params.blend), float(taa_feedbackColor())); - - outFragColor = vec4(taa_resolveColor(nextColor), 1.0); - vec4 sourceColor; vec4 historyColor; - vec4 nextColor; vec2 fragVel = taa_fetchVelocityMapBest(fragUV).xy; bool needsTAA = taa_fetchSourceAndHistory(fragUV, fragVel, sourceColor, historyColor); vec4 nextColor = sourceColor; if (needsTAA) { // clamp history to neighbourhood of current sample - historyColor.rgb = mix(historyColor.rgb, taa_evalConstrainColor(sourceColor, fragUV, fragVel, historyColor).rgb, float(taa_constrainColor())); + historyColor.rgb = mix(historyColor.rgb, taa_evalConstrainColor(sourceColor.rgb, fragUV, fragVel, historyColor.rgb).rgb, float(taa_constrainColor())); if (taa_feedbackColor()) { nextColor = taa_evalFeedbackColor(sourceColor, historyColor, params.blend); diff --git a/libraries/render-utils/src/taa.slh b/libraries/render-utils/src/taa.slh index 64b034a4c6b..cf972bf4023 100644 --- a/libraries/render-utils/src/taa.slh +++ b/libraries/render-utils/src/taa.slh @@ -202,6 +202,7 @@ vec3 taa_findClosestFragment3x3(vec2 uv) vec2 dd = taa_getTexelSize(); vec2 du = vec2(dd.x, 0.0); vec2 dv = vec2(0.0, dd.y); + vec2 dm = vec2(-dd.x, dd.y); vec3 dtl = vec3(-1, -1, taa_fetchDepth(uv - dd)); vec3 dtc = vec3( 0, -1, taa_fetchDepth(uv - dv)); @@ -234,6 +235,7 @@ vec2 taa_fetchVelocityMapBest(vec2 uv) { vec2 dd = taa_getTexelSize(); vec2 du = vec2(dd.x, 0.0); vec2 dv = vec2(0.0, dd.y); + vec2 dm = vec2(dd.x, -dd.y); vec2 dtl = taa_fetchVelocityMap(uv - dd); vec2 dtc = taa_fetchVelocityMap(uv - dv); @@ -297,7 +299,7 @@ vec2 taa_computePrevFragAndEyeUV(vec2 fragUV, vec2 fragVelocity, out vec2 prevEy return taa_fromEyeUVToFragUV(prevEyeUV, stereoSide); } -vec2 taa_fetchSourceAndHistory(vec2 fragUV, vec2 fragVelocity, out vec3 sourceColor, out vec3 historyColor) { +bool taa_fetchSourceAndHistory(vec2 fragUV, vec2 fragVelocity, out vec4 sourceColor, out vec4 historyColor) { sourceColor.rgb = texture(sourceMap, fragUV).rgb; // Store AA intensity in alpha sourceColor.a = texture(intensityMap, fragUV).r; @@ -307,7 +309,7 @@ vec2 taa_fetchSourceAndHistory(vec2 fragUV, vec2 fragVelocity, out vec3 sourceCo vec2 prevEyeUV; vec2 prevFragUV = taa_computePrevFragAndEyeUV(fragUV, fragVelocity, prevEyeUV); sourceColor = taa_transformColor(sourceColor); - historyColor = mix(sourceColor, taa_fetchHistoryMap(prevFragUV).xyz, float(!(any(lessThan(prevEyeUV, vec2(0.0))) || any(greaterThan(prevEyeUV, vec2(1.0)))))); + historyColor = mix(sourceColor, taa_fetchHistoryMap(prevFragUV), float(!(any(lessThan(prevEyeUV, vec2(0.0))) || any(greaterThan(prevEyeUV, vec2(1.0)))))); return true; } else { historyColor = sourceColor; @@ -483,7 +485,7 @@ vec3 taa_evalConstrainColor(vec3 sourceColor, vec2 sourceUV, vec2 sourceVel, vec return taa_clampColor(colorMinMaxAvg[0], colorMinMaxAvg[1], sourceColor, candidateColor); } -vec3 taa_evalFeedbackColor(vec4 sourceColor, vec4 historyColor, float blendFactor) { +vec4 taa_evalFeedbackColor(vec4 sourceColor, vec4 historyColor, float blendFactor) { const float _FeedbackMin = 0.1; const float _FeedbackMax = 0.9; // feedback weight from unbiased luminance diff (t.lottes) diff --git a/tools/gpu-frame-player/src/RenderThread.cpp b/tools/gpu-frame-player/src/RenderThread.cpp index 446200fefa6..53bab44d5d9 100644 --- a/tools/gpu-frame-player/src/RenderThread.cpp +++ b/tools/gpu-frame-player/src/RenderThread.cpp @@ -119,7 +119,7 @@ void RenderThread::renderFrame(gpu::FramePointer& frame) { #ifdef USE_GL _context.makeCurrent(); #endif - if (_correction != glm::mat4()) { + { std::unique_lock lock(_frameLock); if (_correction != glm::mat4()) { _backend->updatePresentFrame(_correction, true); From ab126eb9e4c0ac876579d9868e7dcf79148b43b8 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Mon, 27 Jul 2020 15:16:52 -0700 Subject: [PATCH 05/34] small fixes --- libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp | 5 +++++ libraries/render-utils/src/AntialiasingEffect.cpp | 6 +++++- libraries/render-utils/src/BackgroundStage.cpp | 2 +- libraries/render-utils/src/DebugDeferredBuffer.cpp | 2 +- libraries/render-utils/src/DeferredFrameTransform.h | 2 -- 5 files changed, 12 insertions(+), 5 deletions(-) diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index daa3486b13a..a669080fcc4 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -344,6 +344,11 @@ void GLBackend::renderPassTransfer(const Batch& batch) { case Batch::COMMAND_setViewportTransform: case Batch::COMMAND_setViewTransform: case Batch::COMMAND_setProjectionTransform: + case Batch::COMMAND_setProjectionJitterEnabled: + case Batch::COMMAND_setProjectionJitterSequence: + case Batch::COMMAND_setProjectionJitterScale: + case Batch::COMMAND_saveViewProjectionTransform: + case Batch::COMMAND_setSavedViewProjectionTransform: { CommandCall call = _commandCalls[(*command)]; (this->*(call))(batch, *offset); diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index 120439684c6..cf58d2cd45d 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -244,7 +244,8 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const if (!_antialiasingBuffers || !_intensityFramebuffer) { std::vector antiAliasingBuffers; // Link the antialiasing FBO to texture - auto format = gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA); auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR, gpu::Sampler::WRAP_CLAMP); + auto format = gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA); + auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR, gpu::Sampler::WRAP_CLAMP); for (int i = 0; i < 2; i++) { antiAliasingBuffers.emplace_back(gpu::Framebuffer::create("antialiasing")); const auto& antiAliasingBuffer = antiAliasingBuffers.back(); @@ -285,6 +286,9 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const batch.setResourceTexture(ru::Texture::TaaVelocity, nullptr); } + batch.setResourceTexture(ru::Texture::TaaSource, sourceBuffer->getRenderBuffer(0)); + batch.setResourceTexture(ru::Texture::TaaIntensity, _intensityTexture); + // This is only used during debug batch.setResourceTexture(ru::Texture::TaaDepth, linearDepthBuffer->getLinearDepthTexture()); diff --git a/libraries/render-utils/src/BackgroundStage.cpp b/libraries/render-utils/src/BackgroundStage.cpp index 12e78de7877..ab9b87232c7 100644 --- a/libraries/render-utils/src/BackgroundStage.cpp +++ b/libraries/render-utils/src/BackgroundStage.cpp @@ -89,7 +89,7 @@ void DrawBackgroundStage::run(const render::RenderContextPointer& renderContext, batch.setStateScissorRect(args->_viewport); bool forward = args->_renderMethod == render::Args::RenderMethod::FORWARD; - batch.setProjectionJitterEnabled(forward); + batch.setProjectionJitterEnabled(!forward); // If we're using forward rendering, we need to calculate haze if (forward) { diff --git a/libraries/render-utils/src/DebugDeferredBuffer.cpp b/libraries/render-utils/src/DebugDeferredBuffer.cpp index 6531be84c63..158eb879668 100644 --- a/libraries/render-utils/src/DebugDeferredBuffer.cpp +++ b/libraries/render-utils/src/DebugDeferredBuffer.cpp @@ -232,7 +232,7 @@ static const std::string DEFAULT_VELOCITY_SHADER{ "vec4 getFragmentColor() {" " vec2 velocity = texture(debugTexture0, uv).xy * getWidthHeight(0);" " vec4 velColor = vec4(0.1f * velocity + 0.5f, 0.0f, 1.0f);" - " return dot(velocity,velocity) > 1e-4 ? velColor : vec4(0f, 0f, 1f, 0f);" + " return dot(velocity, velocity) > 1e-4 ? velColor : vec4(0.0f, 0.0f, 1.0f, 0.0f);" "}" }; diff --git a/libraries/render-utils/src/DeferredFrameTransform.h b/libraries/render-utils/src/DeferredFrameTransform.h index 9029d81786d..5d227c15f5f 100644 --- a/libraries/render-utils/src/DeferredFrameTransform.h +++ b/libraries/render-utils/src/DeferredFrameTransform.h @@ -49,8 +49,6 @@ using DeferredFrameTransformPointer = std::shared_ptr; class GenerateDeferredFrameTransform { public: - - using Input = glm::vec2; using Output = DeferredFrameTransformPointer; using JobModel = render::Job::ModelO; From ff4504a5dfd51dc63170204f0f78d2c796310b11 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Tue, 28 Jul 2020 14:31:51 -0700 Subject: [PATCH 06/34] it...seems to be working? --- interface/src/raypick/ParabolaPointer.cpp | 3 ++- interface/src/raypick/ParabolaPointer.h | 1 + .../entities-renderer/src/RenderableEntityItem.cpp | 5 ----- .../entities-renderer/src/RenderableEntityItem.h | 3 +-- .../src/RenderableGizmoEntityItem.cpp | 3 ++- .../src/RenderableLineEntityItem.cpp | 7 +++++-- .../src/RenderableMaterialEntityItem.cpp | 3 ++- .../src/RenderableModelEntityItem.cpp | 4 +++- .../src/RenderableParticleEffectEntityItem.cpp | 6 +++--- .../src/RenderablePolyLineEntityItem.cpp | 2 ++ .../src/RenderablePolyVoxEntityItem.cpp | 3 ++- .../src/RenderableShapeEntityItem.cpp | 5 ++++- .../src/RenderableTextEntityItem.cpp | 11 ++++++++--- .../entities-renderer/src/RenderableTextEntityItem.h | 1 + .../entities-renderer/src/RenderableWebEntityItem.cpp | 3 ++- libraries/gpu/src/gpu/Transform.slh | 10 +++++----- .../render-utils/src/CauterizedMeshPartPayload.cpp | 3 ++- libraries/render-utils/src/MeshPartPayload.cpp | 2 +- libraries/render-utils/src/MeshPartPayload.h | 1 + libraries/render-utils/src/RenderDeferredTask.cpp | 8 ++++---- libraries/render-utils/src/model.slv | 2 +- libraries/render-utils/src/web_browser.slv | 4 ++-- 22 files changed, 54 insertions(+), 36 deletions(-) diff --git a/interface/src/raypick/ParabolaPointer.cpp b/interface/src/raypick/ParabolaPointer.cpp index 5f045c55046..22fb47e5d3f 100644 --- a/interface/src/raypick/ParabolaPointer.cpp +++ b/interface/src/raypick/ParabolaPointer.cpp @@ -444,7 +444,8 @@ void ParabolaPointer::RenderState::ParabolaRenderItem::render(RenderArgs* args) Transform transform; transform.setTranslation(_origin); - batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevTransform); + _prevTransform = transform; batch.setPipeline(getParabolaPipeline(args->_renderMethod == render::Args::RenderMethod::FORWARD)); diff --git a/interface/src/raypick/ParabolaPointer.h b/interface/src/raypick/ParabolaPointer.h index 59168be5edb..bccccb73441 100644 --- a/interface/src/raypick/ParabolaPointer.h +++ b/interface/src/raypick/ParabolaPointer.h @@ -62,6 +62,7 @@ class ParabolaPointer : public PathPointer { render::ItemKey _key; glm::vec3 _origin { 0.0f }; + Transform _prevTransform; bool _isVisibleInSecondaryCamera { DEFAULT_PARABOLA_ISVISIBLEINSECONDARYCAMERA }; bool _drawInFront { DEFAULT_PARABOLA_DRAWINFRONT }; bool _visible { false }; diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp index f34e93eb20f..212baa66340 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp @@ -43,10 +43,6 @@ const Transform& EntityRenderer::getModelTransform() const { return _modelTransform; } -const Transform& EntityRenderer::getPrevModelTransform() const { - return _prevModelTransform; -} - void EntityRenderer::makeStatusGetters(const EntityItemPointer& entity, Item::Status::Getters& statusGetters) { auto nodeList = DependencyManager::get(); // DANGER: nodeList->getSessionUUID() will return null id when not connected to domain. @@ -418,7 +414,6 @@ void EntityRenderer::updateModelTransformAndBound(const EntityItemPointer& entit bool success = false; auto newModelTransform = getTransformToCenterWithMaybeOnlyLocalRotation(entity, success); if (success) { - _prevModelTransform = _modelTransform; _modelTransform = newModelTransform; } diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index 17967badefd..78f99277176 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/libraries/entities-renderer/src/RenderableEntityItem.h @@ -122,7 +122,6 @@ class EntityRenderer : public QObject, public std::enable_shared_from_this_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition(), true)); - batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; Pipeline pipelineType = getPipelineType(materials); if (pipelineType == Pipeline::PROCEDURAL) { diff --git a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp index a36cdde2123..6250edc4085 100644 --- a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp @@ -44,12 +44,15 @@ void LineEntityRenderer::doRender(RenderArgs* args) { PerformanceTimer perfTimer("RenderableLineEntityItem::render"); Q_ASSERT(args->_batch); gpu::Batch& batch = *args->_batch; + const auto& modelTransform = getModelTransform(); - Transform transform = Transform(); + Transform transform; transform.setTranslation(modelTransform.getTranslation()); transform.setRotation(BillboardModeHelpers::getBillboardRotation(modelTransform.getTranslation(), modelTransform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; + if (_linePoints.size() > 1) { DependencyManager::get()->bindSimpleProgram(batch, false, false, false, false, true, _renderLayer != RenderLayer::WORLD || args->_renderMethod == Args::RenderMethod::FORWARD); diff --git a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp index b8f829f4ba3..9c6fd81259f 100644 --- a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp @@ -305,7 +305,8 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch.setModelTransform(transform); + batch.setModelTransform(renderTransform, _prevRenderTransform); + _prevRenderTransform = renderTransform; if (!proceduralRender) { drawMaterial->setTextureTransforms(textureTransform, MaterialMappingMode::UV, true); diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index fa151689718..5e6166c9c7a 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp @@ -1472,7 +1472,9 @@ void ModelEntityRenderer::doRender(RenderArgs* args) { // If the model doesn't have visual geometry, render our bounding box as green wireframe static glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f); gpu::Batch& batch = *args->_batch; - batch.setModelTransform(getModelTransform()); // we want to include the scale as well + Transform transform = getModelTransform(); + batch.setModelTransform(transform, _prevRenderTransform); // we want to include the scale as well + _prevRenderTransform = transform; auto geometryCache = DependencyManager::get(); geometryCache->renderWireCubeInstance(args, batch, greenColor, geometryCache->getShapePipelinePointer(false, false, args->_renderMethod == Args::RenderMethod::FORWARD)); diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp index e2a57840d93..29e0d58b6bc 100644 --- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp @@ -31,7 +31,7 @@ static ShapePipelinePointer shapePipelineFactory(const ShapePlumber& plumber, co state->setDepthTest(true, false, gpu::LESS_EQUAL); state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE, gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE); - PrepareStencil::testMask(*state); + PrepareStencil::testMaskResetNoAA(*state); auto program = gpu::Shader::createProgram(shader::entities_renderer::program::textured_particle); _texturedPipeline = texturedPipeline = gpu::Pipeline::create(program, state); @@ -455,7 +455,7 @@ void ParticleEffectEntityRenderer::doRender(RenderArgs* args) { color.finish = EntityRenderer::calculatePulseColor(_particleProperties.getColorFinish(), _pulseProperties, _created); color.spread = EntityRenderer::calculatePulseColor(_particleProperties.getColorSpread(), _pulseProperties, _created); - batch.setModelTransform(transform); + batch.setModelTransform(transform); // particles are currently always transparent so we don't worry about TAA right now batch.setUniformBuffer(0, _uniformBuffer); batch.setInputFormat(_vertexFormat); @@ -589,4 +589,4 @@ void ParticleEffectEntityRenderer::computeTriangles(const hfm::Model& hfmModel) glm::vec3 scale = bounds.getScale(); _triangleInfo.transform = glm::scale(1.0f / scale) * glm::translate(-bounds.calcCenter()); -} \ No newline at end of file +} diff --git a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp index aca501985a0..d583e8858d1 100644 --- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp @@ -330,6 +330,8 @@ void PolyLineEntityRenderer::doRender(RenderArgs* args) { batch.setModelTransform(transform); batch.setPipeline(_pipelines[{args->_renderMethod, isTransparent()}]); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; batch.setResourceTexture(0, texture); batch.draw(gpu::TRIANGLE_STRIP, (gpu::uint32)(2 * _numVertices), 0); } diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp index 8331e016fdc..24903c2d3d8 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp @@ -1863,7 +1863,8 @@ void PolyVoxEntityRenderer::doRender(RenderArgs* args) { glm::mat4 rotation = glm::mat4_cast(BillboardModeHelpers::getBillboardRotation(_position, _orientation, _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); Transform transform(glm::translate(_position) * rotation * _lastVoxelToLocalMatrix); - batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; batch.setInputFormat(_vertexFormat); batch.setInputBuffer(gpu::Stream::POSITION, _mesh->getVertexBuffer()._buffer, 0, diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp index a6fee033115..483ee28430a 100644 --- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp @@ -112,8 +112,11 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) { auto geometryCache = DependencyManager::get(); GeometryCache::Shape geometryShape = geometryCache->getShapeForEntityShape(_shape); Transform transform; + Transform prevTransform; withReadLock([&] { transform = _renderTransform; + prevTransform = _prevRenderTransform; + _prevRenderTransform = _renderTransform; }); bool wireframe = render::ShapeKey(args->_globalShapeKey).isWireframe() || _primitiveMode == PrimitiveMode::LINES; @@ -121,7 +124,7 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition(), _shape < entity::Shape::Cube || _shape > entity::Shape::Icosahedron)); - batch.setModelTransform(transform); + batch.setModelTransform(transform, prevTransform); Pipeline pipelineType = getPipelineType(materials); if (pipelineType == Pipeline::PROCEDURAL) { diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp index 2858e12afdc..09e10bc73a3 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp @@ -159,14 +159,17 @@ void TextEntityRenderer::doRender(RenderArgs* args) { bool transparent; Transform transform; + Transform prevTransform; withReadLock([&] { transparent = isTransparent(); transform = _renderTransform; + prevTransform = _prevRenderTransform; + transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, + args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); + _prevRenderTransform = transform; }); - transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, - args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch.setModelTransform(transform); + batch.setModelTransform(transform, prevTransform); Pipeline pipelineType = getPipelineType(materials); if (pipelineType == Pipeline::PROCEDURAL) { @@ -359,6 +362,8 @@ void entities::TextPayload::render(RenderArgs* args) { transform.postTranslate(glm::vec3(-0.5, 0.5, 1.0f + EPSILON / dimensions.z)); transform.setScale(scale); batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; glm::vec2 bounds = glm::vec2(dimensions.x - (textRenderable->_leftMargin + textRenderable->_rightMargin), dimensions.y - (textRenderable->_topMargin + textRenderable->_bottomMargin)); textRenderer->draw(batch, textRenderable->_leftMargin / scale, -textRenderable->_topMargin / scale, bounds / scale, scale, diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.h b/libraries/entities-renderer/src/RenderableTextEntityItem.h index 8a18554dea3..738d93704f1 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.h +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.h @@ -105,6 +105,7 @@ class TextPayload { protected: QUuid _entityID; std::weak_ptr _textRenderer; + Transform _prevRenderTransform; int _geometryID { 0 }; }; diff --git a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp index 26cf4cb5454..929ae8a034b 100644 --- a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp @@ -318,7 +318,8 @@ void WebEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch.setModelTransform(transform); + batch.setModelTransform(transform, _prevRenderTransform); + _prevRenderTransform = transform; // Turn off jitter for these entities batch.pushProjectionJitterEnabled(false); diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index 3f22fb80463..dc9dac16c49 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -185,13 +185,13 @@ TransformObject getTransformObject() { } <@endfunc@> -<@func transformModelToPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWorldAlignedPos)@> +<@func transformModelToPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, prevEyeWorldAlignedPos)@> { // transformModelToPrevEyeWorldAlignedPos highp mat4 _mv = <$objectTransform$>._previousModel; _mv[3].xyz -= <$cameraTransform$>._previousViewInverse[3].xyz; - highp vec4 _eyeWApos = (_mv * <$modelPos$>); - <$eyeWorldAlignedPos$> = _eyeWApos; + highp vec4 _prevEyeWApos = (_mv * <$modelPos$>); + <$prevEyeWorldAlignedPos$> = _prevEyeWApos; } <@endfunc@> @@ -275,8 +275,8 @@ TransformObject getTransformObject() { } <@endfunc@> -<@func transformModelToWorldAndEyeAndClipPos(cameraTransform, objectTransform, modelPos, worldPos, eyePos, clipPos)@> - { // transformModelToWorldAndEyeAndClipPos +<@func transformModelToWorldEyeAndClipPos(cameraTransform, objectTransform, modelPos, worldPos, eyePos, clipPos)@> + { // transformModelToWorldEyeAndClipPos vec4 eyeWAPos; <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$> <$worldPos$> = vec4(eyeWAPos.xyz + <$cameraTransform$>._viewInverse[3].xyz, 1.0); diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp index dc1ffb7b671..28e95f27088 100644 --- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp +++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp @@ -77,7 +77,8 @@ void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const Transform if (_cauterizedClusterBuffer) { batch.setUniformBuffer(graphics::slot::buffer::Skinning, _cauterizedClusterBuffer); } - batch.setModelTransform(_cauterizedTransform); + batch.setModelTransform(_cauterizedTransform, _previousModelTransform); + _previousModelTransform = _cauterizedTransform; } else { ModelMeshPartPayload::bindTransform(batch, transform, renderMode); } diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp index e1d7d4afda0..03e77a0ff8b 100644 --- a/libraries/render-utils/src/MeshPartPayload.cpp +++ b/libraries/render-utils/src/MeshPartPayload.cpp @@ -162,7 +162,6 @@ void ModelMeshPartPayload::computeAdjustedLocalBound(const std::vector - <$transformModelToWorldAndEyeAndClipPosAndPrevClipPos(cam, obj, positionMS, _positionWS, _positionES, gl_Position, _prevPositionCS)$> + <$transformModelToWorldEyeClipPosAndPrevClipPos(cam, obj, positionMS, _positionWS, _positionES, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, normalMS, _normalWS)$> <@else@> <$transformModelToClipPos(cam, obj, positionMS, gl_Position)$> diff --git a/libraries/render-utils/src/web_browser.slv b/libraries/render-utils/src/web_browser.slv index 157f4a3cd24..d10128e1920 100644 --- a/libraries/render-utils/src/web_browser.slv +++ b/libraries/render-utils/src/web_browser.slv @@ -34,9 +34,9 @@ void main(void) { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); <@if HIFI_USE_FORWARD@> - <$transformModelToWorldAndEyeAndClipPos(cam, obj, inPosition, _positionWS, _positionES, gl_Position)$> + <$transformModelToWorldEyeAndClipPos(cam, obj, inPosition, _positionWS, _positionES, gl_Position)$> <@else@> - <$transformModelToClipPosAndPrevClip(cam, obj, inPosition, gl_Position, _prevPositionCS)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, inNormal.xyz, _normalWS)$> <@endif@> } \ No newline at end of file From 97fc5b311e3db045589005189e5cd5b11af27a31 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Wed, 29 Jul 2020 11:47:36 -0700 Subject: [PATCH 07/34] trying to fix qml --- .../render-utils/src/AntialiasingEffect.cpp | 37 ++++++++++++++++--- .../render-utils/src/AntialiasingEffect.h | 13 ++++--- .../render-utils/src/RenderDeferredTask.cpp | 4 +- .../utilities/render/luci/Antialiasing.qml | 29 +++++++-------- 4 files changed, 55 insertions(+), 28 deletions(-) diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index cf58d2cd45d..09c33782244 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -40,7 +40,27 @@ gpu::PipelinePointer Antialiasing::_debugBlendPipeline; #define TAA_JITTER_SEQUENCE_LENGTH 16 void AntialiasingSetupConfig::setIndex(int current) { - _index = (current) % TAA_JITTER_SEQUENCE_LENGTH; + _index = (current + TAA_JITTER_SEQUENCE_LENGTH) % TAA_JITTER_SEQUENCE_LENGTH; + emit dirty(); +} + +void AntialiasingSetupConfig::setState(int state) { + _state = (state) % 3; + switch (_state) { + case 0: { + none(); + break; + } + case 1: { + pause(); + break; + } + case 2: + default: { + play(); + break; + } + } emit dirty(); } @@ -114,11 +134,13 @@ void AntialiasingSetup::configure(const Config& config) { _freezedSampleIndex = config.getIndex(); } _scale = config.scale; + + _mode = config.mode; } -void AntialiasingSetup::run(const render::RenderContextPointer& renderContext) { +void AntialiasingSetup::run(const render::RenderContextPointer& renderContext, Output& output) { assert(renderContext->args); - if (!_isStopped) { + if (!_isStopped && _mode == AntialiasingSetupConfig::Mode::TAA) { RenderArgs* args = renderContext->args; gpu::doInBatch("AntialiasingSetup::run", args->_context, [&](gpu::Batch& batch) { @@ -132,6 +154,8 @@ void AntialiasingSetup::run(const render::RenderContextPointer& renderContext) { batch.setProjectionJitterScale(_scale); }); } + + output = _mode; } Antialiasing::Antialiasing(bool isSharpenEnabled) : @@ -208,7 +232,7 @@ void Antialiasing::configure(const Config& config) { _params.edit().debugShowVelocityThreshold = config.debugShowVelocityThreshold; _params.edit().regionInfo.x = config.debugX; - _params.edit().regionInfo.z = config.debugFXAAX; + _debugFXAAX = config.debugFXAAX; _params.edit().setBicubicHistoryFetch(config.bicubicHistoryFetch); @@ -231,7 +255,10 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const const auto& sourceBuffer = deferredFrameBuffer->getLightingFramebuffer(); const auto& linearDepthBuffer = inputs.get2(); const auto& velocityTexture = deferredFrameBuffer->getDeferredVelocityTexture(); - + const auto& mode = inputs.get3(); + + _params.edit().regionInfo.z = mode == AntialiasingSetupConfig::Mode::TAA ? _debugFXAAX : 0.0f; + int width = sourceBuffer->getWidth(); int height = sourceBuffer->getHeight(); diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 5237f77723c..696ba5daaa0 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -60,12 +60,13 @@ class AntialiasingSetup { public: using Config = AntialiasingSetupConfig; - using JobModel = render::Job::Model; + using Output = int; + using JobModel = render::Job::ModelO; AntialiasingSetup(); void configure(const Config& config); - void run(const render::RenderContextPointer& renderContext); + void run(const render::RenderContextPointer& renderContext, Output& output); private: @@ -128,6 +129,7 @@ class AntialiasingConfig : public render::Job::Config { void setDebugFXAA(bool debug) { debugFXAAX = (debug ? 0.0f : 1.0f); emit dirty();} bool debugFXAA() const { return (debugFXAAX == 0.0f ? true : false); } + // TODO: _mode appears in 2 different classes int _mode{ TAA }; // '_' prefix but not private? float blend { 0.2f }; @@ -197,7 +199,7 @@ using TAAParamsBuffer = gpu::StructBuffer; class Antialiasing { public: - using Inputs = render::VaryingSet3; + using Inputs = render::VaryingSet4; using Outputs = gpu::TexturePointer; using Config = AntialiasingConfig; using JobModel = render::Job::ModelIO; @@ -228,8 +230,9 @@ class Antialiasing { TAAParamsBuffer _params; //TODO: check if it's used AntialiasingConfig::Mode _mode{ AntialiasingConfig::TAA }; - float _sharpen{ 0.15f }; - bool _isSharpenEnabled{ true }; + float _sharpen { 0.15f }; + bool _isSharpenEnabled { true }; + float _debugFXAAX { 0.0f }; }; #endif // hifi_AntialiasingEffect_h diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index 0ce18ae0516..2a4026881b2 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -140,7 +140,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren fadeEffect->build(task, opaques); - task.addJob("AntialiasingSetup"); + const auto antialiasingMode = task.addJob("AntialiasingSetup"); // GPU jobs: Start preparing the primary, deferred and lighting buffer const auto scaledPrimaryFramebuffer = task.addJob("PreparePrimaryBufferDeferred"); @@ -221,7 +221,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, shapePlumberForward, false, true, mainViewTransformSlot); // AA job before bloom to limit flickering - const auto antialiasingInputs = Antialiasing::Inputs(deferredFrameTransform, deferredFramebuffer, linearDepthTarget).asVarying(); + const auto antialiasingInputs = Antialiasing::Inputs(deferredFrameTransform, deferredFramebuffer, linearDepthTarget, antialiasingMode).asVarying(); const auto antialiasingIntensityTexture = task.addJob("Antialiasing", antialiasingInputs); // Add bloom diff --git a/scripts/developer/utilities/render/luci/Antialiasing.qml b/scripts/developer/utilities/render/luci/Antialiasing.qml index 5a494a12e17..c279459b222 100644 --- a/scripts/developer/utilities/render/luci/Antialiasing.qml +++ b/scripts/developer/utilities/render/luci/Antialiasing.qml @@ -38,7 +38,7 @@ Column{ Prop.PropEnum { label: "Deferred AA Method" - object: Render.getConfig("RenderMainView.Antialiasing") + object: Render.getConfig("RenderMainView.AntialiasingSetup") property: "mode" enums: [ "Off", @@ -53,14 +53,14 @@ Column{ property: "state" enums: [ "Off", - "On", "Paused", + "On", ] } Separator {} Prop.PropScalar { - visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 2) + visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 1) label: "Sample Index" object: Render.getConfig("RenderMainView.AntialiasingSetup") property: "index" @@ -70,7 +70,7 @@ Column{ integral: true } Row { - visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 2) + visible: (Render.getConfig("RenderMainView.AntialiasingSetup").state == 1) spacing: 10 HifiControls.Button { @@ -105,18 +105,15 @@ Column{ min: 0.5 } Separator {} - Row { - spacing: 10 - Prop.PropBool { - label: "Feedback history color" - object: Render.getConfig("RenderMainView.Antialiasing") - property: "feedbackColor" - } - Prop.PropBool { - label: "History bicubic fetch" - object: Render.getConfig("RenderMainView.Antialiasing") - property: "bicubicHistoryFetch" - } + Prop.PropBool { + label: "Feedback history color" + object: Render.getConfig("RenderMainView.Antialiasing") + property: "feedbackColor" + } + Prop.PropBool { + label: "History bicubic fetch" + object: Render.getConfig("RenderMainView.Antialiasing") + property: "bicubicHistoryFetch" } Prop.PropScalar { label: "Source blend" From 158904e937852735ddb90a36cc7c47a2c53dbeaf Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Wed, 5 Aug 2020 13:19:02 -0700 Subject: [PATCH 08/34] possible improvement for skybox jittering? --- libraries/gpu/src/gpu/Backend.cpp | 2 +- libraries/graphics/src/graphics/skybox.slf | 28 ++++----- libraries/graphics/src/graphics/skybox.slh | 59 +++++++++++++++++++ libraries/graphics/src/graphics/skybox.slv | 7 +++ .../src/procedural/proceduralSkybox.slf | 20 +++---- 5 files changed, 88 insertions(+), 28 deletions(-) create mode 100644 libraries/graphics/src/graphics/skybox.slh diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 3a0b650bece..0b08ffff1a5 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -103,7 +103,7 @@ const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const // This may sound counter-intuitive to use the same jitter value but in fact it is needed. // Think of it this way: // If we have no velocity (no camera or object movement) then we wish to reproject to exactly - // the same pixel value. The current pixel UV when computing the motion vectoris trivially computed + // the same pixel value. The current pixel UV when computing the motion vector is trivially computed // from the fragment coordinates but the previous UV is computed conceptually with an unjittered // projection * previous view matrix in the vertex shader and sent to the fragment to write in the // motion vector as an interpolated attribute. But since the current projection * view matrix is diff --git a/libraries/graphics/src/graphics/skybox.slf b/libraries/graphics/src/graphics/skybox.slf index 4ae53a657f6..315c6ce40f1 100755 --- a/libraries/graphics/src/graphics/skybox.slf +++ b/libraries/graphics/src/graphics/skybox.slf @@ -11,6 +11,8 @@ // <@include graphics/ShaderConstants.h@> +<@include skybox.slh@> + <@if HIFI_USE_FORWARD@> <@include gpu/Transform.slh@> <$declareStandardCameraTransform()$> @@ -19,20 +21,16 @@ <$declareLightBuffer()$> <@include graphics/Haze.slh@> -<@endif@> - -LAYOUT(binding=GRAPHICS_TEXTURE_SKYBOX) uniform samplerCube cubeMap; -struct Skybox { - vec4 color; -}; - -LAYOUT(binding=GRAPHICS_BUFFER_SKYBOX_PARAMS) uniform skyboxBuffer { - Skybox skybox; -}; + layout(location=0) out vec4 _fragColor; +<@else@> + <$declarePackDeferredFragmentSky()$> +<@endif@> -layout(location=0) in vec3 _normal; -layout(location=0) out vec4 _fragColor; +layout(location=0) in vec3 _normal; +<@if not HIFI_USE_FORWARD@> + layout(location=1) in vec4 _prevPositionCS; +<@endif@> void main(void) { // FIXME: For legacy reasons, when skybox.color.a is 0.5, this is equivalent to: @@ -44,10 +42,10 @@ void main(void) { vec3 normal = normalize(_normal); vec3 skyboxTexel = texture(cubeMap, normal).rgb; vec3 skyboxColor = skybox.color.rgb; - _fragColor = vec4(mix(vec3(1.0), skyboxTexel, float(skybox.color.a > 0.0)) * - mix(vec3(1.0), skyboxColor, float(skybox.color.a < 1.0)), 1.0); + vec3 color = mix(vec3(1.0), skyboxTexel, float(skybox.color.a > 0.0)) * mix(vec3(1.0), skyboxColor, float(skybox.color.a < 1.0)); <@if HIFI_USE_FORWARD@> + _fragColor = vec4(color, 1.0); // FIXME: either move this elsewhere or give it access to isHazeEnabled() (which is in render-utils/LightingModel.slh) if (/*(isHazeEnabled() > 0.0) && */(hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) { TransformCamera cam = getTransformCamera(); @@ -63,6 +61,8 @@ void main(void) { vec4 hazeColor = computeHazeColor(fragPositionES.xyz, fragPositionWS.xyz, eyePositionWS.xyz, lightDirectionWS); _fragColor.rgb = mix(_fragColor.rgb, hazeColor.rgb, hazeColor.a); } +<@else@> + packDeferredFragmentSky(_prevPositionCS, color); <@endif@> } diff --git a/libraries/graphics/src/graphics/skybox.slh b/libraries/graphics/src/graphics/skybox.slh new file mode 100644 index 00000000000..a99a462cedf --- /dev/null +++ b/libraries/graphics/src/graphics/skybox.slh @@ -0,0 +1,59 @@ + +<@if not SKYBOX_SLH@> +<@def SKYBOX_SLH@> + +<@include gpu/Transform.slh@> +<$declareStandardCameraTransform()$> + +LAYOUT(binding=GRAPHICS_TEXTURE_SKYBOX) uniform samplerCube cubeMap; + +struct Skybox { + vec4 color; +}; + +LAYOUT(binding=GRAPHICS_BUFFER_SKYBOX_PARAMS) uniform skyboxBuffer { + Skybox skybox; +}; + +<@func declarePackDeferredFragmentSky()@> +// This code is duplicated from render-utils/VelocityWrite.slh because graphics can't include render-utils, but ideally this would only be in one place + +vec2 getEyeTexcoordPos() { + // No need to add 0.5 as, by default, frag coords are pixel centered at (0.5, 0.5) + vec2 texCoordPos = gl_FragCoord.xy; + texCoordPos *= cam_getInvWidthHeight(); + texCoordPos.x -= cam_getStereoSide(); + return texCoordPos; +} + +vec2 packVelocity(vec4 prevPositionCS) { + vec2 uv = getEyeTexcoordPos(); + vec2 prevUV = (prevPositionCS.xy / prevPositionCS.w) * 0.5 + 0.5; + vec2 deltaUV = uv - prevUV; + // Velocity should be computed without any jitter inside. + return deltaUV; +} + +//layout(location = 0) out vec4 _fragColor0; // albedo / metallic +//layout(location = 1) out vec4 _fragColor1; // normal +//layout(location = 2) out vec4 _fragColor2; // scattering / emissive / occlusion +layout(location = 3) out vec4 _velocity; // velocity +layout(location = 4) out vec4 _lighting; // emissive + +void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color) { + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(color, 1.0); +} + +<@endfunc@> + +<@endif@> diff --git a/libraries/graphics/src/graphics/skybox.slv b/libraries/graphics/src/graphics/skybox.slv index 91f5e1dcd96..d52bacfcc0d 100755 --- a/libraries/graphics/src/graphics/skybox.slv +++ b/libraries/graphics/src/graphics/skybox.slv @@ -14,6 +14,9 @@ <$declareStandardTransform()$> layout(location=0) out vec3 _normal; +<@if not HIFI_USE_FORWARD@> + layout(location=1) out vec4 _prevPositionCS; +<@endif@> void main(void) { const float depth = 0.0; @@ -30,6 +33,10 @@ void main(void) { vec3 eyeDir; <$transformClipToEyeDir(cam, clipDir, eyeDir)$> <$transformEyeToWorldDir(cam, eyeDir, _normal)$> + +<@if not HIFI_USE_FORWARD@> + _prevPositionCS = cam._previousProjectionViewUntranslated * (cam._viewInverse * (cam._projectionInverse * vec4(clipDir, 1.0))); +<@endif@> // Position is supposed to come in clip space gl_Position = vec4(clipDir, 1.0); diff --git a/libraries/procedural/src/procedural/proceduralSkybox.slf b/libraries/procedural/src/procedural/proceduralSkybox.slf index f938e0b9a2f..a899695c14a 100644 --- a/libraries/procedural/src/procedural/proceduralSkybox.slf +++ b/libraries/procedural/src/procedural/proceduralSkybox.slf @@ -12,21 +12,14 @@ // <@include graphics/ShaderConstants.h@> -LAYOUT(binding=GRAPHICS_TEXTURE_SKYBOX) uniform samplerCube cubeMap; - -struct Skybox { - vec4 color; -}; - -LAYOUT(binding=GRAPHICS_BUFFER_SKYBOX_PARAMS) uniform skyboxBuffer { - Skybox skybox; -}; - -layout(location=0) in vec3 _normal; -layout(location=0) out vec4 _fragColor; +<@include graphics/skybox.slh@> +<$declarePackDeferredFragmentSky()$> <@include procedural/ProceduralCommon.slh@> +layout(location=0) in vec3 _normal; +layout(location=1) in vec4 _prevPositionCS; + #line 1001 //PROCEDURAL_BLOCK_BEGIN vec3 getSkyboxColor() { @@ -42,5 +35,6 @@ void main(void) { color = max(color, vec3(0)); // Procedural Shaders are expected to be Gamma corrected so let's bring back the RGB in linear space for the rest of the pipeline color = pow(color, vec3(2.2)); - _fragColor = vec4(color, 1.0); + + packDeferredFragmentSky(_prevPositionCS, color); } From a9938bb664dfc4227d3ca86e75a5c10deea09fcf Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Wed, 5 Aug 2020 16:17:35 -0700 Subject: [PATCH 09/34] fix unlit transparent simples + models not showing up --- .../render-utils/src/DeferredBufferWrite.slh | 11 +++++++++ libraries/render-utils/src/model.slf | 17 +++++++++++-- libraries/render-utils/src/simple.slf | 24 +++++++++++++++---- libraries/render-utils/src/simple.slv | 4 ++++ 4 files changed, 50 insertions(+), 6 deletions(-) diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index 6f57c3fc123..aeefd437c72 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -78,4 +78,15 @@ void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 albedo, floa _lighting = vec4(0.0); } +void packDeferredFragmentTranslucentUnlit(vec4 prevPositionCS, vec3 normal, float alpha, vec3 color) { + if (alpha <= 0.0) { + discard; + } + _fragColor0 = vec4(color, alpha); + _fragColor1 = vec4(packNormal(normal), 1.0); + _fragColor2 = vec4(vec3(0.0), 1.0); + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); + _lighting = vec4(color, 1.0); +} + <@endif@> diff --git a/libraries/render-utils/src/model.slf b/libraries/render-utils/src/model.slf index 09e7c2ab7f7..401c8c97488 100644 --- a/libraries/render-utils/src/model.slf +++ b/libraries/render-utils/src/model.slf @@ -31,7 +31,14 @@ <@endif@> <@include gpu/Transform.slh@> <$declareStandardCameraTransform()$> - layout(location=0) out vec4 _fragColor0; + + <@if HIFI_USE_FORWARD@> + layout(location=0) out vec4 _fragColor0; + <@elif HIFI_USE_UNLIT and HIFI_USE_TRANSLUCENT@> + <@include DeferredBufferWrite.slh@> + <@else@> + layout(location=0) out vec4 _fragColor0; + <@endif@> <@else@> <@include DeferredBufferWrite.slh@> <@endif@> @@ -127,8 +134,14 @@ void main(void) { <@if HIFI_USE_SHADOW@> _fragColor0 = vec4(1.0); - <@elif HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> + <@elif HIFI_USE_FORWARD@> _fragColor0 = vec4(albedo * isUnlitEnabled(), opacity); + <@elif HIFI_USE_TRANSLUCENT@> + packDeferredFragmentTranslucentUnlit( + _prevPositionCS, + evalFrontOrBackFaceNormal(normalize(_normalWS)), + opacity, + albedo * isUnlitEnabled()); <@else@> packDeferredFragmentUnlit( _prevPositionCS, diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index 6be2fc60d06..bcac5b09bf2 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -21,9 +21,15 @@ <$declareStandardCameraTransform()$> <@else@> <@include LightingModel.slh@> + <@endif@> <@endif@> +<@if HIFI_USE_FORWARD@> layout(location=0) out vec4 _fragColor0; +<@elif HIFI_USE_TRANSLUCENT@> + <@if not HIFI_USE_UNLIT@> + layout(location=0) out vec4 _fragColor0; + <@endif@> <@endif@> <@if not HIFI_USE_UNLIT@> @@ -38,9 +44,7 @@ <@endif@> <@else@> <@if not HIFI_USE_FORWARD@> - <@if not HIFI_USE_TRANSLUCENT@> - <@include DeferredBufferWrite.slh@> - <@endif@> + <@include DeferredBufferWrite.slh@> <@endif@> <@endif@> @@ -52,6 +56,8 @@ <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; + <@elif not HIFI_USE_FORWARD@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> <@else@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; @@ -137,12 +143,22 @@ void main(void) { DEFAULT_SCATTERING); <@endif@> <@else@> - <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> + <@if HIFI_USE_FORWARD@> _fragColor0 = isUnlitEnabled() * vec4(texel.rgb <@if HIFI_USE_FADE@> + fadeEmissive <@endif@> , texel.a); + <@elif HIFI_USE_TRANSLUCENT@> + packDeferredFragmentTranslucentUnlit( + _prevPositionCS, + evalFrontOrBackFaceNormal(normalize(_normalWS)), + texel.a, + texel.rgb + <@if HIFI_USE_FADE@> + + fadeEmissive + <@endif@> + ); <@else@> packDeferredFragmentUnlit( _prevPositionCS, diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index c3bf87564e5..42e085870af 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -27,6 +27,8 @@ <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; + <@elif not HIFI_USE_FORWARD@> + layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> <@else@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; @@ -44,6 +46,8 @@ void main(void) { <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> <$transformModelToEyeAndClipPos(cam, obj, inPosition, _positionES, gl_Position)$> + <@elif not HIFI_USE_FORWARD@> + <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <@endif@> <@else@> <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> From d143964e9b24521426f9876b2d19afda7c8a698e Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Wed, 19 Aug 2020 18:00:19 -0700 Subject: [PATCH 10/34] tweaking values --- libraries/render-utils/src/AntialiasingEffect.h | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 696ba5daaa0..9a795f7e40f 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -30,7 +30,7 @@ class AntialiasingSetupConfig : public render::Job::Config { public: AntialiasingSetupConfig() : render::Job::Config(true) {} - float scale{ 1.0f }; + float scale{ 0.75f }; bool stop{ false }; bool freeze{ false }; @@ -133,7 +133,7 @@ class AntialiasingConfig : public render::Job::Config { int _mode{ TAA }; // '_' prefix but not private? float blend { 0.2f }; - float sharpen { 0.0f }; + float sharpen { 0.1f }; bool constrainColor { true }; float covarianceGamma { 1.15f }; @@ -228,8 +228,6 @@ class Antialiasing { static gpu::PipelinePointer _debugBlendPipeline; TAAParamsBuffer _params; - //TODO: check if it's used - AntialiasingConfig::Mode _mode{ AntialiasingConfig::TAA }; float _sharpen { 0.15f }; bool _isSharpenEnabled { true }; float _debugFXAAX { 0.0f }; From e7d75ccf1a2a7535db00c6b106e7f416371eedb2 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Fri, 28 Aug 2020 14:11:47 -0700 Subject: [PATCH 11/34] trying to cut down shader size --- libraries/gpu/src/gpu/Batch.h | 1 - libraries/gpu/src/gpu/Transform.slh | 43 ------------------- libraries/graphics/src/graphics/skybox.slh | 2 +- .../render-utils/src/DeferredTransform.slh | 3 +- libraries/render-utils/src/VelocityWrite.slh | 16 ------- libraries/render-utils/src/taa.slh | 1 - .../render/src/render/drawItemStatus.slv | 3 +- 7 files changed, 4 insertions(+), 65 deletions(-) diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h index 7a551af0023..47b4caef0a9 100644 --- a/libraries/gpu/src/gpu/Batch.h +++ b/libraries/gpu/src/gpu/Batch.h @@ -511,7 +511,6 @@ class Batch { Bytes _data; static size_t _dataMax; - // SSBO class... layout MUST match the layout in Transform.slh #include "TransformObject_shared.slh" using TransformObjects = std::vector; diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index dc9dac16c49..4635b431edf 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -150,10 +150,6 @@ TransformObject getTransformObject() { <$declareStandardObjectTransform()$> <@endfunc@> -<@func transformCameraViewport(cameraTransform, viewport)@> - <$viewport$> = <$cameraTransform$>._viewport; -<@endfunc@> - <@func transformStereoClipSpace(clipPos)@> { #ifdef GPU_TRANSFORM_IS_STEREO @@ -185,16 +181,6 @@ TransformObject getTransformObject() { } <@endfunc@> -<@func transformModelToPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, prevEyeWorldAlignedPos)@> - - { // transformModelToPrevEyeWorldAlignedPos - highp mat4 _mv = <$objectTransform$>._previousModel; - _mv[3].xyz -= <$cameraTransform$>._previousViewInverse[3].xyz; - highp vec4 _prevEyeWApos = (_mv * <$modelPos$>); - <$prevEyeWorldAlignedPos$> = _prevEyeWApos; - } -<@endfunc@> - <@func transformModelToEyeAndPrevEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWAPos, prevEyeWAPos)@> { // transformModelToEyeAndPrevEyeWorldAlignedPos @@ -247,21 +233,6 @@ TransformObject getTransformObject() { } <@endfunc@> -<@func transformModelToEyeMonoClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, eyePos, clipPos, monoClipPos, prevClipPos)@> - { // transformModelToEyeMonoClipPosAndPrevClipPos - vec4 eyeWAPos; - vec4 prevEyeWAPos; - <$transformModelToEyeAndPrevEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos, prevEyeWAPos)$> - <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0); - <$monoClipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos; - <$clipPos$> = <$monoClipPos$>; - <$transformStereoClipSpace($clipPos$)$> - - <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * prevEyeWAPos; - // Prev clip pos is in mono clip space - } -<@endfunc@> - <@func transformModelToClipPosAndPrevClipPos(cameraTransform, objectTransform, modelPos, clipPos, prevClipPos)@> { // transformModelToClipPosAndPrevClipPos vec4 eyeWAPos; @@ -376,20 +347,6 @@ TransformObject getTransformObject() { } <@endfunc@> -<@func transformEyeToPrevWorldDir(cameraTransform, eyeDir, prevWorldDir)@> - { // transformEyeToPrevWorldDir - <$prevWorldDir$> = vec3(<$cameraTransform$>._previousViewInverse * vec4(<$eyeDir$>.xyz, 0.0)); - } -<@endfunc@> - -<@func transformEyeToWorldDirAndPrevClipPos(cameraTransform, eyeDir, worldDir, prevClipPos)@> - { // transformEyeToWorldDirAndPrevClipPos - vec4 worldVec = <$cameraTransform$>._viewInverse * vec4(<$eyeDir$>.xyz, 0.0); - <$worldDir$> = worldVec.xyz; - <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * worldVec; - } -<@endfunc@> - <@func transformClipToEyeDir(cameraTransform, clipPos, eyeDir)@> { // transformClipToEyeDir <$eyeDir$> = vec3(<$cameraTransform$>._projectionInverse * vec4(<$clipPos$>.xyz, 1.0)); // Must be 1.0 here diff --git a/libraries/graphics/src/graphics/skybox.slh b/libraries/graphics/src/graphics/skybox.slh index a99a462cedf..f03d9f3e00a 100644 --- a/libraries/graphics/src/graphics/skybox.slh +++ b/libraries/graphics/src/graphics/skybox.slh @@ -25,7 +25,7 @@ LAYOUT(binding=GRAPHICS_BUFFER_SKYBOX_PARAMS) uniform skyboxBuffer { }; <@func declarePackDeferredFragmentSky()@> -// This code is duplicated from render-utils/VelocityWrite.slh because graphics can't include render-utils, but ideally this would only be in one place +// This code belongs in render-utils/VelocityWrite.slh but because graphics can't include render-utils, we have to have it here vec2 getEyeTexcoordPos() { // No need to add 0.5 as, by default, frag coords are pixel centered at (0.5, 0.5) diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index 1e21f877b98..741dafdd8fe 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -112,7 +112,8 @@ int getStereoSideFromFragCoord() { } int getStereoSideFromUV(float uPos) { - return int(uPos >= 0.5 && isStereo());} + return int(uPos >= 0.5 && isStereo()); +} vec2 getStereoSideSize(int resolutionLevel) { return vec2(getStereoSideWidth(resolutionLevel), getStereoSideHeight(resolutionLevel)); diff --git a/libraries/render-utils/src/VelocityWrite.slh b/libraries/render-utils/src/VelocityWrite.slh index 0ca60c7a1ac..91f704e9977 100644 --- a/libraries/render-utils/src/VelocityWrite.slh +++ b/libraries/render-utils/src/VelocityWrite.slh @@ -38,20 +38,4 @@ vec2 packVelocity(vec4 positionCS, vec4 prevPositionCS) { return deltaUV; } -void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color) { - _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); - _lighting = vec4(color, 1.0); -} - -void packDeferredFragmentLighting(vec4 prevPositionCS, vec4 color) { - _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); - _lighting = color; -} - -// Use this version when your shader can possibly be used to rasterize GL_LINES -void packDeferredFragmentLighting(vec4 positionCS, vec4 prevPositionCS, vec4 color) { - _velocity = vec4(packVelocity(positionCS, prevPositionCS), 0.0, 0.0); - _lighting = color; -} - <@endif@> \ No newline at end of file diff --git a/libraries/render-utils/src/taa.slh b/libraries/render-utils/src/taa.slh index cf972bf4023..41b6d2d5a4a 100644 --- a/libraries/render-utils/src/taa.slh +++ b/libraries/render-utils/src/taa.slh @@ -10,7 +10,6 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // -<@include DeferredBuffer.slh@> <@include DeferredTransform.slh@> <$declareDeferredFrameTransform()$> diff --git a/libraries/render/src/render/drawItemStatus.slv b/libraries/render/src/render/drawItemStatus.slv index 7aac26fe2e0..aff8d997166 100644 --- a/libraries/render/src/render/drawItemStatus.slv +++ b/libraries/render/src/render/drawItemStatus.slv @@ -128,8 +128,7 @@ void main(void) { // Final position in pixel space vec2 quadPixelPos = offset.xy + quadPos.xy * 0.5 * iconScale; - vec4 viewport; - <$transformCameraViewport(cam, viewport)$>; + vec4 viewport = cam._viewport; vec2 pixelToClip = vec2(2.0 / viewport.z, 2.0 / viewport.w); gl_Position = anchorPoint + (anchorPoint.w * vec4(quadPixelPos * pixelToClip, 0.0, 0.0)); From 88a65f36712385966bcdf41f457b3535bff3b0f1 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 30 Aug 2020 15:17:52 -0700 Subject: [PATCH 12/34] fix polylines + reduce postSharpen --- libraries/entities-renderer/src/paintStroke.slf | 2 +- libraries/entities-renderer/src/paintStroke.slv | 5 ++--- libraries/gpu/src/gpu/Transform.slh | 8 ++++++++ libraries/render-utils/src/AntialiasingEffect.h | 2 +- 4 files changed, 12 insertions(+), 5 deletions(-) diff --git a/libraries/entities-renderer/src/paintStroke.slf b/libraries/entities-renderer/src/paintStroke.slf index 1b76e536509..25374ec7190 100644 --- a/libraries/entities-renderer/src/paintStroke.slf +++ b/libraries/entities-renderer/src/paintStroke.slf @@ -40,7 +40,7 @@ void main(void) { <@if not HIFI_USE_FORWARD@> <@if HIFI_USE_TRANSLUCENT@> - packDeferredFragmentTranslucent(evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb, DEFAULT_ROUGHNESS); + packDeferredFragmentTranslucentUnlit(_prevPositionCS, evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb); <@else@> packDeferredFragmentUnlit(_prevPositionCS, evalFrontOrBackFaceNormal(_normalWS), texel.a, texel.rgb); <@endif@> diff --git a/libraries/entities-renderer/src/paintStroke.slv b/libraries/entities-renderer/src/paintStroke.slv index bee8e2ed9d7..35308f497d1 100644 --- a/libraries/entities-renderer/src/paintStroke.slv +++ b/libraries/entities-renderer/src/paintStroke.slv @@ -56,10 +56,9 @@ void main(void) { posEye.x += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.x; posEye.y += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.y; posEye.z += _distanceFromCenter * vertex.binormalAndHalfWidth.w * binormalEye.z; -<@if HIFI_USE_FORWARD@> <$transformEyeToClipPos(cam, posEye, gl_Position)$> -<@else@> - <$transformEyeToClipPosAndPrevClipPos(cam, posEye, gl_Position, _prevPositionCS)$> +<@if not HIFI_USE_FORWARD@> + <$transformEyeToPrevClipPos(cam, posEye, _prevPositionCS)$> <$transformEyeToWorldDir(cam, normalEye, _normalWS)$> <@endif@> } else { diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index 4635b431edf..f5959ca8657 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -361,6 +361,14 @@ TransformObject getTransformObject() { } <@endfunc@> +<@func transformEyeToPrevClipPos(cameraTransform, eyePos, prevClipPos)@> + { // transformEyeToClipPos + vec4 worldPos = <$cameraTransform$>._viewInverse * vec4(<$eyePos$>.xyz, 1.0); + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * worldPos; + // Prev clip pos is in mono clip space + } +<@endfunc@> + <@func transformPrevEyeToPrevClipPos(cameraTransform, prevEyePos, prevClipPos)@> { // transformPrevEyeToPrevClipPos <$prevClipPos$> = <$cameraTransform$>._previousViewInverse * vec4(<$prevEyePos$>.xyz, 1.0) - vec4(<$cameraTransform$>._previousViewInverse[3].xyz, 0.0); diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 9a795f7e40f..6948358ec6e 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -133,7 +133,7 @@ class AntialiasingConfig : public render::Job::Config { int _mode{ TAA }; // '_' prefix but not private? float blend { 0.2f }; - float sharpen { 0.1f }; + float sharpen { 0.05f }; bool constrainColor { true }; float covarianceGamma { 1.15f }; From 67d89a1f62c58f9eb9af644808f6140455a44cfe Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 6 Sep 2020 14:49:40 -0700 Subject: [PATCH 13/34] CR, still need to add copyright --- interface/src/SecondaryCamera.cpp | 2 +- .../gpu-gl-common/src/gpu/gl/GLBackend.h | 2 +- .../src/gpu/gl41/GL41BackendTransform.cpp | 2 +- .../src/gpu/gl45/GL45BackendTransform.cpp | 2 +- libraries/gpu-gles/src/gpu/gles/GLESBackend.h | 2 -- .../src/gpu/gles/GLESBackendTransform.cpp | 2 +- libraries/gpu/src/gpu/Backend.cpp | 2 +- libraries/gpu/src/gpu/Backend.h | 4 +-- libraries/gpu/src/gpu/Batch.cpp | 4 +-- libraries/gpu/src/gpu/Batch.h | 24 ++++++++-------- libraries/gpu/src/gpu/DrawUnitQuad.slv | 2 +- libraries/graphics/src/graphics/skybox.slh | 3 +- .../render-utils/src/AntialiasingEffect.cpp | 5 ++++ .../render-utils/src/AntialiasingEffect.h | 28 +++++++++---------- .../render-utils/src/DeferredBufferWrite.slh | 1 + .../render-utils/src/DeferredFramebuffer.cpp | 2 +- .../render-utils/src/DeferredFramebuffer.h | 4 +-- .../render-utils/src/DeferredTransform.slh | 2 +- libraries/render-utils/src/HighlightEffect.h | 6 ++-- libraries/render-utils/src/RenderViewTask.cpp | 2 +- libraries/render-utils/src/RenderViewTask.h | 7 ++++- libraries/render-utils/src/VelocityWrite.slh | 2 +- libraries/render-utils/src/aa_blend.slf | 2 +- libraries/render-utils/src/grid.slv | 4 +-- 24 files changed, 62 insertions(+), 54 deletions(-) diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp index b643e566796..185d2ca1b80 100644 --- a/interface/src/SecondaryCamera.cpp +++ b/interface/src/SecondaryCamera.cpp @@ -275,7 +275,7 @@ class EndSecondaryCameraFrame { // Restores renderContext. void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor) { const auto cachedArg = task.addJob("SecondaryCamera"); - task.addJob("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1, 2); + task.addJob("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1, RenderViewTask::TransformOffset::SECONDARY_VIEW); task.addJob("EndSecondaryCamera", cachedArg); } \ No newline at end of file diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index 0fc7dc8d574..cdb1ea6cf25 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -441,7 +441,7 @@ class GLBackend : public Backend, public std::enable_shared_from_this struct SaveTransform { ViewProjectionState _state; - size_t _cameraOffset{ INVALID_OFFSET }; + size_t _cameraOffset { INVALID_OFFSET }; }; TransformCamera _camera; diff --git a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp index 52bfbbf577c..6d7e1081944 100644 --- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp +++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTransform.cpp @@ -129,4 +129,4 @@ void GL41Backend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch glBindBuffer(GL_COPY_WRITE_BUFFER, 0); (void)CHECK_GL_ERROR(); } -} \ No newline at end of file +} diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp index ae7170d2822..644ec6ae8e3 100644 --- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp +++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTransform.cpp @@ -129,4 +129,4 @@ void GL45Backend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch glCopyNamedBufferSubData(_transform._cameraBuffer, object->_buffer, savedTransform._cameraOffset, dstOffset, size); (void)CHECK_GL_ERROR(); } -} \ No newline at end of file +} diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h index 0e636250256..65eb85fd6ba 100644 --- a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h +++ b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h @@ -76,8 +76,6 @@ class GLESBackend : public GLBackend { void allocateStorage() const; void syncSampler() const override; const Size _size { 0 }; - - }; class GLESAttachmentTexture : public GLESFixedAllocationTexture { diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp b/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp index be5e2a25570..14cc9a5a4de 100644 --- a/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp +++ b/libraries/gpu-gles/src/gpu/gles/GLESBackendTransform.cpp @@ -131,4 +131,4 @@ void GLESBackend::do_copySavedViewProjectionTransformToBuffer(const Batch& batch glBindBuffer(GL_COPY_WRITE_BUFFER, 0); (void)CHECK_GL_ERROR(); } -} \ No newline at end of file +} diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 0b08ffff1a5..2da1ad7079c 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -115,4 +115,4 @@ const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const _stereoInfo = Vec4(0.0f); return *this; -} \ No newline at end of file +} diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index 39bec795cfc..dfefd754bcd 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -47,7 +47,7 @@ struct ContextStats { class Backend { public: - virtual ~Backend(){}; + virtual ~Backend() {} virtual void shutdown() {} virtual const std::string& getVersion() const = 0; @@ -135,4 +135,4 @@ class Backend { } -#endif \ No newline at end of file +#endif diff --git a/libraries/gpu/src/gpu/Batch.cpp b/libraries/gpu/src/gpu/Batch.cpp index 89e63d3325d..a254331ffa9 100644 --- a/libraries/gpu/src/gpu/Batch.cpp +++ b/libraries/gpu/src/gpu/Batch.cpp @@ -269,7 +269,7 @@ void Batch::setProjectionJitterEnabled(bool isProjectionEnabled) { } void Batch::pushProjectionJitterEnabled(bool isProjectionEnabled) { - ADD_COMMAND(setProjectionJitterEnabled); + ADD_COMMAND(setProjectionJitterEnabled); _params.emplace_back(isProjectionEnabled & 1); } @@ -811,4 +811,4 @@ void Batch::flush() { } buffer->flush(); } -} \ No newline at end of file +} diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h index 47b4caef0a9..e3417d54347 100644 --- a/libraries/gpu/src/gpu/Batch.h +++ b/libraries/gpu/src/gpu/Batch.h @@ -154,20 +154,20 @@ class Batch { // multi command desctription for multiDrawIndexedIndirect class DrawIndirectCommand { public: - uint _count{ 0 }; - uint _instanceCount{ 0 }; - uint _firstIndex{ 0 }; - uint _baseInstance{ 0 }; + uint _count { 0 }; + uint _instanceCount { 0 }; + uint _firstIndex { 0 }; + uint _baseInstance { 0 }; }; // multi command desctription for multiDrawIndexedIndirect class DrawIndexedIndirectCommand { public: - uint _count{ 0 }; - uint _instanceCount{ 0 }; - uint _firstIndex{ 0 }; - uint _baseVertex{ 0 }; - uint _baseInstance{ 0 }; + uint _count { 0 }; + uint _instanceCount { 0 }; + uint _firstIndex { 0 }; + uint _baseVertex { 0 }; + uint _baseInstance { 0 }; }; // Transform Stage @@ -538,10 +538,10 @@ class Batch { bool _isJitterOnProjectionEnabled { false }; - uint16_t _drawcallUniform{ 0 }; - uint16_t _drawcallUniformReset{ 0 }; + uint16_t _drawcallUniform { 0 }; + uint16_t _drawcallUniformReset { 0 }; - bool _enableStereo{ true }; + bool _enableStereo { true }; bool _enableSkybox { false }; protected: diff --git a/libraries/gpu/src/gpu/DrawUnitQuad.slv b/libraries/gpu/src/gpu/DrawUnitQuad.slv index 7fcc7f97382..909ab81655f 100644 --- a/libraries/gpu/src/gpu/DrawUnitQuad.slv +++ b/libraries/gpu/src/gpu/DrawUnitQuad.slv @@ -24,4 +24,4 @@ void main(void) { vec4 pos = UNIT_QUAD[gl_VertexID]; gl_Position = pos; -} \ No newline at end of file +} diff --git a/libraries/graphics/src/graphics/skybox.slh b/libraries/graphics/src/graphics/skybox.slh index f03d9f3e00a..fa85a70b737 100644 --- a/libraries/graphics/src/graphics/skybox.slh +++ b/libraries/graphics/src/graphics/skybox.slh @@ -3,7 +3,7 @@ // libraries/graphics/src // // Created by HifiExperiments on 8/5/2020. -// Copyright 2020 Vircadia +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -43,6 +43,7 @@ vec2 packVelocity(vec4 prevPositionCS) { return deltaUV; } +// Must match layout in DeferredBufferWrite.slh, but only velocity and lighting are used //layout(location = 0) out vec4 _fragColor0; // albedo / metallic //layout(location = 1) out vec4 _fragColor1; // normal //layout(location = 2) out vec4 _fragColor2; // scattering / emissive / occlusion diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index 09c33782244..0439f38e03d 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -118,6 +118,11 @@ int AntialiasingSetupConfig::play() { return _state; } +void AntialiasingSetupConfig::setAAMode(int mode) { + this->mode = glm::clamp(mode, 0, (int)AntialiasingSetupConfig::MODE_COUNT); + emit dirty(); +} + AntialiasingSetup::AntialiasingSetup() { _sampleSequence.reserve(TAA_JITTER_SEQUENCE_LENGTH + 1); // Fill in with jitter samples diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 6948358ec6e..76d507edb4c 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -30,9 +30,9 @@ class AntialiasingSetupConfig : public render::Job::Config { public: AntialiasingSetupConfig() : render::Job::Config(true) {} - float scale{ 0.75f }; - bool stop{ false }; - bool freeze{ false }; + float scale { 0.75f }; + bool stop { false }; + bool freeze { false }; void setIndex(int current); void setState(int state); @@ -51,8 +51,8 @@ public slots: void dirty(); private: - int _state{ 0 }; - int _index{ 0 }; + int _state { 0 }; + int _index { 0 }; }; @@ -140,15 +140,15 @@ class AntialiasingConfig : public render::Job::Config { bool feedbackColor { false }; bool bicubicHistoryFetch { true }; - float debugX{ 0.0f }; - float debugFXAAX{ 1.0f }; - float debugShowVelocityThreshold{ 1.0f }; - glm::vec2 debugCursorTexcoord{ 0.5f, 0.5f }; - float debugOrbZoom{ 2.0f }; + float debugX { 0.0f }; + float debugFXAAX { 1.0f }; + float debugShowVelocityThreshold { 1.0f }; + glm::vec2 debugCursorTexcoord { 0.5f, 0.5f }; + float debugOrbZoom { 2.0f }; bool debug { false }; bool showCursorPixel { false }; - bool showClosestFragment{ false }; + bool showClosestFragment { false }; signals: void dirty(); @@ -163,9 +163,9 @@ struct TAAParams { float covarianceGamma { 0.9f }; float debugShowVelocityThreshold { 1.0f }; - glm::ivec4 flags{ 0 }; - glm::vec4 pixelInfo{ 0.5f, 0.5f, 2.0f, 0.0f }; - glm::vec4 regionInfo{ 0.0f, 0.0f, 1.0f, 0.0f }; + glm::ivec4 flags { 0 }; + glm::vec4 pixelInfo { 0.5f, 0.5f, 2.0f, 0.0f }; + glm::vec4 regionInfo { 0.0f, 0.0f, 1.0f, 0.0f }; void setConstrainColor(bool enabled) { SET_BIT(flags.y, 1, enabled); } bool isConstrainColor() const { return (bool)GET_BIT(flags.y, 1); } diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index aeefd437c72..5bdbd2ec393 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -14,6 +14,7 @@ <@include DeferredBuffer.slh@> <@include DeferredBufferWrite_shared.slh@> +// Must match layout in skybox.slh layout(location = DEFERRED_COLOR_SLOT) out vec4 _fragColor0; // albedo / metallic layout(location = DEFERRED_NORMAL_SLOT) out vec4 _fragColor1; // Normal layout(location = DEFERRED_SPECULAR_SLOT) out vec4 _fragColor2; // scattering / emissive / occlusion diff --git a/libraries/render-utils/src/DeferredFramebuffer.cpp b/libraries/render-utils/src/DeferredFramebuffer.cpp index 679ae375194..d2b4d8fec40 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.cpp +++ b/libraries/render-utils/src/DeferredFramebuffer.cpp @@ -191,4 +191,4 @@ void SetDeferredFramebuffer::run(const render::RenderContextPointer& renderConte batch.setFramebuffer(framebuffer->getFramebuffer(_type)); args->_batch = nullptr; }); -} \ No newline at end of file +} diff --git a/libraries/render-utils/src/DeferredFramebuffer.h b/libraries/render-utils/src/DeferredFramebuffer.h index f3cbdf59336..7a4e6014de6 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.h +++ b/libraries/render-utils/src/DeferredFramebuffer.h @@ -81,7 +81,7 @@ class SetDeferredFramebuffer { void run(const render::RenderContextPointer& renderContext, const DeferredFramebufferPointer& framebuffer); protected: - DeferredFramebuffer::Type _type{ DeferredFramebuffer::FULL }; + DeferredFramebuffer::Type _type { DeferredFramebuffer::FULL }; }; -#endif // hifi_DeferredFramebuffer_h \ No newline at end of file +#endif // hifi_DeferredFramebuffer_h diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index 741dafdd8fe..ffc8406e8bf 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -50,7 +50,7 @@ float getProjScale(int resolutionLevel) { } mat4 getProjectionMono() { - return frameTransform.infos.projectionMono; + return frameTransform.infos.projectionMono; } // positive near distance of the projection diff --git a/libraries/render-utils/src/HighlightEffect.h b/libraries/render-utils/src/HighlightEffect.h index fd2ebc63a42..b65836fe9e8 100644 --- a/libraries/render-utils/src/HighlightEffect.h +++ b/libraries/render-utils/src/HighlightEffect.h @@ -125,7 +125,7 @@ class DrawHighlightMask { HighlightSharedParametersPointer _sharedParameters; gpu::BufferPointer _boundsBuffer; gpu::StructBuffer _outlineWidth; - uint _transformSlot; + uint _transformSlot { 0 }; static gpu::PipelinePointer _stencilMaskPipeline; static gpu::PipelinePointer _stencilMaskFillPipeline; @@ -186,7 +186,7 @@ class DebugHighlight { gpu::PipelinePointer _depthPipeline; int _geometryDepthId { 0 }; bool _isDisplayEnabled { false }; - uint _transformSlot; + uint _transformSlot { 0 }; const gpu::PipelinePointer& getDepthPipeline(); void initializePipelines(); @@ -209,5 +209,3 @@ class DrawHighlightTask { }; #endif // hifi_render_utils_HighlightEffect_h - - diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp index ae84d320d86..6dbad76e801 100644 --- a/libraries/render-utils/src/RenderViewTask.cpp +++ b/libraries/render-utils/src/RenderViewTask.cpp @@ -37,7 +37,7 @@ void DeferredForwardSwitchJob::build(JobModel& task, const render::Varying& inpu task.addBranch("RenderForwardTask", 1, input, transformOffset); } -void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask, uint8_t transformOffset) { +void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask, TransformOffset transformOffset) { const auto items = task.addJob("FetchCullSort", cullFunctor, tagBits, tagMask); // Issue the lighting model, aka the big global settings for the view diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h index 1cc57113824..d69f00591b2 100644 --- a/libraries/render-utils/src/RenderViewTask.h +++ b/libraries/render-utils/src/RenderViewTask.h @@ -49,8 +49,13 @@ class RenderViewTask { RenderViewTask() {} + enum class TransformOffset: uint8_t { + MAIN_VIEW = 0, + SECONDARY_VIEW = 1 + }; + void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, - uint8_t tagBits = 0x00, uint8_t tagMask = 0x00, uint8_t transformOffset = 0); + uint8_t tagBits = 0x00, uint8_t tagMask = 0x00, TransformOffset transformOffset = TransformOffset::MAIN_VIEW); }; diff --git a/libraries/render-utils/src/VelocityWrite.slh b/libraries/render-utils/src/VelocityWrite.slh index 91f704e9977..77e12333cb3 100644 --- a/libraries/render-utils/src/VelocityWrite.slh +++ b/libraries/render-utils/src/VelocityWrite.slh @@ -38,4 +38,4 @@ vec2 packVelocity(vec4 positionCS, vec4 prevPositionCS) { return deltaUV; } -<@endif@> \ No newline at end of file +<@endif@> diff --git a/libraries/render-utils/src/aa_blend.slf b/libraries/render-utils/src/aa_blend.slf index cc23b3b088b..8391bba2218 100644 --- a/libraries/render-utils/src/aa_blend.slf +++ b/libraries/render-utils/src/aa_blend.slf @@ -49,4 +49,4 @@ void main(void) { } else { outFragColor = texelFetch(colorTexture, ivec2(gl_FragCoord.xy), 0); } -} \ No newline at end of file +} diff --git a/libraries/render-utils/src/grid.slv b/libraries/render-utils/src/grid.slv index 8cca8467d89..1e718931599 100644 --- a/libraries/render-utils/src/grid.slv +++ b/libraries/render-utils/src/grid.slv @@ -4,7 +4,7 @@ // Generated on <$_SCRIBE_DATE$> // // Created by HifiExperiments on 7/24/2020 -// Copyright 2020 Vircadia +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -33,4 +33,4 @@ void main(void) { <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> <$transformModelToWorldDir(cam, obj, inNormal.xyz, varNormal)$> varPosition = inPosition.xyz; -} \ No newline at end of file +} From 3f9e3e87cbb3283c7e369db970df441aaa6c1352 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 6 Sep 2020 15:09:11 -0700 Subject: [PATCH 14/34] copyright --- interface/src/graphics/GraphicsEngine.cpp | 5 +++-- interface/src/raypick/ParabolaPointer.cpp | 3 ++- interface/src/raypick/ParabolaPointer.h | 1 + libraries/entities-renderer/src/RenderableEntityItem.cpp | 1 + libraries/entities-renderer/src/RenderableEntityItem.h | 1 + .../entities-renderer/src/RenderableGizmoEntityItem.cpp | 1 + libraries/entities-renderer/src/RenderableLineEntityItem.cpp | 1 + .../entities-renderer/src/RenderableMaterialEntityItem.cpp | 1 + .../entities-renderer/src/RenderableModelEntityItem.cpp | 1 + .../src/RenderableParticleEffectEntityItem.cpp | 1 + .../entities-renderer/src/RenderablePolyLineEntityItem.cpp | 1 + .../entities-renderer/src/RenderablePolyVoxEntityItem.cpp | 1 + .../entities-renderer/src/RenderableShapeEntityItem.cpp | 1 + libraries/entities-renderer/src/RenderableTextEntityItem.cpp | 1 + libraries/entities-renderer/src/RenderableTextEntityItem.h | 1 + libraries/entities-renderer/src/paintStroke.slf | 1 + libraries/entities-renderer/src/paintStroke.slv | 1 + libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp | 1 + libraries/gpu-gl-common/src/gpu/gl/GLBackend.h | 1 + libraries/gpu/src/gpu/Backend.cpp | 1 + libraries/gpu/src/gpu/Backend.h | 1 + libraries/gpu/src/gpu/FrameIOKeys.h | 1 + libraries/gpu/src/gpu/FrameReader.cpp | 1 + libraries/gpu/src/gpu/FrameWriter.cpp | 1 + libraries/gpu/src/gpu/Transform.slh | 1 + libraries/graphics/src/graphics/skybox.slf | 1 + libraries/graphics/src/graphics/skybox.slv | 1 + libraries/procedural/src/procedural/proceduralSkybox.slf | 1 + libraries/render-utils/src/AntialiasingEffect.cpp | 1 + libraries/render-utils/src/AntialiasingEffect.h | 1 + libraries/render-utils/src/BackgroundStage.cpp | 1 + libraries/render-utils/src/CauterizedMeshPartPayload.cpp | 1 + libraries/render-utils/src/DebugDeferredBuffer.cpp | 1 + libraries/render-utils/src/DeferredBufferWrite.slh | 1 + libraries/render-utils/src/DeferredFrameTransform.h | 1 + libraries/render-utils/src/DeferredTransform.slh | 1 + libraries/render-utils/src/HighlightEffect.h | 1 + libraries/render-utils/src/MeshPartPayload.cpp | 1 + libraries/render-utils/src/MeshPartPayload.h | 1 + libraries/render-utils/src/RenderCommonTask.cpp | 1 + libraries/render-utils/src/RenderDeferredTask.cpp | 1 + libraries/render-utils/src/RenderHUDLayerTask.cpp | 1 + libraries/render-utils/src/RenderHUDLayerTask.h | 1 + libraries/render-utils/src/VelocityWrite.slh | 1 + libraries/render-utils/src/grid.slf | 1 + libraries/render-utils/src/model.slf | 1 + libraries/render-utils/src/model.slv | 1 + libraries/render-utils/src/simple.slf | 1 + libraries/render-utils/src/simple.slv | 1 + libraries/render-utils/src/taa.slf | 1 + libraries/render-utils/src/taa.slh | 1 + libraries/render-utils/src/web_browser.slv | 1 + libraries/render/src/render/drawItemStatus.slv | 1 + scripts/developer/utilities/render/luci/Antialiasing.qml | 1 + tools/gpu-frame-player/src/RenderThread.cpp | 1 + 55 files changed, 58 insertions(+), 3 deletions(-) diff --git a/interface/src/graphics/GraphicsEngine.cpp b/interface/src/graphics/GraphicsEngine.cpp index 727fd3c8449..bd58a4004ef 100644 --- a/interface/src/graphics/GraphicsEngine.cpp +++ b/interface/src/graphics/GraphicsEngine.cpp @@ -3,6 +3,7 @@ // // Created by Sam Gateau on 29/6/2018. // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. @@ -189,7 +190,7 @@ void GraphicsEngine::render_performFrame() { { PROFILE_RANGE(render, "/pluginBeginFrameRender"); - // If a display plugin loses its underlying support, it + // If a display plugin loses it's underlying support, it // needs to be able to signal us to not use it if (!displayPlugin->beginFrameRender(_renderFrameCount)) { QMetaObject::invokeMethod(qApp, "updateDisplayMode"); @@ -269,7 +270,7 @@ void GraphicsEngine::render_performFrame() { PROFILE_RANGE(render, "/renderOverlay"); PerformanceTimer perfTimer("renderOverlay"); // NOTE: There is no batch associated with this renderArgs - // the ApplicationOverlay class assumes it's viewport is set up to be the device size + // the ApplicationOverlay class assumes its viewport is set up to be the device size renderArgs._viewport = glm::ivec4(0, 0, qApp->getDeviceSize()); qApp->getApplicationOverlay().renderOverlay(&renderArgs); } diff --git a/interface/src/raypick/ParabolaPointer.cpp b/interface/src/raypick/ParabolaPointer.cpp index 22fb47e5d3f..8431ff92125 100644 --- a/interface/src/raypick/ParabolaPointer.cpp +++ b/interface/src/raypick/ParabolaPointer.cpp @@ -1,6 +1,7 @@ // // Created by Sam Gondelman 7/17/2018 // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. @@ -480,4 +481,4 @@ namespace render { template <> const ShapeKey shapeGetShapeKey(const ParabolaPointer::RenderState::ParabolaRenderItem::Pointer& payload) { return ShapeKey::Builder::ownPipeline(); } -} \ No newline at end of file +} diff --git a/interface/src/raypick/ParabolaPointer.h b/interface/src/raypick/ParabolaPointer.h index bccccb73441..0857836e494 100644 --- a/interface/src/raypick/ParabolaPointer.h +++ b/interface/src/raypick/ParabolaPointer.h @@ -1,6 +1,7 @@ // // Created by Sam Gondelman 7/17/2018 // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp index 212baa66340..4e0214ddf1c 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Brad Hefta-Gaub on 12/6/13. // Copyright 2013 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index 78f99277176..3d9b5b748d7 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/libraries/entities-renderer/src/RenderableEntityItem.h @@ -4,6 +4,7 @@ // // Created by Brad Hefta-Gaub on 12/6/13. // Copyright 2013 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp b/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp index d43729ca6be..6fcaa6d4c93 100644 --- a/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp @@ -1,6 +1,7 @@ // // Created by Sam Gondelman on 1/22/19 // Copyright 2019 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp index 6250edc4085..88161f8b8b4 100644 --- a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Seth Alves on 5/11/15. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp index 9c6fd81259f..e99f7b06d29 100644 --- a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp @@ -1,6 +1,7 @@ // // Created by Sam Gondelman on 1/18/2018 // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index 5e6166c9c7a..cb1162db4ff 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Brad Hefta-Gaub on 8/6/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp index 29e0d58b6bc..accaae0a1ca 100644 --- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp @@ -3,6 +3,7 @@ // interface/src // // Created by Jason Rickwald on 3/2/15. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp index d583e8858d1..9869b6438d3 100644 --- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Eric Levin on 8/10/15 // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp index 24903c2d3d8..580e4443986 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Seth Alves on 5/19/15. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // Copyright 2022-2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp index 483ee28430a..c3bd36640f0 100644 --- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2016/05/09 // Copyright 2013 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp index 09e10bc73a3..a7c26985421 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp @@ -4,6 +4,7 @@ // // Created by Brad Hefta-Gaub on 8/6/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.h b/libraries/entities-renderer/src/RenderableTextEntityItem.h index 738d93704f1..df256a5cd07 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.h +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.h @@ -4,6 +4,7 @@ // // Created by Brad Hefta-Gaub on 8/6/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. diff --git a/libraries/entities-renderer/src/paintStroke.slf b/libraries/entities-renderer/src/paintStroke.slf index 25374ec7190..4b73d50bd7d 100644 --- a/libraries/entities-renderer/src/paintStroke.slf +++ b/libraries/entities-renderer/src/paintStroke.slf @@ -5,6 +5,7 @@ // // Created by Eric Levin on 8/10/2015 // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/entities-renderer/src/paintStroke.slv b/libraries/entities-renderer/src/paintStroke.slv index 35308f497d1..23315cbc2d9 100644 --- a/libraries/entities-renderer/src/paintStroke.slv +++ b/libraries/entities-renderer/src/paintStroke.slv @@ -5,6 +5,7 @@ // // Created by Eric Levin on 7/20/15. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index a669080fcc4..efdafd2f6f7 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 10/27/2014. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index cdb1ea6cf25..6abded4aa9f 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 10/27/2014. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 2da1ad7079c..91eaf55a43d 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -4,6 +4,7 @@ // // Created by Olivier Prat on 05/25/2018. // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index dfefd754bcd..0fa20ed55bf 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -4,6 +4,7 @@ // // Created by Olivier Prat on 05/18/2018. // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/FrameIOKeys.h b/libraries/gpu/src/gpu/FrameIOKeys.h index 6a5b7a3e461..6cc4a6bd8c9 100644 --- a/libraries/gpu/src/gpu/FrameIOKeys.h +++ b/libraries/gpu/src/gpu/FrameIOKeys.h @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2018/10/14 // Copyright 2013-2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/FrameReader.cpp b/libraries/gpu/src/gpu/FrameReader.cpp index e7e75ad0b96..79858e28883 100644 --- a/libraries/gpu/src/gpu/FrameReader.cpp +++ b/libraries/gpu/src/gpu/FrameReader.cpp @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2018/10/14 // Copyright 2013-2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/FrameWriter.cpp b/libraries/gpu/src/gpu/FrameWriter.cpp index d2258a5382b..eb530412805 100644 --- a/libraries/gpu/src/gpu/FrameWriter.cpp +++ b/libraries/gpu/src/gpu/FrameWriter.cpp @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2018/10/14 // Copyright 2013-2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index f5959ca8657..91d986f78af 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -3,6 +3,7 @@ // // Created by Sam Gateau on 2/10/15. // Copyright 2013 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/graphics/src/graphics/skybox.slf b/libraries/graphics/src/graphics/skybox.slf index 315c6ce40f1..86f1f942fca 100755 --- a/libraries/graphics/src/graphics/skybox.slf +++ b/libraries/graphics/src/graphics/skybox.slf @@ -5,6 +5,7 @@ // // Created by Sam Gateau on 5/5/2015. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/graphics/src/graphics/skybox.slv b/libraries/graphics/src/graphics/skybox.slv index d52bacfcc0d..991f0c938fc 100755 --- a/libraries/graphics/src/graphics/skybox.slv +++ b/libraries/graphics/src/graphics/skybox.slv @@ -5,6 +5,7 @@ // // Created by Sam Gateau on 5/5/2015. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/procedural/src/procedural/proceduralSkybox.slf b/libraries/procedural/src/procedural/proceduralSkybox.slf index a899695c14a..dc59cb62a91 100644 --- a/libraries/procedural/src/procedural/proceduralSkybox.slf +++ b/libraries/procedural/src/procedural/proceduralSkybox.slf @@ -6,6 +6,7 @@ // // Created by Sam Gateau on 5/5/2015. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index 0439f38e03d..4f0c01189f7 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -4,6 +4,7 @@ // // Created by Raffi Bedikian on 8/30/15 // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 76d507edb4c..f21e420048a 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -4,6 +4,7 @@ // // Created by Raffi Bedikian on 8/30/15 // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // Copyright 2022-2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. diff --git a/libraries/render-utils/src/BackgroundStage.cpp b/libraries/render-utils/src/BackgroundStage.cpp index ab9b87232c7..38fe0aea3df 100644 --- a/libraries/render-utils/src/BackgroundStage.cpp +++ b/libraries/render-utils/src/BackgroundStage.cpp @@ -3,6 +3,7 @@ // // Created by Sam Gateau on 5/9/2017. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp index 28e95f27088..c8180a27d6e 100644 --- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp +++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp @@ -4,6 +4,7 @@ // // Created by Andrew Meadows 2017.01.17 // Copyright 2017 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/DebugDeferredBuffer.cpp b/libraries/render-utils/src/DebugDeferredBuffer.cpp index 158eb879668..c0ad71fcfbb 100644 --- a/libraries/render-utils/src/DebugDeferredBuffer.cpp +++ b/libraries/render-utils/src/DebugDeferredBuffer.cpp @@ -4,6 +4,7 @@ // // Created by Clement on 12/3/15. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index 5bdbd2ec393..fc410bad20a 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 1/12/15. // Copyright 2013 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/DeferredFrameTransform.h b/libraries/render-utils/src/DeferredFrameTransform.h index 5d227c15f5f..a0f78791994 100644 --- a/libraries/render-utils/src/DeferredFrameTransform.h +++ b/libraries/render-utils/src/DeferredFrameTransform.h @@ -4,6 +4,7 @@ // // Created by Sam Gateau 6/3/2016. // Copyright 2016 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/DeferredTransform.slh b/libraries/render-utils/src/DeferredTransform.slh index ffc8406e8bf..b354e27f927 100644 --- a/libraries/render-utils/src/DeferredTransform.slh +++ b/libraries/render-utils/src/DeferredTransform.slh @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 6/2/16. // Copyright 2016 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/HighlightEffect.h b/libraries/render-utils/src/HighlightEffect.h index b65836fe9e8..f65c3647ef6 100644 --- a/libraries/render-utils/src/HighlightEffect.h +++ b/libraries/render-utils/src/HighlightEffect.h @@ -4,6 +4,7 @@ // // Created by Olivier Prat on 08/08/17. // Copyright 2017 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp index 03e77a0ff8b..03b60b661ec 100644 --- a/libraries/render-utils/src/MeshPartPayload.cpp +++ b/libraries/render-utils/src/MeshPartPayload.cpp @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 10/3/15. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h index 8e49275e25c..f0a1a418c3f 100644 --- a/libraries/render-utils/src/MeshPartPayload.h +++ b/libraries/render-utils/src/MeshPartPayload.h @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 10/3/15. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/RenderCommonTask.cpp b/libraries/render-utils/src/RenderCommonTask.cpp index 4348c63dbe3..aa40d8d95ec 100644 --- a/libraries/render-utils/src/RenderCommonTask.cpp +++ b/libraries/render-utils/src/RenderCommonTask.cpp @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2018/01/09 // Copyright 2013-2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index 2a4026881b2..fded1126562 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -5,6 +5,7 @@ // // Created by Sam Gateau on 5/29/15. // Copyright 2016 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/RenderHUDLayerTask.cpp b/libraries/render-utils/src/RenderHUDLayerTask.cpp index 8c2ac35c4cf..b3720a4cf79 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.cpp +++ b/libraries/render-utils/src/RenderHUDLayerTask.cpp @@ -1,6 +1,7 @@ // // Created by Sam Gateau on 2019/06/14 // Copyright 2013-2019 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/RenderHUDLayerTask.h b/libraries/render-utils/src/RenderHUDLayerTask.h index 263b3cce004..5e70e735845 100644 --- a/libraries/render-utils/src/RenderHUDLayerTask.h +++ b/libraries/render-utils/src/RenderHUDLayerTask.h @@ -1,6 +1,7 @@ // // Created by Sam Gateau on 2019/06/14 // Copyright 2013-2019 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/VelocityWrite.slh b/libraries/render-utils/src/VelocityWrite.slh index 77e12333cb3..dc9918b6d50 100644 --- a/libraries/render-utils/src/VelocityWrite.slh +++ b/libraries/render-utils/src/VelocityWrite.slh @@ -4,6 +4,7 @@ // // Created by Olivier Prat on 10/19/18. // Copyright 2018 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/grid.slf b/libraries/render-utils/src/grid.slf index 519506ea54f..a27693ff51c 100644 --- a/libraries/render-utils/src/grid.slf +++ b/libraries/render-utils/src/grid.slf @@ -5,6 +5,7 @@ // // Created by Zach Pomerantz on 2/16/2016. // Copyright 2016 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/model.slf b/libraries/render-utils/src/model.slf index 401c8c97488..09601001a68 100644 --- a/libraries/render-utils/src/model.slf +++ b/libraries/render-utils/src/model.slf @@ -5,6 +5,7 @@ // // Created by Andrzej Kapolka on 5/6/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/model.slv b/libraries/render-utils/src/model.slv index a39be1f7fdf..67b6cfa3654 100644 --- a/libraries/render-utils/src/model.slv +++ b/libraries/render-utils/src/model.slv @@ -5,6 +5,7 @@ // // Created by Hifi Engine Team // Copyright 2019 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index bcac5b09bf2..be0026864da 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -5,6 +5,7 @@ // // Created by Andrzej Kapolka on 9/15/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index 42e085870af..9a8d3ca31f6 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -5,6 +5,7 @@ // // Created by Andrzej Kapolka on 9/15/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/taa.slf b/libraries/render-utils/src/taa.slf index 881b35074e5..8a4b4aff652 100644 --- a/libraries/render-utils/src/taa.slf +++ b/libraries/render-utils/src/taa.slf @@ -5,6 +5,7 @@ // // Created by Sam Gateau on 8/14/2017 // Copyright 2017 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/taa.slh b/libraries/render-utils/src/taa.slh index 41b6d2d5a4a..a082ec2531c 100644 --- a/libraries/render-utils/src/taa.slh +++ b/libraries/render-utils/src/taa.slh @@ -5,6 +5,7 @@ // // Created by Sam Gateau on 8/17/2017 // Copyright 2017 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render-utils/src/web_browser.slv b/libraries/render-utils/src/web_browser.slv index d10128e1920..0d7a82da8a3 100644 --- a/libraries/render-utils/src/web_browser.slv +++ b/libraries/render-utils/src/web_browser.slv @@ -5,6 +5,7 @@ // // Created by Andrzej Kapolka on 9/15/14. // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/libraries/render/src/render/drawItemStatus.slv b/libraries/render/src/render/drawItemStatus.slv index aff8d997166..a70112ffe6d 100644 --- a/libraries/render/src/render/drawItemStatus.slv +++ b/libraries/render/src/render/drawItemStatus.slv @@ -7,6 +7,7 @@ // // Created by Sam Gateau on 6/30/2015. // Copyright 2015 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/scripts/developer/utilities/render/luci/Antialiasing.qml b/scripts/developer/utilities/render/luci/Antialiasing.qml index c279459b222..10627fcab48 100644 --- a/scripts/developer/utilities/render/luci/Antialiasing.qml +++ b/scripts/developer/utilities/render/luci/Antialiasing.qml @@ -3,6 +3,7 @@ // // Created by Sam Gateau on 8/14/2017 // Copyright 2016 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0.html diff --git a/tools/gpu-frame-player/src/RenderThread.cpp b/tools/gpu-frame-player/src/RenderThread.cpp index 53bab44d5d9..c0e3d5ff695 100644 --- a/tools/gpu-frame-player/src/RenderThread.cpp +++ b/tools/gpu-frame-player/src/RenderThread.cpp @@ -1,6 +1,7 @@ // // Created by Bradley Austin Davis on 2018/10/21 // Copyright 2014 High Fidelity, Inc. +// Copyright 2020 Vircadia contributors. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html From acc0b57f7b357ed209f2515c0905dfcacc352217 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 6 Sep 2020 22:34:21 -0700 Subject: [PATCH 15/34] fix build error --- libraries/render-utils/src/RenderViewTask.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h index d69f00591b2..22a11a9292c 100644 --- a/libraries/render-utils/src/RenderViewTask.h +++ b/libraries/render-utils/src/RenderViewTask.h @@ -49,7 +49,7 @@ class RenderViewTask { RenderViewTask() {} - enum class TransformOffset: uint8_t { + enum TransformOffset: uint8_t { MAIN_VIEW = 0, SECONDARY_VIEW = 1 }; From 5da7ff8d00cb714c44b16e8d152cbb4fb2c4fe26 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sat, 28 Nov 2020 22:11:36 -0800 Subject: [PATCH 16/34] test 1, use only haze color --- libraries/graphics/src/graphics/Haze.slh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/libraries/graphics/src/graphics/Haze.slh b/libraries/graphics/src/graphics/Haze.slh index a2d8bb05232..fc0352d8943 100644 --- a/libraries/graphics/src/graphics/Haze.slh +++ b/libraries/graphics/src/graphics/Haze.slh @@ -176,15 +176,15 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition float hazeAmount = 1.0 - exp(-hazeIntegral); // Compute color after haze effect - potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); } // Mix with background at far range const float BLEND_DISTANCE = 27000.0f; - vec4 outFragColor = potentialFragColor; - outFragColor.a *= mix(1.0, hazeParams.backgroundBlend, float(distance > BLEND_DISTANCE)); + potentialFragColor.a *= mix(1.0, hazeParams.backgroundBlend, float(distance > BLEND_DISTANCE)); - return outFragColor; + return potentialFragColor; } <@endif@> From b6e88307df589a9749aac2d505345896400d27e0 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 29 Nov 2020 18:21:10 -0800 Subject: [PATCH 17/34] test 2, same as test 1 but only on half the screen --- libraries/graphics/src/graphics/Haze.slh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/graphics/src/graphics/Haze.slh b/libraries/graphics/src/graphics/Haze.slh index fc0352d8943..a4db78b4daf 100644 --- a/libraries/graphics/src/graphics/Haze.slh +++ b/libraries/graphics/src/graphics/Haze.slh @@ -177,7 +177,7 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition // Compute color after haze effect //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); + potentialFragColor = vec4(blendedHazeColor.rgb, fragPositionES.x > 0.0f ? 1.0f : hazeAmount); } // Mix with background at far range From af271e7b1232c5cb94bffce3fee80a1a285927c8 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 29 Nov 2020 21:00:42 -0800 Subject: [PATCH 18/34] test 3, multiple debug areas --- libraries/graphics/src/graphics/Haze.slh | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/libraries/graphics/src/graphics/Haze.slh b/libraries/graphics/src/graphics/Haze.slh index a4db78b4daf..5eb4f487d63 100644 --- a/libraries/graphics/src/graphics/Haze.slh +++ b/libraries/graphics/src/graphics/Haze.slh @@ -177,7 +177,17 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition // Compute color after haze effect //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - potentialFragColor = vec4(blendedHazeColor.rgb, fragPositionES.x > 0.0f ? 1.0f : hazeAmount); + if (fragPositionES.x < 1.0f) { + potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + } else if (fragPositionES.x < 2.0f) { + potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); + } else if (fragPositionES.x < 3.0f) { + potentialFragColor = vec4(vec3(fract(distance)), 1.0f); + } else if (fragPositionES.x < 4.0f) { + potentialFragColor = vec4(vec3(fract(t)), 1.0f); + } else { + potentialFragColor = vec4(vec3(fract(deltaHeight)), 1.0f); + } } // Mix with background at far range From f9ad4ea9188c5b17bc3dc09bc72ba342d324cb47 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Mon, 30 Nov 2020 21:30:11 -0800 Subject: [PATCH 19/34] test 4, adding range based haze debug --- libraries/graphics/src/graphics/Haze.slh | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/libraries/graphics/src/graphics/Haze.slh b/libraries/graphics/src/graphics/Haze.slh index 5eb4f487d63..75e89092c6c 100644 --- a/libraries/graphics/src/graphics/Haze.slh +++ b/libraries/graphics/src/graphics/Haze.slh @@ -154,7 +154,14 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition float hazeAmount = 1.0 - exp(-distance * hazeParams.hazeRangeFactor); // Compute color after haze effect - potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + if (fragPositionES.x < -0.5f) { + potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); + } else if (fragPositionES.x < 0.0f) { + potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); + } else { + potentialFragColor = vec4(vec3(fract(distance)), 1.0f); + } } else { // Haze is based on both range and altitude // Taken from www.crytek.com/download/GDC2007_RealtimeAtmoFxInGamesRev.ppt From 25b49ea60e3907d92a1b3f4a2224d5496e82ffbf Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Tue, 1 Dec 2020 21:41:46 -0800 Subject: [PATCH 20/34] trying to simplify framebuffer use --- libraries/graphics/src/graphics/Haze.slh | 22 ++-------------- libraries/graphics/src/graphics/skybox.slf | 2 +- libraries/graphics/src/graphics/skybox.slh | 17 +++++++----- .../src/procedural/proceduralSkybox.slf | 2 +- libraries/render-utils/src/BloomEffect.cpp | 3 --- .../src/DeferredFrameTransform.cpp | 2 +- .../render-utils/src/DeferredFramebuffer.cpp | 26 +------------------ .../render-utils/src/DeferredFramebuffer.h | 22 ---------------- .../render-utils/src/RenderCommonTask.cpp | 11 -------- libraries/render-utils/src/RenderCommonTask.h | 7 ----- .../render-utils/src/RenderDeferredTask.cpp | 4 --- 11 files changed, 17 insertions(+), 101 deletions(-) diff --git a/libraries/graphics/src/graphics/Haze.slh b/libraries/graphics/src/graphics/Haze.slh index 75e89092c6c..2a98177e836 100644 --- a/libraries/graphics/src/graphics/Haze.slh +++ b/libraries/graphics/src/graphics/Haze.slh @@ -154,14 +154,7 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition float hazeAmount = 1.0 - exp(-distance * hazeParams.hazeRangeFactor); // Compute color after haze effect - //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - if (fragPositionES.x < -0.5f) { - potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - } else if (fragPositionES.x < 0.0f) { - potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); - } else { - potentialFragColor = vec4(vec3(fract(distance)), 1.0f); - } + potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); } else { // Haze is based on both range and altitude // Taken from www.crytek.com/download/GDC2007_RealtimeAtmoFxInGamesRev.ppt @@ -183,18 +176,7 @@ vec4 computeHazeColor(vec3 fragPositionES, vec3 fragPositionWS, vec3 eyePosition float hazeAmount = 1.0 - exp(-hazeIntegral); // Compute color after haze effect - //potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - if (fragPositionES.x < 1.0f) { - potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); - } else if (fragPositionES.x < 2.0f) { - potentialFragColor = vec4(blendedHazeColor.rgb, 1.0f); - } else if (fragPositionES.x < 3.0f) { - potentialFragColor = vec4(vec3(fract(distance)), 1.0f); - } else if (fragPositionES.x < 4.0f) { - potentialFragColor = vec4(vec3(fract(t)), 1.0f); - } else { - potentialFragColor = vec4(vec3(fract(deltaHeight)), 1.0f); - } + potentialFragColor = vec4(blendedHazeColor.rgb, hazeAmount); } // Mix with background at far range diff --git a/libraries/graphics/src/graphics/skybox.slf b/libraries/graphics/src/graphics/skybox.slf index 86f1f942fca..394af6f2609 100755 --- a/libraries/graphics/src/graphics/skybox.slf +++ b/libraries/graphics/src/graphics/skybox.slf @@ -63,7 +63,7 @@ void main(void) { _fragColor.rgb = mix(_fragColor.rgb, hazeColor.rgb, hazeColor.a); } <@else@> - packDeferredFragmentSky(_prevPositionCS, color); + packDeferredFragmentSky(_prevPositionCS, color, normal); <@endif@> } diff --git a/libraries/graphics/src/graphics/skybox.slh b/libraries/graphics/src/graphics/skybox.slh index fa85a70b737..a5c0eaf678e 100644 --- a/libraries/graphics/src/graphics/skybox.slh +++ b/libraries/graphics/src/graphics/skybox.slh @@ -14,6 +14,8 @@ <@include gpu/Transform.slh@> <$declareStandardCameraTransform()$> +<@include gpu/PackedNormal.slh@> + LAYOUT(binding=GRAPHICS_TEXTURE_SKYBOX) uniform samplerCube cubeMap; struct Skybox { @@ -44,15 +46,18 @@ vec2 packVelocity(vec4 prevPositionCS) { } // Must match layout in DeferredBufferWrite.slh, but only velocity and lighting are used -//layout(location = 0) out vec4 _fragColor0; // albedo / metallic -//layout(location = 1) out vec4 _fragColor1; // normal -//layout(location = 2) out vec4 _fragColor2; // scattering / emissive / occlusion +layout(location = 0) out vec4 _fragColor0; // albedo / metallic +layout(location = 1) out vec4 _fragColor1; // normal +layout(location = 2) out vec4 _fragColor2; // scattering / emissive / occlusion layout(location = 3) out vec4 _velocity; // velocity layout(location = 4) out vec4 _lighting; // emissive -void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color) { - _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); - _lighting = vec4(color, 1.0); +void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color, vec3 normal) { + _fragColor0 = vec4(color, 0.6f); + _fragColor1 = vec4(packNormal(normal), 1.0f); + _fragColor2 = vec4(0.0f); + _velocity = vec4(packVelocity(prevPositionCS), 0.0f, 0.0f); + _lighting = vec4(color, 1.0f); } <@endfunc@> diff --git a/libraries/procedural/src/procedural/proceduralSkybox.slf b/libraries/procedural/src/procedural/proceduralSkybox.slf index dc59cb62a91..b6c68faa5c2 100644 --- a/libraries/procedural/src/procedural/proceduralSkybox.slf +++ b/libraries/procedural/src/procedural/proceduralSkybox.slf @@ -37,5 +37,5 @@ void main(void) { // Procedural Shaders are expected to be Gamma corrected so let's bring back the RGB in linear space for the rest of the pipeline color = pow(color, vec3(2.2)); - packDeferredFragmentSky(_prevPositionCS, color); + packDeferredFragmentSky(_prevPositionCS, color, _normal); } diff --git a/libraries/render-utils/src/BloomEffect.cpp b/libraries/render-utils/src/BloomEffect.cpp index 206d1cacf70..1aae75e97df 100644 --- a/libraries/render-utils/src/BloomEffect.cpp +++ b/libraries/render-utils/src/BloomEffect.cpp @@ -78,9 +78,6 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons gpu::doInBatch("BloomThreshold::run", args->_context, [&](gpu::Batch& batch) { batch.enableStereo(false); - // We need to clear in case there are zones of the buffer that are stencil tagged as "No Bloom" - batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, gpu::Vec4(0.0f)); - batch.setViewportTransform(viewport); batch.setProjectionTransform(glm::mat4()); batch.resetViewTransform(); diff --git a/libraries/render-utils/src/DeferredFrameTransform.cpp b/libraries/render-utils/src/DeferredFrameTransform.cpp index 80ac8e357a1..5c379a0324a 100644 --- a/libraries/render-utils/src/DeferredFrameTransform.cpp +++ b/libraries/render-utils/src/DeferredFrameTransform.cpp @@ -25,7 +25,7 @@ void DeferredFrameTransform::update(RenderArgs* args) { auto farZ = args->getViewFrustum().getFarClip(); auto& frameTransformBuffer = _frameTransformBuffer.edit(); - frameTransformBuffer.infos.depthInfo = glm::vec4(nearZ*farZ, farZ - nearZ, -farZ, 0.0f); + frameTransformBuffer.infos.depthInfo = glm::vec4(nearZ * farZ, farZ - nearZ, -farZ, 0.0f); frameTransformBuffer.infos.pixelInfo = args->_viewport; args->getViewFrustum().evalProjectionMatrix(frameTransformBuffer.infos.projectionMono); diff --git a/libraries/render-utils/src/DeferredFramebuffer.cpp b/libraries/render-utils/src/DeferredFramebuffer.cpp index d2b4d8fec40..661c334965e 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.cpp +++ b/libraries/render-utils/src/DeferredFramebuffer.cpp @@ -106,19 +106,6 @@ gpu::TexturePointer DeferredFramebuffer::getPrimaryDepthTexture() { return _primaryDepthTexture; } -gpu::FramebufferPointer DeferredFramebuffer::getFramebuffer(Type type) { - switch (type) { - default: - return getDeferredFramebuffer(); - case COLOR_DEPTH: - return getDeferredFramebufferDepthColor(); - case LIGHTING: - return getLightingFramebuffer(); - case LIGHTING_VELOCITY: - return getLightingWithVelocityFramebuffer(); - }; -} - gpu::FramebufferPointer DeferredFramebuffer::getDeferredFramebuffer() { if (!_deferredFramebuffer) { allocate(); @@ -180,15 +167,4 @@ gpu::TexturePointer DeferredFramebuffer::getLightingTexture() { allocate(); } return _lightingTexture; -} - -void SetDeferredFramebuffer::run(const render::RenderContextPointer& renderContext, const DeferredFramebufferPointer& framebuffer) { - assert(renderContext->args); - RenderArgs* args = renderContext->args; - - gpu::doInBatch("SetDeferredFramebuffer::run", args->_context, [&](gpu::Batch& batch) { - args->_batch = &batch; - batch.setFramebuffer(framebuffer->getFramebuffer(_type)); - args->_batch = nullptr; - }); -} +} \ No newline at end of file diff --git a/libraries/render-utils/src/DeferredFramebuffer.h b/libraries/render-utils/src/DeferredFramebuffer.h index 7a4e6014de6..aba9f697a29 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.h +++ b/libraries/render-utils/src/DeferredFramebuffer.h @@ -20,19 +20,9 @@ // DeferredFramebuffer is a helper class gathering in one place the GBuffer (Framebuffer) and lighting framebuffer class DeferredFramebuffer { public: - enum Type { - FULL = 0, - COLOR_DEPTH, - LIGHTING, - LIGHTING_VELOCITY, - - MAX_TYPE - }; DeferredFramebuffer(); - gpu::FramebufferPointer getFramebuffer(Type type); - gpu::FramebufferPointer getDeferredFramebuffer(); gpu::FramebufferPointer getDeferredFramebufferDepthColor(); @@ -72,16 +62,4 @@ class DeferredFramebuffer { using DeferredFramebufferPointer = std::shared_ptr; -class SetDeferredFramebuffer { -public: - using JobModel = render::Job::ModelI; - - SetDeferredFramebuffer(DeferredFramebuffer::Type type) : _type(type) {} - - void run(const render::RenderContextPointer& renderContext, const DeferredFramebufferPointer& framebuffer); - -protected: - DeferredFramebuffer::Type _type { DeferredFramebuffer::FULL }; -}; - #endif // hifi_DeferredFramebuffer_h diff --git a/libraries/render-utils/src/RenderCommonTask.cpp b/libraries/render-utils/src/RenderCommonTask.cpp index aa40d8d95ec..cf20bff06b0 100644 --- a/libraries/render-utils/src/RenderCommonTask.cpp +++ b/libraries/render-utils/src/RenderCommonTask.cpp @@ -47,17 +47,6 @@ void EndGPURangeTimer::run(const render::RenderContextPointer& renderContext, co config->setGPUBatchRunTime(timer->getGPUAverage(), timer->getBatchAverage()); } -void SetFramebuffer::run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& framebuffer) { - assert(renderContext->args); - RenderArgs* args = renderContext->args; - - gpu::doInBatch("SetFramebuffer::run", args->_context, [&](gpu::Batch& batch) { - args->_batch = &batch; - batch.setFramebuffer(framebuffer); - args->_batch = nullptr; - }); -} - DrawLayered3D::DrawLayered3D(const render::ShapePlumberPointer& shapePlumber, bool opaque, bool jitter, unsigned int transformSlot) : _shapePlumber(shapePlumber), _transformSlot(transformSlot), diff --git a/libraries/render-utils/src/RenderCommonTask.h b/libraries/render-utils/src/RenderCommonTask.h index 550d330b50b..e8603c003fb 100644 --- a/libraries/render-utils/src/RenderCommonTask.h +++ b/libraries/render-utils/src/RenderCommonTask.h @@ -79,13 +79,6 @@ class DrawLayered3D { bool _isJitterEnabled { false }; }; -class SetFramebuffer { -public: - using JobModel = render::Job::ModelI; - - void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& framebuffer); -}; - class Blit { public: using JobModel = render::Job::ModelI; diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index fded1126562..1e4c929cda9 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -196,12 +196,10 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren const auto deferredLightingInputs = RenderDeferred::Inputs(deferredFrameTransform, deferredFramebuffer, extraDeferredBuffer, lightingModel, lightClusters, lightFrame, shadowFrame, hazeFrame).asVarying(); task.addJob("RenderDeferred", deferredLightingInputs); - task.addJob("SetDeferredFramebufferBackground", deferredFramebuffer, DeferredFramebuffer::FULL); // Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying(); task.addJob("DrawBackgroundDeferred", backgroundInputs, backgroundViewTransformSlot); - task.addJob("SetDeferredFramebufferHaze", deferredFramebuffer, DeferredFramebuffer::LIGHTING); const auto drawHazeInputs = render::Varying(DrawHaze::Inputs(hazeFrame, lightingFramebuffer, linearDepthTarget, deferredFrameTransform, lightingModel, lightFrame)); task.addJob("DrawHazeDeferred", drawHazeInputs); @@ -214,10 +212,8 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren task.addJob("DrawHighlight", outlineInputs, mainViewTransformSlot); // Layered Over (in front) - task.addJob("SetOpaqueLayeredFramebuffer", deferredFramebuffer, DeferredFramebuffer::LIGHTING_VELOCITY); const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); task.addJob("DrawInFrontOpaque", inFrontOpaquesInputs, shapePlumberForward, true, true, mainViewTransformSlot); - task.addJob("SetTransparentLayeredFramebuffer", deferredFramebuffer, DeferredFramebuffer::LIGHTING); const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, deferredFrameTransform, lightingModel, hazeFrame).asVarying(); task.addJob("DrawInFrontTransparent", inFrontTransparentsInputs, shapePlumberForward, false, true, mainViewTransformSlot); From 24ce49e360d405abe66b1ec748c77664238a6ef7 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Thu, 17 Dec 2020 22:52:40 -0800 Subject: [PATCH 21/34] passing prev pos and normal --- .../entities-renderer/src/textured_particle.slv | 7 +++++++ libraries/gpu/src/gpu/Transform.slh | 12 ++++++++++++ 2 files changed, 19 insertions(+) diff --git a/libraries/entities-renderer/src/textured_particle.slv b/libraries/entities-renderer/src/textured_particle.slv index 98d25eae2ea..483acadd35a 100644 --- a/libraries/entities-renderer/src/textured_particle.slv +++ b/libraries/entities-renderer/src/textured_particle.slv @@ -172,5 +172,12 @@ void main(void) { ); vec4 quadPos = radius * vec4(UNIT_QUAD[twoTriID], 0.0); vec4 eyePos = anchorPoint + rotation * quadPos; + +<@if not HIFI_USE_FORWARD@> + vec3 normalEye = vec3(0.0f, 0.0f, 1.0f); + <$transformEyeToWorldDir(cam, normalEye, _normalWS)$> + <$transformEyeToClipPosAndPrevClipPos(cam, eyePos, gl_Position, _prevPositionCS)$> +<@else@> <$transformEyeToClipPos(cam, eyePos, gl_Position)$> +<@endif@> } diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh index 91d986f78af..5653d67a262 100644 --- a/libraries/gpu/src/gpu/Transform.slh +++ b/libraries/gpu/src/gpu/Transform.slh @@ -370,6 +370,18 @@ TransformObject getTransformObject() { } <@endfunc@> +<@func transformEyeToClipPosAndPrevClipPos(cameraTransform, eyePos, clipPos, prevClipPos)@> + { // transformEyeToClipPosAndPrevClipPos + <$clipPos$> = <$cameraTransform$>._projection * vec4(<$eyePos$>.xyz, 1.0); + + <$transformStereoClipSpace($clipPos$)$> + + vec4 worldPos = <$cameraTransform$>._viewInverse * vec4(<$eyePos$>.xyz, 1.0); + <$prevClipPos$> = <$cameraTransform$>._previousProjectionViewUntranslated * worldPos; + // Prev clip pos is in mono clip space + } +<@endfunc@> + <@func transformPrevEyeToPrevClipPos(cameraTransform, prevEyePos, prevClipPos)@> { // transformPrevEyeToPrevClipPos <$prevClipPos$> = <$cameraTransform$>._previousViewInverse * vec4(<$prevEyePos$>.xyz, 1.0) - vec4(<$cameraTransform$>._previousViewInverse[3].xyz, 0.0); From e521e763252486355bbd5f2b1033ec23b1454d42 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Fri, 18 Dec 2020 23:17:13 -0800 Subject: [PATCH 22/34] messing with simple shaders --- libraries/graphics/src/graphics/skybox.slh | 12 +++--- .../render-utils/src/DeferredBufferWrite.slh | 40 +++++++++---------- libraries/render-utils/src/grid.slf | 2 +- libraries/render-utils/src/parabola.slf | 2 +- libraries/render-utils/src/simple.slf | 31 +++++++------- libraries/render-utils/src/simple.slv | 14 +++---- 6 files changed, 49 insertions(+), 52 deletions(-) diff --git a/libraries/graphics/src/graphics/skybox.slh b/libraries/graphics/src/graphics/skybox.slh index a5c0eaf678e..e84f770c7d0 100644 --- a/libraries/graphics/src/graphics/skybox.slh +++ b/libraries/graphics/src/graphics/skybox.slh @@ -46,16 +46,16 @@ vec2 packVelocity(vec4 prevPositionCS) { } // Must match layout in DeferredBufferWrite.slh, but only velocity and lighting are used -layout(location = 0) out vec4 _fragColor0; // albedo / metallic -layout(location = 1) out vec4 _fragColor1; // normal -layout(location = 2) out vec4 _fragColor2; // scattering / emissive / occlusion +layout(location = 0) out vec4 _albedoMetallic; // albedo / metallic +layout(location = 1) out vec4 _normalRoughness; // normal / roughness +layout(location = 2) out vec4 _scatteringEmissiveOcclusion; // scattering / emissive / occlusion layout(location = 3) out vec4 _velocity; // velocity layout(location = 4) out vec4 _lighting; // emissive void packDeferredFragmentSky(vec4 prevPositionCS, vec3 color, vec3 normal) { - _fragColor0 = vec4(color, 0.6f); - _fragColor1 = vec4(packNormal(normal), 1.0f); - _fragColor2 = vec4(0.0f); + _albedoMetallic = vec4(color, 0.6f); + _normalRoughness = vec4(packNormal(normal), 1.0f); + _scatteringEmissiveOcclusion = vec4(0.0f); _velocity = vec4(packVelocity(prevPositionCS), 0.0f, 0.0f); _lighting = vec4(color, 1.0f); } diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh index fc410bad20a..99e62153fab 100644 --- a/libraries/render-utils/src/DeferredBufferWrite.slh +++ b/libraries/render-utils/src/DeferredBufferWrite.slh @@ -16,9 +16,9 @@ <@include DeferredBufferWrite_shared.slh@> // Must match layout in skybox.slh -layout(location = DEFERRED_COLOR_SLOT) out vec4 _fragColor0; // albedo / metallic -layout(location = DEFERRED_NORMAL_SLOT) out vec4 _fragColor1; // Normal -layout(location = DEFERRED_SPECULAR_SLOT) out vec4 _fragColor2; // scattering / emissive / occlusion +layout(location = DEFERRED_COLOR_SLOT) out vec4 _albedoMetallic; // albedo / metallic +layout(location = DEFERRED_NORMAL_SLOT) out vec4 _normalRoughness; // normal / roughness +layout(location = DEFERRED_SPECULAR_SLOT) out vec4 _scatteringEmissiveOcclusion; // scattering / emissive / occlusion layout(location = DEFERRED_VELOCITY_SLOT) out vec4 _velocity; // velocity layout(location = DEFERRED_LIGHTING_SLOT) out vec4 _lighting; // emissive @@ -38,9 +38,9 @@ void packDeferredFragment(vec4 prevPositionCS, vec3 normal, float alpha, vec3 al } float check = float(scattering > 0.0); - _fragColor0 = vec4(albedo, mix(packShadedMetallic(metallic), packScatteringMetallic(metallic), check)); - _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); - _fragColor2 = vec4(mix(emissive, vec3(scattering), check), occlusion); + _albedoMetallic = vec4(albedo, mix(packShadedMetallic(metallic), packScatteringMetallic(metallic), check)); + _normalRoughness = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); + _scatteringEmissiveOcclusion = vec4(mix(emissive, vec3(scattering), check), occlusion); _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); _lighting = vec4(isEmissiveEnabled() * emissive, 1.0); } @@ -50,9 +50,9 @@ void packDeferredFragmentLightmap(vec4 prevPositionCS, vec3 normal, float alpha, discard; } - _fragColor0 = vec4(albedo, packLightmappedMetallic(metallic)); - _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); - _fragColor2 = vec4(isLightmapEnabled() * lightmap, 1.0); + _albedoMetallic = vec4(albedo, packLightmappedMetallic(metallic)); + _normalRoughness = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); + _scatteringEmissiveOcclusion = vec4(isLightmapEnabled() * lightmap, 1.0); _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); _lighting = vec4(isLightmapEnabled() * lightmap * albedo, 1.0); } @@ -62,21 +62,21 @@ void packDeferredFragmentUnlit(vec4 prevPositionCS, vec3 normal, float alpha, ve if (alpha < 0.999999) { discard; } - _fragColor0 = vec4(color, packUnlit()); - _fragColor1 = vec4(packNormal(normal), 1.0); - _fragColor2 = vec4(vec3(0.0), 1.0); + _albedoMetallic = vec4(color, packUnlit()); + _normalRoughness = vec4(packNormal(normal), 1.0); + _scatteringEmissiveOcclusion = vec4(vec3(0.0), 1.0); _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); _lighting = vec4(color, 1.0); } -void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 albedo, float roughness) { +void packDeferredFragmentTranslucent(vec4 prevPositionCS, vec3 normal, float alpha, vec3 albedo, float roughness) { if (alpha <= 0.0) { discard; } - _fragColor0 = vec4(albedo.rgb, alpha); - _fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); - _fragColor2 = vec4(vec3(0.0), 1.0); - _velocity = vec4(0.0); + _albedoMetallic = vec4(albedo.rgb, alpha); + _normalRoughness = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0)); + _scatteringEmissiveOcclusion = vec4(vec3(0.0), 1.0); + _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); _lighting = vec4(0.0); } @@ -84,9 +84,9 @@ void packDeferredFragmentTranslucentUnlit(vec4 prevPositionCS, vec3 normal, floa if (alpha <= 0.0) { discard; } - _fragColor0 = vec4(color, alpha); - _fragColor1 = vec4(packNormal(normal), 1.0); - _fragColor2 = vec4(vec3(0.0), 1.0); + _albedoMetallic = vec4(color, alpha); + _normalRoughness = vec4(packNormal(normal), 1.0); + _scatteringEmissiveOcclusion = vec4(vec3(0.0), 1.0); _velocity = vec4(packVelocity(prevPositionCS), 0.0, 0.0); _lighting = vec4(color, 1.0); } diff --git a/libraries/render-utils/src/grid.slf b/libraries/render-utils/src/grid.slf index a27693ff51c..ff98e2b56d8 100644 --- a/libraries/render-utils/src/grid.slf +++ b/libraries/render-utils/src/grid.slf @@ -47,7 +47,7 @@ void main(void) { <@if not HIFI_USE_TRANSLUCENT@> packDeferredFragmentUnlit(_prevPositionCS, NORMAL, 1.0, varColor.rgb); <@else@> - packDeferredFragmentTranslucent(NORMAL, varColor.a, varColor.rgb, DEFAULT_ROUGHNESS); + packDeferredFragmentTranslucent(_prevPositionCS, NORMAL, varColor.a, varColor.rgb, DEFAULT_ROUGHNESS); <@endif@> <@else@> _fragColor0 = varColor; diff --git a/libraries/render-utils/src/parabola.slf b/libraries/render-utils/src/parabola.slf index e6b754c33de..cd97a79113d 100644 --- a/libraries/render-utils/src/parabola.slf +++ b/libraries/render-utils/src/parabola.slf @@ -24,7 +24,7 @@ void main(void) { <@if not HIFI_USE_TRANSLUCENT@> packDeferredFragmentUnlit(_prevPositionCS, vec3(1.0, 0.0, 0.0), 1.0, _color.rgb); <@else@> - packDeferredFragmentTranslucent(vec3(1.0, 0.0, 0.0), _color.a, _color.rgb, DEFAULT_ROUGHNESS); + packDeferredFragmentTranslucent(_prevPositionCS, vec3(1.0, 0.0, 0.0), _color.a, _color.rgb, DEFAULT_ROUGHNESS); <@endif@> <@else@> _fragColor0 = _color; diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index be0026864da..b74e0410954 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -27,25 +27,16 @@ <@if HIFI_USE_FORWARD@> layout(location=0) out vec4 _fragColor0; -<@elif HIFI_USE_TRANSLUCENT@> - <@if not HIFI_USE_UNLIT@> - layout(location=0) out vec4 _fragColor0; - <@endif@> +<@else@> + <@include DeferredBufferWrite.slh@> <@endif@> <@if not HIFI_USE_UNLIT@> + <@include GlobalLight.slh@> <@if HIFI_USE_TRANSLUCENT@> - <@include GlobalLight.slh@> <$declareEvalGlobalLightingAlphaBlended()$> <@elif HIFI_USE_FORWARD@> - <@include GlobalLight.slh@> <$declareEvalSkyboxGlobalColor(_SCRIBE_NULL, HIFI_USE_FORWARD)$> - <@else@> - <@include DeferredBufferWrite.slh@> - <@endif@> -<@else@> - <@if not HIFI_USE_FORWARD@> - <@include DeferredBufferWrite.slh@> <@endif@> <@endif@> @@ -57,10 +48,9 @@ <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; - <@elif not HIFI_USE_FORWARD@> - layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> -<@else@> +<@endif@> +<@if not HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> <@if HIFI_USE_FADE@> @@ -99,12 +89,13 @@ void main(void) { <@if not HIFI_USE_UNLIT@> <@if HIFI_USE_TRANSLUCENT@> - _fragColor0 = vec4(evalGlobalLightingAlphaBlended( + vec3 normal = evalFrontOrBackFaceNormal(normalize(_normalWS)); + vec4 color = vec4(evalGlobalLightingAlphaBlended( cam._viewInverse, 1.0, DEFAULT_OCCLUSION, fragPosition, - evalFrontOrBackFaceNormal(normalize(_normalWS)), + normal, texel.rgb, fresnel, metallic, @@ -115,6 +106,12 @@ void main(void) { , DEFAULT_ROUGHNESS, texel.a), texel.a); + + <@if HIFI_USE_FORWARD@> + _fragColor0 = color; + <@else@> + packDeferredFragmentTranslucent(_prevPositionCS, normal, color.a, color.rgb, DEFAULT_ROUGHNESS); + <@endif@> <@elif HIFI_USE_FORWARD@> _fragColor0 = vec4(evalSkyboxGlobalColor( cam._viewInverse, diff --git a/libraries/render-utils/src/simple.slv b/libraries/render-utils/src/simple.slv index 9a8d3ca31f6..42aebf13a1b 100644 --- a/libraries/render-utils/src/simple.slv +++ b/libraries/render-utils/src/simple.slv @@ -28,10 +28,9 @@ <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; - <@elif not HIFI_USE_FORWARD@> - layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> -<@else@> +<@endif@> +<@if not HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; @@ -46,12 +45,13 @@ void main(void) { TransformObject obj = getTransformObject(); <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@if not HIFI_USE_UNLIT@> - <$transformModelToEyeAndClipPos(cam, obj, inPosition, _positionES, gl_Position)$> - <@elif not HIFI_USE_FORWARD@> - <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> + <$transformModelToEyeWorldAlignedPos(cam, obj, inPosition, _positionES)$> <@endif@> -<@else@> +<@endif@> +<@if not HIFI_USE_FORWARD@> <$transformModelToClipPosAndPrevClipPos(cam, obj, inPosition, gl_Position, _prevPositionCS)$> +<@else@> + <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$> <@endif@> <@if HIFI_USE_FADE@> From 277afdfa25b382cf30edf48eb50c8b03543ef5ad Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sat, 19 Dec 2020 14:05:07 -0800 Subject: [PATCH 23/34] reworking other shaders to fix amd bug --- libraries/render-utils/src/model.slf | 22 +++++------ libraries/render-utils/src/sdf_text3D.slf | 38 +++++++++++++------ libraries/render-utils/src/sdf_text3D.slv | 9 ++++- libraries/render-utils/src/simple.slf | 19 +++------- .../render-utils/src/simple_procedural.slf | 14 +++---- 5 files changed, 57 insertions(+), 45 deletions(-) diff --git a/libraries/render-utils/src/model.slf b/libraries/render-utils/src/model.slf index 09601001a68..f9fe96796bc 100644 --- a/libraries/render-utils/src/model.slf +++ b/libraries/render-utils/src/model.slf @@ -17,6 +17,12 @@ <@include CullFace.slh@> <@if not HIFI_USE_SHADOW@> + <@if HIFI_USE_FORWARD@> + layout(location=0) out vec4 _fragColor0; + <@else@> + <@include DeferredBufferWrite.slh@> + <@endif@> + <@if HIFI_USE_FORWARD or HIFI_USE_TRANSLUCENT@> <@include DefaultMaterials.slh@> <@include GlobalLight.slh@> @@ -32,16 +38,6 @@ <@endif@> <@include gpu/Transform.slh@> <$declareStandardCameraTransform()$> - - <@if HIFI_USE_FORWARD@> - layout(location=0) out vec4 _fragColor0; - <@elif HIFI_USE_UNLIT and HIFI_USE_TRANSLUCENT@> - <@include DeferredBufferWrite.slh@> - <@else@> - layout(location=0) out vec4 _fragColor0; - <@endif@> - <@else@> - <@include DeferredBufferWrite.slh@> <@endif@> <@else@> layout(location=0) out vec4 _fragColor0; @@ -316,7 +312,7 @@ void main(void) { vec4(0), vec4(0), opacity); } - _fragColor0 = vec4(evalGlobalLightingAlphaBlended( + vec4 outColor = vec4(evalGlobalLightingAlphaBlended( cam._viewInverse, 1.0, occlusion, @@ -332,8 +328,9 @@ void main(void) { , surfaceWS, opacity, localLighting.rgb), opacity); + packDeferredFragmentTranslucent(_prevPositionCS, fragNormalWS, outColor.a, outColor.rgb, roughness); <@else@> - _fragColor0 = vec4(evalLightmappedColor( + vec4 outColor = vec4(evalLightmappedColor( cam._viewInverse, 1.0, DEFAULT_OCCLUSION, @@ -341,6 +338,7 @@ void main(void) { albedo, lightmap), opacity); + packDeferredFragmentLightmap(_prevPositionCS, fragNormalWS, outColor.a, outColor.rgb, roughness, metallic, outColor.rgb); <@endif@> <@endif@> <@endif@> diff --git a/libraries/render-utils/src/sdf_text3D.slf b/libraries/render-utils/src/sdf_text3D.slf index 9996dc58eff..7b7820194b7 100644 --- a/libraries/render-utils/src/sdf_text3D.slf +++ b/libraries/render-utils/src/sdf_text3D.slf @@ -21,7 +21,9 @@ <@include gpu/Transform.slh@> <$declareStandardCameraTransform()$> +<@endif@> +<@if HIFI_USE_FORWARD@> layout(location=0) out vec4 _fragColor0; <@else@> <@include DeferredBufferWrite.slh@> @@ -34,7 +36,8 @@ <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) in vec4 _positionES; -<@else@> +<@endif@> +<@if not HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) in vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) in vec3 _normalWS; @@ -53,28 +56,35 @@ void main() { } <@endif@> + vec3 normal = normalize(_normalWS); + <@if HIFI_USE_UNLIT@> - <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> - _fragColor0 = vec4(color.rgb * isUnlitEnabled(), color.a); + vec4 outColor = vec4(color.rgb * isUnlitEnabled(), color.a); + + <@if HIFI_USE_FORWARD@> + _fragColor0 = outColor; + <@elif HIFI_USE_TRANSLUCENT@> + packDeferredFragmentTranslucent(_prevPositionCS, normal, outColor.a, outColor.rgb, DEFAULT_ROUGHNESS); <@else@> packDeferredFragmentUnlit( _prevPositionCS, - normalize(_normalWS), - color.a, - color.rgb); + normal, + outColor.a, + outColor.rgb); <@endif@> <@else@> <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> TransformCamera cam = getTransformCamera(); vec3 fragPosition = _positionES.xyz; + vec4 outColor; <@if HIFI_USE_TRANSLUCENT@> - _fragColor0 = vec4(evalGlobalLightingAlphaBlended( + outColor = vec4(evalGlobalLightingAlphaBlended( cam._viewInverse, 1.0, DEFAULT_OCCLUSION, fragPosition, - normalize(_normalWS), + normal, color.rgb, DEFAULT_FRESNEL, DEFAULT_METALLIC, @@ -82,22 +92,28 @@ void main() { DEFAULT_ROUGHNESS, color.a), color.a); <@else@> - _fragColor0 = vec4(evalSkyboxGlobalColor( + outColor = vec4(evalSkyboxGlobalColor( cam._viewInverse, 1.0, DEFAULT_OCCLUSION, fragPosition, - normalize(_normalWS), + normal, color.rgb, DEFAULT_FRESNEL, DEFAULT_METALLIC, DEFAULT_ROUGHNESS), color.a); <@endif@> + + <@if HIFI_USE_FORWARD@> + _fragColor0 = outColor; + <@else@> + packDeferredFragmentTranslucent(_prevPositionCS, normal, outColor.a, outColor.rgb, DEFAULT_ROUGHNESS); + <@endif@> <@else@> packDeferredFragment( _prevPositionCS, - normalize(_normalWS), + normal, color.a, color.rgb, DEFAULT_ROUGHNESS, diff --git a/libraries/render-utils/src/sdf_text3D.slv b/libraries/render-utils/src/sdf_text3D.slv index a9436fd7da6..7f39ade82d1 100644 --- a/libraries/render-utils/src/sdf_text3D.slv +++ b/libraries/render-utils/src/sdf_text3D.slv @@ -21,7 +21,8 @@ <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_POSITION_ES) out vec4 _positionES; -<@else@> +<@endif@> +<@if not HIFI_USE_FORWARD@> layout(location=RENDER_UTILS_ATTR_PREV_POSITION_CS) out vec4 _prevPositionCS; <@endif@> layout(location=RENDER_UTILS_ATTR_NORMAL_WS) out vec3 _normalWS; @@ -46,7 +47,11 @@ void main() { <@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> <$transformModelToEyeAndClipPos(cam, obj, position, _positionES, gl_Position)$> <@else@> - <$transformModelToClipPosAndPrevClipPos(cam, obj, position, gl_Position, _prevPositionCS)$> + <$transformModelToClipPos(cam, obj, position, gl_Position)$> +<@endif@> + +<@if not HIFI_USE_FORWARD@> + <$transformModelToPrevClipPos(cam, obj, position, _prevPositionCS)$> <@endif@> const vec3 normal = vec3(0, 0, 1); diff --git a/libraries/render-utils/src/simple.slf b/libraries/render-utils/src/simple.slf index b74e0410954..610ac094e55 100644 --- a/libraries/render-utils/src/simple.slf +++ b/libraries/render-utils/src/simple.slf @@ -141,32 +141,25 @@ void main(void) { DEFAULT_SCATTERING); <@endif@> <@else@> - <@if HIFI_USE_FORWARD@> - _fragColor0 = isUnlitEnabled() * vec4(texel.rgb + vec3 color = isUnlitEnabled() * (texel.rgb <@if HIFI_USE_FADE@> + fadeEmissive <@endif@> - , texel.a); + ); + <@if HIFI_USE_FORWARD@> + _fragColor0 = vec4(color, texel.a); <@elif HIFI_USE_TRANSLUCENT@> packDeferredFragmentTranslucentUnlit( _prevPositionCS, evalFrontOrBackFaceNormal(normalize(_normalWS)), texel.a, - texel.rgb - <@if HIFI_USE_FADE@> - + fadeEmissive - <@endif@> - ); + color); <@else@> packDeferredFragmentUnlit( _prevPositionCS, evalFrontOrBackFaceNormal(normalize(_normalWS)), 1.0, - texel.rgb - <@if HIFI_USE_FADE@> - + fadeEmissive - <@endif@> - ); + color); <@endif@> <@endif@> } diff --git a/libraries/render-utils/src/simple_procedural.slf b/libraries/render-utils/src/simple_procedural.slf index de41a380653..d0cf9a53b22 100644 --- a/libraries/render-utils/src/simple_procedural.slf +++ b/libraries/render-utils/src/simple_procedural.slf @@ -10,15 +10,13 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // -<@if not HIFI_USE_TRANSLUCENT@> - <@include DeferredBufferWrite.slh@> -<@else@> +<@include DeferredBufferWrite.slh@> + +<@if HIFI_USE_TRANSLUCENT@> <@include DefaultMaterials.slh@> <@include GlobalLight.slh@> <$declareEvalGlobalLightingAlphaBlended()$> - - layout(location=0) out vec4 _fragColor0; <@endif@> <@include gpu/Transform.slh@> @@ -168,10 +166,11 @@ void main(void) { scattering); } <@else@> + vec4 color; if (emissiveAmount > 0.0) { - _fragColor0 = vec4(diffuse, alpha); + color = vec4(diffuse, alpha); } else { - _fragColor0 = vec4(evalGlobalLightingAlphaBlended( + color = vec4(evalGlobalLightingAlphaBlended( cam._viewInverse, 1.0, occlusion, @@ -184,5 +183,6 @@ void main(void) { roughness, alpha), alpha); } + packDeferredFragmentTranslucent(_prevPositionCS, normal, color.a, color.rgb, roughness); <@endif@> } From a1b5c6cf2d6e005500d1e047114df5202dc981c9 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sat, 19 Dec 2020 15:42:19 -0800 Subject: [PATCH 24/34] cleanup --- .../display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp | 2 +- libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp | 2 +- libraries/gpu-gl-common/src/gpu/gl/GLBackend.h | 2 +- libraries/gpu/src/gpu/Backend.h | 2 +- libraries/render-utils/src/DeferredFramebuffer.cpp | 2 +- libraries/render-utils/src/DeferredFramebuffer.h | 2 -- tools/gpu-frame-player/src/RenderThread.cpp | 2 +- 7 files changed, 6 insertions(+), 8 deletions(-) diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp index bfd21be9890..e4fa39e3339 100644 --- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp +++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp @@ -357,7 +357,7 @@ void OpenGLDisplayPlugin::customizeContext() { auto presentThread = DependencyManager::get(); Q_ASSERT(thread() == presentThread->thread()); - getGLBackend()->updatePresentFrame(mat4(), true); + getGLBackend()->updatePresentFrame(mat4()); for (auto& cursorValue : _cursorsData) { auto& cursorData = cursorValue.second; diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index efdafd2f6f7..0fbfa25a04c 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -1009,7 +1009,7 @@ void GLBackend::recycle() const { _textureManagement._transferEngine->manageMemory(); } -void GLBackend::updatePresentFrame(const Mat4& correction, bool reset) { +void GLBackend::updatePresentFrame(const Mat4& correction) { auto invCorrection = glm::inverse(correction); _transform._presentFrame.correction = correction; _transform._presentFrame.correctionInverse = invCorrection; diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index 6abded4aa9f..ecbbb9de83f 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -122,7 +122,7 @@ class GLBackend : public Backend, public std::enable_shared_from_this // Shutdown rendering and persist any required resources void shutdown() override; - void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false) override; + void updatePresentFrame(const Mat4& correction = Mat4()) override; void render(const Batch& batch) final override; diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index 0fa20ed55bf..87e9fb8cc78 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -60,7 +60,7 @@ class Backend { virtual void syncProgram(const gpu::ShaderPointer& program) = 0; virtual void recycle() const = 0; virtual void downloadFramebuffer(const FramebufferPointer& srcFramebuffer, const Vec4i& region, QImage& destImage) = 0; - virtual void updatePresentFrame(const Mat4& correction = Mat4(), bool reset = false) = 0; + virtual void updatePresentFrame(const Mat4& correction = Mat4()) = 0; virtual bool supportedTextureFormat(const gpu::Element& format) = 0; diff --git a/libraries/render-utils/src/DeferredFramebuffer.cpp b/libraries/render-utils/src/DeferredFramebuffer.cpp index 661c334965e..c99073a18a2 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.cpp +++ b/libraries/render-utils/src/DeferredFramebuffer.cpp @@ -167,4 +167,4 @@ gpu::TexturePointer DeferredFramebuffer::getLightingTexture() { allocate(); } return _lightingTexture; -} \ No newline at end of file +} diff --git a/libraries/render-utils/src/DeferredFramebuffer.h b/libraries/render-utils/src/DeferredFramebuffer.h index aba9f697a29..ed107b677f5 100644 --- a/libraries/render-utils/src/DeferredFramebuffer.h +++ b/libraries/render-utils/src/DeferredFramebuffer.h @@ -15,8 +15,6 @@ #include "gpu/Resource.h" #include "gpu/Framebuffer.h" - #include "render/Engine.h" - // DeferredFramebuffer is a helper class gathering in one place the GBuffer (Framebuffer) and lighting framebuffer class DeferredFramebuffer { public: diff --git a/tools/gpu-frame-player/src/RenderThread.cpp b/tools/gpu-frame-player/src/RenderThread.cpp index c0e3d5ff695..d74551a9bc1 100644 --- a/tools/gpu-frame-player/src/RenderThread.cpp +++ b/tools/gpu-frame-player/src/RenderThread.cpp @@ -123,7 +123,7 @@ void RenderThread::renderFrame(gpu::FramePointer& frame) { { std::unique_lock lock(_frameLock); if (_correction != glm::mat4()) { - _backend->updatePresentFrame(_correction, true); + _backend->updatePresentFrame(_correction); } } _backend->recycle(); From ad71d94ed528699b421d1b41f41ac69394384ce5 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 27 Dec 2020 14:42:41 -0800 Subject: [PATCH 25/34] fix for issues TAA_3 and TAA_4 --- libraries/render-utils/src/sdf_text3D.slv | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/libraries/render-utils/src/sdf_text3D.slv b/libraries/render-utils/src/sdf_text3D.slv index 7f39ade82d1..f1c8f3dc300 100644 --- a/libraries/render-utils/src/sdf_text3D.slv +++ b/libraries/render-utils/src/sdf_text3D.slv @@ -44,16 +44,14 @@ void main() { TransformCamera cam = getTransformCamera(); TransformObject obj = getTransformObject(); -<@if HIFI_USE_TRANSLUCENT or HIFI_USE_FORWARD@> +<@if HIFI_USE_FORWARD@> <$transformModelToEyeAndClipPos(cam, obj, position, _positionES, gl_Position)$> +<@elif HIFI_USE_TRANSLUCENT@> + <$transformModelToEyeClipPosAndPrevClipPos(cam, obj, position, _positionES, gl_Position, _prevPositionCS)$> <@else@> <$transformModelToClipPos(cam, obj, position, gl_Position)$> <@endif@> -<@if not HIFI_USE_FORWARD@> - <$transformModelToPrevClipPos(cam, obj, position, _prevPositionCS)$> -<@endif@> - const vec3 normal = vec3(0, 0, 1); <$transformModelToWorldDir(cam, obj, normal, _normalWS)$> } \ No newline at end of file From a2acc66fcbe1b8880f874613b2fa159d22f5bfcc Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sun, 27 Dec 2020 23:17:44 -0800 Subject: [PATCH 26/34] render settings affect mirror too --- .../scripting/RenderScriptingInterface.cpp | 62 +++++++++++++++---- 1 file changed, 49 insertions(+), 13 deletions(-) diff --git a/interface/src/scripting/RenderScriptingInterface.cpp b/interface/src/scripting/RenderScriptingInterface.cpp index 654df929f8d..331d43e635f 100644 --- a/interface/src/scripting/RenderScriptingInterface.cpp +++ b/interface/src/scripting/RenderScriptingInterface.cpp @@ -84,10 +84,16 @@ void RenderScriptingInterface::forceRenderMethod(RenderMethod renderMethod) { _renderMethod = (int)renderMethod; _renderMethodSetting.set((int)renderMethod); - auto config = dynamic_cast(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch")); + auto renderConfig = qApp->getRenderEngine()->getConfiguration(); + auto config = dynamic_cast(renderConfig->getConfig("RenderMainView.DeferredForwardSwitch")); if (config) { config->setBranch((int)renderMethod); } + + auto secondaryConfig = dynamic_cast(renderConfig->getConfig("RenderSecondView.DeferredForwardSwitch")); + if (secondaryConfig) { + secondaryConfig->setBranch((int)renderMethod); + } }); } @@ -111,17 +117,16 @@ void RenderScriptingInterface::forceShadowsEnabled(bool enabled) { _renderSettingLock.withWriteLock([&] { _shadowsEnabled = (enabled); _shadowsEnabledSetting.set(enabled); + Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled); auto renderConfig = qApp->getRenderEngine()->getConfiguration(); assert(renderConfig); auto lightingModelConfig = renderConfig->getConfig("RenderMainView.LightingModel"); if (lightingModelConfig) { - Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled); lightingModelConfig->setShadow(enabled); } auto secondaryLightingModelConfig = renderConfig->getConfig("RenderSecondView.LightingModel"); if (secondaryLightingModelConfig) { - Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled); secondaryLightingModelConfig->setShadow(enabled); } }); @@ -142,12 +147,18 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) { _renderSettingLock.withWriteLock([&] { _ambientOcclusionEnabled = (enabled); _ambientOcclusionEnabledSetting.set(enabled); + Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled); - auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.LightingModel"); + auto renderConfig = qApp->getRenderEngine()->getConfiguration(); + auto lightingModelConfig = renderConfig->getConfig("RenderMainView.LightingModel"); if (lightingModelConfig) { - Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled); lightingModelConfig->setAmbientOcclusion(enabled); } + + auto secondaryLightingModelConfig = renderConfig->getConfig("RenderSecondView.LightingModel"); + if (secondaryLightingModelConfig) { + secondaryLightingModelConfig->setAmbientOcclusion(enabled); + } }); } @@ -191,12 +202,13 @@ void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mo _renderSettingLock.withWriteLock([&] { _antialiasingMode = mode; + auto renderConfig = qApp->getRenderEngine()->getConfiguration(); // TODO: this may be needed if there are problems with changing antialiasing settings - //auto mainViewAntialiasingSetupConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.AntialiasingSetup"); - auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.JitterCam"); - auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.Antialiasing"); - auto secondViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderSecondView.JitterCam"); - auto secondViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig("RenderSecondView.Antialiasing"); + //auto mainViewAntialiasingSetupConfig = renderConfig->getConfig("RenderMainView.AntialiasingSetup"); + auto mainViewJitterCamConfig = renderConfig->getConfig("RenderMainView.JitterCam"); + auto mainViewAntialiasingConfig = renderConfig->getConfig("RenderMainView.Antialiasing"); + auto secondViewJitterCamConfig = renderConfig->getConfig("RenderSecondView.JitterCam"); + auto secondViewAntialiasingConfig = renderConfig->getConfig("RenderSecondView.Antialiasing"); if (mode != AntialiasingConfig::Mode::NONE && mode != AntialiasingConfig::Mode::TAA && mode != AntialiasingConfig::Mode::FXAA) { @@ -208,6 +220,19 @@ void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mo if (secondViewJitterCamConfig && secondViewAntialiasingConfig) { setAntialiasingModeForView( mode, secondViewJitterCamConfig, secondViewAntialiasingConfig); } + //TODO: + + //auto secondViewAntialiasingSetupConfig = renderConfig->getConfig("RenderSecondView.AntialiasingSetup"); + //auto secondViewAntialiasingConfig = renderConfig->getConfig("RenderSecondView.Antialiasing"); + //if (secondViewAntialiasingSetupConfig && secondViewAntialiasingConfig) { + // if (enabled) { + // secondViewAntialiasingSetupConfig ->play(); + // secondViewAntialiasingConfig->setDebugFXAA(false); + // } else { + // secondViewAntialiasingSetupConfig ->none(); + // secondViewAntialiasingConfig->setDebugFXAA(true); + // } + _antialiasingModeSetting.set(_antialiasingMode); }); @@ -273,7 +298,7 @@ void RenderScriptingInterface::forceViewportResolutionScale(float scale) { return; } _renderSettingLock.withWriteLock([&] { - _viewportResolutionScale = (scale); + _viewportResolutionScale = scale; _viewportResolutionScaleSetting.set(scale); auto renderConfig = qApp->getRenderEngine()->getConfiguration(); @@ -281,12 +306,23 @@ void RenderScriptingInterface::forceViewportResolutionScale(float scale) { auto deferredView = renderConfig->getConfig("RenderMainView.RenderDeferredTask"); // mainView can be null if we're rendering in forward mode if (deferredView) { - deferredView->setProperty("resolutionScale", _viewportResolutionScale); + deferredView->setProperty("resolutionScale", scale); } auto forwardView = renderConfig->getConfig("RenderMainView.RenderForwardTask"); // mainView can be null if we're rendering in forward mode if (forwardView) { - forwardView->setProperty("resolutionScale", _viewportResolutionScale); + forwardView->setProperty("resolutionScale", scale); + } + + auto deferredSecondView = renderConfig->getConfig("RenderSecondView.RenderDeferredTask"); + // mainView can be null if we're rendering in forward mode + if (deferredSecondView) { + deferredSecondView->setProperty("resolutionScale", scale); + } + auto forwardSecondView = renderConfig->getConfig("RenderMainView.RenderForwardTask"); + // mainView can be null if we're rendering in forward mode + if (forwardSecondView) { + forwardSecondView->setProperty("resolutionScale", scale); } }); } From a40ca14aefab02bd1521cf70af8f4a75f451431e Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Mon, 28 Dec 2020 15:05:11 -0800 Subject: [PATCH 27/34] some more fixes for TAA_3 and TAA_4 + other improvements --- libraries/render-utils/src/AntialiasingEffect.cpp | 1 - libraries/render-utils/src/RenderDeferredTask.cpp | 2 +- libraries/render-utils/src/sdf_text3D.slv | 2 +- libraries/render/src/render/DrawStatus.cpp | 2 +- libraries/render/src/render/DrawStatus.h | 4 +++- 5 files changed, 6 insertions(+), 5 deletions(-) diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index 4f0c01189f7..c3abb79d268 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -216,7 +216,6 @@ const gpu::PipelinePointer& Antialiasing::getDebugBlendPipeline() { gpu::StatePointer state = std::make_shared(); PrepareStencil::testNoAA(*state); - // Good to go add the brand new pipeline _debugBlendPipeline = gpu::Pipeline::create(program, state); } diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index 1e4c929cda9..cfee877bbd2 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -388,7 +388,7 @@ void RenderDeferredTaskDebug::build(JobModel& task, const render::Varying& input // Grab a texture map representing the different status icons and assign that to the drawStatusJob auto iconMapPath = PathUtils::resourcesPath() + "icons/statusIconAtlas.svg"; auto statusIconMap = DependencyManager::get()->getImageTexture(iconMapPath, image::TextureUsage::STRICT_TEXTURE); - task.addJob("DrawStatus", opaques, DrawStatus(statusIconMap)); + task.addJob("DrawStatus", opaques, DrawStatus(statusIconMap, mainViewTransformSlot)); } const auto debugZoneInputs = DebugZoneLighting::Inputs(deferredFrameTransform, lightFrame, backgroundFrame).asVarying(); diff --git a/libraries/render-utils/src/sdf_text3D.slv b/libraries/render-utils/src/sdf_text3D.slv index f1c8f3dc300..e110b7bd9e0 100644 --- a/libraries/render-utils/src/sdf_text3D.slv +++ b/libraries/render-utils/src/sdf_text3D.slv @@ -49,7 +49,7 @@ void main() { <@elif HIFI_USE_TRANSLUCENT@> <$transformModelToEyeClipPosAndPrevClipPos(cam, obj, position, _positionES, gl_Position, _prevPositionCS)$> <@else@> - <$transformModelToClipPos(cam, obj, position, gl_Position)$> + <$transformModelToClipPosAndPrevClipPos(cam, obj, position, gl_Position, _prevPositionCS)$> <@endif@> const vec3 normal = vec3(0, 0, 1); diff --git a/libraries/render/src/render/DrawStatus.cpp b/libraries/render/src/render/DrawStatus.cpp index 5ca49e64c89..b3a6ed658f9 100644 --- a/libraries/render/src/render/DrawStatus.cpp +++ b/libraries/render/src/render/DrawStatus.cpp @@ -206,7 +206,7 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inI // Alright, something to render let's do it gpu::doInBatch("DrawStatus::run", args->_context, [&](gpu::Batch& batch) { batch.setViewportTransform(args->_viewport); - batch.setSavedViewProjectionTransform(render::RenderEngine::TS_MAIN_VIEW); + batch.setSavedViewProjectionTransform(_transformSlot); batch.setModelTransform(Transform()); // bind the one gpu::Pipeline we need diff --git a/libraries/render/src/render/DrawStatus.h b/libraries/render/src/render/DrawStatus.h index 166144d90d6..b217eb54fd5 100644 --- a/libraries/render/src/render/DrawStatus.h +++ b/libraries/render/src/render/DrawStatus.h @@ -47,7 +47,7 @@ namespace render { using JobModel = Job::ModelI; DrawStatus() {} - DrawStatus(const gpu::TexturePointer statusIconMap) { setStatusIconMap(statusIconMap); } + DrawStatus(const gpu::TexturePointer statusIconMap, uint transformSlot) : _transformSlot(transformSlot) { setStatusIconMap(statusIconMap); } void configure(const Config& config); void run(const RenderContextPointer& renderContext, const Input& input); @@ -71,6 +71,8 @@ namespace render { gpu::BufferPointer _instanceBuffer; gpu::Stream::FormatPointer _vertexFormat; gpu::TexturePointer _statusIconMap; + + uint _transformSlot; }; } From cf9e4bd0891412df9bd7fca13c3814fbfe2f9760 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Mon, 28 Dec 2020 23:55:00 -0800 Subject: [PATCH 28/34] remove unnecessary shader method --- libraries/render-utils/src/VelocityWrite.slh | 8 -------- 1 file changed, 8 deletions(-) diff --git a/libraries/render-utils/src/VelocityWrite.slh b/libraries/render-utils/src/VelocityWrite.slh index dc9918b6d50..0ef02427872 100644 --- a/libraries/render-utils/src/VelocityWrite.slh +++ b/libraries/render-utils/src/VelocityWrite.slh @@ -31,12 +31,4 @@ vec2 packVelocity(vec4 prevPositionCS) { return deltaUV; } -vec2 packVelocity(vec4 positionCS, vec4 prevPositionCS) { - vec2 uv = positionCS.xy / positionCS.w; - vec2 prevUV = prevPositionCS.xy / prevPositionCS.w; - vec2 deltaUV = (uv - prevUV) * 0.5; - // Velocity should be computed without any jitter inside. - return deltaUV; -} - <@endif@> From 6c12b4b4c5c4b3d3cc7476722ebb1ac28e0b06a1 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Thu, 28 Jan 2021 19:34:21 -0800 Subject: [PATCH 29/34] fixes and cleanup --- interface/src/raypick/ParabolaPointer.cpp | 6 ++-- interface/src/raypick/ParabolaPointer.h | 2 +- .../src/RenderableGizmoEntityItem.cpp | 4 ++- .../src/RenderableGridEntityItem.cpp | 7 +++-- .../src/RenderableImageEntityItem.cpp | 5 +++- .../src/RenderableLineEntityItem.cpp | 4 ++- .../src/RenderableMaterialEntityItem.cpp | 4 ++- .../src/RenderableModelEntityItem.cpp | 4 ++- .../src/RenderablePolyLineEntityItem.cpp | 4 ++- .../src/RenderablePolyVoxEntityItem.cpp | 4 ++- .../src/RenderableShapeEntityItem.cpp | 4 ++- .../src/RenderableTextEntityItem.cpp | 9 ++++-- .../src/RenderableWebEntityItem.cpp | 4 ++- .../gpu-gl-common/src/gpu/gl/GLBackend.cpp | 6 ++-- .../src/gpu/gl/GLBackendTransform.cpp | 7 +++-- libraries/gpu/src/gpu/Batch.cpp | 2 +- libraries/gpu/src/gpu/Batch.h | 2 +- .../render-utils/src/AntialiasingEffect.cpp | 28 ++++++++----------- .../render-utils/src/AntialiasingEffect.h | 14 ++++++++-- libraries/render-utils/src/RenderViewTask.h | 2 +- 20 files changed, 76 insertions(+), 46 deletions(-) diff --git a/interface/src/raypick/ParabolaPointer.cpp b/interface/src/raypick/ParabolaPointer.cpp index 8431ff92125..96b02fc1fd9 100644 --- a/interface/src/raypick/ParabolaPointer.cpp +++ b/interface/src/raypick/ParabolaPointer.cpp @@ -445,8 +445,10 @@ void ParabolaPointer::RenderState::ParabolaRenderItem::render(RenderArgs* args) Transform transform; transform.setTranslation(_origin); - batch.setModelTransform(transform, _prevTransform); - _prevTransform = transform; + batch.setModelTransform(transform, _prevRenderTransform); + if (args->_renderMode == RenderArgs::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == RenderArgs::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } batch.setPipeline(getParabolaPipeline(args->_renderMethod == render::Args::RenderMethod::FORWARD)); diff --git a/interface/src/raypick/ParabolaPointer.h b/interface/src/raypick/ParabolaPointer.h index 0857836e494..aa399e3b841 100644 --- a/interface/src/raypick/ParabolaPointer.h +++ b/interface/src/raypick/ParabolaPointer.h @@ -63,7 +63,7 @@ class ParabolaPointer : public PathPointer { render::ItemKey _key; glm::vec3 _origin { 0.0f }; - Transform _prevTransform; + Transform _prevRenderTransform; bool _isVisibleInSecondaryCamera { DEFAULT_PARABOLA_ISVISIBLEINSECONDARYCAMERA }; bool _drawInFront { DEFAULT_PARABOLA_DRAWINFRONT }; bool _visible { false }; diff --git a/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp b/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp index 6fcaa6d4c93..2b7d45dc4c1 100644 --- a/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp @@ -267,7 +267,9 @@ void GizmoEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition(), true)); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } Pipeline pipelineType = getPipelineType(materials); if (pipelineType == Pipeline::PROCEDURAL) { diff --git a/libraries/entities-renderer/src/RenderableGridEntityItem.cpp b/libraries/entities-renderer/src/RenderableGridEntityItem.cpp index e374fe29c06..76ae8760be4 100644 --- a/libraries/entities-renderer/src/RenderableGridEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableGridEntityItem.cpp @@ -105,7 +105,10 @@ void GridEntityRenderer::doRender(RenderArgs* args) { } transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch->setModelTransform(transform); + batch->setModelTransform(transform, _prevRenderTransform); + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } auto minCorner = glm::vec2(-0.5f, -0.5f); auto maxCorner = glm::vec2(0.5f, 0.5f); @@ -120,4 +123,4 @@ void GridEntityRenderer::doRender(RenderArgs* args) { minorGridRowDivisions, minorGridColDivisions, MINOR_GRID_EDGE, majorGridRowDivisions, majorGridColDivisions, MAJOR_GRID_EDGE, color, forward, _geometryId); -} \ No newline at end of file +} diff --git a/libraries/entities-renderer/src/RenderableImageEntityItem.cpp b/libraries/entities-renderer/src/RenderableImageEntityItem.cpp index 9592a3e57fa..2b599a25c03 100644 --- a/libraries/entities-renderer/src/RenderableImageEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableImageEntityItem.cpp @@ -189,7 +189,10 @@ void ImageEntityRenderer::doRender(RenderArgs* args) { } transform.setScale(scale); } - batch->setModelTransform(transform); + batch->setModelTransform(transform, _prevRenderTransform); + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } Pipeline pipelineType = getPipelineType(materials); if (pipelineType == Pipeline::PROCEDURAL) { diff --git a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp index 88161f8b8b4..95fe17c986e 100644 --- a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp @@ -52,7 +52,9 @@ void LineEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(modelTransform.getTranslation(), modelTransform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } if (_linePoints.size() > 1) { DependencyManager::get()->bindSimpleProgram(batch, false, false, false, false, true, diff --git a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp index e99f7b06d29..1079e2f1de8 100644 --- a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp @@ -307,7 +307,9 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); batch.setModelTransform(renderTransform, _prevRenderTransform); - _prevRenderTransform = renderTransform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = renderTransform; + } if (!proceduralRender) { drawMaterial->setTextureTransforms(textureTransform, MaterialMappingMode::UV, true); diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index cb1162db4ff..5a6697028e2 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp @@ -1475,7 +1475,9 @@ void ModelEntityRenderer::doRender(RenderArgs* args) { gpu::Batch& batch = *args->_batch; Transform transform = getModelTransform(); batch.setModelTransform(transform, _prevRenderTransform); // we want to include the scale as well - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } auto geometryCache = DependencyManager::get(); geometryCache->renderWireCubeInstance(args, batch, greenColor, geometryCache->getShapePipelinePointer(false, false, args->_renderMethod == Args::RenderMethod::FORWARD)); diff --git a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp index 9869b6438d3..1e7e3f688b2 100644 --- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp @@ -332,7 +332,9 @@ void PolyLineEntityRenderer::doRender(RenderArgs* args) { batch.setPipeline(_pipelines[{args->_renderMethod, isTransparent()}]); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } batch.setResourceTexture(0, texture); batch.draw(gpu::TRIANGLE_STRIP, (gpu::uint32)(2 * _numVertices), 0); } diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp index 580e4443986..c7581f3ec12 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp @@ -1865,7 +1865,9 @@ void PolyVoxEntityRenderer::doRender(RenderArgs* args) { args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); Transform transform(glm::translate(_position) * rotation * _lastVoxelToLocalMatrix); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } batch.setInputFormat(_vertexFormat); batch.setInputBuffer(gpu::Stream::POSITION, _mesh->getVertexBuffer()._buffer, 0, diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp index c3bd36640f0..39896b3279f 100644 --- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp @@ -117,7 +117,9 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) { withReadLock([&] { transform = _renderTransform; prevTransform = _prevRenderTransform; - _prevRenderTransform = _renderTransform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = _renderTransform; + } }); bool wireframe = render::ShapeKey(args->_globalShapeKey).isWireframe() || _primitiveMode == PrimitiveMode::LINES; diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp index a7c26985421..a60f1c5159b 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp @@ -167,7 +167,9 @@ void TextEntityRenderer::doRender(RenderArgs* args) { prevTransform = _prevRenderTransform; transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = modelTransform; + } }); batch.setModelTransform(transform, prevTransform); @@ -362,9 +364,10 @@ void entities::TextPayload::render(RenderArgs* args) { float scale = textRenderable->_lineHeight / textRenderer->getFontSize(); transform.postTranslate(glm::vec3(-0.5, 0.5, 1.0f + EPSILON / dimensions.z)); transform.setScale(scale); - batch.setModelTransform(transform); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } glm::vec2 bounds = glm::vec2(dimensions.x - (textRenderable->_leftMargin + textRenderable->_rightMargin), dimensions.y - (textRenderable->_topMargin + textRenderable->_bottomMargin)); textRenderer->draw(batch, textRenderable->_leftMargin / scale, -textRenderable->_topMargin / scale, bounds / scale, scale, diff --git a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp index 929ae8a034b..b11e5407704 100644 --- a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp @@ -319,7 +319,9 @@ void WebEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); batch.setModelTransform(transform, _prevRenderTransform); - _prevRenderTransform = transform; + if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = transform; + } // Turn off jitter for these entities batch.pushProjectionJitterEnabled(false); diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index 0fbfa25a04c..d2a8af8732d 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -1010,12 +1010,10 @@ void GLBackend::recycle() const { } void GLBackend::updatePresentFrame(const Mat4& correction) { - auto invCorrection = glm::inverse(correction); _transform._presentFrame.correction = correction; - _transform._presentFrame.correctionInverse = invCorrection; + _transform._presentFrame.correctionInverse = glm::inverse(correction); - auto& projectionJitter = _transform._projectionJitter; - projectionJitter._currentSampleIndex++; + _transform._projectionJitter._currentSampleIndex++; // Update previous views of saved transforms for (auto& viewProjState : _transform._savedTransforms) { diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp index 86f48f792ab..127b54ef750 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp @@ -232,13 +232,14 @@ void GLBackend::do_saveViewProjectionTransform(const Batch& batch, size_t paramO auto slotId = batch._params[paramOffset + 0]._uint; slotId = std::min(slotId, gpu::Batch::MAX_TRANSFORM_SAVE_SLOT_COUNT); - _transform._savedTransforms[slotId]._cameraOffset = INVALID_OFFSET; + auto& savedTransform = _transform._savedTransforms[slotId]; + savedTransform._cameraOffset = INVALID_OFFSET; _transform._currentSavedTransformSlot = slotId; // If we are saving this transform to a save slot, then it means we are tracking the history of the view // so copy the previous corrected view to the transform state. - _transform._viewProjectionState._previousCorrectedView = _transform._savedTransforms[slotId]._state._previousCorrectedView; + _transform._viewProjectionState._previousCorrectedView = savedTransform._state._previousCorrectedView; preUpdateTransform(); - _transform._savedTransforms[slotId]._state.copyExceptPrevious(_transform._viewProjectionState); + savedTransform._state.copyExceptPrevious(_transform._viewProjectionState); } void GLBackend::do_setSavedViewProjectionTransform(const Batch& batch, size_t paramOffset) { diff --git a/libraries/gpu/src/gpu/Batch.cpp b/libraries/gpu/src/gpu/Batch.cpp index a254331ffa9..bc53bf9c8e4 100644 --- a/libraries/gpu/src/gpu/Batch.cpp +++ b/libraries/gpu/src/gpu/Batch.cpp @@ -596,7 +596,7 @@ void Batch::captureDrawCallInfoImpl() { if (_invalidModel) { TransformObject object; _currentModel.getMatrix(object._model); - _previousModel.getMatrix(object._previousModel); + _previousModel.getMatrix(object._previousModel); // FIXME - we don't want to be using glm::inverse() here but it fixes the flickering issue we are // seeing with planky blocks in toybox. Our implementation of getInverseMatrix() is buggy in cases diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h index e3417d54347..df9161bdda2 100644 --- a/libraries/gpu/src/gpu/Batch.h +++ b/libraries/gpu/src/gpu/Batch.h @@ -212,7 +212,7 @@ class Batch { void setResourceTexture(uint32 slot, const TexturePointer& texture); void setResourceTexture(uint32 slot, const TextureView& view); // not a command, just a shortcut from a TextureView void setResourceTextureTable(const TextureTablePointer& table, uint32 slot = 0); - void setResourceFramebufferSwapChainTexture(uint32 slot, const FramebufferSwapChainPointer& framebuffer, unsigned int swpaChainIndex, unsigned int renderBufferSlot = 0U); // not a command, just a shortcut from a TextureView + void setResourceFramebufferSwapChainTexture(uint32 slot, const FramebufferSwapChainPointer& framebuffer, unsigned int swapChainIndex, unsigned int renderBufferSlot = 0U); // not a command, just a shortcut from a TextureView // Ouput Stage void setFramebuffer(const FramebufferPointer& framebuffer); diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp index c3abb79d268..444431fabfa 100644 --- a/libraries/render-utils/src/AntialiasingEffect.cpp +++ b/libraries/render-utils/src/AntialiasingEffect.cpp @@ -169,9 +169,7 @@ Antialiasing::Antialiasing(bool isSharpenEnabled) : } Antialiasing::~Antialiasing() { - _antialiasingBuffers.reset(); - _antialiasingTextures[0].reset(); - _antialiasingTextures[1].reset(); + _antialiasingBuffers.clear(); } const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() { @@ -267,13 +265,11 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const int width = sourceBuffer->getWidth(); int height = sourceBuffer->getHeight(); - if (_antialiasingBuffers && _antialiasingBuffers->get(0) && _antialiasingBuffers->get(0)->getSize() != uvec2(width, height)) { - _antialiasingBuffers.reset(); - _antialiasingTextures[0].reset(); - _antialiasingTextures[1].reset(); + if (_antialiasingBuffers._swapChain && _antialiasingBuffers._swapChain->get(0) && _antialiasingBuffers._swapChain->get(0)->getSize() != uvec2(width, height)) { + _antialiasingBuffers.clear(); } - if (!_antialiasingBuffers || !_intensityFramebuffer) { + if (!_antialiasingBuffers._swapChain || !_intensityFramebuffer) { std::vector antiAliasingBuffers; // Link the antialiasing FBO to texture auto format = gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA); @@ -281,10 +277,10 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const for (int i = 0; i < 2; i++) { antiAliasingBuffers.emplace_back(gpu::Framebuffer::create("antialiasing")); const auto& antiAliasingBuffer = antiAliasingBuffers.back(); - _antialiasingTextures[i] = gpu::Texture::createRenderBuffer(format, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); - antiAliasingBuffer->setRenderBuffer(0, _antialiasingTextures[i]); + _antialiasingBuffers._textures[i] = gpu::Texture::createRenderBuffer(format, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); + antiAliasingBuffer->setRenderBuffer(0, _antialiasingBuffers._textures[i]); } - _antialiasingBuffers = std::make_shared(antiAliasingBuffers); + _antialiasingBuffers._swapChain = std::make_shared(antiAliasingBuffers); _intensityTexture = gpu::Texture::createRenderBuffer(gpu::Element::COLOR_R_8, width, height, gpu::Texture::SINGLE_MIP, defaultSampler); _intensityFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("taaIntensity")); @@ -311,7 +307,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const // TAA step if (!_params->isFXAAEnabled()) { - batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaHistory, _antialiasingBuffers, 0); + batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaHistory, _antialiasingBuffers._swapChain, 0); batch.setResourceTexture(ru::Texture::TaaVelocity, velocityTexture); } else { batch.setResourceTexture(ru::Texture::TaaHistory, nullptr); @@ -327,7 +323,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const batch.setUniformBuffer(ru::Buffer::TaaParams, _params); batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredFrameTransform->getFrameTransformBuffer()); - batch.setFramebufferSwapChain(_antialiasingBuffers, 1); + batch.setFramebufferSwapChain(_antialiasingBuffers._swapChain, 1); batch.setPipeline(getAntialiasingPipeline()); batch.draw(gpu::TRIANGLE_STRIP, 4); @@ -337,11 +333,11 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const batch.setFramebuffer(sourceBuffer); if (_params->isDebug()) { batch.setPipeline(getDebugBlendPipeline()); - batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaNext, _antialiasingBuffers, 1); + batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaNext, _antialiasingBuffers._swapChain, 1); } else { batch.setPipeline(getBlendPipeline()); // Must match the binding point in the aa_blend.slf shader - batch.setResourceFramebufferSwapChainTexture(0, _antialiasingBuffers, 1); + batch.setResourceFramebufferSwapChainTexture(0, _antialiasingBuffers._swapChain, 1); // Disable sharpen if FXAA if (!_blendParamsBuffer) { _blendParamsBuffer = std::make_shared(sizeof(glm::vec4), nullptr); @@ -350,7 +346,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const batch.setUniformBuffer(0, _blendParamsBuffer); } batch.draw(gpu::TRIANGLE_STRIP, 4); - batch.advance(_antialiasingBuffers); + batch.advance(_antialiasingBuffers._swapChain); batch.setUniformBuffer(ru::Buffer::TaaParams, nullptr); batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, nullptr); diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index f21e420048a..395bf2722aa 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -216,9 +216,17 @@ class Antialiasing { const gpu::PipelinePointer& getDebugBlendPipeline(); private: - - gpu::FramebufferSwapChainPointer _antialiasingBuffers; - gpu::TexturePointer _antialiasingTextures[2]; + struct AntialiasingBuffer { + gpu::FramebufferSwapChainPointer _swapChain; + gpu::TexturePointer _textures[2]; + + void clear() { + _swapChain.reset(); + _textures[0].reset(); + _textures[1].reset(); + } + }; + AntialiasingBuffer _antialiasingBuffers; gpu::FramebufferPointer _intensityFramebuffer; gpu::TexturePointer _intensityTexture; gpu::BufferPointer _blendParamsBuffer; diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h index 22a11a9292c..8911431c884 100644 --- a/libraries/render-utils/src/RenderViewTask.h +++ b/libraries/render-utils/src/RenderViewTask.h @@ -51,7 +51,7 @@ class RenderViewTask { enum TransformOffset: uint8_t { MAIN_VIEW = 0, - SECONDARY_VIEW = 1 + SECONDARY_VIEW = 2 // each view uses 1 transform for the main view, and one for the background, so these need to be increments of 2 }; void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, From 22709dc4c0a2d68ac1f22b43d621a91de9087596 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Tue, 2 Feb 2021 21:24:03 -0800 Subject: [PATCH 30/34] save previous projection and use it for calculations to fix mirrors --- .../gpu-gl-common/src/gpu/gl/GLBackend.cpp | 1 + .../gpu-gl-common/src/gpu/gl/GLBackend.h | 1 + .../src/gpu/gl/GLBackendTransform.cpp | 18 ++++++++++----- libraries/gpu/src/gpu/Backend.cpp | 22 ++++++------------- libraries/gpu/src/gpu/Backend.h | 8 ++++--- 5 files changed, 26 insertions(+), 24 deletions(-) diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp index d2a8af8732d..e80279fa87f 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp @@ -1018,6 +1018,7 @@ void GLBackend::updatePresentFrame(const Mat4& correction) { // Update previous views of saved transforms for (auto& viewProjState : _transform._savedTransforms) { viewProjState._state._previousCorrectedView = viewProjState._state._correctedView; + viewProjState._state._previousProjection = viewProjState._state._projection; } } diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index ecbbb9de83f..826e8be6ca4 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -430,6 +430,7 @@ class GLBackend : public Backend, public std::enable_shared_from_this Transform _correctedView; Transform _previousCorrectedView; Mat4 _projection; + Mat4 _previousProjection; bool _viewIsCamera; void copyExceptPrevious(const ViewProjectionState& other) { diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp index 127b54ef750..42daa0bc1c3 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp @@ -23,6 +23,7 @@ void GLBackend::do_setViewTransform(const Batch& batch, size_t paramOffset) { // then, in consequence, the view will NOT be corrected in the present thread. In which case // the previousCorrectedView should be the same as the view. _transform._viewProjectionState._previousCorrectedView = _transform._viewProjectionState._view; + _transform._viewProjectionState._previousProjection = _transform._viewProjectionState._projection; _transform._viewProjectionState._viewIsCamera = batch._params[paramOffset + 1]._uint != 0; _transform._invalidView = true; // The current view / proj doesn't correspond to a saved camera slot @@ -131,22 +132,26 @@ void GLBackend::TransformStageState::pushCameraBufferElement(const StereoState& if (stereo.isStereo()) { #ifdef GPU_STEREO_CAMERA_BUFFER cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, jitter), + _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, + jitter), _camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, jitter))); + _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, + jitter))); #else cameras.push_back((_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, jitter))); + _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, jitter))); cameras.push_back((_camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, jitter))); + _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, jitter))); #endif } else { #ifdef GPU_STEREO_CAMERA_BUFFER cameras.push_back(CameraBufferElement( - _camera.getMonoCamera(_skybox, _viewProjectionState._correctedView, _viewProjectionState._previousCorrectedView, jitter))); + _camera.getMonoCamera(_skybox, _viewProjectionState._correctedView, _viewProjectionState._previousCorrectedView, + _viewProjectionState._previousProjection, jitter))); #else cameras.push_back((_camera.getMonoCamera(_skybox, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, jitter))); + _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, + jitter))); #endif } } @@ -238,6 +243,7 @@ void GLBackend::do_saveViewProjectionTransform(const Batch& batch, size_t paramO // If we are saving this transform to a save slot, then it means we are tracking the history of the view // so copy the previous corrected view to the transform state. _transform._viewProjectionState._previousCorrectedView = savedTransform._state._previousCorrectedView; + _transform._viewProjectionState._previousProjection = savedTransform._state._previousProjection; preUpdateTransform(); savedTransform._state.copyExceptPrevious(_transform._viewProjectionState); } diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 91eaf55a43d..63bc9d86827 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -40,6 +40,7 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const StereoState& _stereo, const Transform& view, const Transform& previousView, + const Mat4& previousProjection, Vec2 normalizedJitter) const { TransformCamera result = *this; Transform eyeView = view; @@ -58,7 +59,7 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, result._projection[2][0] += normalizedJitter.x; result._projection[2][1] += normalizedJitter.y; - result.recomputeDerived(eyeView, eyePreviousView); + result.recomputeDerived(eyeView, eyePreviousView, previousProjection); result._stereoInfo = Vec4(1.0f, (float)eye, 1.0f / result._viewport.z, 1.0f / result._viewport.w); @@ -68,6 +69,7 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, Backend::TransformCamera Backend::TransformCamera::getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, + const Mat4& previousProjection, Vec2 normalizedJitter) const { TransformCamera result = *this; @@ -76,14 +78,15 @@ Backend::TransformCamera Backend::TransformCamera::getMonoCamera(bool isSkybox, } result._projection[2][0] += normalizedJitter.x; result._projection[2][1] += normalizedJitter.y; - result.recomputeDerived(view, previousView); + result.recomputeDerived(view, previousView, previousProjection); result._stereoInfo = Vec4(0.0f, 0.0f, 1.0f / result._viewport.z, 1.0f / result._viewport.w); return result; } const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const Transform& view, - const Transform& previousView) const { + const Transform& previousView, + const Mat4& previousProjection) const { _projectionInverse = glm::inverse(_projection); // Get the viewEyeToWorld matrix form the transformView as passed to the gpu::Batch @@ -100,18 +103,7 @@ const Backend::TransformCamera& Backend::TransformCamera::recomputeDerived(const viewUntranslated = _previousView; viewUntranslated[3] = Vec4(0.0f, 0.0f, 0.0f, 1.0f); - // We suppose that the projection, including jitter, hasn't changed from previous frame - // This may sound counter-intuitive to use the same jitter value but in fact it is needed. - // Think of it this way: - // If we have no velocity (no camera or object movement) then we wish to reproject to exactly - // the same pixel value. The current pixel UV when computing the motion vector is trivially computed - // from the fragment coordinates but the previous UV is computed conceptually with an unjittered - // projection * previous view matrix in the vertex shader and sent to the fragment to write in the - // motion vector as an interpolated attribute. But since the current projection * view matrix is - // jittered, the effectively rasterized interpolated previous UV will be slightly offset. That offset - // is exactly the jitter amount. So we add that jitter amount to the projection in the projection * previous - // view matrix computation. Hope this makes sense. - _previousProjectionViewUntranslated = _projection * viewUntranslated; + _previousProjectionViewUntranslated = previousProjection * viewUntranslated; _stereoInfo = Vec4(0.0f); diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index 87e9fb8cc78..d5b3e83ccd0 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -69,11 +69,13 @@ class Backend { class TransformCamera : public _TransformCamera { public: - const Backend::TransformCamera& recomputeDerived(const Transform& view, const Transform& previousView) const; + const Backend::TransformCamera& recomputeDerived(const Transform& view, const Transform& previousView, const Mat4& previousProjection) const; // Jitter should be divided by framebuffer size - TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, Vec2 normalizedJitter) const; + TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, const Mat4& previousProjection, + Vec2 normalizedJitter) const; // Jitter should be divided by framebuffer size - TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& view, const Transform& previousView, Vec2 normalizedJitter) const; + TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& view, const Transform& previousView, + const Mat4& previousProjection, Vec2 normalizedJitter) const; }; template From 3aab937b0b09a74ca1164f18e9788345dc8086f8 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Tue, 2 Feb 2021 22:17:15 -0800 Subject: [PATCH 31/34] fix model velocity vector --- libraries/render-utils/src/CauterizedMeshPartPayload.cpp | 6 ++++-- libraries/render-utils/src/MeshPartPayload.cpp | 4 +++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp index c8180a27d6e..ba3ad2fb14b 100644 --- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp +++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp @@ -78,8 +78,10 @@ void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const Transform if (_cauterizedClusterBuffer) { batch.setUniformBuffer(graphics::slot::buffer::Skinning, _cauterizedClusterBuffer); } - batch.setModelTransform(_cauterizedTransform, _previousModelTransform); - _previousModelTransform = _cauterizedTransform; + batch.setModelTransform(_cauterizedTransform, _prevRenderTransform); + if (renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = _cauterizedTransform; + } } else { ModelMeshPartPayload::bindTransform(batch, transform, renderMode); } diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp index 03b60b661ec..55ee331e653 100644 --- a/libraries/render-utils/src/MeshPartPayload.cpp +++ b/libraries/render-utils/src/MeshPartPayload.cpp @@ -194,7 +194,9 @@ void ModelMeshPartPayload::bindTransform(gpu::Batch& batch, const Transform& tra batch.setUniformBuffer(graphics::slot::buffer::Skinning, _clusterBuffer); } batch.setModelTransform(transform, _previousModelTransform); - _previousModelTransform = _drawTransform; + if (renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { + _prevRenderTransform = _drawTransform; + } } void ModelMeshPartPayload::drawCall(gpu::Batch& batch) const { From 0208dcac4e0cee1ea0795bb507f162624624cb85 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Sat, 6 Feb 2021 21:08:59 -0800 Subject: [PATCH 32/34] this seems better? --- libraries/gpu/src/gpu/Backend.cpp | 11 +++++++++-- libraries/gpu/src/gpu/Backend.h | 4 ++-- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 63bc9d86827..9ffebd29e0f 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -40,7 +40,7 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const StereoState& _stereo, const Transform& view, const Transform& previousView, - const Mat4& previousProjection, + Mat4 previousProjection, Vec2 normalizedJitter) const { TransformCamera result = *this; Transform eyeView = view; @@ -59,6 +59,9 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, result._projection[2][0] += normalizedJitter.x; result._projection[2][1] += normalizedJitter.y; + previousProjection[2][0] += normalizedJitter.x; + previousProjection[2][1] += normalizedJitter.y; + result.recomputeDerived(eyeView, eyePreviousView, previousProjection); result._stereoInfo = Vec4(1.0f, (float)eye, 1.0f / result._viewport.z, 1.0f / result._viewport.w); @@ -69,7 +72,7 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, Backend::TransformCamera Backend::TransformCamera::getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, - const Mat4& previousProjection, + Mat4 previousProjection, Vec2 normalizedJitter) const { TransformCamera result = *this; @@ -78,6 +81,10 @@ Backend::TransformCamera Backend::TransformCamera::getMonoCamera(bool isSkybox, } result._projection[2][0] += normalizedJitter.x; result._projection[2][1] += normalizedJitter.y; + + previousProjection[2][0] += normalizedJitter.x; + previousProjection[2][1] += normalizedJitter.y; + result.recomputeDerived(view, previousView, previousProjection); result._stereoInfo = Vec4(0.0f, 0.0f, 1.0f / result._viewport.z, 1.0f / result._viewport.w); diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index d5b3e83ccd0..8d3a01df197 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -71,11 +71,11 @@ class Backend { public: const Backend::TransformCamera& recomputeDerived(const Transform& view, const Transform& previousView, const Mat4& previousProjection) const; // Jitter should be divided by framebuffer size - TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, const Mat4& previousProjection, + TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, Mat4 previousProjection, Vec2 normalizedJitter) const; // Jitter should be divided by framebuffer size TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& view, const Transform& previousView, - const Mat4& previousProjection, Vec2 normalizedJitter) const; + Mat4 previousProjection, Vec2 normalizedJitter) const; }; template From 89610a9cf8968e8e5c2eb2d27900d9a4c3f0eda5 Mon Sep 17 00:00:00 2001 From: HifiExperiments Date: Fri, 19 Feb 2021 20:23:33 -0800 Subject: [PATCH 33/34] this is a complete guess --- .../gpu-gl-common/src/gpu/gl/GLBackend.h | 4 +-- .../src/gpu/gl/GLBackendTransform.cpp | 26 +++++++++---------- libraries/gpu/src/gpu/Backend.cpp | 20 +++++++++----- libraries/gpu/src/gpu/Backend.h | 10 +++---- 4 files changed, 33 insertions(+), 27 deletions(-) diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h index 826e8be6ca4..8d07b069d6f 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h @@ -486,8 +486,8 @@ class GLBackend : public Backend, public std::enable_shared_from_this mutable List::const_iterator _camerasItr; mutable size_t _currentCameraOffset{ INVALID_OFFSET }; - void pushCameraBufferElement(const StereoState& stereo, TransformCameras& cameras) const; - void preUpdate(size_t commandIndex, const StereoState& stereo); + void pushCameraBufferElement(const StereoState& stereo, const StereoState& prevStereo, TransformCameras& cameras) const; + void preUpdate(size_t commandIndex, const StereoState& stereo, const StereoState& prevStereo); void update(size_t commandIndex, const StereoState& stereo) const; void bindCurrentCamera(int stereoSide) const; } _transform; diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp index 42daa0bc1c3..8230bbd5c44 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp @@ -124,24 +124,22 @@ void GLBackend::syncTransformStateCache() { _transform._enabledDrawcallInfoBuffer = false; } -void GLBackend::TransformStageState::pushCameraBufferElement(const StereoState& stereo, TransformCameras& cameras) const { +void GLBackend::TransformStageState::pushCameraBufferElement(const StereoState& stereo, const StereoState& prevStereo, TransformCameras& cameras) const { const float jitterAmplitude = _projectionJitter._scale; const Vec2 jitterScale = Vec2(jitterAmplitude * float(_projectionJitter._isEnabled & 1)) / Vec2(_viewport.z, _viewport.w); const Vec2 jitter = jitterScale * _projectionJitter._offset; if (stereo.isStereo()) { #ifdef GPU_STEREO_CAMERA_BUFFER - cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, - jitter), - _camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, - jitter))); + cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, prevStereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter), + _camera.getEyeCamera(1, stereo, prevStereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); #else - cameras.push_back((_camera.getEyeCamera(0, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, jitter))); - cameras.push_back((_camera.getEyeCamera(1, stereo, _viewProjectionState._correctedView, - _viewProjectionState._previousCorrectedView, _viewProjectionState._previousProjection, jitter))); + cameras.push_back((_camera.getEyeCamera(0, stereo, prevStereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); + cameras.push_back((_camera.getEyeCamera(1, stereo, prevStereo, _viewProjectionState._correctedView, + _viewProjectionState._previousCorrectedView, jitter))); #endif } else { #ifdef GPU_STEREO_CAMERA_BUFFER @@ -157,10 +155,10 @@ void GLBackend::TransformStageState::pushCameraBufferElement(const StereoState& } void GLBackend::preUpdateTransform() { - _transform.preUpdate(_commandIndex, _stereo); + _transform.preUpdate(_commandIndex, _stereo, _prevStereo); } -void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const StereoState& stereo) { +void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const StereoState& stereo, const StereoState& prevStereo) { // Check all the dirty flags and update the state accordingly if (_invalidViewport) { _camera._viewport = glm::vec4(_viewport); @@ -189,7 +187,7 @@ void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const Stereo size_t offset = _cameraUboSize * _cameras.size(); _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset)); - pushCameraBufferElement(stereo, _cameras); + pushCameraBufferElement(stereo, prevStereo, _cameras); if (_currentSavedTransformSlot != INVALID_SAVED_CAMERA_SLOT) { // Save the offset of the saved camera slot in the camera buffer. Can be used to copy // that data, or (in the future) to reuse the offset. diff --git a/libraries/gpu/src/gpu/Backend.cpp b/libraries/gpu/src/gpu/Backend.cpp index 9ffebd29e0f..c344b4c535e 100644 --- a/libraries/gpu/src/gpu/Backend.cpp +++ b/libraries/gpu/src/gpu/Backend.cpp @@ -36,25 +36,33 @@ ContextMetricSize Backend::texturePendingGPUTransferMemSize; ContextMetricSize Backend::textureResourcePopulatedGPUMemSize; ContextMetricSize Backend::textureResourceIdealGPUMemSize; +void Backend::setStereoState(const StereoState& stereo) { + _prevStereo = _stereo; + _stereo = stereo; +} + Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, - const StereoState& _stereo, + const StereoState& stereo, + const StereoState& prevStereo, const Transform& view, const Transform& previousView, - Mat4 previousProjection, Vec2 normalizedJitter) const { TransformCamera result = *this; Transform eyeView = view; Transform eyePreviousView = previousView; - if (!_stereo._skybox) { - eyeView.postTranslate(-Vec3(_stereo._eyeViews[eye][3])); - eyePreviousView.postTranslate(-Vec3(_stereo._eyeViews[eye][3])); + if (!stereo._skybox) { + eyeView.postTranslate(-Vec3(stereo._eyeViews[eye][3])); + eyePreviousView.postTranslate(-Vec3(prevStereo._eyeViews[eye][3])); } else { // FIXME: If "skybox" the ipd is set to 0 for now, let s try to propose a better solution for this in the future eyePreviousView.setTranslation(vec3()); } - result._projection = _stereo._eyeProjections[eye]; + result._projection = stereo._eyeProjections[eye]; + Mat4 previousProjection = prevStereo._eyeProjections[eye]; // Apply jitter to projections + // We divided by the framebuffer size, which was double-sized, to normalize the jitter, but we want a normal amount of jitter + // for each eye, so we multiply by 2 to get back to normal normalizedJitter.x *= 2.0f; result._projection[2][0] += normalizedJitter.x; result._projection[2][1] += normalizedJitter.y; diff --git a/libraries/gpu/src/gpu/Backend.h b/libraries/gpu/src/gpu/Backend.h index 8d3a01df197..901780829cd 100644 --- a/libraries/gpu/src/gpu/Backend.h +++ b/libraries/gpu/src/gpu/Backend.h @@ -53,7 +53,7 @@ class Backend { virtual void shutdown() {} virtual const std::string& getVersion() const = 0; - void setStereoState(const StereoState& stereo) { _stereo = stereo; } + void setStereoState(const StereoState& stereo); virtual void render(const Batch& batch) = 0; virtual void syncCache() = 0; @@ -71,11 +71,10 @@ class Backend { public: const Backend::TransformCamera& recomputeDerived(const Transform& view, const Transform& previousView, const Mat4& previousProjection) const; // Jitter should be divided by framebuffer size - TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, Mat4 previousProjection, - Vec2 normalizedJitter) const; + TransformCamera getMonoCamera(bool isSkybox, const Transform& view, Transform previousView, Mat4 previousProjection, Vec2 normalizedJitter) const; // Jitter should be divided by framebuffer size - TransformCamera getEyeCamera(int eye, const StereoState& stereo, const Transform& view, const Transform& previousView, - Mat4 previousProjection, Vec2 normalizedJitter) const; + TransformCamera getEyeCamera(int eye, const StereoState& stereo, const StereoState& prevStereo, const Transform& view, const Transform& previousView, + Vec2 normalizedJitter) const; }; template @@ -134,6 +133,7 @@ class Backend { friend class Context; mutable ContextStats _stats; StereoState _stereo; + StereoState _prevStereo; }; } From 6e3586b2366f0f6b51460622342093e763993443 Mon Sep 17 00:00:00 2001 From: ksuprynowicz Date: Sun, 2 Jul 2023 21:57:25 +0200 Subject: [PATCH 34/34] Fixes after TAA rebase --- .../dialogs/graphics/GraphicsSettings.qml | 3 +- .../scripting/RenderScriptingInterface.cpp | 40 ++++++------- .../src/scripting/RenderScriptingInterface.h | 12 ++-- .../src/RenderableMaterialEntityItem.cpp | 5 +- .../src/RenderableTextEntityItem.cpp | 3 +- .../src/textured_particle.slv | 8 +-- .../src/gpu/gl/GLBackendTransform.cpp | 3 +- .../render-utils/src/AntialiasingEffect.h | 59 ++++++++++--------- .../src/CauterizedMeshPartPayload.cpp | 5 +- .../render-utils/src/MeshPartPayload.cpp | 9 ++- libraries/render-utils/src/MeshPartPayload.h | 5 +- .../render-utils/src/drawWorkloadProxy.slv | 10 +++- 12 files changed, 89 insertions(+), 73 deletions(-) diff --git a/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml b/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml index 707a890edb9..3a4b6af53ff 100644 --- a/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml +++ b/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml @@ -4,6 +4,7 @@ // // Created by Zach Fox on 2019-07-10 // Copyright 2019 High Fidelity, Inc. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -501,7 +502,7 @@ Flickable { ListModel { id: antialiasingModel - // Maintain same order as "AntialiasingConfig::Mode". + // Maintain same order as "AntialiasingSetupConfig::Mode". ListElement { text: "None" } diff --git a/interface/src/scripting/RenderScriptingInterface.cpp b/interface/src/scripting/RenderScriptingInterface.cpp index 331d43e635f..5243bacae32 100644 --- a/interface/src/scripting/RenderScriptingInterface.cpp +++ b/interface/src/scripting/RenderScriptingInterface.cpp @@ -19,14 +19,14 @@ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){ auto scriptEngine = manager->engine().get(); scriptRegisterMetaType, scriptValueToEnumClass >(scriptEngine, "RenderMethod"); - scriptRegisterMetaType, scriptValueToEnumClass >(scriptEngine, "Mode"); + scriptRegisterMetaType, scriptValueToEnumClass >(scriptEngine, "Mode"); })); STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){ auto scriptEngine = manager->engine().get(); scriptEngine->registerEnum("Render.RenderMethod",QMetaEnum::fromType()); - scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType()); + scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType()); }); RenderScriptingInterface* RenderScriptingInterface::getInstance() { @@ -49,7 +49,7 @@ void RenderScriptingInterface::loadSettings() { _shadowsEnabled = (_shadowsEnabledSetting.get()); _ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get()); //_antialiasingMode = (_antialiasingModeSetting.get()); - _antialiasingMode = static_cast(_antialiasingModeSetting.get()); + _antialiasingMode = static_cast(_antialiasingModeSetting.get()); _viewportResolutionScale = (_viewportResolutionScaleSetting.get()); _fullScreenScreen = (_fullScreenScreenSetting.get()); }); @@ -162,57 +162,57 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) { }); } -AntialiasingConfig::Mode RenderScriptingInterface::getAntialiasingMode() const { +AntialiasingSetupConfig::Mode RenderScriptingInterface::getAntialiasingMode() const { return _antialiasingMode; } -void RenderScriptingInterface::setAntialiasingMode(AntialiasingConfig::Mode mode) { +void RenderScriptingInterface::setAntialiasingMode(AntialiasingSetupConfig::Mode mode) { if (_antialiasingMode != mode) { forceAntialiasingMode(mode); emit settingsChanged(); } } -void setAntialiasingModeForView(AntialiasingConfig::Mode mode, JitterSampleConfig *jitterCamConfig, AntialiasingConfig *antialiasingConfig) { +void setAntialiasingModeForView(AntialiasingSetupConfig::Mode mode, AntialiasingSetupConfig *antialiasingSetupConfig, AntialiasingConfig *antialiasingConfig) { switch (mode) { - case AntialiasingConfig::Mode::NONE: - jitterCamConfig->none(); + case AntialiasingSetupConfig::Mode::NONE: + antialiasingSetupConfig->none(); antialiasingConfig->blend = 1; antialiasingConfig->setDebugFXAA(false); break; - case AntialiasingConfig::Mode::TAA: - jitterCamConfig->play(); + case AntialiasingSetupConfig::Mode::TAA: + antialiasingSetupConfig->play(); antialiasingConfig->blend = 0.25; antialiasingConfig->setDebugFXAA(false); break; - case AntialiasingConfig::Mode::FXAA: - jitterCamConfig->none(); + case AntialiasingSetupConfig::Mode::FXAA: + antialiasingSetupConfig->none(); antialiasingConfig->blend = 0.25; antialiasingConfig->setDebugFXAA(true); break; default: - jitterCamConfig->none(); + antialiasingSetupConfig->none(); antialiasingConfig->blend = 1; antialiasingConfig->setDebugFXAA(false); break; } } -void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mode) { +void RenderScriptingInterface::forceAntialiasingMode(AntialiasingSetupConfig::Mode mode) { _renderSettingLock.withWriteLock([&] { _antialiasingMode = mode; auto renderConfig = qApp->getRenderEngine()->getConfiguration(); // TODO: this may be needed if there are problems with changing antialiasing settings //auto mainViewAntialiasingSetupConfig = renderConfig->getConfig("RenderMainView.AntialiasingSetup"); - auto mainViewJitterCamConfig = renderConfig->getConfig("RenderMainView.JitterCam"); + auto mainViewJitterCamConfig = renderConfig->getConfig("RenderMainView.JitterCam"); auto mainViewAntialiasingConfig = renderConfig->getConfig("RenderMainView.Antialiasing"); - auto secondViewJitterCamConfig = renderConfig->getConfig("RenderSecondView.JitterCam"); + auto secondViewJitterCamConfig = renderConfig->getConfig("RenderSecondView.JitterCam"); auto secondViewAntialiasingConfig = renderConfig->getConfig("RenderSecondView.Antialiasing"); - if (mode != AntialiasingConfig::Mode::NONE - && mode != AntialiasingConfig::Mode::TAA - && mode != AntialiasingConfig::Mode::FXAA) { - _antialiasingMode = AntialiasingConfig::Mode::NONE; + if (mode != AntialiasingSetupConfig::Mode::NONE + && mode != AntialiasingSetupConfig::Mode::TAA + && mode != AntialiasingSetupConfig::Mode::FXAA) { + _antialiasingMode = AntialiasingSetupConfig::Mode::NONE; } if (mainViewJitterCamConfig && mainViewAntialiasingConfig) { setAntialiasingModeForView( mode, mainViewJitterCamConfig, mainViewAntialiasingConfig); diff --git a/interface/src/scripting/RenderScriptingInterface.h b/interface/src/scripting/RenderScriptingInterface.h index 2025c715105..dd95cca568e 100644 --- a/interface/src/scripting/RenderScriptingInterface.h +++ b/interface/src/scripting/RenderScriptingInterface.h @@ -39,7 +39,7 @@ class RenderScriptingInterface : public QObject { Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged) Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled NOTIFY settingsChanged) Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged) - Q_PROPERTY(AntialiasingConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged) + Q_PROPERTY(AntialiasingSetupConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged) Q_PROPERTY(float viewportResolutionScale READ getViewportResolutionScale WRITE setViewportResolutionScale NOTIFY settingsChanged) Q_PROPERTY(float verticalFieldOfView READ getVerticalFieldOfView WRITE setVerticalFieldOfView NOTIFY settingsChanged) @@ -153,14 +153,14 @@ public slots: * @function Render.getAntialiasingMode * @returns {AntialiasingMode} The active anti-aliasing mode. */ - AntialiasingConfig::Mode getAntialiasingMode() const; + AntialiasingSetupConfig::Mode getAntialiasingMode() const; /*@jsdoc * Sets the active anti-aliasing mode. * @function Render.setAntialiasingMode * @param {AntialiasingMode} The active anti-aliasing mode. */ - void setAntialiasingMode(AntialiasingConfig::Mode mode); + void setAntialiasingMode(AntialiasingSetupConfig::Mode mode); /*@jsdoc * Gets the view port resolution scale. @@ -236,7 +236,7 @@ public slots: int _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED }; bool _shadowsEnabled{ true }; bool _ambientOcclusionEnabled{ false }; - AntialiasingConfig::Mode _antialiasingMode{ AntialiasingConfig::Mode::NONE }; + AntialiasingSetupConfig::Mode _antialiasingMode{ AntialiasingSetupConfig::Mode::NONE }; float _viewportResolutionScale{ 1.0f }; QString _fullScreenScreen; @@ -246,7 +246,7 @@ public slots: Setting::Handle _shadowsEnabledSetting { "shadowsEnabled", true }; Setting::Handle _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", false }; //Setting::Handle _antialiasingModeSetting { "antialiasingMode", AntialiasingConfig::Mode::TAA }; - Setting::Handle _antialiasingModeSetting { "antialiasingMode", AntialiasingConfig::Mode::NONE }; + Setting::Handle _antialiasingModeSetting { "antialiasingMode", AntialiasingSetupConfig::Mode::NONE }; Setting::Handle _viewportResolutionScaleSetting { "viewportResolutionScale", 1.0f }; Setting::Handle _fullScreenScreenSetting { "fullScreenScreen", "" }; @@ -254,7 +254,7 @@ public slots: void forceRenderMethod(RenderMethod renderMethod); void forceShadowsEnabled(bool enabled); void forceAmbientOcclusionEnabled(bool enabled); - void forceAntialiasingMode(AntialiasingConfig::Mode mode); + void forceAntialiasingMode(AntialiasingSetupConfig::Mode mode); void forceViewportResolutionScale(float scale); static std::once_flag registry_flag; diff --git a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp index 1079e2f1de8..57a0e87faec 100644 --- a/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp @@ -2,6 +2,7 @@ // Created by Sam Gondelman on 1/18/2018 // Copyright 2018 High Fidelity, Inc. // Copyright 2020 Vircadia contributors. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -306,9 +307,9 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); - batch.setModelTransform(renderTransform, _prevRenderTransform); + batch.setModelTransform(transform, _prevRenderTransform); if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { - _prevRenderTransform = renderTransform; + _prevRenderTransform = transform; } if (!proceduralRender) { diff --git a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp index a60f1c5159b..bebb6c169dc 100644 --- a/libraries/entities-renderer/src/RenderableTextEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableTextEntityItem.cpp @@ -5,6 +5,7 @@ // Created by Brad Hefta-Gaub on 8/6/14. // Copyright 2014 High Fidelity, Inc. // Copyright 2020 Vircadia contributors. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -168,7 +169,7 @@ void TextEntityRenderer::doRender(RenderArgs* args) { transform.setRotation(BillboardModeHelpers::getBillboardRotation(transform.getTranslation(), transform.getRotation(), _billboardMode, args->_renderMode == RenderArgs::RenderMode::SHADOW_RENDER_MODE ? BillboardModeHelpers::getPrimaryViewFrustumPosition() : args->getViewFrustum().getPosition())); if (args->_renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { - _prevRenderTransform = modelTransform; + _prevRenderTransform = transform; } }); diff --git a/libraries/entities-renderer/src/textured_particle.slv b/libraries/entities-renderer/src/textured_particle.slv index 483acadd35a..ed4c5c57639 100644 --- a/libraries/entities-renderer/src/textured_particle.slv +++ b/libraries/entities-renderer/src/textured_particle.slv @@ -5,6 +5,7 @@ // texture_particle.vert // // Copyright 2015 High Fidelity, Inc. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -172,12 +173,5 @@ void main(void) { ); vec4 quadPos = radius * vec4(UNIT_QUAD[twoTriID], 0.0); vec4 eyePos = anchorPoint + rotation * quadPos; - -<@if not HIFI_USE_FORWARD@> - vec3 normalEye = vec3(0.0f, 0.0f, 1.0f); - <$transformEyeToWorldDir(cam, normalEye, _normalWS)$> - <$transformEyeToClipPosAndPrevClipPos(cam, eyePos, gl_Position, _prevPositionCS)$> -<@else@> <$transformEyeToClipPos(cam, eyePos, gl_Position)$> -<@endif@> } diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp index 8230bbd5c44..0f07fde876c 100644 --- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp +++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendTransform.cpp @@ -4,6 +4,7 @@ // // Created by Sam Gateau on 3/8/2015. // Copyright 2014 High Fidelity, Inc. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -31,7 +32,7 @@ void GLBackend::do_setViewTransform(const Batch& batch, size_t paramOffset) { } void GLBackend::do_setProjectionTransform(const Batch& batch, size_t paramOffset) { - memcpy(glm::value_ptr(_transform._projection), batch.readData(batch._params[paramOffset]._uint), sizeof(Mat4)); + memcpy(glm::value_ptr(_transform._viewProjectionState._projection), batch.readData(batch._params[paramOffset]._uint), sizeof(Mat4)); _transform._invalidProj = true; // The current view / proj doesn't correspond to a saved camera slot _transform._currentSavedTransformSlot = INVALID_SAVED_CAMERA_SLOT; diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h index 395bf2722aa..c2c4f530573 100644 --- a/libraries/render-utils/src/AntialiasingEffect.h +++ b/libraries/render-utils/src/AntialiasingEffect.h @@ -28,12 +28,38 @@ class AntialiasingSetupConfig : public render::Job::Config { Q_PROPERTY(bool freeze MEMBER freeze NOTIFY dirty) Q_PROPERTY(bool stop MEMBER stop NOTIFY dirty) Q_PROPERTY(int index READ getIndex NOTIFY dirty) + Q_PROPERTY(int state READ getState WRITE setState NOTIFY dirty) + Q_PROPERTY(int mode READ getAAMode WRITE setAAMode NOTIFY dirty) + public: AntialiasingSetupConfig() : render::Job::Config(true) {} + /*@jsdoc + *Antialiasing modes. + * + * + * + * + * + * + * + * + * + *
ValueNameDescription
0NONEAntialiasing is disabled.
1TAATemporal Antialiasing.
2FXAAFXAA.
3MODE_COUNTInducates number of antialiasing modes
+ * @typedef {number} AntialiasingMode + */ + enum Mode { + NONE = 0, + TAA, + FXAA, + MODE_COUNT + }; + Q_ENUM(Mode) // Stored as signed int. + float scale { 0.75f }; bool stop { false }; bool freeze { false }; + int mode { TAA }; void setIndex(int current); void setState(int state); @@ -48,6 +74,10 @@ public slots: int getIndex() const { return _index; } int getState() const { return _state; } + + void setAAMode(int mode); + int getAAMode() const { return mode; } + signals: void dirty(); @@ -76,6 +106,7 @@ class AntialiasingSetup { int _freezedSampleIndex { 0 }; bool _isStopped { false }; bool _isFrozen { false }; + int _mode { AntialiasingSetupConfig::Mode::TAA }; }; @@ -102,37 +133,9 @@ class AntialiasingConfig : public render::Job::Config { public: AntialiasingConfig() : render::Job::Config(true) {} - /*@jsdoc - *Antialiasing modes. - * - * - * - * - * - * - * - * - * - *
ValueNameDescription
0NONEAntialiasing is disabled.
1TAATemporal Antialiasing.
2FXAAFXAA.
3MODE_COUNTInducates number of antialiasing modes
- * @typedef {number} AntialiasingMode - */ - enum Mode { - NONE = 0, - TAA, - FXAA, - MODE_COUNT - }; - Q_ENUM(Mode) // Stored as signed int. - - void setAAMode(int mode); - int getAAMode() const { return _mode; } - void setDebugFXAA(bool debug) { debugFXAAX = (debug ? 0.0f : 1.0f); emit dirty();} bool debugFXAA() const { return (debugFXAAX == 0.0f ? true : false); } - // TODO: _mode appears in 2 different classes - int _mode{ TAA }; // '_' prefix but not private? - float blend { 0.2f }; float sharpen { 0.05f }; diff --git a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp index ba3ad2fb14b..2238b4be7fb 100644 --- a/libraries/render-utils/src/CauterizedMeshPartPayload.cpp +++ b/libraries/render-utils/src/CauterizedMeshPartPayload.cpp @@ -5,6 +5,7 @@ // Created by Andrew Meadows 2017.01.17 // Copyright 2017 High Fidelity, Inc. // Copyright 2020 Vircadia contributors. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -78,9 +79,9 @@ void CauterizedMeshPartPayload::bindTransform(gpu::Batch& batch, const Transform if (_cauterizedClusterBuffer) { batch.setUniformBuffer(graphics::slot::buffer::Skinning, _cauterizedClusterBuffer); } - batch.setModelTransform(_cauterizedTransform, _prevRenderTransform); + batch.setModelTransform(_cauterizedTransform, _previousRenderTransform); if (renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { - _prevRenderTransform = _cauterizedTransform; + _previousRenderTransform = _cauterizedTransform; } } else { ModelMeshPartPayload::bindTransform(batch, transform, renderMode); diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp index 55ee331e653..d6de057307e 100644 --- a/libraries/render-utils/src/MeshPartPayload.cpp +++ b/libraries/render-utils/src/MeshPartPayload.cpp @@ -5,6 +5,7 @@ // Created by Sam Gateau on 10/3/15. // Copyright 2015 High Fidelity, Inc. // Copyright 2020 Vircadia contributors. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -193,9 +194,13 @@ void ModelMeshPartPayload::bindTransform(gpu::Batch& batch, const Transform& tra if (_clusterBuffer) { batch.setUniformBuffer(graphics::slot::buffer::Skinning, _clusterBuffer); } - batch.setModelTransform(transform, _previousModelTransform); + // TODO: I'm not sure of this + //batch.setModelTransform(transform, _previousModelTransform); + batch.setModelTransform(transform, _previousRenderTransform); if (renderMode == Args::RenderMode::DEFAULT_RENDER_MODE || renderMode == Args::RenderMode::MIRROR_RENDER_MODE) { - _prevRenderTransform = _drawTransform; + // TODO: I'm not sure of this + //_prevRenderTransform = _drawTransform; + _previousRenderTransform = transform; } } diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h index f0a1a418c3f..b185ff9c9e9 100644 --- a/libraries/render-utils/src/MeshPartPayload.h +++ b/libraries/render-utils/src/MeshPartPayload.h @@ -5,6 +5,7 @@ // Created by Sam Gateau on 10/3/15. // Copyright 2015 High Fidelity, Inc. // Copyright 2020 Vircadia contributors. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -68,6 +69,9 @@ class ModelMeshPartPayload { static bool enableMaterialProceduralShaders; +protected: + mutable Transform _previousRenderTransform; + private: void initCache(const ModelPointer& model, int shapeID); @@ -100,7 +104,6 @@ class ModelMeshPartPayload { Transform _parentTransform; graphics::Box _localBound; graphics::Box _adjustedLocalBound; - //TODO: add mutable Transform _previousModelTransform; ? }; namespace render { diff --git a/libraries/render-utils/src/drawWorkloadProxy.slv b/libraries/render-utils/src/drawWorkloadProxy.slv index f728f94afcb..a6e5ab7022e 100644 --- a/libraries/render-utils/src/drawWorkloadProxy.slv +++ b/libraries/render-utils/src/drawWorkloadProxy.slv @@ -7,6 +7,7 @@ // // Created by Sam Gateau on 6/29/2015. // Copyright 2015 High Fidelity, Inc. +// Copyright 2023 Overte e.V. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html @@ -28,8 +29,13 @@ vec4 getPosition(WorkloadProxy proxy, vec4 spriteVert, vec4 proxyPosEye) { vec3 dirZ = -normalize(proxyPosEye.xyz); vec3 dirX = normalize(cross(vec3(0.0, 1.0, 0.0), dirZ)); vec3 dirY = vec3(0.0, 1.0, 0.0); - - return vec4(proxyPosEye.xyz + proxy.sphere.w * (dirX * spriteVert.x + dirY * spriteVert.y /* + dirZ * spriteVert.z*/), 1.0); + // Workaround for Nvidia driver bug + vec4 pos = vec4(1.0, 1.0, 1.0, 1.0); + pos.x = proxyPosEye.x + proxy.sphere.w * ( dirX.x * spriteVert.x + dirY.x * spriteVert.y + dirZ.x * spriteVert.z); + pos.y = proxyPosEye.y + proxy.sphere.w * ( dirX.y * spriteVert.x + dirY.y * spriteVert.y + dirZ.y * spriteVert.z); + pos.z = proxyPosEye.z + proxy.sphere.w * ( dirX.z * spriteVert.x + dirY.z * spriteVert.y + dirZ.z * spriteVert.z); + return pos; + //return vec4(proxyPosEye.xyz + proxy.sphere.w * (dirX * spriteVert.x + dirY * spriteVert.y /* + dirZ * spriteVert.z*/), 1.0); } void main(void) {