Update 2.0

.github/workflows/build-vitruvio.yml

@@ -2,10 +2,17 @@ name: build-vitruvio
 
 on: 
   push:
+    # Careful! No fall-through for the filters.
     branches:
       - main
       - develop
-      - 'arisona/workflows'
+
+  pull_request:
+    # Careful! No fall-through for the filters.
+    branches:
+      - main
+      - develop
+      - workflow_integration
 
 jobs:
   package-host-main:
@@ -16,7 +23,9 @@ jobs:
       - uses: actions/checkout@v2
       - run: |
           C:\dev\git\zrh-xr-devops\scripts\ue_build_action.py ${{github.workspace}} ${{github.ref_name}} vitruvio_host_package_shipping
-
+      - run: |
+          C:\dev\git\zrh-xr-devops\scripts\ue_run_action.py ${{github.workspace}} ${{github.ref_name}} vitruvio_host_package_shipping
+
   build-plugin-main:
     runs-on: [self-hosted, zrh-unreal]
     name: Build plugin on main branch
@@ -29,16 +38,18 @@ jobs:
   package-host-develop:
     runs-on: [self-hosted, zrh-unreal]
     name: Package host project (debug) on develop branch
-    if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/arisona/workflows'
+    if: github.ref != 'refs/heads/main'
     steps:
       - uses: actions/checkout@v2
       - run: |
           C:\dev\git\zrh-xr-devops\scripts\ue_build_action.py ${{github.workspace}} ${{github.ref_name}} vitruvio_host_package_debug
-
+      - run: |
+          C:\dev\git\zrh-xr-devops\scripts\ue_run_action.py ${{github.workspace}} ${{github.ref_name}} vitruvio_host_package_debug
+
   build-plugin-develop:
     runs-on: [self-hosted, zrh-unreal]
     name: Build plugin on develop branch
-    if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/arisona/workflows'
+    if: github.ref != 'refs/heads/main'
     steps:
       - uses: actions/checkout@v2
       - run: |

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/Private/Codec/CodecMain.cpp

@@ -23,7 +23,7 @@
 namespace
 {
 const int VERSION_MAJOR = 3;
-const int VERSION_MINOR = 0;
+const int VERSION_MINOR = 1;
 } // namespace
 
 extern "C"

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/Private/Codec/Encoder/UnrealGeometryEncoder.cpp

