Instance rendering support

Editor/Scripts/ProjectSettings/MeshSyncPlayerConfigSection.cs

@@ -17,6 +17,7 @@ internal class Contents {
 
         public static readonly GUIContent Visibility      = EditorGUIUtility.TrTextContent("Visibility");
         public static readonly GUIContent UpdateTransform = EditorGUIUtility.TrTextContent("Update Transform");
+        public static readonly GUIContent RenderInstances = EditorGUIUtility.TrTextContent("Render Instances");
 
         public static readonly GUIContent[] ComponentSyncs = new [] {
             EditorGUIUtility.TrTextContent("Camera"),
@@ -112,7 +113,7 @@ internal void Setup(VisualElement parent) {
         AddPlayerConfigField<Toggle,bool>(syncSettingsFoldout, Contents.Visibility, config.SyncVisibility,
             (bool newValue) => { config.SyncVisibility = newValue; }
         );
-        
+
         //import
         Foldout importSettingsFoldout = containerInstance.Query<Foldout>("ImportSettingsFoldout").First();
         ModelImporterSettings modelImporterSettings = config.GetModelImporterSettings();

Plugin~/CMakeLists.txt

@@ -52,7 +52,11 @@ endif()
 # Custom scripts
 include(AddPlugin)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+if(APPLE)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+elseif(WIN32)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17")
+endif()
 
 # Force Unicode character set
 add_definitions(-DUNICODE -D_UNICODE)

Plugin~/Docs/en/BuildPlugins.md

@@ -112,7 +112,7 @@ $ xcodebuild -scheme mscore -configuration Release build
 
 ### Prerequisites (Linux)
 
-1. Make sure C++14 development is supported, and define `CC` and `CXX` environment variables to point to C++14 dev tools.  
+1. Make sure C++17 development is supported, and define `CC` and `CXX` environment variables to point to C++17 dev tools.  
    For example, by installing [devtoolset-7](https://www.softwarecollections.org/en/scls/rhscl/devtoolset-7/) in in CentOS 7, 
    and then defining `CC` and `CXX` environment variables as follows:
    ``` 

Plugin~/Src/MeshSync/AsyncSceneSender.cpp

@@ -73,16 +73,23 @@ void AsyncSceneSender::send()
 
     if (assets.empty() && textures.empty() && materials.empty() &&
         transforms.empty() && geometries.empty() && animations.empty() &&
-        deleted_entities.empty() && deleted_materials.empty())
+        instanceInfos.empty() && instanceMeshes.empty() &&
+        deleted_entities.empty() && deleted_materials.empty() && 
+        deleted_instances.empty())
         return;
 
     SetupDataFlags(transforms);
     SetupDataFlags(geometries);
+    SetupDataFlags(instanceMeshes);
+
     AssignIDs(transforms, id_table);
     AssignIDs(geometries, id_table);
+    AssignIDs(instanceMeshes, id_table);
+
     // sort by order. not id.
     std::sort(transforms.begin(), transforms.end(), [](auto& a, auto& b) { return a->order < b->order; });
     std::sort(geometries.begin(), geometries.end(), [](auto& a, auto& b) { return a->order < b->order; });
+    std::sort(instanceMeshes.begin(), instanceMeshes.end(), [](auto& a, auto& b) { return a->order < b->order; });
 
     auto append = [](auto& dst, auto& src) { dst.insert(dst.end(), src.begin(), src.end()); };
 
@@ -154,6 +161,30 @@ void AsyncSceneSender::send()
         };
     }
 
+    //instance meshes
+    if (!instanceMeshes.empty()) {
+        for (auto& mesh : instanceMeshes) {
+            ms::SetMessage mes;
+            setup_message(mes);
+            mes.scene->settings = scene_settings;
+            mes.scene->instanceMeshes = { mesh };
+            succeeded = succeeded && client.send(mes);
+            if (!succeeded)
+                goto cleanup;
+        }
+    }
+
+    // instance infos
+    if (!instanceInfos.empty()) {
+        ms::SetMessage mes;
+        setup_message(mes);
+        mes.scene->settings = scene_settings;
+        mes.scene->instanceInfos = instanceInfos;
+        succeeded = succeeded && client.send(mes);
+        if (!succeeded)
+            goto cleanup;
+    }
+
     // animations
     if (!animations.empty()) {
         ms::SetMessage mes;
@@ -166,11 +197,16 @@ void AsyncSceneSender::send()
     }
 
     // deleted
-    if (!deleted_entities.empty() || !deleted_materials.empty()) {
+    if (!deleted_entities.empty() || 
+        !deleted_materials.empty() || 
+        !deleted_instances.empty()) {
+
         ms::DeleteMessage mes;
         setup_message(mes);
         mes.entities = deleted_entities;
         mes.materials = deleted_materials;
+        mes.instances = deleted_instances;
+
         succeeded = succeeded && client.send(mes);
         if (!succeeded)
             goto cleanup;

Plugin~/Src/MeshSync/Include/MeshSync/SceneExporter.h

@@ -6,6 +6,8 @@
 #include "MeshSync/msIDGenerator.h" //PathToID
 #include "MeshSync/SceneGraph/msScene.h" //AssetPtr
 
+msDeclClassPtr(InstanceInfo)
+
 namespace ms {
 
 class SceneExporter
@@ -18,9 +20,12 @@ class SceneExporter
     std::vector<TransformPtr> transforms;
     std::vector<TransformPtr> geometries;
     std::vector<AnimationClipPtr> animations;
+    std::vector<InstanceInfoPtr> instanceInfos;
+    std::vector<TransformPtr> instanceMeshes;
 
     std::vector<Identifier> deleted_entities;
     std::vector<Identifier> deleted_materials;
+    std::vector<Identifier> deleted_instances;
 
     std::function<void()> on_prepare, on_success, on_error, on_complete;
     PathToID id_table;

Plugin~/Src/MeshSync/Include/MeshSync/SceneGraph/msEntityConverter.h

@@ -1,20 +1,18 @@
 #pragma once
 
 #include "MeshSync/MeshSync.h"
+#include "MeshSync/SceneGraph/msEntity.h"
+#include "MeshSync/SceneGraph/msTransform.h"
+#include "MeshSync/SceneGraph/msCamera.h"
+#include "MeshSync/SceneGraph/msLight.h"
+#include "MeshSync/SceneGraph/msMesh.h"
+#include "MeshSync/SceneGraph/msPoints.h"
+#include "MeshSync/SceneGraph/msAnimation.h"
 
 msDeclClassPtr(AnimationClip)
 
 namespace ms {
 
-class Entity;
-class Transform;
-class Camera;
-class Light;
-class Mesh;
-class Points;
-class Animation;
-class AnimationCurve;
-
 class EntityConverter
 {
 public:

Plugin~/Src/MeshSync/Include/MeshSync/SceneGraph/msInstanceInfo.h

@@ -0,0 +1,49 @@
+#pragma once
+#include "MeshUtils/muMath.h"
+#include "MeshSync/msFoundation.h"
+#include "MeshSync/SceneGraph/msIdentifier.h"
+#include "MeshSync/SceneGraph/msMesh.h"
+
+namespace ms {
+	using namespace std;
+	using namespace mu;
+	class InstanceInfo
+	{
+		uint64_t m_hash = 0;
+
+	public:
+
+		/// <summary>
+		/// /// Path on the hierachy tree to the mesh that the instances refer to.
+		/// /// </summary>
+		string path;
+
+		string parent_path;
+
+		/// <summary>
+		/// World transforms of the instances
+		/// </summary>
+		SharedVector<float4x4> transforms;
+
+		void serialize(ostream& os);
+		void deserialize(istream& is);
+
+		InstanceInfo();
+		InstanceInfo(const InstanceInfo& v);
+		InstanceInfo& operator=(const InstanceInfo& v);
+		InstanceInfo(InstanceInfo&& v) noexcept; // noexcept to enforce std::vector to use move constructor
+		InstanceInfo& operator=(InstanceInfo&& v);
+
+		msDefinePool(InstanceInfo);
+
+		void clear();
+
+		static shared_ptr<InstanceInfo> create(std::istream& is);
+		uint64_t hash();
+
+		Identifier getIdentifier();
+
+	};
+	msSerializable(InstanceInfo)
+}
+

Plugin~/Src/MeshSync/Include/MeshSync/SceneGraph/msScene.h

@@ -12,12 +12,16 @@
 //Used in template
 #include "MeshSync/SceneGraph/msTransform.h"
 
+#include "MeshSync/SceneGraph/msInstanceInfo.h"
+
 //Forward declarations
 msDeclClassPtr(Asset);
 msDeclClassPtr(Constraint);
 msDeclClassPtr(Scene);
 
 msDeclStructPtr(SceneImportSettings);
+msDeclStructPtr(InstanceInfo)
+msDeclClassPtr(EntityConverter)
 
 namespace ms {
 
@@ -38,6 +42,8 @@ struct SceneDataFlags
     uint32_t has_assets : 1;
     uint32_t has_entities : 1;
     uint32_t has_constraints : 1;
+    uint32_t has_instanceInfos : 1;
+    uint32_t has_instanceMeshes : 1;
 
     SceneDataFlags();
 };
@@ -51,6 +57,8 @@ class Scene
     std::vector<AssetPtr> assets;
     std::vector<TransformPtr> entities;
     std::vector<ConstraintPtr> constraints;
+    std::vector<InstanceInfoPtr> instanceInfos;
+    std::vector<TransformPtr> instanceMeshes;
 
     // non-serializable
     std::list<RawVector<char>> scene_buffers;
@@ -105,6 +113,10 @@ class Scene
     bool submeshesHaveUniqueMaterial() const;
 
     void dbgDump() const;
+
+private:
+    void updateEntities(const ms::SceneImportSettings& cv, const std::vector<ms::EntityConverterPtr>& converters, std::vector<ms::TransformPtr> entities);
+
 };
 msSerializable(Scene);
 

Plugin~/Src/MeshSync/Include/MeshSync/SceneGraph/msTransform.h

@@ -54,6 +54,7 @@ using super = Entity;
     mu::float4x4 toMatrix() const;
     void assignMatrix(const mu::float4x4& v);
     void applyMatrix(const mu::float4x4& v);
+    void reset();
 
     void addUserProperty(const Variant& v);
     void addUserProperty(Variant&& v);

Plugin~/Src/MeshSync/Include/MeshSync/msProtocol.h

@@ -86,6 +86,7 @@ using super = Message;
 public:
     std::vector<Identifier> entities;
     std::vector<Identifier> materials;
+    std::vector<Identifier> instances;
 
     DeleteMessage();
     void serialize(std::ostream& os) const override;

Plugin~/Src/MeshSync/SceneExporter.cpp

@@ -21,9 +21,11 @@ void SceneExporter::clear()
     transforms.clear();
     geometries.clear();
     animations.clear();
+    instanceInfos.clear();
 
     deleted_entities.clear();
     deleted_materials.clear();
+    deleted_instances.clear();
 }
 
 void SceneExporter::add(ScenePtr scene)

Plugin~/Src/MeshSync/SceneGraph/msInstanceInfo.cpp

@@ -0,0 +1,69 @@
+#include "MeshSync/SceneGraph/msInstanceInfo.h"
+#include <MeshSync/msFoundation.h>
+#include <MeshSync/SceneGraph/msIdentifier.h>
+
+namespace ms {
+	void InstanceInfo::serialize(ostream& os)
+	{
+		write(os, path);
+		write(os, parent_path);
+		write(os, transforms);
+
+	}
+
+	void InstanceInfo::deserialize(istream& is)
+	{
+		read(is, path);
+		read(is, parent_path);
+		read(is, transforms);
+	}
+	void InstanceInfo::clear()
+	{
+		this->path = "";
+		this->parent_path = "";
+		this->transforms.clear();
+	}
+
+	shared_ptr<InstanceInfo> InstanceInfo::create(istream& is)
+	{
+		auto ret = InstanceInfo::create();
+		ret->deserialize(is);
+		return ret;
+	}
+
+	uint64_t InstanceInfo::hash()
+	{
+		return m_hash;
+	}
+	Identifier InstanceInfo::getIdentifier()
+	{
+		return Identifier{ path, InvalidID};
+	}
+
+	InstanceInfo::InstanceInfo() {}
+
+	InstanceInfo::InstanceInfo(const InstanceInfo& v)
+	{
+		*this = v;
+	}
+
+	InstanceInfo& InstanceInfo::operator=(const InstanceInfo& v)
+	{
+		path = v.path;
+		transforms = v.transforms;
+		return *this;
+	}
+
+	InstanceInfo::InstanceInfo(InstanceInfo&& v) noexcept
+	{
+		*this = std::move(v);
+	}
+
+	InstanceInfo& InstanceInfo::operator=(InstanceInfo&& v)
+	{
+		path = std::move(v.path);
+		transforms = std::move(v.transforms);
+		return *this;
+	}
+
+}