Split SDynamicObject from graph objects

Add SDynamicGraphObject and derive SEffect and SCustomMaterial from it.

Change-Id: I97fc561069d72ab550eebcad76c240a7fb5ad142
Reviewed-by: Kaj Grönholm <kaj.gronholm@qt.io>
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>

14 files changed, 168 insertions, 166 deletions

diff --git a/src/engine/Qt3DSRenderRuntimeBindingImplTranslation.cpp b/src/engine/Qt3DSRenderRuntimeBindingImplTranslation.cpp
index 1167698..8d298a9 100644
--- a/src/engine/Qt3DSRenderRuntimeBindingImplTranslation.cpp
+++ b/src/engine/Qt3DSRenderRuntimeBindingImplTranslation.cpp
@@ -1358,10 +1358,11 @@ struct SDynamicObjectTranslatorContext : public STranslatorContext
             }
         }
     }
-    void ApplyChanges(SPresentation &inPresentation, IQt3DSRenderContext &inRenderContext,
+    bool ApplyChanges(SPresentation &inPresentation, IQt3DSRenderContext &inRenderContext,
                       SDynamicObject &inObject, Q3DStudio::TElement &element,
                       IDynamicObjectSystem &inSystem)
     {
+        bool ret = false;
         if (element.GetActive()) {
             NVConstDataRef<qt3ds::render::dynamic::SPropertyDefinition> theProperties =
                 inSystem.GetProperties(inObject.m_ClassName);
@@ -1408,8 +1409,9 @@ struct SDynamicObjectTranslatorContext : public STranslatorContext
                     }
                 }
             }
-            theItem.m_Flags.SetDirty(true);
+            ret = true;
         }
+        return ret;
     }
 };
 
@@ -1428,9 +1430,10 @@ struct SEffectTranslator : public Qt3DSTranslator
     {
         SRuntimePropertyParser theParser(inPresentation, inRenderContext, *m_Element);
         SEffect &theItem = *static_cast<SEffect *>(m_RenderObject);
-        static_cast<SDynamicObjectTranslatorContext *>(m_TranslatorContext)
-            ->ApplyChanges(inPresentation, inRenderContext, theItem, Element(),
+        bool dirty = static_cast<SDynamicObjectTranslatorContext *>(m_TranslatorContext)
+            ->ApplyChanges(inPresentation, inRenderContext, *theItem.m_dynamicObject, Element(),
                            inRenderContext.GetDynamicObjectSystem());
+        theItem.m_Flags.SetDirty(dirty);
         theItem.SetActive(Element().GetActive(), inRenderContext.GetEffectSystem());
     }
 };
