Fix progressive antialiasing

There were two problems with the antialiasing. The default materials
inside container were never cleared dirty. The subpresentation rendering
didn't correctly set the dirty flags when the same subpresentation is
rendered multiple times.

Task-number: QT3DS-1796
Change-Id: Ice1942ec4b919df009c59aa3ffdfc8efd430db1e
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
Reviewed-by: Jari Karppinen <jari.karppinen@qt.io>
Reviewed-by: Pasi Keränen <pasi.keranen@qt.io>

1 files changed, 14 insertions, 17 deletions

diff --git a/src/runtimerender/rendererimpl/Qt3DSRendererImplLayerRenderPreparationData.cpp b/src/runtimerender/rendererimpl/Qt3DSRendererImplLayerRenderPreparationData.cpp
index 5d1e4ed..6dcd4c9 100644
--- a/src/runtimerender/rendererimpl/Qt3DSRendererImplLayerRenderPreparationData.cpp
+++ b/src/runtimerender/rendererimpl/Qt3DSRendererImplLayerRenderPreparationData.cpp
@@ -501,10 +501,8 @@ namespace render {
 
             if (theMaterial != NULL && theMaterial->m_Type == GraphObjectTypes::DefaultMaterial) {
                 SDefaultMaterial *theDefaultMaterial = static_cast<SDefaultMaterial *>(theMaterial);
-                // Don't clear dirty flags if the material was referenced.
-                bool clearMaterialFlags = theMaterial == inPath.m_Material;
                 SDefaultMaterialPreparationResult prepResult(PrepareDefaultMaterialForRender(
-                    *theDefaultMaterial, theFlags, subsetOpacity, clearMaterialFlags));
+                    *theDefaultMaterial, theFlags, subsetOpacity));
 
                 theFlags = prepResult.m_RenderableFlags;
                 if (inPath.m_PathType == PathTypes::Geometry) {
@@ -546,7 +544,8 @@ namespace render {
                 // Don't clear dirty flags if the material was referenced.
                 // bool clearMaterialFlags = theMaterial == inPath.m_Material;
                 SDefaultMaterialPreparationResult prepResult(
-                    PrepareCustomMaterialForRender(*theCustomMaterial, theFlags, subsetOpacity));
+                    PrepareCustomMaterialForRender(*theCustomMaterial, theFlags, subsetOpacity,
+                                                   retval));
 
                 theFlags = prepResult.m_RenderableFlags;
                 if (inPath.m_PathType == PathTypes::Geometry) {
@@ -661,8 +660,7 @@ namespace render {
     }
 
     SDefaultMaterialPreparationResult SLayerRenderPreparationData::PrepareDefaultMaterialForRender(
-        SDefaultMaterial &inMaterial, SRenderableObjectFlags &inExistingFlags, QT3DSF32 inOpacity,
-        bool inClearDirtyFlags)
+        SDefaultMaterial &inMaterial, SRenderableObjectFlags &inExistingFlags, QT3DSF32 inOpacity)
     {
         SDefaultMaterial *theMaterial = &inMaterial;
         SDefaultMaterialPreparationResult retval(GenerateLightingKey(theMaterial->m_Lighting));
@@ -676,8 +674,6 @@ namespace render {
             renderableFlags |= RenderPreparationResultFlagValues::Dirty;
         }
         subsetOpacity *= theMaterial->m_Opacity;
-        if (inClearDirtyFlags)
-            theMaterial->m_Dirty.UpdateDirtyForFrame();
 
         SRenderableImage *firstImage = NULL;
 
@@ -781,11 +777,14 @@ namespace render {
         retval.m_FirstImage = firstImage;
         if (retval.m_RenderableFlags.IsDirty())
             retval.m_Dirty = true;
+        if (retval.m_Dirty)
+            m_Renderer.addMaterialDirtyClear(&inMaterial);
         return retval;
     }
 
     SDefaultMaterialPreparationResult SLayerRenderPreparationData::PrepareCustomMaterialForRender(
-        SCustomMaterial &inMaterial, SRenderableObjectFlags &inExistingFlags, QT3DSF32 inOpacity)
+        SCustomMaterial &inMaterial, SRenderableObjectFlags &inExistingFlags, QT3DSF32 inOpacity,
+        bool alreadyDirty)
     {
         SDefaultMaterialPreparationResult retval(GenerateLightingKey(
             DefaultMaterialLighting::FragmentLighting)); // always fragment lighting
@@ -837,6 +836,8 @@ namespace render {
 #undef CHECK_IMAGE_AND_PREPARE
 
         retval.m_FirstImage = firstImage;
+        if (retval.m_Dirty || alreadyDirty)
+            m_Renderer.addMaterialDirtyClear(&inMaterial);
         return retval;
     }
 
@@ -927,10 +928,6 @@ namespace render {
                         subsetDirty | (theSubset.m_WireframeMode != inModel.m_WireframeMode);
                     inModel.m_WireframeMode = false;
                 }
-                // Only clear flags on the materials in this direct hierarchy.  Do not clear them of
-                // this
-                // references materials in another hierarchy.
-                bool clearMaterialDirtyFlags = theMaterialObject == theSourceMaterialObject;
 
                 if (theMaterialObject == NULL)
                     continue;
@@ -939,8 +936,8 @@ namespace render {
                     SDefaultMaterial &theMaterial(
                         static_cast<SDefaultMaterial &>(*theMaterialObject));
                     SDefaultMaterialPreparationResult theMaterialPrepResult(
-                        PrepareDefaultMaterialForRender(theMaterial, renderableFlags, subsetOpacity,
-                                                        clearMaterialDirtyFlags));
+                        PrepareDefaultMaterialForRender(theMaterial, renderableFlags,
+                                                        subsetOpacity));
                     SShaderDefaultMaterialKey theGeneratedKey = theMaterialPrepResult.m_MaterialKey;
                     subsetOpacity = theMaterialPrepResult.m_Opacity;
                     SRenderableImage *firstImage(theMaterialPrepResult.m_FirstImage);
@@ -969,11 +966,11 @@ namespace render {
                     ICustomMaterialSystem &theMaterialSystem(
                         qt3dsContext.GetCustomMaterialSystem());
                     subsetDirty |= theMaterialSystem.PrepareForRender(
-                        theModelContext.m_Model, theSubset, theMaterial, clearMaterialDirtyFlags);
+                        theModelContext.m_Model, theSubset, theMaterial);
 
                     SDefaultMaterialPreparationResult theMaterialPrepResult(
                         PrepareCustomMaterialForRender(theMaterial, renderableFlags,
-                                                       subsetOpacity));
+                                                       subsetOpacity, subsetDirty));
                     SShaderDefaultMaterialKey theGeneratedKey = theMaterialPrepResult.m_MaterialKey;
                     subsetOpacity = theMaterialPrepResult.m_Opacity;
                     SRenderableImage *firstImage(theMaterialPrepResult.m_FirstImage);