Use images with dynamic object textures

Task-number: QT3DS-4063
Change-Id: Ia07f21be65ebda9733773504eb2e0ddce4009fab
Reviewed-by: Kaj Grönholm <kaj.gronholm@qt.io>
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>

1 files changed, 30 insertions, 139 deletions

diff --git a/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp b/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
index 4dade3f..1b2e6a0 100644
--- a/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
+++ b/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
@@ -875,8 +875,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
     TShaderMap m_ShaderMap;
     nvvector<TCustomMaterialTextureEntry> m_TextureEntries;
     nvvector<SCustomMaterialBuffer> m_AllocatedBuffers;
-    nvvector<TAllocatedImageEntry> m_AllocatedImages;
-    nvvector<SCustomMaterial::TImageMapHash *> m_materialImageMaps;
     bool m_UseFastBlits;
     eastl::string m_ShaderNameBuilder;
     QT3DSU64 m_LastFrameTime;
@@ -891,8 +889,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
         , m_ShaderMap(ct.GetAllocator(), "SMaterialSystem::m_ShaderMap")
         , m_TextureEntries(ct.GetAllocator(), "SMaterialSystem::m_TextureEntries")
         , m_AllocatedBuffers(ct.GetAllocator(), "SMaterialSystem::m_AllocatedBuffers")
-        , m_AllocatedImages(ct.GetAllocator(), "SMaterialSystem::m_AllocatedImages")
-        , m_materialImageMaps(ct.GetAllocator(), "SMaterialSystem::m_materialImageMaps")
         , m_UseFastBlits(true)
         , m_LastFrameTime(0)
         , m_MillisecondsSinceLastFrame(0)
@@ -914,18 +910,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
     {
         while (m_AllocatedBuffers.size())
             ReleaseBuffer(0);
-
-        for (QT3DSU32 idx = 0; idx < m_AllocatedImages.size(); ++idx) {
-            SImage *pImage = m_AllocatedImages[idx].second;
-            QT3DS_FREE(m_CoreContext.GetAllocator(), pImage);
-        }
-        for (QT3DSU32 idx = 0; idx < m_materialImageMaps.size(); ++idx) {
-            auto *matmap = m_materialImageMaps[idx];
-            matmap->~nvhash_map();
-            QT3DS_FREE(m_CoreContext.GetAllocator(), matmap);
-        }
-        m_materialImageMaps.clear();
-        m_AllocatedImages.clear();
     }
 
     void ReleaseBuffer(QT3DSU32 inIdx)
@@ -1014,14 +998,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
         return m_AllocatedBuffers.size();
     }
 
