Engine: Resource system multiple issues #1075

engine/includes/editor/assetconverter.h

@@ -93,7 +93,7 @@ class ENGINE_EXPORT AssetConverterSettings : public Object {
     void setCurrentVersion(uint32_t version);
 
     const StringList subKeys() const;
-    TString subItem(const TString &key) const;
+    TString subItem(const TString &key, bool create = false) const;
     virtual Variant subItemData(const TString &key) const;
     TString subTypeName(const TString &key) const;
     int32_t subType(const TString &key) const;
@@ -103,8 +103,8 @@ class ENGINE_EXPORT AssetConverterSettings : public Object {
     void setSubItem(const TString &name, const TString &uuid, const TString &type);
     virtual void setSubItemData(const TString &name, const Variant &data);
 
-    AssetConverter::ReturnCode saveBinary(const Variant &data);
-    TString saveSubData(const Variant &data, const TString &path, const TString &type);
+    AssetConverter::ReturnCode saveBinary(const Variant &data, const TString &path);
+    AssetConverter::ReturnCode saveSubData(Resource *resource, const TString &name, const TString &type);
 
     bool loadSettings();
     void saveSettings();

engine/includes/editor/converters/assimpconverter.h

@@ -73,8 +73,6 @@ class AssimpImportSettings : public AssetConverterSettings {
 
     Object::ObjectList m_renders;
 
-    StringList m_resources;
-
     BonesList m_bones;
 
     MeshMap m_meshes;

engine/includes/editor/viewport/tasks/gizmorender.h

@@ -55,7 +55,7 @@ class GizmoRender : public PipelineTask {
             m_solidCube->setColors(Vector4Vector(m_solidCube->vertices().size(), Vector4(0.0f, 0.46f, 0.74f, 0.25f)));
         }
 
-        Actor *cameraActor = Engine::composeActor("Camera", "Camera");
+        Actor *cameraActor = Engine::composeActor<Camera>("Camera");
         m_camera = cameraActor->getComponent<Camera>();
         m_camera->setFar(4.0f);
         m_camera->setNear(0.1f);

engine/includes/engine.h

@@ -107,12 +107,15 @@ class ENGINE_EXPORT Engine : public ObjectSystem {
 
     static TString organizationName();
 
-    static void setResource(Object *object, const TString &uuid);
-
     static bool setPlatformAdaptor(PlatformAdaptor *platform);
 
     static Actor *composeActor(const TString &component, const TString &name, Object *parent = nullptr);
 
+    template<typename T>
+    static Actor *composeActor(const TString &name, Object *parent = nullptr) {
+        return composeActor(T::metaClass()->name(), name, parent);
+    }
+
     Object::ObjectList getAllObjectsByType(const TString &type) const override;
 
     void addNativeBehaviour(NativeBehaviour *native);

engine/src/editor/assetconverter.cpp

@@ -301,11 +301,14 @@ const StringList AssetConverterSettings::subKeys() const {
 /*!
     Returns UUID of a sub-item by \a key.
 */
-TString AssetConverterSettings::subItem(const TString &key) const {
+TString AssetConverterSettings::subItem(const TString &key, bool create) const {
     auto it = m_subItems.find(key);
     if(it != m_subItems.end()) {
         return it->second.uuid;
     }
+    if(create) {
+        return QUuid::createUuid().toString().toStdString();
+    }
     return TString();
 }
 /*!
@@ -357,8 +360,8 @@ void AssetConverterSettings::setSubItemData(const TString &name, const Variant &
     Q_UNUSED(data)
 }
 
-AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &data) {
-    File file(absoluteDestination());
+AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &data, const TString &path) {
+    File file(path);
     if(file.open(File::WriteOnly)) {
         std::set<TString> types;
         for(auto &it : data.toList()) {
@@ -376,25 +379,20 @@ AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &dat
     return AssetConverter::InternalError;
 }
 /*!
-    Saves binary \a data as a sub-item with given destination \a path and asset \a type.
-    This method generated UUID id needed and registers a new sub-item.
+    Saves binary data of \a resource as a sub-item with given destination \a name and asset \a type.
     \sa AssetConverterSettings::setSubItem()
 */
-TString AssetConverterSettings::saveSubData(const Variant &data, const TString &path, const TString &type) {
-    TString uuid(subItem(path));
-    if(uuid.isEmpty()) {
-        uuid = QUuid::createUuid().toString().toStdString();
-    }
+AssetConverter::ReturnCode AssetConverterSettings::saveSubData(Resource *resource, const TString &name, const TString &type) {
+    TString uuid(subItem(name));
 
     Url dst(absoluteDestination());
-    File file(dst.absoluteDir() + "/" + uuid);
-    if(file.open(File::WriteOnly)) {
-        file.write(Bson::save(data));
-        file.close();
 
-        setSubItem(path, uuid, type);
+    AssetConverter::ReturnCode result = saveBinary(Engine::toVariant(resource), dst.absoluteDir() + "/" + uuid);
+    if(result == AssetConverter::Success) {
+        setSubItem(name, uuid, type);
     }
-    return uuid;
+
+    return result;
 }
 /*!
     Loads settings from metadata file ([source].set)

engine/src/editor/converters/animconverter.cpp

@@ -30,15 +30,15 @@ AssetConverter::ReturnCode AnimConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         AnimationClip *clip = Engine::loadResource<AnimationClip>(settings->destination());
         if(clip == nullptr) {
-            clip = Engine::objectCreate<AnimationClip>();
+            clip = Engine::objectCreate<AnimationClip>(settings->destination());
         }
 
         VariantMap map;
         map[gTracks] = readJson(src.readAll(), settings).toList();
         clip->loadUserData(map);
         src.close();
 
-        return settings->saveBinary(Engine::toVariant(clip));
+        return settings->saveBinary(Engine::toVariant(clip), settings->absoluteDestination());
     }
 
     return InternalError;

engine/src/editor/converters/assimpconverter.cpp

@@ -196,8 +196,8 @@ Actor *AssimpConverter::createActor(const AssetConverterSettings *settings, cons
     if(dynamic_cast<Prefab *>(resource) != nullptr) {
         return static_cast<Actor *>(static_cast<Prefab *>(resource)->actor()->clone());
     } else if(dynamic_cast<Mesh *>(resource) != nullptr) {
-        Actor *object = Engine::composeActor("MeshRender", "");
-        MeshRender *render = static_cast<MeshRender *>(object->component("MeshRender"));
+        Actor *object = Engine::composeActor<MeshRender>("");
+        MeshRender *render = object->getComponent<MeshRender>();
         if(render) {
             render->setMesh(static_cast<Mesh *>(resource));
         }
@@ -210,7 +210,6 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
     AssimpImportSettings *fbxSettings = static_cast<AssimpImportSettings *>(settings);
 
     fbxSettings->m_renders.clear();
-    fbxSettings->m_resources.clear();
     fbxSettings->m_bones.clear();
     fbxSettings->m_actors.clear();
     fbxSettings->m_meshes.clear();
@@ -247,8 +246,16 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
             }
         }
 
+        Prefab *prefab = Engine::loadResource<Prefab>(settings->destination());
+        if(prefab == nullptr) {
+            prefab = Engine::objectCreate<Prefab>(settings->destination());
+        }
+
+        /// \todo We need to reuse actors if possible
         Actor *root = importObject(scene, scene->mRootNode, nullptr, fbxSettings);
 
+        prefab->setActor(root);
+
         if(!fbxSettings->m_bones.empty()) {
             importPose(fbxSettings);
         } else {
@@ -266,12 +273,12 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
 
         aiReleaseImport(scene);
 
+        TString name(root->name());
+        root->setName(settings->destination()); // fixes the same name of root in the different files issue
         stabilizeUUID(root);
+        root->setName(name);
 
-        Prefab *prefab = Engine::objectCreate<Prefab>("");
-        prefab->setActor(root);
-
-        return settings->saveBinary(Engine::toVariant(prefab));
+        return settings->saveBinary(Engine::toVariant(prefab), settings->absoluteDestination());
     }
     return InternalError;
 }
@@ -374,7 +381,11 @@ Mesh *AssimpConverter::importMesh(const aiScene *scene, const aiNode *element, A
             const aiMesh *item = scene->mMeshes[element->mMeshes[index]];
 
             if(mesh == nullptr) {
-                mesh = Engine::objectCreate<Mesh>(item->mName.C_Str());
+                TString uuid = fbxSettings->subItem(actor->name(), true);
+                mesh = Engine::loadResource<Mesh>(uuid);
+                if(mesh == nullptr) {
+                    mesh = Engine::objectCreate<Mesh>(uuid);
+                }
             }
 
             count_v += item->mNumVertices;
@@ -509,18 +520,10 @@ Mesh *AssimpConverter::importMesh(const aiScene *scene, const aiNode *element, A
             total_i += indexCount;
         }
 
-        TString uuid = fbxSettings->saveSubData(Engine::toVariant(mesh), actor->name(), MetaType::name<Mesh>());
+        fbxSettings->saveSubData(mesh, actor->name(), MetaType::name<Mesh>());
+        fbxSettings->m_meshes[hash] = mesh;
 
-        Mesh *resource = Engine::loadResource<Mesh>(uuid);
-        if(resource == nullptr) {
-            Engine::setResource(mesh, uuid);
-            fbxSettings->m_resources.push_back(uuid);
-            resource = mesh;
-        }
-
-        fbxSettings->m_meshes[hash] = resource;
-
-        return resource;
+        return mesh;
     }
     return nullptr;
 }
@@ -614,7 +617,11 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
     for(uint32_t a = 0; a < scene->mNumAnimations; a++) {
         aiAnimation *animation = scene->mAnimations[a];
 
-        AnimationClip clip;
+        TString uuid = fbxSettings->subItem(animation->mName.C_Str(), true);
+        AnimationClip *clip = Engine::loadResource<AnimationClip>(uuid);
+        if(clip == nullptr) {
+            clip = Engine::objectCreate<AnimationClip>(uuid);
+        }
 
         double animRate = (animation->mTicksPerSecond > 0) ? animation->mTicksPerSecond : 1;
 
@@ -660,7 +667,7 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeVectorTrack(track, fbxSettings->positionError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
 
                 if(channel->mNumRotationKeys > 1) {
@@ -692,7 +699,7 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeQuaternionTrack(track, fbxSettings->rotationError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
 
                 if(channel->mNumScalingKeys > 1) {
@@ -724,19 +731,23 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeVectorTrack(track, fbxSettings->scaleError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
             }
         }
 
-        clip.m_tracks.sort(compare);
+        clip->m_tracks.sort(compare);
 
-        fbxSettings->saveSubData(Engine::toVariant(&clip), animation->mName.C_Str(), MetaType::name<AnimationClip>());
+        fbxSettings->saveSubData(clip, animation->mName.C_Str(), MetaType::name<AnimationClip>());
     }
 }
 
 void AssimpConverter::importPose(AssimpImportSettings *fbxSettings) {
-    Pose *pose = new Pose;
+    TString uuid = fbxSettings->subItem("Pose", true);
+    Pose *pose = Engine::loadResource<Pose>(uuid);
+    if(pose == nullptr) {
+        pose = Engine::objectCreate<Pose>(uuid);
+    }
 
     for(auto it : fbxSettings->m_bones) {
         aiVector3D scl, rot, pos;
@@ -755,20 +766,11 @@ void AssimpConverter::importPose(AssimpImportSettings *fbxSettings) {
         pose->addBone(&b);
     }
 
-    TString uuid = fbxSettings->saveSubData(Engine::toVariant(pose), "Pose", MetaType::name<Pose>());
-
-    Pose *resource = Engine::loadResource<Pose>(uuid);
-    if(resource == nullptr) {
-        Engine::setResource(pose, uuid);
-        fbxSettings->m_resources.push_back(uuid);
-        resource = pose;
-    }
-
-    fbxSettings->m_resources.push_back(uuid);
+    fbxSettings->saveSubData(pose, "Pose", MetaType::name<Pose>());
 
     if(fbxSettings->m_rootBone) {
         Armature *armature = static_cast<Armature *>(fbxSettings->m_rootBone->addComponent("Armature"));
-        armature->setBindPose(resource);
+        armature->setBindPose(pose);
 
         for(auto r : fbxSettings->m_renders) {
             SkinnedMeshRender *render = static_cast<SkinnedMeshRender *>(r);

engine/src/editor/converters/controlschemeconverter.cpp

@@ -22,7 +22,7 @@ AssetConverter::ReturnCode ControlSchemeConverter::convertFile(AssetConverterSet
     if(src.open(File::ReadOnly)) {
         ControlScheme *scheme = Engine::loadResource<ControlScheme>(settings->destination());
         if(scheme == nullptr) {
-            scheme = Engine::objectCreate<ControlScheme>();
+            scheme = Engine::objectCreate<ControlScheme>(settings->destination());
         }
 
         VariantMap map;
@@ -31,7 +31,7 @@ AssetConverter::ReturnCode ControlSchemeConverter::convertFile(AssetConverterSet
 
         src.close();
 
-        return settings->saveBinary(Engine::toVariant(scheme));
+        return settings->saveBinary(Engine::toVariant(scheme), settings->absoluteDestination());
     }
     return InternalError;
 }

engine/src/editor/converters/fontconverter.cpp

@@ -25,7 +25,7 @@ AssetConverter::ReturnCode FontConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         Font *font = Engine::loadResource<Font>(settings->destination());
         if(font == nullptr) {
-            font = Engine::objectCreate<Font>();
+            font = Engine::objectCreate<Font>(settings->destination());
         }
 
         VariantMap map;
@@ -34,7 +34,7 @@ AssetConverter::ReturnCode FontConverter::convertFile(AssetConverterSettings *se
 
         font->loadUserData(map);
 
-        return settings->saveBinary(Engine::toVariant(font));
+        return settings->saveBinary(Engine::toVariant(font), settings->absoluteDestination());
     }
     return InternalError;
 }

engine/src/editor/converters/prefabconverter.cpp

@@ -73,14 +73,13 @@ void PrefabConverter::createFromTemplate(const TString &destination) {
 void PrefabConverter::makePrefab(Actor *actor, AssetConverterSettings *settings) {
     File file(settings->source());
     if(file.open(File::WriteOnly)) {
-        Prefab *fab = Engine::objectCreate<Prefab>("");
+        Prefab *fab = Engine::objectCreate<Prefab>(settings->destination());
         fab->setActor(actor);
 
         file.write(Json::save(Engine::toVariant(fab), 0));
         file.close();
 
         settings->saveSettings();
-        Engine::setResource(fab, settings->destination());
     }
 }
 
@@ -104,7 +103,7 @@ AssetConverter::ReturnCode PrefabConverter::convertFile(AssetConverterSettings *
         Variant variant = readJson(src.readAll(), settings);
         src.close();
 
-        return settings->saveBinary(variant);
+        return settings->saveBinary(variant, settings->absoluteDestination());
     }
     return result;
 }

engine/src/editor/converters/textconverter.cpp

@@ -23,7 +23,7 @@ AssetConverter::ReturnCode TextConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         Text *text = Engine::loadResource<Text>(settings->destination());
         if(text == nullptr) {
-            text = Engine::objectCreate<Text>();
+            text = Engine::objectCreate<Text>(settings->destination());
         }
 
         TString content(src.readAll());
@@ -33,7 +33,7 @@ AssetConverter::ReturnCode TextConverter::convertFile(AssetConverterSettings *se
             memcpy(text->data(), content.data(), content.size());
         }
 
-        return settings->saveBinary(Engine::toVariant(text));
+        return settings->saveBinary(Engine::toVariant(text), settings->absoluteDestination());
     }
 
     return InternalError;