@@ -1450,9 +1453,10 @@ struct SCustomMaterialTranslator : public Qt3DSTranslator
     {
         SRuntimePropertyParser theParser(inPresentation, inRenderContext, *m_Element);
         SCustomMaterial &theItem = *static_cast<SCustomMaterial *>(m_RenderObject);
-        static_cast<SDynamicObjectTranslatorContext *>(m_TranslatorContext)
-            ->ApplyChanges(inPresentation, inRenderContext, theItem, Element(),
+        bool dirty = static_cast<SDynamicObjectTranslatorContext *>(m_TranslatorContext)
+            ->ApplyChanges(inPresentation, inRenderContext, *theItem.m_dynamicObject, Element(),
                            inRenderContext.GetDynamicObjectSystem());
+        theItem.m_Flags.SetDirty(dirty);
         bool active = m_Element->GetActive();
         if (active != theItem.m_Flags.IsActive()) {
             theItem.m_Flags.SetActive(active);
diff --git a/src/runtime/Qt3DSQmlEngine.cpp b/src/runtime/Qt3DSQmlEngine.cpp
index 1f481b4..0bbc2a3 100644
--- a/src/runtime/Qt3DSQmlEngine.cpp
+++ b/src/runtime/Qt3DSQmlEngine.cpp
@@ -1623,7 +1623,8 @@ void CQmlEngineImpl::createMaterials(const QString &subPresId,
         if (isCustomMaterial) {
             newMaterial = customMaterialSystem->CreateCustomMaterial(matClass, allocator);
             newMaterial->m_Id = newMatId;
-            auto dynObj = static_cast<qt3ds::render::SDynamicObject *>(newMaterial);
+            auto dynGraphObj = static_cast<qt3ds::render::SDynamicGraphObject *>(newMaterial);
+            auto dynObj = dynGraphObj->m_dynamicObject;
 
             QHashIterator<QString, qt3ds::render::dynamic::SPropertyDefinition>
                     dynPropIter(dynPropDefs);
@@ -2779,7 +2780,7 @@ void CQmlEngineImpl::setDynamicObjectProperty(qt3ds::render::SDynamicObject &mat
                                               const dynamic::SPropertyDefinition &propDesc,
                                               const TDataType &propValue)
 {
-    memCopy(material.GetDataSectionBegin() + propDesc.m_Offset, &propValue, sizeof(TDataType));
+    memCopy(material.GetDataSectionOffset(propDesc.m_Offset), &propValue, sizeof(TDataType));
 }
 
 /**
diff --git a/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp b/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
index 03c1a01..4dade3f 100644
--- a/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
+++ b/src/runtimerender/Qt3DSRenderCustomMaterialSystem.cpp
@@ -956,7 +956,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
         if (IsMaterialRegistered(inName))
             return false;
         m_CoreContext.GetDynamicObjectSystemCore().Register(
-            inName, inProperties, sizeof(SCustomMaterial), GraphObjectTypes::CustomMaterial);
+            inName, inProperties, GraphObjectTypes::CustomMaterial);
         IDynamicObjectClass *theClass =
             m_CoreContext.GetDynamicObjectSystemCore().GetDynamicObjectClass(inName);
         if (theClass == NULL) {
@@ -1103,7 +1103,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
     SCustomMaterial *CreateCustomMaterial(CRegisteredString inName,
                                           NVAllocatorCallback &inSceneGraphAllocator) override
     {
-        SCustomMaterial *theMaterial = static_cast<SCustomMaterial *>(
+        SCustomMaterial *theMaterial = QT3DS_NEW(inSceneGraphAllocator, SCustomMaterial)(
             m_CoreContext.GetDynamicObjectSystemCore().CreateInstance(inName,
                                                                       inSceneGraphAllocator));
         SMaterialClass *theClass = GetMaterialClass(inName);
@@ -1358,15 +1358,16 @@ struct SMaterialSystem : public ICustomMaterialSystem
                             NVRenderShaderProgram &inShader, const SApplyInstanceValue &inCommand)
     {
         // sanity check
+        SDynamicObject &dynObj = *inMaterial.m_dynamicObject;
         if (inCommand.m_PropertyName.IsValid()) {
             bool canGetData =
                 inCommand.m_ValueOffset + getSizeofShaderDataType(inCommand.m_ValueType)
-                <= inMaterial.m_DataSectionByteSize;
+                <= dynObj.m_DataSectionByteSize;
             if (canGetData == false) {
                 QT3DS_ASSERT(false);
                 return;
             }
-            QT3DSU8 *dataPtr = inMaterial.GetDataSectionBegin() + inCommand.m_ValueOffset;
+            QT3DSU8 *dataPtr = dynObj.GetDataSectionOffset(inCommand.m_ValueOffset);
             const SPropertyDefinition *theDefinition =
                 inClass.m_Class->FindPropertyByName(inCommand.m_PropertyName);
             if (theDefinition)
@@ -1382,7 +1383,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
                 // This is fine, the property wasn't found and we continue, no problem.
                 if (!theConstant)
                     continue;
-                QT3DSU8 *dataPtr = inMaterial.GetDataSectionBegin() + theDefinition.m_Offset;
+                QT3DSU8 *dataPtr = dynObj.GetDataSectionOffset(theDefinition.m_Offset);
                 DoApplyInstanceValue(inMaterial, dataPtr, theDefinition.m_Name,
                                      theDefinition.m_DataType, inShader, theDefinition);
             }
@@ -1944,7 +1945,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
         for (QT3DSU32 idx = 0, end = theDefs.size(); idx < end; ++idx) {
             const SPropertyDefinition &theDefinition(theDefs[idx]);
             if (theDefinition.m_DataType == NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
-                QT3DSU8 *dataPtr = inMaterial.GetDataSectionBegin() + theDefinition.m_Offset;
+                QT3DSU8 *dataPtr = inMaterial.m_dynamicObject->GetDataSectionOffset(theDefinition.m_Offset);
                 StaticAssert<sizeof(CRegisteredString)
                              == sizeof(NVRenderTexture2DPtr)>::valid_expression();
                 CRegisteredString *theStrPtr = reinterpret_cast<CRegisteredString *>(dataPtr);
@@ -2012,7 +2013,7 @@ struct SMaterialSystem : public ICustomMaterialSystem
             if (def.m_DataType == NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
                 SImage *pImage = nullptr;
                 CRegisteredString theStrPtr = *reinterpret_cast<CRegisteredString *>(
-                    inMaterial.GetDataSectionBegin() + def.m_Offset);
+                    inMaterial.m_dynamicObject->GetDataSectionOffset(def.m_Offset));
 
                 if (theStrPtr.IsValid()) {
                     QT3DSU32 index = FindAllocatedImage(theStrPtr);
@@ -2095,13 +2096,11 @@ struct SMaterialSystem : public ICustomMaterialSystem
         for (QT3DSU32 idx = 0, end = thePropDefs.size(); idx < end; ++idx) {
             if (thePropDefs[idx].m_DataType == NVRenderShaderDataTypes::QT3DSF32
                 && AreEqual(thePropDefs[idx].m_Name.c_str(), "displaceAmount")) {
-                QT3DSF32 theValue = *reinterpret_cast<const QT3DSF32 *>(inMaterial.GetDataSectionBegin()
-                                                                  + thePropDefs[idx].m_Offset);
+                QT3DSF32 theValue = *reinterpret_cast<const QT3DSF32 *>(inMaterial.m_dynamicObject->GetDataSectionOffset(thePropDefs[idx].m_Offset));
                 inMaterial.m_DisplaceAmount = theValue;
             } else if (thePropDefs[idx].m_DataType == NVRenderShaderDataTypes::QT3DSVec3
                        && AreEqual(thePropDefs[idx].m_Name.c_str(), "displace_tiling")) {
-                QT3DSVec3 theValue = *reinterpret_cast<const QT3DSVec3 *>(inMaterial.GetDataSectionBegin()
-                                                                    + thePropDefs[idx].m_Offset);
+                QT3DSVec3 theValue = *reinterpret_cast<const QT3DSVec3 *>(inMaterial.m_dynamicObject->GetDataSectionOffset(thePropDefs[idx].m_Offset));
                 if (theValue.x != inMaterial.m_DisplacementMap->m_Scale.x
                     || theValue.y != inMaterial.m_DisplacementMap->m_Scale.y) {
                     inMaterial.m_DisplacementMap->m_Scale = QT3DSVec2(theValue.x, theValue.y);
diff --git a/src/runtimerender/Qt3DSRenderDynamicObjectSystem.cpp b/src/runtimerender/Qt3DSRenderDynamicObjectSystem.cpp
index 6553ee9..9f867b3 100644
--- a/src/runtimerender/Qt3DSRenderDynamicObjectSystem.cpp
+++ b/src/runtimerender/Qt3DSRenderDynamicObjectSystem.cpp
@@ -412,7 +412,6 @@ struct SDynamicObjClassImpl : public IDynamicObjectClass
     CRegisteredString m_Id;
     NVConstDataRef<SPropertyDefinition> m_PropertyDefinitions;
     QT3DSU32 m_PropertySectionByteSize;
-    QT3DSU32 m_BaseObjectSize;
     GraphObjectTypes::Enum m_GraphObjectType;
     QT3DSU8 *m_PropertyDefaultData;
     NVConstDataRef<SCommand *> m_RenderCommands;
@@ -424,14 +423,13 @@ struct SDynamicObjClassImpl : public IDynamicObjectClass
     SDynamicObjClassImpl(
         NVAllocatorCallback &alloc, CRegisteredString id,
         NVConstDataRef<SPropertyDefinition> definitions, QT3DSU32 propertySectionByteSize,
-        QT3DSU32 baseObjectSize, GraphObjectTypes::Enum objectType, QT3DSU8 *propDefaultData,
+        GraphObjectTypes::Enum objectType, QT3DSU8 *propDefaultData,
         bool inRequiresDepthTexture = false,
         NVRenderTextureFormats::Enum inOutputFormat = NVRenderTextureFormats::RGBA8)
         : m_Allocator(&alloc)
         , m_Id(id)
         , m_PropertyDefinitions(definitions)
         , m_PropertySectionByteSize(propertySectionByteSize)
-        , m_BaseObjectSize(baseObjectSize)
         , m_GraphObjectType(objectType)
         , m_PropertyDefaultData(propDefaultData)
         , mRefCount(0)
@@ -512,7 +510,6 @@ struct SDynamicObjClassImpl : public IDynamicObjectClass
     }
     QT3DSU32 GetPropertySectionByteSize() const override { return m_PropertySectionByteSize; }
     const QT3DSU8 *GetDefaultValueBuffer() const override { return m_PropertyDefaultData; }
-    QT3DSU32 GetBaseObjectSize() const override { return m_BaseObjectSize; }
     GraphObjectTypes::Enum GraphObjectType() const override { return m_GraphObjectType; }
     const SPropertyDefinition *FindDefinition(CRegisteredString &str) const
     {
@@ -651,7 +648,7 @@ struct SDynamicObjectSystemImpl : public IDynamicObjectSystem
     }
 
     bool Register(CRegisteredString inName,
-                          NVConstDataRef<SPropertyDeclaration> inProperties, QT3DSU32 inBaseObjectSize,
+                          NVConstDataRef<SPropertyDeclaration> inProperties,
                           GraphObjectTypes::Enum inGraphObjectType) override
     {
         if (IsRegistered(inName)) {
@@ -687,7 +684,7 @@ struct SDynamicObjectSystemImpl : public IDynamicObjectSystem
             memZero(defaultData, defaultSize);
         SDynamicObjClassImpl *theClass = new (allocData)
             SDynamicObjClassImpl(m_Allocator, inName, toDataRef(defPtr, inProperties.size()),
-                                 dataSectionSize, inBaseObjectSize, inGraphObjectType, defaultData);
+                                 dataSectionSize, inGraphObjectType, defaultData);
         m_Classes.insert(eastl::make_pair(inName, theClass));
         return true;
     }
@@ -877,12 +874,10 @@ struct SDynamicObjectSystemImpl : public IDynamicObjectSystem
             QT3DS_ASSERT(false);
             return NULL;
         }
-        QT3DSU32 totalObjectSize = theClass->m_BaseObjectSize + theClass->m_PropertySectionByteSize;
+        QT3DSU32 totalObjectSize = theClass->m_PropertySectionByteSize + sizeof(SDynamicObject);
         SDynamicObject *retval = reinterpret_cast<SDynamicObject *>(inSceneGraphAllocator.allocate(
             totalObjectSize, inClassName.c_str(), __FILE__, __LINE__));
-        new (retval)
-            SDynamicObject(theClass->m_GraphObjectType, inClassName,
-                           theClass->m_PropertySectionByteSize, theClass->m_BaseObjectSize);
+        new (retval) SDynamicObject(inClassName, theClass->m_PropertySectionByteSize);
         memCopy(retval->GetDataSectionBegin(), theClass->m_PropertyDefaultData,
                 theClass->m_PropertySectionByteSize);
         return retval;
@@ -1183,7 +1178,7 @@ struct SDynamicObjectSystemImpl : public IDynamicObjectSystem
             QT3DSU32 numRenderCommands = theClass->m_RenderCommands.size();
             new (theClass) SDynamicObjClassImpl(
                 m_Allocator, theClass->m_Id, theClass->m_PropertyDefinitions,
-                theClass->m_PropertySectionByteSize, theClass->m_BaseObjectSize,
+                theClass->m_PropertySectionByteSize,
                 theClass->m_GraphObjectType, theClass->m_PropertyDefaultData,
                 theClass->m_RequiresDepthTexture, theClass->m_OutputFormat);
 
diff --git a/src/runtimerender/Qt3DSRenderDynamicObjectSystem.h b/src/runtimerender/Qt3DSRenderDynamicObjectSystem.h
index 5379df2..a6e3be7 100644
--- a/src/runtimerender/Qt3DSRenderDynamicObjectSystem.h
+++ b/src/runtimerender/Qt3DSRenderDynamicObjectSystem.h
@@ -162,7 +162,6 @@ namespace render {
         virtual NVConstDataRef<dynamic::SPropertyDefinition> GetProperties() const = 0;
         virtual QT3DSU32 GetPropertySectionByteSize() const = 0;
         virtual const QT3DSU8 *GetDefaultValueBuffer() const = 0;
-        virtual QT3DSU32 GetBaseObjectSize() const = 0;
         virtual GraphObjectTypes::Enum GraphObjectType() const = 0;
         virtual const dynamic::SPropertyDefinition *
         FindPropertyByName(CRegisteredString inName) const = 0;
@@ -183,7 +182,7 @@ namespace render {
 
         virtual bool Register(CRegisteredString inName,
                               NVConstDataRef<dynamic::SPropertyDeclaration> inProperties,
-                              QT3DSU32 inBaseObjectSize, GraphObjectTypes::Enum inGraphObjectType) = 0;
+                              GraphObjectTypes::Enum inGraphObjectType) = 0;
 
         virtual bool Unregister(CRegisteredString inName) = 0;
 
diff --git a/src/runtimerender/Qt3DSRenderEffectSystem.cpp b/src/runtimerender/Qt3DSRenderEffectSystem.cpp
index b15d0bc..1cfdc59 100644
--- a/src/runtimerender/Qt3DSRenderEffectSystem.cpp
+++ b/src/runtimerender/Qt3DSRenderEffectSystem.cpp
@@ -601,7 +601,7 @@ struct SEffectSystem : public IEffectSystem
         if (IsEffectRegistered(inName))
             return false;
 
-        m_CoreContext.GetDynamicObjectSystemCore().Register(inName, inProperties, sizeof(SEffect),
+        m_CoreContext.GetDynamicObjectSystemCore().Register(inName, inProperties,
                                                             GraphObjectTypes::Effect);
         IDynamicObjectClass &theClass =
             *m_CoreContext.GetDynamicObjectSystemCore().GetDynamicObjectClass(inName);
@@ -689,7 +689,7 @@ struct SEffectSystem : public IEffectSystem
     {
         if (IsEffectRegistered(inName))
             return false;
-        m_CoreContext.GetDynamicObjectSystemCore().Register(inName, inProperties, sizeof(SEffect),
+        m_CoreContext.GetDynamicObjectSystemCore().Register(inName, inProperties,
                                                             GraphObjectTypes::Effect);
         IDynamicObjectClass &theClass =
             *m_CoreContext.GetDynamicObjectSystemCore().GetDynamicObjectClass(inName);
@@ -818,10 +818,12 @@ struct SEffectSystem : public IEffectSystem
             return NULL;
         StaticAssert<(sizeof(SEffect) % 4 == 0)>::valid_expression();
 
-        SEffect *theEffect = (SEffect *)m_CoreContext.GetDynamicObjectSystemCore().CreateInstance(
+        SDynamicObject *dynamicObject = m_CoreContext.GetDynamicObjectSystemCore().CreateInstance(
             inEffectName, inSceneGraphAllocator);
-        theEffect->Initialize();
-        return theEffect;
+
+        SEffect *effect = QT3DS_NEW(inSceneGraphAllocator, SEffect)(dynamicObject);
+        effect->Initialize();
+        return effect;
     }
 
     void AllocateBuffer(SEffect &inEffect, const SAllocateBuffer &inCommand, QT3DSU32 inFinalWidth,
@@ -1137,12 +1139,12 @@ struct SEffectSystem : public IEffectSystem
         if (inCommand.m_PropertyName.IsValid()) {
             bool canGetData =
                 inCommand.m_ValueOffset + getSizeofShaderDataType(inCommand.m_ValueType)
-                <= inEffect.m_DataSectionByteSize;
+                <= inEffect.m_dynamicObject->m_DataSectionByteSize;
             if (canGetData == false) {
                 QT3DS_ASSERT(false);
                 return;
             }
-            QT3DSU8 *dataPtr = inEffect.GetDataSectionBegin() + inCommand.m_ValueOffset;
+            QT3DSU8 *dataPtr = inEffect.m_dynamicObject->GetDataSectionOffset(inCommand.m_ValueOffset);
             const SPropertyDefinition *theDefinition =
                 inClass.m_DynamicClass->FindPropertyByName(inCommand.m_PropertyName);
             if (theDefinition)
@@ -1158,7 +1160,7 @@ struct SEffectSystem : public IEffectSystem
                 // This is fine, the property wasn't found and we continue, no problem.
                 if (!theConstant)
                     continue;
-                QT3DSU8 *dataPtr = inEffect.GetDataSectionBegin() + theDefinition.m_Offset;
+                QT3DSU8 *dataPtr = inEffect.m_dynamicObject->GetDataSectionOffset(theDefinition.m_Offset);
                 DoApplyInstanceValue(inEffect, dataPtr, theDefinition.m_Name,
                                      theDefinition.m_DataType, inShader, theDefinition);
             }
@@ -1903,7 +1905,7 @@ struct SEffectSystem : public IEffectSystem
             if (theDefinition.m_DataType == NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
                 SImage *pImage = nullptr;
 
-                QT3DSU8 *dataPtr = inEffect.GetDataSectionBegin() + theDefinition.m_Offset;
+                QT3DSU8 *dataPtr = inEffect.m_dynamicObject->GetDataSectionOffset(theDefinition.m_Offset);
                 StaticAssert<sizeof(CRegisteredString)
                              == sizeof(NVRenderTexture2DPtr)>::valid_expression();
                 CRegisteredString *theStrPtr = reinterpret_cast<CRegisteredString *>(dataPtr);
diff --git a/src/runtimerender/Qt3DSRenderGraphObjectSerializer.cpp b/src/runtimerender/Qt3DSRenderGraphObjectSerializer.cpp
index 358c5aa..bb75a40 100644
--- a/src/runtimerender/Qt3DSRenderGraphObjectSerializer.cpp
+++ b/src/runtimerender/Qt3DSRenderGraphObjectSerializer.cpp
@@ -122,6 +122,18 @@ struct SSerializerWriteContext
 #endif
     }
 
+    template <typename TObjType, typename Type>
+    void AddPtrOffset(Type type, const TObjType *inObject)
+    {
+        QT3DSU32 objOffset = m_MemoryBuffer.size() - m_DataBlockStart;
+        m_OffsetMap.insert(eastl::make_pair(inObject, objOffset));
+// In debug we keep stats on how much each type of object
+// contributes to the file size.
+#ifdef _DEBUG
+        GetStatEntry(type) += sizeof(TObjType);
+#endif
+    }
+
     void Remap(CRegisteredString &inStr) { inStr.Remap(m_StrRemapMap); }
 
     template <typename TObjType>
@@ -138,6 +150,7 @@ struct SSerializerWriteContext
     }
 
     void RemapMaterial(SGraphObject *&inPtr) { Remap(inPtr); }
+    void RemapDynamicObject(GraphObjectTypes::Enum type, SDynamicObject *&inPtr) { Remap(inPtr); }
 
     template <typename TObjType>
     void NullPtr(TObjType *&inPtr)
@@ -187,6 +200,7 @@ struct SSerializerReadContext : public SDataReader
         }
     }
     void RemapMaterial(SGraphObject *&inPtr) { Remap(inPtr); }
+    void RemapDynamicObject(GraphObjectTypes::Enum type, SDynamicObject *&inPtr) { Remap(inPtr); }
     // Nulling out pointers was done on write, so we don't do it here.
     template <typename TObjType>
     void NullPtr(TObjType *&)
@@ -202,6 +216,8 @@ struct SGraphObjectSerializerImpl
     static TObjType *Read(SSerializerReadContext &inReadContext);
 };
 
+static SDynamicObject *Write(GraphObjectTypes::Enum type, const SDynamicObject &ioObject, SSerializerWriteContext &outSavedBuffer);
+
 struct SWriteRemapper
 {
     SSerializerWriteContext &m_WriteBuffer;
@@ -249,6 +265,11 @@ struct SWriteRemapper
             }
         }
     }
+    void RemapDynamicObject(GraphObjectTypes::Enum inType, const SDynamicObject *inObj)
+    {
+        if (inObj)
+            Write(inType, *inObj, m_WriteBuffer);
+    }
     template <typename TObjType>
     void NullPtr(const TObjType *)
     {
@@ -282,6 +303,21 @@ TObject *WriteGenericGraphObjectNoRemap(const TObject &ioObject,
     return reinterpret_cast<TObject *>(outSavedBuffer.m_MemoryBuffer.begin() + theOffset);
 }
 
+template <typename TObject, typename Type>
+TObject *WriteGenericGraphObjectNoRemap(Type type, const TObject &ioObject,
+                                        SSerializerWriteContext &outSavedBuffer)
+{
+    if (outSavedBuffer.HasWrittenObject(&ioObject))
+        return NULL;
+
+    outSavedBuffer.AddPtrOffset(type, &ioObject);
+    QT3DSU32 theOffset = outSavedBuffer.m_MemoryBuffer.size();
+    outSavedBuffer.m_MemoryBuffer.write(ioObject);
+    // Probably the buffer stays aligned but we want to work to keep it that way.
+    Align(outSavedBuffer.m_MemoryBuffer);
+    return reinterpret_cast<TObject *>(outSavedBuffer.m_MemoryBuffer.begin() + theOffset);
+}
+
 template <typename TObject>
 TObject *WriteGenericGraphObject(const TObject &ioObject, SSerializerWriteContext &outSavedBuffer)
 {
@@ -335,7 +371,7 @@ void RemapProperties(SDynamicObject &ioObject, SSerializerWriteContext &outSaved
         const SPropertyDefinition &theDef(theObjectProps[idx]);
         if (theDef.m_DataType == qt3ds::render::NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
             CRegisteredString *theStr = reinterpret_cast<CRegisteredString *>(
-                ioObject.GetDataSectionBegin() + theDef.m_Offset);
+                ioObject.GetDataSectionOffset(theDef.m_Offset));
             outSavedBuffer.Remap(*theStr);
         }
     }
@@ -353,99 +389,32 @@ void RemapProperties(SDynamicObject &ioObject, SSerializerReadContext &inReadCon
         const SPropertyDefinition &theDefinition(theProperties[idx]);
         if (theDefinition.m_DataType == NVRenderShaderDataTypes::NVRenderTexture2DPtr) {
             CRegisteredString *theString = reinterpret_cast<CRegisteredString *>(
-                ioObject.GetDataSectionBegin() + theDefinition.m_Offset);
+                ioObject.GetDataSectionOffset(theDefinition.m_Offset));
             inReadContext.Remap(*theString);
         }
     }
 }
 
-template <>
-struct SGraphObjectSerializerImpl<SEffect>
+static SDynamicObject *Write(GraphObjectTypes::Enum type, const SDynamicObject &ioObject, SSerializerWriteContext &outSavedBuffer)
 {
-    static SGraphObject *Write(const SEffect &ioObject, SSerializerWriteContext &outSavedBuffer)
-    {
-        size_t itemOffset = outSavedBuffer.m_MemoryBuffer.size();
-        SEffect *theNewEffect =
-            static_cast<SEffect *>(WriteGenericGraphObjectNoRemap(ioObject, outSavedBuffer));
-        if (theNewEffect) {
-            theNewEffect->m_Context = NULL;
-            // Writing it out is easy.  Reading it back in means we have to have a correctly setup
-            // IEffectManager so we
-            // can remap strings.
-            outSavedBuffer.m_MemoryBuffer.write(ioObject.GetDataSectionBegin(),
-                                                ioObject.m_DataSectionByteSize);
-            Align(outSavedBuffer.m_MemoryBuffer);
-            SWriteRemapper theWriteRemapper(outSavedBuffer);
-            // Write any connected objects.
-            theNewEffect =
-                reinterpret_cast<SEffect *>(outSavedBuffer.m_MemoryBuffer.begin() + itemOffset);
-            theNewEffect->Remap(theWriteRemapper);
-        }
-        return theNewEffect;
-    }
-
-    static void Remap(SEffect &ioObject, SSerializerWriteContext &outSavedBuffer)
-    {
-        CRegisteredString theClassName = ioObject.m_ClassName;
-        ioObject.Remap(outSavedBuffer);
-        RemapProperties(ioObject, outSavedBuffer, theClassName);
-    }
-
-    static SEffect *Read(SSerializerReadContext &inReadContext)
-    {
-        SEffect *theEffect = ReadGenericGraphObject<SEffect>(inReadContext);
-        if (theEffect) {
-            inReadContext.m_CurrentPtr += theEffect->m_DataSectionByteSize;
-            inReadContext.Align();
-            RemapProperties(*theEffect, inReadContext);
-        }
-        return theEffect;
-    }
-};
-
-template <>
-struct SGraphObjectSerializerImpl<SCustomMaterial>
-{
-    static SGraphObject *Write(const SCustomMaterial &ioObject,
-                               SSerializerWriteContext &outSavedBuffer)
-    {
-        size_t itemOffset = outSavedBuffer.m_MemoryBuffer.size();
-        SCustomMaterial *theNewObject = static_cast<SCustomMaterial *>(
-            WriteGenericGraphObjectNoRemap(ioObject, outSavedBuffer));
-        if (theNewObject) {
-            // Writing it out is easy.  Reading it back in means we have to have a correctly setup
-            // IEffectManager so we
-            // can remap strings.
-            outSavedBuffer.m_MemoryBuffer.write(ioObject.GetDataSectionBegin(),
-                                                ioObject.m_DataSectionByteSize);
-            Align(outSavedBuffer.m_MemoryBuffer);
-            theNewObject = reinterpret_cast<SCustomMaterial *>(outSavedBuffer.m_MemoryBuffer.begin()
-                                                               + itemOffset);
-            SWriteRemapper theWriteRemapper(outSavedBuffer);
-            // Write any connected objects.
-            theNewObject->Remap(theWriteRemapper);
-        }
-        return theNewObject;
-    }
-
-    static void Remap(SCustomMaterial &ioObject, SSerializerWriteContext &outSavedBuffer)
-    {
-        CRegisteredString theClassName(ioObject.m_ClassName);
-        ioObject.Remap(outSavedBuffer);
-        RemapProperties(ioObject, outSavedBuffer, theClassName);
-    }
-
-    static SCustomMaterial *Read(SSerializerReadContext &inReadContext)
-    {
-        SCustomMaterial *theMaterial = ReadGenericGraphObject<SCustomMaterial>(inReadContext);
-        if (theMaterial) {
-            inReadContext.m_CurrentPtr += theMaterial->m_DataSectionByteSize;
-            inReadContext.Align();
-            RemapProperties(*theMaterial, inReadContext);
-        }
-        return theMaterial;
+    size_t itemOffset = outSavedBuffer.m_MemoryBuffer.size();
+    SDynamicObject *theNewObject = static_cast<SDynamicObject *>(
+        WriteGenericGraphObjectNoRemap(type, ioObject, outSavedBuffer));
+    if (theNewObject) {
+        // Writing it out is easy.  Reading it back in means we have to have a correctly setup
+        // IEffectManager so we
+        // can remap strings.
+        outSavedBuffer.m_MemoryBuffer.write(ioObject.GetDataSectionBegin(),
+                                            ioObject.m_DataSectionByteSize);
+        Align(outSavedBuffer.m_MemoryBuffer);
+        theNewObject = reinterpret_cast<SDynamicObject *>(outSavedBuffer.m_MemoryBuffer.begin()
+                                                           + itemOffset);
+        SWriteRemapper theWriteRemapper(outSavedBuffer);
+        // Write any connected objects.
+        theNewObject->Remap(theWriteRemapper);
     }
-};
+    return theNewObject;
+}
 
 #ifdef _INTEGRITYPLATFORM
     template <typename TObjType>
diff --git a/src/runtimerender/Qt3DSRenderMaterialHelpers.h b/src/runtimerender/Qt3DSRenderMaterialHelpers.h
index afb799e..ad0325f 100644
--- a/src/runtimerender/Qt3DSRenderMaterialHelpers.h
+++ b/src/runtimerender/Qt3DSRenderMaterialHelpers.h
@@ -69,7 +69,7 @@ namespace render {
             return NULL;
         }
         if (obj->m_Type == GraphObjectTypes::CustomMaterial)
-            return static_cast<SCustomMaterial *>(obj)->m_NextSibling;
+            return static_cast<SCustomMaterial *>(obj)->m_MaterialSibling;
         else if (obj->m_Type == GraphObjectTypes::DefaultMaterial)
             return static_cast<SDefaultMaterial *>(obj)->m_NextSibling;
         else
@@ -83,7 +83,7 @@ namespace render {
             return;
         }
         if (obj.m_Type == GraphObjectTypes::CustomMaterial)
-            static_cast<SCustomMaterial *>(&obj)->m_NextSibling = sibling;
+            static_cast<SCustomMaterial *>(&obj)->m_MaterialSibling = sibling;
         else if (obj.m_Type == GraphObjectTypes::DefaultMaterial)
             static_cast<SDefaultMaterial *>(&obj)->m_NextSibling = sibling;
         else
diff --git a/src/runtimerender/Qt3DSRenderUIPLoader.cpp b/src/runtimerender/Qt3DSRenderUIPLoader.cpp
index 769c28e..e68d44a 100644
--- a/src/runtimerender/Qt3DSRenderUIPLoader.cpp
+++ b/src/runtimerender/Qt3DSRenderUIPLoader.cpp
@@ -108,6 +108,7 @@ using qt3ds::render::SDefaultMaterial;
 using qt3ds::render::SImage;
 using qt3ds::render::SGraphObject;
 using qt3ds::render::SDynamicObject;
+using qt3ds::render::SDynamicGraphObject;
 using qt3ds::render::SEffect;
 using qt3ds::render::SCustomMaterial;
 using qt3ds::render::GraphObjectTypes;
@@ -1005,7 +1006,7 @@ struct SRenderUIPLoader : public IDOMReferenceResolver
                                   const qt3ds::render::dynamic::SPropertyDefinition &inPropDesc,
                                   const TDataType &inProp)
     {
-        memCopy(inEffect.GetDataSectionBegin() + inPropDesc.m_Offset, &inProp, sizeof(TDataType));
+        memCopy(inEffect.GetDataSectionOffset(inPropDesc.m_Offset), &inProp, sizeof(TDataType));
     }
     template <typename TDataType>
     void SetDynamicObjectProperty(SDynamicObject &inEffect,
@@ -1018,10 +1019,14 @@ struct SRenderUIPLoader : public IDOMReferenceResolver
     }
     void ParseProperties(SCustomMaterial &inItem, IPropertyParser &inParser)
     {
-        ParseProperties(static_cast<SDynamicObject &>(inItem), inParser);
+        ParseProperties(static_cast<SDynamicGraphObject &>(inItem), inParser);
         ParseProperties(inItem.m_Lightmaps, inParser);
         ITERATE_QT3DS_RENDER_CUSTOM_MATERIAL_PROPERTIES
     }
+    void ParseProperties(SDynamicGraphObject &inItem, IPropertyParser &inParser)
+    {
+        ParseProperties(*inItem.m_dynamicObject, inParser);
+    }
     void ParseProperties(SDynamicObject &inDynamicObject, IPropertyParser &inParser)
     {
         NVConstDataRef<qt3ds::render::dynamic::SPropertyDefinition> theProperties =
diff --git a/src/runtimerender/graphobjects/Qt3DSRenderCustomMaterial.h b/src/runtimerender/graphobjects/Qt3DSRenderCustomMaterial.h
index 7c6b10e..5eb49fe 100644
--- a/src/runtimerender/graphobjects/Qt3DSRenderCustomMaterial.h
+++ b/src/runtimerender/graphobjects/Qt3DSRenderCustomMaterial.h
@@ -58,15 +58,14 @@ namespace render {
 
     typedef NVFlags<SCustomMaterialShaderKeyValues::Enum, QT3DSU32> SCustomMaterialShaderKeyFlags;
 
-    struct SCustomMaterial : public SDynamicObject
+    struct SCustomMaterial : public SDynamicGraphObject
     {
-    private:
-        // These objects are only created via the dynamic object system.
-        SCustomMaterial(const SCustomMaterial &);
-        SCustomMaterial &operator=(const SCustomMaterial &);
-        SCustomMaterial();
-
     public:
+        SCustomMaterial(SDynamicObject *dynamicObject)
+            : SDynamicGraphObject(GraphObjectTypes::CustomMaterial, dynamicObject)
+        {
+        }
+
         // lightmap section
         SLightmaps m_Lightmaps;
         // material section
@@ -81,7 +80,7 @@ namespace render {
         typedef qt3ds::foundation::nvhash_map<CRegisteredString, SImage *> TImageMapHash;
         TImageMapHash *m_imageMaps;
 
-        SGraphObject *m_NextSibling;
+        SGraphObject *m_MaterialSibling;
 
         SCustomMaterialShaderKeyFlags m_ShaderKeyValues; ///< input from MDL files
         QT3DSU32 m_LayerCount; ///< input from MDL files
@@ -96,7 +95,7 @@ namespace render {
             m_hasTransparency = false;
             m_hasRefraction = false;
             m_hasVolumetricDF = false;
-            m_NextSibling = NULL;
+            m_MaterialSibling = NULL;
             m_DirtyFlagWithInFrame = m_Flags.IsDirty();
             m_IblProbe = NULL;
             m_EmissiveMap2 = NULL;
@@ -143,10 +142,10 @@ namespace render {
         template <typename TRemapperType>
         void Remap(TRemapperType &inRemapper)
         {
-            SDynamicObject::Remap(inRemapper);
+            SDynamicGraphObject::Remap(inRemapper);
             m_Lightmaps.Remap(inRemapper);
             inRemapper.Remap(m_IblProbe);
-            inRemapper.RemapMaterial(m_NextSibling);
+            inRemapper.RemapMaterial(m_MaterialSibling);
             inRemapper.Remap(m_EmissiveMap2);
             inRemapper.Remap(m_DisplacementMap);
         }
diff --git a/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.cpp b/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.cpp
index 8e927fe..4f580ce 100644
--- a/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.cpp
+++ b/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.cpp
@@ -39,12 +39,10 @@ using namespace qt3ds;
 using namespace qt3ds::render;
 using namespace qt3ds::foundation;
 
-SDynamicObject::SDynamicObject(GraphObjectTypes::Enum inType, CRegisteredString inObjName,
-                               QT3DSU32 inDSByteSize, QT3DSU32 thisObjSize)
-    : SGraphObject(inType)
-    , m_ClassName(inObjName)
+SDynamicObject::SDynamicObject(CRegisteredString inObjName,
+                               QT3DSU32 inDSByteSize)
+    : m_ClassName(inObjName)
     , m_DataSectionByteSize(inDSByteSize)
-    , m_ThisObjectSize(thisObjSize)
 {
 }
 
@@ -56,7 +54,7 @@ void SDynamicObject::SetPropertyValueT(const dynamic::SPropertyDefinition &inDef
         QT3DS_ASSERT(false);
         return;
     }
-    memCopy(GetDataSectionBegin() + inDefinition.m_Offset, &inValue, sizeof(inValue));
+    memCopy(GetDataSectionOffset(inDefinition.m_Offset), &inValue, sizeof(inValue));
 }
 
 void SDynamicObject::SetPropertyValue(const dynamic::SPropertyDefinition &inDefinition,
@@ -77,7 +75,7 @@ void SDynamicObject::SetPropertyValue(const dynamic::SPropertyDefinition &inDefi
         QT3DS_ASSERT(false);
         return;
     }
-    memCopy(GetDataSectionBegin() + inDefinition.m_Offset + inOffset, &inValue, sizeof(inValue));
+    memCopy(GetDataSectionOffset(inDefinition.m_Offset + inOffset), &inValue, sizeof(inValue));
 }
 void SDynamicObject::SetPropertyValue(const dynamic::SPropertyDefinition &inDefinition,
                                       const QT3DSVec2 &inValue)
@@ -179,3 +177,10 @@ void SDynamicObject::SetPropertyValue(const dynamic::SPropertyDefinition &inDefi
     SetStrPropertyValueT(const_cast<dynamic::SPropertyDefinition &>(inDefinition), inValue,
                          inProjectDir, ioWorkspace, inStrTable);
 }
+
+SDynamicGraphObject::SDynamicGraphObject(GraphObjectTypes::Enum inType,
+                                         SDynamicObject *dynamicObject)
+    : SGraphObject(inType), m_dynamicObject(dynamicObject), m_ClassName(m_dynamicObject->m_ClassName)
+{
+
+}
diff --git a/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.h b/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.h
index 92ab3b2..f20d3f7 100644
--- a/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.h
+++ b/src/runtimerender/graphobjects/Qt3DSRenderDynamicObject.h
@@ -44,20 +44,18 @@ namespace render {
     }
 
     // Dynamic objects are objects that have variable number of properties during runtime.
-    struct SDynamicObject : public SGraphObject
+    struct SDynamicObject
     {
         CRegisteredString m_ClassName;
-        NodeFlags m_Flags;
         QT3DSU32 m_DataSectionByteSize;
-        QT3DSU32 m_ThisObjectSize;
 
-        SDynamicObject(GraphObjectTypes::Enum inType, CRegisteredString inClassName,
-                       QT3DSU32 inDSByteSize, QT3DSU32 thisObjSize);
+        SDynamicObject(CRegisteredString inClassName,
+                       QT3DSU32 inDSByteSize);
 
         QT3DSU8 *GetDataSectionBegin()
         {
             QT3DSU8 *thisObjectStart = reinterpret_cast<QT3DSU8 *>(this);
-            QT3DSU8 *retval = thisObjectStart + m_ThisObjectSize;
+            QT3DSU8 *retval = thisObjectStart + sizeof(SDynamicObject);
             QT3DS_ASSERT((reinterpret_cast<size_t>(retval) % 4 == 0));
             return retval;
         }
@@ -67,6 +65,16 @@ namespace render {
             return const_cast<SDynamicObject *>(this)->GetDataSectionBegin();
         }
 
+        QT3DSU8 *GetDataSectionOffset(QT3DSU32 offset)
+        {
+            return GetDataSectionBegin() + offset;
+        }
+
+        const QT3DSU8 *GetDataSectionOffset(QT3DSU32 offset) const
+        {
+            return const_cast<SDynamicObject *>(this)->GetDataSectionBegin() + offset;
+        }
+
         QT3DSU8 *GetDataSectionEnd() { return GetDataSectionBegin() + m_DataSectionByteSize; }
 
         template <typename TDataType>
@@ -104,10 +112,27 @@ namespace render {
         template <typename TRemapperType>
         void Remap(TRemapperType &inRemapper)
         {
-            SGraphObject::Remap(inRemapper);
             inRemapper.Remap(m_ClassName);
         }
     };
+
+    struct SDynamicGraphObject : public SGraphObject
+    {
+        SDynamicObject *m_dynamicObject = nullptr;
+        CRegisteredString m_ClassName;
+        NodeFlags m_Flags;
+
+        SDynamicGraphObject(GraphObjectTypes::Enum inType, SDynamicObject *dynamicObject);
+
+        // Generic method used during serialization
+        // to remap string and object pointers
+        template <typename TRemapperType>
+        void Remap(TRemapperType &inRemapper)
+        {
+            SGraphObject::Remap(inRemapper);
+            inRemapper.RemapDynamicObject(m_Type, m_dynamicObject);
+        }
+    };
 }
 }
 #endif
diff --git a/src/runtimerender/graphobjects/Qt3DSRenderEffect.cpp b/src/runtimerender/graphobjects/Qt3DSRenderEffect.cpp
index 325073d..3c12ede 100644
--- a/src/runtimerender/graphobjects/Qt3DSRenderEffect.cpp
+++ b/src/runtimerender/graphobjects/Qt3DSRenderEffect.cpp
@@ -53,7 +53,7 @@ void SEffect::SetActive(bool inActive, IEffectSystem &inManager)
             inManager.ResetEffectFrameData(*m_Context);
         m_Flags.SetDirty(true);
         if (inActive)
-            inManager.SetEffectRequiresCompilation(m_ClassName, true);
+            inManager.SetEffectRequiresCompilation(m_dynamicObject->m_ClassName, true);
     }
 }
 
diff --git a/src/runtimerender/graphobjects/Qt3DSRenderEffect.h b/src/runtimerender/graphobjects/Qt3DSRenderEffect.h
index e0db3d9..11e2b10 100644
--- a/src/runtimerender/graphobjects/Qt3DSRenderEffect.h
+++ b/src/runtimerender/graphobjects/Qt3DSRenderEffect.h
@@ -47,15 +47,14 @@ namespace render {
     // them and they have completely variable properties.
     // see IEffectManager in order to create these effects.
     // The data for the effect immediately follows the effect
-    struct SEffect : public SDynamicObject
+    struct SEffect : public SDynamicGraphObject
     {
-    private:
-        // These objects are only created via the dynamic object system.
-        SEffect(const SEffect &);
-        SEffect &operator=(const SEffect &);
-        SEffect();
-
     public:
+        SEffect(SDynamicObject *dynamicObject)
+            : SDynamicGraphObject(GraphObjectTypes::Effect, dynamicObject)
+        {
+        }
+
         SLayer *m_Layer;
         SEffect *m_NextEffect;
         // Opaque pointer to context type implemented by the effect system.
@@ -84,7 +83,7 @@ namespace render {
         template <typename TRemapperType>
         void Remap(TRemapperType &inRemapper)
         {
-            SDynamicObject::Remap(inRemapper);
+            SDynamicGraphObject::Remap(inRemapper);
             inRemapper.Remap(m_Layer);
             inRemapper.Remap(m_NextEffect);
             inRemapper.NullPtr(m_Context);