-    virtual QT3DSU32 FindAllocatedImage(CRegisteredString inName)
-    {
-        for (QT3DSU32 idx = 0, end = m_AllocatedImages.size(); idx < end; ++idx)
-            if (m_AllocatedImages[idx].first == inName)
-                return idx;
-        return QT3DSU32(-1);
-    }
-
     virtual bool TextureNeedsMips(const SPropertyDefinition *inPropDec,
                                   qt3ds::render::NVRenderTexture2D *inTexture)
     {
@@ -1297,6 +1273,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
                               NVRenderShaderProgram &inShader,
                               const SPropertyDefinition &inDefinition)
     {
+        IStringTable &strTable = m_CoreContext.GetStringTable();
         qt3ds::render::NVRenderShaderConstantBase *theConstant =
             inShader.GetShaderConstant(inPropertyName);
         using namespace qt3ds::render;
@@ -1306,29 +1283,36 @@ struct SMaterialSystem : public ICustomMaterialSystem
                     StaticAssert<sizeof(CRegisteredString)
                                  == sizeof(NVRenderTexture2DPtr)>::valid_expression();
                     CRegisteredString *theStrPtr = reinterpret_cast<CRegisteredString *>(inDataPtr);
-                    if (theStrPtr->IsValid() && inMaterial.m_imageMaps) {
-                        SImage *image = (*inMaterial.m_imageMaps)[inPropertyName];
-                        if (image) {
-                            if (image->m_ImagePath != *theStrPtr) {
-                                // Should not happen
-                                QT3DS_ASSERT(false);
-                            } else {
-                                IOffscreenRenderManager &offscreenRenderer(
-                                    m_Context->GetOffscreenRenderManager());
-                                if (offscreenRenderer.HasOffscreenRenderer(*theStrPtr)) {
-                                    SOffscreenRenderResult result
-                                            = offscreenRenderer.GetRenderedItem(*theStrPtr);
-                                    if (result.m_Texture) {
-                                        SetSubpresentation(inShader, inPropertyName,
-                                                           result.m_Texture, &inDefinition);
-                                    }
-                                } else {
-                                    SetTexture(inShader, inPropertyName,
-                                               image->m_TextureData.m_Texture, &inDefinition,
-                                               TextureNeedsMips(&inDefinition,
-                                                                image->m_TextureData.m_Texture));
-                                }
+
+                    SImage *image = inMaterial.getImageById(*theStrPtr);
+                    if (image) {
+                        CRegisteredString strU = strTable.RegisterStr(
+                                    QString::fromLatin1(inPropertyName.c_str()) + "TransformU");
+                        CRegisteredString strV = strTable.RegisterStr(
+                                    QString::fromLatin1(inPropertyName.c_str()) + "TransformV");
+                        qt3ds::render::NVRenderShaderConstantBase *transformU =
+                            inShader.GetShaderConstant(strU);
+                        qt3ds::render::NVRenderShaderConstantBase *transformV =
+                            inShader.GetShaderConstant(strV);
+                        image->CalculateTextureTransform();
+                        const QT3DSMat44 &textureTransform = image->m_TextureTransform;
+                        const QT3DSF32 *dataPtr(textureTransform.front());
+                        inShader.SetPropertyValue(transformU,
+                                                  QT3DSVec3(dataPtr[0], dataPtr[4], dataPtr[12]));
+                        inShader.SetPropertyValue(transformV,
+                                                  QT3DSVec3(dataPtr[1], dataPtr[5], dataPtr[13]));
+                        if (image->m_TextureData.m_Texture) {
+                            auto *texture = image->m_TextureData.m_Texture;
+                            texture->SetTextureWrapS(image->m_HorizontalTilingMode);
+                            texture->SetTextureWrapT(image->m_VerticalTilingMode);
+                            texture->SetMinFilter(inDefinition.m_MinFilterOp);
+                            texture->SetMagFilter(inDefinition.m_MagFilterOp);
+                            if (inDefinition.m_MinFilterOp != NVRenderTextureMinifyingOp::Nearest
+                                    && inDefinition.m_MinFilterOp != NVRenderTextureMinifyingOp::Linear
+                                    && !texture->GetNumMipmaps()) {
+                                texture->GenerateMipmaps();
                             }
+                            inShader.SetPropertyValue(theConstant, texture);
                         }
                     }
                 } else {
@@ -1995,97 +1979,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
        return theClass->m_Class->RequiresCompilation();
     }
 
-    SCustomMaterial::TImageMapHash *newImageMap(NVAllocatorCallback &allocator)
-    {
-        const char *name = "SCustomMaterial::TImageMapHash";
-        SCustomMaterial::TImageMapHash *ret
-                = new (QT3DS_ALLOC(allocator, sizeof(SCustomMaterial::TImageMapHash), name))
-                        SCustomMaterial::TImageMapHash(allocator, name);
-        m_materialImageMaps.push_back(ret);
-        return ret;
-    }
-
-    virtual void PrepareTextureForRender(SMaterialClass &inClass, SCustomMaterial &inMaterial)
-    {
-        NVConstDataRef<SPropertyDefinition> thePropDefs = inClass.m_Class->GetProperties();
-        for (QT3DSU32 idx = 0, end = thePropDefs.size(); idx < end; ++idx) {
-            const SPropertyDefinition &def = thePropDefs[idx];
-            if (def.m_DataType == NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
-                SImage *pImage = nullptr;
-                CRegisteredString theStrPtr = *reinterpret_cast<CRegisteredString *>(
-                    inMaterial.m_dynamicObject->GetDataSectionOffset(def.m_Offset));
-
-                if (theStrPtr.IsValid()) {
-                    QT3DSU32 index = FindAllocatedImage(theStrPtr);
-                    if (index == QT3DSU32(-1)) {
-                        pImage = QT3DS_NEW(m_CoreContext.GetAllocator(), SImage)();
-                        m_AllocatedImages.push_back(eastl::make_pair(theStrPtr, pImage));
-                    } else {
-                        pImage = m_AllocatedImages[index].second;
-                    }
-
-                    switch (def.m_TexUsageType) {
-                    case NVRenderTextureTypeValue::Displace:
-                        if (inMaterial.m_DisplacementMap != pImage) {
-                            inMaterial.m_DisplacementMap = pImage;
-                            inMaterial.m_DisplacementMap->m_ImagePath = theStrPtr;
-                            inMaterial.m_DisplacementMap->m_ImageShaderName =
-                                def.m_Name; // this is our name in the shader
-                            inMaterial.m_DisplacementMap->m_VerticalTilingMode =
-                                def.m_CoordOp;
-                            inMaterial.m_DisplacementMap->m_HorizontalTilingMode =
-                                def.m_CoordOp;
-                            pImage->m_Flags.SetDirty(true);
-                            pImage->m_Flags.SetForceLoad(true);
-                        }
-                        break;
-                    case NVRenderTextureTypeValue::Emissive2:
-                        if (inMaterial.m_EmissiveMap2 != pImage) {
-                            inMaterial.m_EmissiveMap2 = pImage;
-                            inMaterial.m_EmissiveMap2->m_ImagePath = theStrPtr;
-                            inMaterial.m_EmissiveMap2->m_ImageShaderName =
-                                def.m_Name; // this is our name in the shader
-                            inMaterial.m_EmissiveMap2->m_VerticalTilingMode =
-                                def.m_CoordOp;
-                            inMaterial.m_EmissiveMap2->m_HorizontalTilingMode =
-                                def.m_CoordOp;
-                            pImage->m_Flags.SetDirty(true);
-                            pImage->m_Flags.SetForceLoad(true);
-                        }
-                        break;
-                    default:
-                        if (!inMaterial.m_imageMaps)
-                            inMaterial.m_imageMaps = newImageMap(m_CoreContext.GetAllocator());
-                        if ((*inMaterial.m_imageMaps)[def.m_Name] != pImage) {
-                            (*inMaterial.m_imageMaps)[def.m_Name] = pImage;
-                            pImage->m_ImagePath = theStrPtr;
-                            pImage->m_ImageShaderName = def.m_Name;
-                            pImage->m_VerticalTilingMode = def.m_CoordOp;
-                            pImage->m_HorizontalTilingMode = def.m_CoordOp;
-                            pImage->m_Flags.SetDirty(true);
-                            pImage->m_Flags.SetForceLoad(true);
-                        }
-                        break;
-                    }
-                } else {
-                    switch (def.m_TexUsageType) {
-                    case NVRenderTextureTypeValue::Displace:
-                        inMaterial.m_DisplacementMap = nullptr;
-                        break;
-                    case NVRenderTextureTypeValue::Emissive2:
-                        inMaterial.m_EmissiveMap2 = nullptr;
-                        break;
-                    default:
-                        if (!inMaterial.m_imageMaps)
-                            inMaterial.m_imageMaps = newImageMap(m_CoreContext.GetAllocator());
-                        (*inMaterial.m_imageMaps)[def.m_Name] = nullptr;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
     virtual void PrepareDisplacementForRender(SMaterialClass &inClass, SCustomMaterial &inMaterial)
     {
         if (inMaterial.m_DisplacementMap == NULL)
@@ -2112,8 +2005,6 @@ struct SMaterialSystem : public ICustomMaterialSystem
 
     void PrepareMaterialForRender(SMaterialClass &inClass, SCustomMaterial &inMaterial)
     {
-        PrepareTextureForRender(inClass, inMaterial);
-
         if (inClass.m_HasDisplacement)
             PrepareDisplacementForRender(inClass, inMaterial);
     }