@@ -1,4 +1,4 @@
-/* Copyright 2020 Esri
+/* Copyright 2023 Esri
  *
  * Licensed under the Apache License Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -148,22 +148,28 @@ uint32_t scanValidTextures(const prtx::MaterialPtr& mat)
 		return highestUVSet + 1;
 }
 
-// use shape name by default for the actor and if the instance originates from a file we use the file name for better readability
-std::wstring createInstanceName(const prtx::EncodePreparator::FinalizedInstance& fi)
+struct InstanceIdentifier
+{
+	std::wstring name;
+	std::wstring meshId;
+};
+
+// use shape name by default and if the instance originates from a file we use the file name for better readability
+InstanceIdentifier createInstanceIdentifier(const prtx::EncodePreparator::FinalizedInstance& fi)
 {
 	const auto geometry = fi.getGeometry();
 	const auto uri = geometry->getURI();
 
-	if (uri->isFilePath())
-		return uri->getBaseName();
+	if (!uri->getExtension().empty())
+		return { uri->getBaseName(), uri->getPath() };
 
 	std::wstring meshName = fi.getShapeName();
 
 	// remove last point similar to the model hierarchy
 	if (!meshName.empty() && meshName.back() == '.')
 		meshName = meshName.substr(0, meshName.length() - 1);
 
-	return meshName;
+	return { meshName, uri->getPath() + L"/" + meshName};
 }
 
 std::wstring uriToPath(const prtx::TexturePtr& t)
@@ -514,7 +520,7 @@ SerializedGeometry serializeGeometry(const prtx::GeometryPtrVector& geometries,
 	return sg;
 }
 
-void encodeMesh(IUnrealCallbacks* cb, const SerializedGeometry& sg, wchar_t const* name, int32_t prototypeIndex, const std::wstring& uri,
+void encodeMesh(IUnrealCallbacks* cb, const SerializedGeometry& sg, wchar_t const* name, wchar_t const* meshId, int32_t prototypeIndex, const std::wstring& uri,
 				prtx::GeometryPtrVector geometries, std::vector<prtx::MaterialPtrVector> materials)
 {
 	auto puvs = toPtrVec(sg.uvs);
@@ -543,7 +549,7 @@ void encodeMesh(IUnrealCallbacks* cb, const SerializedGeometry& sg, wchar_t cons
 		++matIt;
 	}
 
-	cb->addMesh(name, prototypeIndex, uri.c_str(), sg.coords.data(), sg.coords.size(), sg.normals.data(), sg.normals.size(),
+	cb->addMesh(name, meshId, prototypeIndex, uri.c_str(), sg.coords.data(), sg.coords.size(), sg.normals.data(), sg.normals.size(),
 				sg.faceVertexCounts.data(), sg.faceVertexCounts.size(), sg.vertexIndices.data(), sg.vertexIndices.size(), sg.normalIndices.data(),
 				sg.normalIndices.size(),
 
@@ -574,9 +580,16 @@ UnrealGeometryEncoder::UnrealGeometryEncoder(const std::wstring& id, const prt::
 
 void UnrealGeometryEncoder::init(prtx::GenerateContext&)
 {
+	mNsMesh = mNamePrep.newNamespace();
+	mNsMaterial = mNamePrep.newNamespace();
+
+	mEncPrep = prtx::EncodePreparator::create(true, mNamePrep, mNsMesh, mNsMaterial);
+
 	auto* callbacks = dynamic_cast<IUnrealCallbacks*>(getCallbacks());
 	if (callbacks == nullptr)
 		throw prtx::StatusException(prt::STATUS_ILLEGAL_CALLBACK_OBJECT);
+
+	callbacks->init();
 }
 
 void UnrealGeometryEncoder::encode(prtx::GenerateContext& context, size_t initialShapeIndex)
@@ -585,39 +598,17 @@ void UnrealGeometryEncoder::encode(prtx::GenerateContext& context, size_t initia
 
 	IUnrealCallbacks* cb = static_cast<IUnrealCallbacks*>(getCallbacks());
 
-	const bool emitAttrs = getOptions()->getBool(EO_EMIT_ATTRIBUTES);
-
-	prtx::DefaultNamePreparator namePrep;
-	prtx::NamePreparator::NamespacePtr nsMesh = namePrep.newNamespace();
-	prtx::NamePreparator::NamespacePtr nsMaterial = namePrep.newNamespace();
-	prtx::EncodePreparatorPtr encPrep = prtx::EncodePreparator::create(true, namePrep, nsMesh, nsMaterial);
-
-	// generate geometry
-	prtx::ReportsAccumulatorPtr reportsAccumulator{prtx::SummarizingReportsAccumulator::create()};
-	prtx::ReportingStrategyPtr reportsCollector{prtx::AllShapesReportingStrategy::create(context, initialShapeIndex, reportsAccumulator)};
 	prtx::LeafIteratorPtr li = prtx::LeafIterator::create(context, initialShapeIndex);
 	for (prtx::ShapePtr shape = li->getNext(); shape; shape = li->getNext())
 	{
-		encPrep->add(context.getCache(), shape, initialShape.getAttributeMap());
+		mEncPrep->add(context.getCache(), shape, initialShape.getAttributeMap());
 	}
 
-	const prtx::EncodePreparator::PreparationFlags PREP_FLAGS =
-		prtx::EncodePreparator::PreparationFlags()
-			.instancing(true)
-			.meshMerging(prtx::MeshMerging::ALL_OF_SAME_MATERIAL_AND_TYPE)
-			.triangulate(false)
-			.processHoles(prtx::HoleProcessor::TRIANGULATE_FACES_WITH_HOLES)
-			.mergeVertices(true)
-			.cleanupVertexNormals(true)
-			.cleanupUVs(true)
-			.processVertexNormals(prtx::VertexNormalProcessor::SET_MISSING_TO_FACE_NORMALS)
-			.indexSharing(prtx::EncodePreparator::PreparationFlags::INDICES_SEPARATE_FOR_ALL_VERTEX_ATTRIBUTES);
-
-	prtx::EncodePreparator::InstanceVector instances;
-	encPrep->fetchFinalizedInstances(instances, PREP_FLAGS);
-	convertGeometry(initialShape, instances, cb);
-
+	const bool emitAttrs = getOptions()->getBool(EO_EMIT_ATTRIBUTES);
 	if (emitAttrs) {
+		prtx::ReportsAccumulatorPtr reportsAccumulator{prtx::SummarizingReportsAccumulator::create()};
+		prtx::ReportingStrategyPtr reportsCollector{prtx::AllShapesReportingStrategy::create(context, initialShapeIndex, reportsAccumulator)};
+
 		const prtx::ReportsPtr& reports = reportsCollector->getReports();
 		if (reports) {
 			prtx::PRTUtils::AttributeMapPtr reportMap = convertReportToAttributeMap(reports);
@@ -626,32 +617,28 @@ void UnrealGeometryEncoder::encode(prtx::GenerateContext& context, size_t initia
 	}
 }
 
-void UnrealGeometryEncoder::convertGeometry(const prtx::InitialShape& initialShape, const prtx::EncodePreparator::InstanceVector& instances,
-											IUnrealCallbacks* cb) const
+void UnrealGeometryEncoder::convertGeometry(const prtx::EncodePreparator::InstanceVector& instances, IUnrealCallbacks* cb)
 {
-	std::set<int> serializedPrototypes;
-
 	prtx::GeometryPtrVector geometries;
 	std::vector<prtx::MaterialPtrVector> materials;
 	prtx::PRTUtils::AttributeMapBuilderPtr instanceMatAmb(prt::AttributeMapBuilder::create());
 	for (const auto& inst : instances)
 	{
-		if (inst.getPrototypeIndex() != -1)
+		if (inst.getPrototypeIndex() != prtx::EncodePreparator::FinalizedInstance::NO_PROTOTYPE_INDEX)
 		{
 			const prtx::MaterialPtrVector& instMaterials = inst.getMaterials();
 			const prtx::GeometryPtr& instGeom = inst.getGeometry();
 
 			AttributeMapNOPtrVectorOwner instMaterialsAttributeMap;
 
-			if (serializedPrototypes.find(inst.getPrototypeIndex()) == serializedPrototypes.end())
+			InstanceIdentifier identifier = createInstanceIdentifier(inst);
+
+			if (serializedPrototypes.find(identifier.meshId) == serializedPrototypes.end())
 			{
 				const std::wstring uri = instGeom->getURI()->wstring();
 				const SerializedGeometry sg = serializeGeometry({instGeom}, {instMaterials});
-				const std::wstring instName = createInstanceName(inst);
-
-				encodeMesh(cb, sg, instName.c_str(), inst.getPrototypeIndex(), uri, {instGeom}, {instMaterials});
-
-				serializedPrototypes.insert(inst.getPrototypeIndex());
+				encodeMesh(cb, sg, identifier.name.c_str(), identifier.meshId.c_str(), inst.getPrototypeIndex(), uri, {instGeom}, {instMaterials});
+				serializedPrototypes.insert(identifier.meshId);
 			}
 
 			const prtx::MeshPtrVector& meshes = instGeom->getMeshes();
@@ -663,7 +650,7 @@ void UnrealGeometryEncoder::convertGeometry(const prtx::InitialShape& initialSha
 				instMaterialsAttributeMap.v.push_back(instanceMatAmb->createAttributeMapAndReset());
 			}
 
-			cb->addInstance(inst.getPrototypeIndex(), inst.getTransformation().data(), instMaterialsAttributeMap.v.data(),
+			cb->addInstance(inst.getPrototypeIndex(), identifier.meshId.c_str(), inst.getTransformation().data(), instMaterialsAttributeMap.v.data(),
 							instMaterialsAttributeMap.v.size());
 		}
 		else
@@ -676,14 +663,36 @@ void UnrealGeometryEncoder::convertGeometry(const prtx::InitialShape& initialSha
 	if (geometries.size() > 0)
 	{
 		const SerializedGeometry sg = serializeGeometry(geometries, materials);
-		encodeMesh(cb, sg, initialShape.getName(), -1, L"", geometries, materials);
+		encodeMesh(cb, sg, L"", L"", prtx::EncodePreparator::FinalizedInstance::NO_PROTOTYPE_INDEX, L"", geometries, materials);
 	}
 
 	if (DBG)
 		log_debug(L"UnrealGeometryEncoder::convertGeometry: end");
 }
 
-void UnrealGeometryEncoder::finish(prtx::GenerateContext& /*context*/) {}
+void UnrealGeometryEncoder::finish(prtx::GenerateContext& /*context*/)
+{
+	IUnrealCallbacks* cb = static_cast<IUnrealCallbacks*>(getCallbacks());
+
+	const prtx::EncodePreparator::PreparationFlags PREP_FLAGS =
+		prtx::EncodePreparator::PreparationFlags()
+			.instancing(true)
+			.meshMerging(prtx::MeshMerging::ALL_OF_SAME_MATERIAL_AND_TYPE)
+			.triangulate(false)
+			.processHoles(prtx::HoleProcessor::TRIANGULATE_FACES_WITH_HOLES)
+			.mergeVertices(true)
+			.cleanupVertexNormals(true)
+			.cleanupUVs(true)
+			.processVertexNormals(prtx::VertexNormalProcessor::SET_MISSING_TO_FACE_NORMALS)
+			.indexSharing(prtx::EncodePreparator::PreparationFlags::INDICES_SEPARATE_FOR_ALL_VERTEX_ATTRIBUTES);
+
+	prtx::EncodePreparator::InstanceVector instances;
+	mEncPrep->fetchFinalizedInstances(instances, PREP_FLAGS);
+
+	convertGeometry(instances, cb);
+
+	cb->finish();
+}
 
 UnrealGeometryEncoderFactory* UnrealGeometryEncoderFactory::createInstance()
 {

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/Private/Codec/Encoder/UnrealGeometryEncoder.h

@@ -1,4 +1,4 @@
-/* Copyright 2020 Esri
+/* Copyright 2023 Esri
  *
  * Licensed under the Apache License Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,6 +34,7 @@
 #include "Codec/CodecMain.h"
 
 #include <iostream>
+#include <set>
 #include <stdexcept>
 #include <string>
 
@@ -45,16 +46,22 @@ class UnrealGeometryEncoder final : public prtx::GeometryEncoder
 {
 public:
 	UnrealGeometryEncoder(const std::wstring& id, const prt::AttributeMap* options, prt::Callbacks* callbacks);
-	~UnrealGeometryEncoder() override = default;
+	virtual ~UnrealGeometryEncoder() override = default;
 
 public:
-	void init(prtx::GenerateContext& context) override;
-	void encode(prtx::GenerateContext& context, size_t initialShapeIndex) override;
-	void finish(prtx::GenerateContext& context) override;
+	virtual void init(prtx::GenerateContext& context) override;
+	virtual void encode(prtx::GenerateContext& context, size_t initialShapeIndex) override;
+	virtual void finish(prtx::GenerateContext& context) override;
 
 private:
-	void convertGeometry(const prtx::InitialShape& initialShape, const prtx::EncodePreparator::InstanceVector& instances,
-						 IUnrealCallbacks* callbacks) const;
+	void convertGeometry(const prtx::EncodePreparator::InstanceVector& instances, IUnrealCallbacks* callbacks);
+
+	prtx::DefaultNamePreparator mNamePrep;
+    prtx::EncodePreparatorPtr mEncPrep;
+    prtx::NamePreparator::NamespacePtr mNsMesh;
+    prtx::NamePreparator::NamespacePtr mNsMaterial;
+
+	std::set<std::wstring> serializedPrototypes;
 };
 
 class UnrealGeometryEncoderFactory final : public prtx::EncoderFactory, public prtx::Singleton<UnrealGeometryEncoderFactory>

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/Public/Codec/Encoder/IUnrealCallbacks.h

@@ -26,8 +26,10 @@ class IUnrealCallbacks : public prt::Callbacks
 	~IUnrealCallbacks() override = default;
 
 	/**
-	 * @param name initial shape name, optionally used to create primitive groups on output
+	 * @param name either the name of the inserted asset or the shape name
+	 * @param meshId unique identifier of this mesh
 	 * @param prototypeId the id of the prototype or -1 of not cached
+	 * @param uri the uri of the inserted asset or empty otherwise
 	 * @param vtx vertex coordinate array
 	 * @param vtxSize of vertex coordinate array
 	 * @param nrm vertex normal array
@@ -43,7 +45,7 @@ class IUnrealCallbacks : public prt::Callbacks
 	 * types)
 	 */
 	// clang-format off
-	virtual void addMesh(const wchar_t* name,
+	virtual void addMesh(const wchar_t* name, const wchar_t* meshId,
 	                     int32_t prototypeId, const wchar_t* uri,
 	                     const double* vtx, size_t vtxSize,
 	                     const double* nrm, size_t nrmSize,
@@ -64,15 +66,18 @@ class IUnrealCallbacks : public prt::Callbacks
 	/**
 	 * Add a new instance with the given id, transform and an optional set of overriding attributes for this instance
 	 *
-	 * @param prototypeId the id of the prorotype. An @ref addMesh call with the specified prorotypeId will be called before
+	 * @param prototypeId the id of the prototype. An @ref addMesh call with the specified prototype id will be called before
 	 *                    the call to addInstance and addReport
+	 * @param meshId unique identifier of this mesh
 	 * @param transform the transformation matrix of this instance
 	 * @param instanceMaterial override materials for this instance
 	 * @param numInstanceMaterials number of instance material overrides. Is either 0 or is equal to the number
 	 *                             of materials of the original mesh (by prototypeId)
 	 */
-	virtual void addInstance(int32_t prototypeId, const double* transform, const prt::AttributeMap** instanceMaterial,
+	virtual void addInstance(int32_t prototypeId, const wchar_t* meshId, const double* transform, const prt::AttributeMap** instanceMaterial,
 							 size_t numInstanceMaterials) = 0;
-
+
+	virtual void init() = 0;
+	virtual void finish() = 0;
 	virtual void addReport(const prt::AttributeMap* reports) = 0;
 };

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/Public/PRTTypes.h

@@ -47,6 +47,7 @@ using AttributeMapBuilderUPtr = std::unique_ptr<prt::AttributeMapBuilder, PRTDes
 using AttributeMapBuilderVector = std::vector<AttributeMapBuilderUPtr>;
 using InitialShapePtr = std::shared_ptr<const prt::InitialShape>;
 using InitialShapeUPtr = std::unique_ptr<const prt::InitialShape, PRTDestroyer>;
+using InitialShapeUPtrVector = std::vector<InitialShapeUPtr>;
 using InitialShapeBuilderPtr = std::shared_ptr<const prt::InitialShapeBuilder>;
 using InitialShapeBuilderUPtr = std::unique_ptr<prt::InitialShapeBuilder, PRTDestroyer>;
 using InitialShapeBuilderVector = std::vector<InitialShapeBuilderUPtr>;

VitruvioHost/Plugins/Vitruvio/Extras/UnrealGeometryEncoder/UnrealGeometryEncoder.Target.cs

@@ -38,7 +38,6 @@ public UnrealGeometryEncoderTarget(TargetInfo Target)
 		bShouldCompileAsDLL = true;
 
 		bBuildDeveloperTools = false;
-		bUseMallocProfiler = false;
 		bBuildWithEditorOnlyData = true;
 		bCompileAgainstEngine = false;
 		bCompileAgainstCoreUObject = false;

VitruvioHost/Plugins/Vitruvio/Source/ThirdParty/PRT/PRT.Build.cs

@@ -1,4 +1,4 @@
-/* Copyright 2023 Esri
+/* Copyright 2024 Esri
  *
  * Licensed under the Apache License Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,8 +28,8 @@ public class PRT : ModuleRules
 
 	// PRT version and toolchain (needs to be correct for download URL)
 	private const int PrtMajor = 3;
-	private const int PrtMinor = 0;
-	private const int PrtBuild = 8905;
+	private const int PrtMinor = 1;
+	private const int PrtBuild = 9666;
 
 	private const string PrtCoreDllName = "com.esri.prt.core.dll";
 

VitruvioHost/Plugins/Vitruvio/Source/ThirdParty/UnrealGeometryEncoderLib/UnrealGeometryEncoderLib.Build.cs

@@ -1,4 +1,4 @@
-/* Copyright 2023 Esri
+/* Copyright 2024 Esri
  *
  * Licensed under the Apache License Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.