Full support for layer representation in the scene with named layers, meshes sorted into layers and layers within layers.

.github/workflows/close-issue.yml

@@ -1,78 +0,0 @@
-name: Update issue Status
-
-on:
-  issues:
-    types: [closed]
-
-jobs:
-  update_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          
-          echo "$PROJECT_ID"
-          echo "$STATUS_FIELD_ID"
-          
-          echo 'DONE_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .settings | fromjson | .options[] | select(.name== "Done") | .id' project_data.json) >> $GITHUB_ENV
-          echo "$DONE_ID"
-
-      - name: Add Issue to project #it's already in the project, but we do this to get its node id!
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
-          
-      - name: Update Status
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $status:ID!, $id:ID!, $value:String!) {
-              set_status: updateProjectNextItemField(
-                input: {
-                  projectId: $project
-                  itemId: $id
-                  fieldId: $status
-                  value: $value
-                }
-              ) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f status=$STATUS_FIELD_ID -f id=$ITEM_ID -f value=${{ env.DONE_ID }}
-          

.github/workflows/open-issue.yml

@@ -1,50 +0,0 @@
-name: Move new issues into Project
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-     
-      - name: Add Issue to project
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

.gitignore

@@ -31,10 +31,9 @@
 *.out
 *.app
 *.umap
-
-Binaries/
-Intermediate/
-Saved/
-
-.idea/
-.vs/
+SpeckleUnrealProject/Binaries/
+SpeckleUnrealProject/Intermediate/
+SpeckleUnrealProject/Plugins/SpeckleUnreal/Binaries/
+SpeckleUnrealProject/Plugins/SpeckleUnreal/Intermediate/
+SpeckleUnrealProject/Saved/
+SpeckleUnrealProject/.vs/

.vs/ProjectSettings.json

@@ -0,0 +1,3 @@
+{
+  "CurrentProjectSetting": "No Configurations"
+}

.vs/VSWorkspaceState.json

@@ -0,0 +1,8 @@
+{
+  "ExpandedNodes": [
+    "",
+    "\\SpeckleUnreal",
+    "\\SpeckleUnreal\\Source"
+  ],
+  "PreviewInSolutionExplorer": false
+}

LICENSE

@@ -1,201 +1,21 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+MIT License
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Copyright (c) 2020 mobiusnode
 
-   1. Definitions.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2021 AEC Systems
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,34 +1,56 @@
-# Speckle Unreal
+# SpeckleUnreal
 
-[![Twitter Follow](https://img.shields.io/twitter/follow/SpeckleSystems?style=social)](https://twitter.com/SpeckleSystems) [![Community forum users](https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&style=flat-square&logo=discourse&logoColor=white)](https://speckle.community) [![website](https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square)](https://speckle.systems) [![docs](https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&logo=read-the-docs&logoColor=white)](https://speckle.guide/dev/)
+[![Version](https://img.shields.io/badge/Version-v0.1.0-orange)](https://github.com/mobiusnode/SpeckleUnreal) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](http://makeapullrequest.com)
 
-Plugin for Unreal Engine to import objects from Speckle v2.
+Our Team is developing a Speckle plugin and interoperability transport schema for UE4. Our goal is to enable Revit/Dynamo and Rhino/Grasshopper to send + receive geometry to UE4 for visualization. Our current priority is to establish and release a data sender (TO UE4). We’re also working on receiver methods, however our initial focus  is on Rhino/Grasshopper to UE4 translation and the attachment of UE4-specific metadata to the core JSON ‘blobs’ in transport.
 
+In this repository you will find the source code, assets and project settings of the SpeckleUnreal plugin for Unreal Engine app development (Unreal Engine 4.25.1 or newer recommended).
 
-Screencast of an example: https://user-images.githubusercontent.com/2551138/114720093-61403e00-9d40-11eb-8045-6e8ca656554d.mp4
+# Useful Links
+Use the following links to access resources related to bug reporting, issues, feature requests, and general questions regarding SpeckleUnreal. Future releases may not contain these links & note.
 
+## Speckle Unreal Server
+https://speckle.mobiusnode.io
 
+## Discourse Forums (Bugs, Issues, etc.)
+https://discourse.mobiusnode.io
 
+## SpeckleUnreal Slack Workspace
+https://speckle-works-unreal.slack.com
+
+## YouTub Demo & Tutorial - Getting Started
+https://bit.ly/3ehHQE6
 
 ## NOTICE
 
-* Our Unreal Connector is in an beta stage of development. Currently we only support receiving objects, and there is no UI to fetch lists of streams/commits/branches.
-* We officially support Unreal Engine 4.26 and 4.27, and have experimental support for UE5.
+* Tested on Windows and MacOS and Linux.
+* Only displays meshes. Breps are converted using their display values.
 * Does not use the Speckle Kit workflow as conversions all happen in C++. 
 
 ## How To Install
 
 
-1. Download `speckle-unreal` repository archive from https://github.com/specklesystems/speckle-unreal/archive/refs/heads/main.zip 
-1. Extract the downloaded archive into your project's `Plugins` directory (if your project directory doesn't contain a directory called Plugins, you should create it)
-1. Open your UE project (or restart the editor if you already have it opened). This will build the plugin in your environment.
+1. Clone the repository or download it as a zip file.
+2. Navigate to `SpeckleUnrealProject` > `Plugins` and copy the `SpeckleUnreal` folder
+3. Paste the folder into your Unreal project under `YourUnrealProjectFolder` > `Plugins` (Create a `Plugins` folder if you don't already have one).
+4. Reopen your project.
 
 We will eventually look to distributing the plugin officially on the Unreal Engine Marketplace but for now you'll need to install the plugin manually like this.
 
-See our [docs](https://speckle.guide/user/unreal.html) for usage instructions.
+---
 
-## Credits
-Based off the original Unreal integration for Speckle v1 by Mark and Jak which can be found here: [https://github.com/mobiusnode/SpeckleUnreal](https://github.com/mobiusnode/SpeckleUnreal).
+## Roadmap
 
-https://user-images.githubusercontent.com/2551138/114720051-571e3f80-9d40-11eb-9099-d3394747a1d3.mp4
+> Roadmap is subject to change. Last reviewed 10th of July 2020.
 
+| Version | Defining Feature                  						  				         |
+| ------- | -------------------------------------------------------------------------------- |
+| ~0.1~   | ~First prototype release as Unreal Engine plugin~   								 			         |
+| 0.2   | New component workflow and custom materials assigned via inspector~		 |
+| 0.3   | Spawn geometry in transform heirarchy based on layer data		    	         |
+| 0.4   | User login API, get Stream API and no dependency on a local install of Speckle |
+| 0.5   | Rendering Rule API                      |
+| 0.6   | Support Lines, Points, Numbers and Text|
+| 0.7     | Local caching of Speckle streams			                                     |
+| 0.8     | Implement Sender API    			                                 |
+| 1.0     | Production ready (out of preview)      			                                 |

Source/SpeckleUnreal/Private/API/Operations/ReceiveOperation.cpp

@@ -1,90 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "API/Operations/ReceiveOperation.h"
-
-#include "Dom/JsonObject.h"
-#include "Transports/Transport.h"
-#include "API/SpeckleSerializer.h"
-#include "Objects/Base.h"
-#include "Mixpanel.h"
-
-
-UReceiveOperation* UReceiveOperation::ReceiveOperation(UObject* WorldContextObject, const FString& ObjectId, TScriptInterface<ITransport> RemoteTransport, TScriptInterface<ITransport> LocalTransport)
-{
-    UReceiveOperation* Node = NewObject<UReceiveOperation>();
-    Node->ObjectId = ObjectId;
-    Node->RemoteTransport = RemoteTransport;
-    Node->LocalTransport = LocalTransport;
-
-	Node->RegisterWithGameInstance(WorldContextObject);
-    return Node;
-}
-
-
-void UReceiveOperation::Activate()
-{
-	FAnalytics::TrackEvent("unknown", "unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
-
-	//Async(EAsyncExecution::Thread, [this]{Receive();});
-	Receive();
-}
-
-void UReceiveOperation::Receive()
-{
-	check(LocalTransport != nullptr);
-	
-	// 1. Try and get object from local transport
-	auto Obj = LocalTransport->GetSpeckleObject(ObjectId);
-
-	if (Obj != nullptr )
-	{
-		HandleReceive(Obj);
-		return;
-	}
-
-	// 2. Try and get object from remote transport
-	if(RemoteTransport == nullptr)
-	{
-		FString ErrorMessage = TEXT("Could not find specified object using the local transport, and you didn't provide a fallback remote from which to pull it.");
-		HandleError(ErrorMessage);
-		return;
-	}
-
-	FTransportCopyObjectCompleteDelegate CompleteDelegate;
-	CompleteDelegate.BindUObject(this, &UReceiveOperation::HandleReceive);
-	FTransportErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindUObject(this, &UReceiveOperation::HandleError);
-	
-	RemoteTransport->CopyObjectAndChildren(ObjectId, LocalTransport, CompleteDelegate, ErrorDelegate);
-}
-
-void UReceiveOperation::HandleReceive(TSharedPtr<FJsonObject> Object)
-{
-	check(IsInGameThread())
-	
-	FEditorScriptExecutionGuard ScriptGuard;
-	if(Object == nullptr)
-	{
-		OnError.Broadcast(nullptr, FString::Printf(TEXT("Failed to get object %s from transport"), *ObjectId));
-	}
-	else
-	{
-		UBase* Res = USpeckleSerializer::DeserializeBase(Object, LocalTransport);
-		if(IsValid(Res))
-			OnReceiveSuccessfully.Broadcast(Res, "");
-		else
-			OnError.Broadcast(nullptr, FString::Printf(TEXT("Root Speckle Object %s failed to deserialize"), *ObjectId));
-	}
-		
-	
-	SetReadyToDestroy();
-}
-
-void UReceiveOperation::HandleError(FString& Message)
-{
-	FEditorScriptExecutionGuard ScriptGuard;
-	OnError.Broadcast(nullptr, Message);
-	SetReadyToDestroy();
-}
-

Source/SpeckleUnreal/Private/API/Operations/SendOperation.cpp

@@ -1,33 +0,0 @@
-#include "API/Operations/SendOperation.h"
-
-#include "Mixpanel.h"
-#include "Transports/Transport.h"
-
-
-USendOperation* USendOperation::SendOperation(UObject* WorldContextObject, UBase* Base, TArray<TScriptInterface<ITransport>> Transports)
-{
-	
-	USendOperation* Node = NewObject<USendOperation>();
-	Node->Base = Base;
-	Node->Transports = Transports;
-
-	Node->RegisterWithGameInstance(WorldContextObject);
-	return Node;
-}
-
-void USendOperation::Activate()
-{
-	FAnalytics::TrackEvent("unknown", "unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
-	Send();
-}
-
-void USendOperation::Send()
-{
-	check(Transports.Num() > 0);
-
-	for (const auto t : Transports)
-	{
-		//TODO
-		//ITransport::
-	}
-}

Source/SpeckleUnreal/Private/API/SpeckleSerializer.cpp

@@ -1,81 +0,0 @@
-#include "API/SpeckleSerializer.h"
-
-#include "Objects/Base.h"
-#include "LogSpeckle.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-#include "Objects/ObjectModelRegistry.h"
-#include "Templates/SubclassOf.h"
-#include "Transports/Transport.h"
-#include "UObject/Package.h"
-
-
-UBase* USpeckleSerializer::DeserializeBase(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	if(Obj == nullptr) return nullptr;
-
-	{ // Handle Detached Objects
-		TSharedPtr<FJsonObject> DetachedObject;
-		if(USpeckleObjectUtils::ResolveReference(Obj, ReadTransport, DetachedObject))
-		{
-			return DeserializeBase(DetachedObject, ReadTransport);
-		}
-	}
-	
-	FString SpeckleType;	
-	if (!Obj->TryGetStringField("speckle_type", SpeckleType)) return nullptr;
-	FString ObjectId = "";	
-	Obj->TryGetStringField("id", ObjectId);
-		
-	TSubclassOf<UBase> BaseType;
-
-	FString WorkingType(SpeckleType);
-	
-	int32 Tries = 1000;
-	while(ensure(Tries-- > 0))
-	{
-		//Try and deserialize
-		if(UObjectModelRegistry::TryGetRegisteredType(WorkingType, BaseType))
-		{
-			UBase* Base = NewObject<UBase>(GetTransientPackage(), BaseType);
-			if(Base->Parse(Obj, ReadTransport))
-				return Base; 
-		}
-
-		//If we couldn't even deserialize this to a Base
-		if(WorkingType == "Base" || BaseType == UBase::StaticClass())
-		{
-			UE_LOG(LogSpeckle, Warning, TEXT("Skipping deserilization of %s id: %s - object could not be deserilaized to Base"), *SpeckleType, *ObjectId );
-			return nullptr;
-		}
-
-		//Try the next type
-		if(!UObjectModelRegistry::ParentType(WorkingType, WorkingType))
-		{
-			WorkingType = "Base";
-			UE_LOG(LogSpeckle, Verbose, TEXT("Unrecognised SpeckleType %s - Object id: %s Will be deserialized as Base"), *SpeckleType, *ObjectId );
-		}
-	}
-	return nullptr;
-}
-
-UBase* USpeckleSerializer::DeserializeBaseById(const FString& ObjectId,
-	const TScriptInterface<ITransport> ReadTransport)
-{
-	auto Obj = ReadTransport->GetSpeckleObject(ObjectId);
-	return DeserializeBase(Obj, ReadTransport);
-}
-
-
-UBase* TrySetProperties(const TSubclassOf<UBase> BaseType, const FString& SerialisedObject, TScriptInterface<ITransport> Transport)
-{
-	UBase* Base = NewObject<UBase>(GetTransientPackage(), BaseType);
-
-	
-	TSharedRef<FJsonStringReader> Reader = FJsonStringReader::Create(SerialisedObject);
-	for(auto foo : Reader.)
-	{
-		
-	}
-	
-	return Base;
-}

Source/SpeckleUnreal/Private/Analytics.cpp

@@ -1,84 +0,0 @@
-#include "Mixpanel.h"
-
-#include "Containers/UnrealString.h"
-#include "HttpModule.h"
-#include "Kismet/GameplayStatics.h"
-#include "LogSpeckle.h"
-#include "Interfaces/IHttpResponse.h"
-#include "Launch/Resources/Version.h"
-#include "Misc/Base64.h"
-#include "Policies/CondensedJsonPrintPolicy.h"
-#include "Serialization/JsonSerializerMacros.h"
-#include "Serialization/JsonWriter.h"
-
-const FString FAnalytics::MixpanelToken = TEXT("acd87c5a50b56df91a795e999812a3a4");
-const FString FAnalytics::MixpanelServer = TEXT("https://analytics.speckle.systems");
-const FString FAnalytics::VersionedApplicationName = FString::Printf(TEXT("Unreal Engine %d.%d"), ENGINE_MAJOR_VERSION, ENGINE_MINOR_VERSION);
-
-void FAnalytics::TrackEvent(const FString& Email, const FString& Server, const FString& EventName)
-{
-	const TMap<FString, FString> CustomProperties;
-	TrackEvent(Email, Server, EventName, CustomProperties);
-}
-
-void FAnalytics::TrackEvent(const FString& Email, const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties)
-{
-#if !SUPPRESS_SPECKLE_ANALYTICS
-
-	
-	FString HashedEmail = "@" + Hash(Email); //prepending an @ so we distinguish logged and non-logged users
-	FString HashedServer = Hash(Server);
-	
-	TMap<FString, FString> Properties 
-	{
-		{ "distinct_id", HashedEmail },
-		{ "server_id", HashedServer },
-		{ "token", MixpanelToken },
-		{ "hostApp", "Unreal Engine" },
-		{ "hostAppVersion", VersionedApplicationName },
-		{ "$os",  *UGameplayStatics::GetPlatformName() },
-		{ "type", "action" }
-	};
-
-	
-	Properties.Append(CustomProperties);
-	
-	FString Json;
-	{
-		auto Writer = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&Json);
-		FJsonSerializerWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> Serializer(Writer);
-		Serializer.StartObject();
-		FString EventNameString = EventName;
-		Serializer.Serialize(TEXT("event"), EventNameString);
-		Serializer.SerializeMap(TEXT("properties"), Properties);
-		Serializer.EndObject();
-		Writer->Close();
-	}
-	const FString Data = FBase64::Encode(Json);
-
-	// Create Request
-	const FHttpRequestRef Request = FHttpModule::Get().CreateRequest();
-	{
-		Request->SetURL(MixpanelServer + "/track?ip=1&data=" + Data);
-		Request->SetHeader("Content-Type", "application/x-www-form-urlencoded");
-		Request->SetHeader("Accept", TEXT("text/plain"));
-		Request->SetVerb("POST");
-	}
-
-	Request->OnProcessRequestComplete().BindLambda([](FHttpRequestPtr, FHttpResponsePtr Response, bool)
-	{
-		UE_LOG(LogSpeckle, Verbose, TEXT("Recieved Mixpanel resonse %d"), Response->GetResponseCode());
-	});
-
-	const bool RequestSent = Request->ProcessRequest();
-	if(!RequestSent)
-	{
-		UE_LOG(LogSpeckle, Log, TEXT("Failed to send Mixpanel event to %s"), *MixpanelServer);
-	}
-#endif
-}
-
-FString FAnalytics::Hash(const FString& Input)
-{
-	return FMD5::HashAnsiString(*Input.ToLower());
-}

Source/SpeckleUnreal/Private/Conversion/Converters/AggregateConverter.cpp

@@ -1,138 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#include "Conversion/Converters/AggregateConverter.h"
-
-#include "LogSpeckle.h"
-#include "Templates/SubclassOf.h"
-
-
-void UAggregateConverter::OnConvertersChangeHandler()
-{
-	SpeckleTypeMap.Empty();
-
-	for(int i = 0; i < SpeckleConverters.Num(); i++)
-	{
-		const UObject* Converter = SpeckleConverters[i];
-		if(Converter != nullptr && !Converter->GetClass()->ImplementsInterface(USpeckleConverter::StaticClass()))
-		{
-			UE_LOG(LogSpeckle, Warning, TEXT("Converter {%s} is not a valid converter, Expected to implement interface %s"), *Converter->GetClass()->GetName(), *USpeckleConverter::StaticClass()->GetName())
-			SpeckleConverters.RemoveAt(i);
-			i--;
-		}
-	}
-}
-
-#if WITH_EDITOR
-void UAggregateConverter::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
-{
-	Super::PostEditChangeProperty(PropertyChangedEvent);
-	
-	if (PropertyChangedEvent.GetPropertyName() == GET_MEMBER_NAME_CHECKED(UAggregateConverter, SpeckleConverters))
-	{
-		OnConvertersChangeHandler();
-	}
-}
-#endif
-
-void UAggregateConverter::ConvertToSpeckle_Implementation(const UObject* Object, UBase* SpeckleObject)
-{
-	//TODO implement ToSpeckle
-	unimplemented();
-}
-
-
-UObject* UAggregateConverter::ConvertToNative_Implementation(const UBase* Object, UWorld* World,  TScriptInterface<ISpeckleConverter>& )
-{
-	return ConvertToNativeInternal(Object, World);
-}
-
-UObject* UAggregateConverter::ConvertToNativeInternal(const UBase* Object, UWorld* World)
-{
-	check(IsInGameThread());
-	
-	if(!IsValid(Object)) return nullptr;
-	
-	const TSubclassOf<UBase> Type = Object->GetClass();
-	UObject* Converter = GetConverter(Type).GetObject();
-	if(!IsValid(Converter))
-	{
-		if(Type != UBase::StaticClass())
-		{
-			UE_LOG(LogSpeckle, Warning, TEXT("Skipping Object %s: No conversion functions exist for %s"), *Object->Id, *Type->GetName());
-		}
-		return nullptr;
-	}
-
-	UE_LOG(LogSpeckle, Log, TEXT("Converting object of type: %s id: %s"), *Type->GetName(), *Object->Id);
-	
-	FEditorScriptExecutionGuard ScriptGuard;
-	
-	TScriptInterface<ISpeckleConverter> MainConverter = this;
-	
-	check(Converter->IsValidLowLevel());
-	return Execute_ConvertToNative(Converter, Object, World, MainConverter);
-
-}
-
-bool UAggregateConverter::CanConvertToNative_Implementation(TSubclassOf<UBase> BaseType)
-{
-	return GetConverter(BaseType).GetInterface() != nullptr;
-}
-
-
-TScriptInterface<ISpeckleConverter> UAggregateConverter::GetConverter(const TSubclassOf<UBase> BaseType)
-{
-	// Check if this SpeckleType has a known converter.
-	if(SpeckleTypeMap.Contains(BaseType))
-	{
-		return SpeckleTypeMap[BaseType];
-	}
-
-	// Try and find one that can convert this SpeckleType.
-	FEditorScriptExecutionGuard ScriptGuard;
-	for(UObject* Converter : SpeckleConverters)
-	{
-		if(!CheckValidConverter(Converter)) continue;
-		
-		if(Execute_CanConvertToNative(Converter, BaseType))
-		{ 
-			//Found a Converter! Save this mapping for next time.
-			SpeckleTypeMap.Add(BaseType, Converter);
-			return Converter;
-		}
-	}
-	
-	// SpeckleType has no conversions.
-	SpeckleTypeMap.Add(BaseType, nullptr);
-	return nullptr;
-}
-
-void UAggregateConverter::FinishConversion_Implementation()
-{
-	FinishConversion_Internal();
-}
-
-void UAggregateConverter::FinishConversion_Internal()
-{
-	for (UObject* Converter : SpeckleConverters)
-	{
-		if(!CheckValidConverter(Converter)) continue;
-		
-		Execute_FinishConversion(Converter);
-	}
-	OnConvertersChangeHandler();
-}
-
-bool UAggregateConverter::CheckValidConverter(const UObject* Converter, bool LogWarning)
-{
-	if(Converter == nullptr) return false;
-	
-	if(Converter->Implements<USpeckleConverter>()) return true;
-	
-	if(LogWarning)
-	{
-		UE_LOG(LogSpeckle, Warning, TEXT("Converter {%s} is not a valid converter, Expected to implement interface {%s}"), *Converter->GetClass()->GetName(), *USpeckleConverter::StaticClass()->GetName())
-	}
-	
-	return false;
-}

Source/SpeckleUnreal/Private/Conversion/Converters/BlockConverter.cpp

@@ -1,53 +0,0 @@
-#include "Conversion/Converters/BlockConverter.h"
-
-#include "Objects/Other/BlockInstance.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-#include "Engine/World.h"
-
-UBlockConverter::UBlockConverter()
-{
-	SpeckleTypes.Add(UBlockInstance::StaticClass());
-	
-	BlockInstanceActorType = AActor::StaticClass();
-	ActorMobility = EComponentMobility::Static;
-}
-
-UObject* UBlockConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>&)
-{
-	const UBlockInstance* Block = Cast<UBlockInstance>(SpeckleBase);
-	if(Block == nullptr) return nullptr;
-
-	return BlockToNative(Block, World);
-}
-
-AActor* UBlockConverter::BlockToNative(const UBlockInstance* Block, UWorld* World)
-{
-	AActor* BlockActor = CreateEmptyActor(World, USpeckleObjectUtils::CreateTransform(Block->Transform));
-	//Return the block actor as is,
-	//Other converter logic will convert child geometries because UBlockInstance intentionally left them as dynamic properties
-	return BlockActor;
-}
-
-AActor* UBlockConverter::CreateEmptyActor(UWorld* World, const FTransform& Transform, const FActorSpawnParameters& SpawnParameters)
-{
-	AActor* Actor = World->SpawnActor<AActor>(BlockInstanceActorType, Transform, SpawnParameters);
-
-	if(!Actor->HasValidRootComponent())
-	{
-		USceneComponent* Scene = NewObject<USceneComponent>(Actor, "Root");
-		Scene->SetRelativeTransform(Transform);
-		Actor->SetRootComponent(Scene);
-		Scene->RegisterComponent();
-	}
-	USceneComponent* RootComponent = Actor->GetRootComponent();
-	
-	RootComponent->SetMobility(ActorMobility);
-	
-	return Actor;
-}
-
-UBase* UBlockConverter::ConvertToSpeckle_Implementation(const UObject* Object)
-{
-	unimplemented();
-	return nullptr; //TODO implement
-}

Source/SpeckleUnreal/Private/Conversion/Converters/MaterialConverter.cpp

@@ -1,179 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Conversion/Converters/MaterialConverter.h"
-
-#include "AssetRegistry/AssetRegistryModule.h"
-#include "Materials/MaterialInstanceConstant.h"
-#include "Materials/MaterialInstanceDynamic.h"
-#include "Objects/Other/RenderMaterial.h"
-#include "UObject/ConstructorHelpers.h"
-
-
-UMaterialConverter::UMaterialConverter()
-{
-	static ConstructorHelpers::FObjectFinder<UMaterial> SpeckleMaterial(TEXT("Material'/SpeckleUnreal/SpeckleMaterial.SpeckleMaterial'"));
-	static ConstructorHelpers::FObjectFinder<UMaterial> SpeckleGlassMaterial(TEXT("Material'/SpeckleUnreal/SpeckleGlassMaterial.SpeckleGlassMaterial'"));
-
-	DefaultMeshMaterial = SpeckleMaterial.Object;
-	BaseMeshOpaqueMaterial = SpeckleMaterial.Object;
-	BaseMeshTransparentMaterial = SpeckleGlassMaterial.Object;
-	
-#if WITH_EDITORONLY_DATA
-	UseConstMaterials = NotPlay;
-#endif
-	
-	SpeckleTypes.Add(URenderMaterial::StaticClass());
-}
-
-UObject* UMaterialConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld*, TScriptInterface<ISpeckleConverter>&)
-{
-	const URenderMaterial* m = Cast<URenderMaterial>(SpeckleBase);
-	
-	if(m == nullptr) return DefaultMeshMaterial;
-	
-	return GetMaterial(m);
-}
-
-UMaterialInterface* UMaterialConverter::GetMaterial(const URenderMaterial* SpeckleMaterial)
-{
-	if(SpeckleMaterial == nullptr || SpeckleMaterial->Id == "") return DefaultMeshMaterial; //Material is invalid
-	
-	// 1. Check Overrides
-	UMaterialInterface* NativeMaterial;
-	if(TryGetOverride(SpeckleMaterial, NativeMaterial))
-		return NativeMaterial;
-
-	// 2. Check transient cache
-	if(ConvertedMaterials.Contains(SpeckleMaterial->Id))
-	{
-		return ConvertedMaterials[SpeckleMaterial->Id];
-	}
-	
-	// 3. Check Assets
-	UPackage* Package = GetPackage(SpeckleMaterial->Id);
-	
-	NativeMaterial = Cast<UMaterialInterface>(Package->FindAssetInPackage());
-	if(IsValid(NativeMaterial))
-	{
-	   return NativeMaterial;
-	}
-	
-	// 4. Convert
-	return RenderMaterialToNative(SpeckleMaterial, Package);
-}
-
-bool UMaterialConverter::TryGetOverride(const URenderMaterial* SpeckleMaterial, UMaterialInterface*& OutMaterial) const
-{
-	const auto MaterialID = SpeckleMaterial->Id;
-	
-
-	//Override by id
-	if(MaterialOverridesById.Contains(MaterialID))
-	{
-		OutMaterial = MaterialOverridesById[MaterialID];
-		return true;
-	}
-	//Override by name
-	const FString Name = SpeckleMaterial->Name;
-	for (const UMaterialInterface* Mat : MaterialOverridesByName)
-	{
-		if(ensureAlways(IsValid(Mat)) && Mat->GetName() == Name)
-		{
-			OutMaterial = MaterialOverridesById[MaterialID];
-			return true;
-		}
-	}
-	
-	
-	return false;
-}
-
-FString UMaterialConverter::RemoveInvalidFileChars(const FString& InString) const
-{
-	return FPaths::MakeValidFileName(InString.Replace(TEXT("."), TEXT("_"), ESearchCase::CaseSensitive));
-}
-
-UMaterialInterface* UMaterialConverter::RenderMaterialToNative(const URenderMaterial* SpeckleMaterial, UPackage* Package)
-{
-	UMaterialInterface* MaterialBase = SpeckleMaterial->Opacity >= 1
-	    ? BaseMeshOpaqueMaterial
-	    : BaseMeshTransparentMaterial;
-	
-	UMaterialInstance* MaterialInstance;
-#if WITH_EDITOR
-	if (ShouldCreateConstMaterial(UseConstMaterials))
-	{
-		const FName Name = MakeUniqueObjectName(Package, UMaterialInstanceConstant::StaticClass(), *RemoveInvalidFileChars(SpeckleMaterial->Name));
-
-		//TStrongObjectPtr< UMaterialInstanceConstantFactoryNew > MaterialFact( NewObject< UMaterialInstanceConstantFactoryNew >() );
-		//MaterialFact->InitialParent = MaterialBase;
-		//UMaterialInstanceConstant* ConstMaterial = Cast< UMaterialInstanceConstant >( MaterialFact->FactoryCreateNew( UMaterialInstanceConstant::StaticClass(), Package, Name, RF_Public, nullptr, GWarn ) );
-		UMaterialInstanceConstant* ConstMaterial = NewObject<UMaterialInstanceConstant>(Package, Name, RF_Public | RF_Standalone);
-		
-		MaterialInstance = ConstMaterial;
-		ConstMaterial->SetParentEditorOnly(MaterialBase);
-		ConstMaterial->SetScalarParameterValueEditorOnly(FMaterialParameterInfo("Opacity"), SpeckleMaterial->Opacity);
-		ConstMaterial->SetScalarParameterValueEditorOnly(FMaterialParameterInfo("Metallic"), SpeckleMaterial->Metalness);
-		ConstMaterial->SetScalarParameterValueEditorOnly(FMaterialParameterInfo("Roughness"), SpeckleMaterial->Roughness);
-		ConstMaterial->SetVectorParameterValueEditorOnly(FMaterialParameterInfo("BaseColor"), SpeckleMaterial->Diffuse);
-		ConstMaterial->SetVectorParameterValueEditorOnly(FMaterialParameterInfo("EmissiveColor"), SpeckleMaterial->Emissive);
-		
-		//ConstMaterial->InitStaticPermutation();
-		
-		ConstMaterial->MarkPackageDirty();
-
-		FAssetRegistryModule::AssetCreated(MaterialInstance);
-	}
-	else
-#endif
-	{
-		UMaterialInstanceDynamic* DynMaterial = UMaterialInstanceDynamic::Create(MaterialBase, Package, FName(SpeckleMaterial->Name));
-		MaterialInstance = DynMaterial;
-		
-		DynMaterial->SetScalarParameterValue("Opacity", SpeckleMaterial->Opacity);
-		DynMaterial->SetScalarParameterValue("Metallic", SpeckleMaterial->Metalness);
-		DynMaterial->SetScalarParameterValue("Roughness", SpeckleMaterial->Roughness);
-		DynMaterial->SetVectorParameterValue("BaseColor", SpeckleMaterial->Diffuse);
-		DynMaterial->SetVectorParameterValue("EmissiveColor", SpeckleMaterial->Emissive);
-		
-		DynMaterial->SetFlags(RF_Public);
-	}
-	
-	ConvertedMaterials.Add(SpeckleMaterial->Id, MaterialInstance);
-	
-	return MaterialInstance;
-	
-}
-
-void UMaterialConverter::FinishConversion_Implementation()
-{
-	ConvertedMaterials.Empty();
-}
-
-UPackage* UMaterialConverter::GetPackage(const FString& ObjectID ) const
-{
-	const FString PackagePath = FPaths::Combine(TEXT("/Game/Speckle/Materials"), ObjectID);
-	return CreatePackage(*PackagePath);
-}
-
-
-#if WITH_EDITOR
-bool UMaterialConverter::ShouldCreateConstMaterial(TEnumAsByte<EConstMaterialOptions> Options)
-{
-	if(!GIsEditor) return false;
-	
-	switch(Options)
-	{
-		case Never:
-			return false;
-		case NotPlay:
-			return !FApp::IsGame();
-		case Always:
-			return true;
-		default:
-			unimplemented();
-			return false;
-	}
-}
-#endif

Source/SpeckleUnreal/Private/Conversion/Converters/PointCloudConverter.cpp

@@ -1,95 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Conversion/Converters/PointCloudConverter.h"
-
-#include "LidarPointCloudActor.h"
-#include "LidarPointCloudComponent.h"
-#include "Objects/Geometry/PointCloud.h"
-
-
-UPointCloudConverter::UPointCloudConverter()
-{
-	SpeckleTypes.Add(UPointCloud::StaticClass());
-	
-	PointCloudActorType = ALidarPointCloudActor::StaticClass();
-	ActorMobility = EComponentMobility::Static;
-}
-
-
-UObject* UPointCloudConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>&)
-{
-	const UPointCloud* p = Cast<UPointCloud>(SpeckleBase);
-	
-	if(p == nullptr) return nullptr;
-	
-	return PointCloudToNative(p, World);
-}
-
-
-ALidarPointCloudActor* UPointCloudConverter::PointCloudToNative(const UPointCloud* SpecklePointCloud, UWorld* World)
-{
-	TArray<FLidarPointCloudPoint> LidarPoints;
-	
-	LidarPoints.Reserve(SpecklePointCloud->Points.Num());
-
-	for(int i = 0; i < SpecklePointCloud->Points.Num(); i++)
-	{
-		FColor c = SpecklePointCloud->Colors.Num() > i? SpecklePointCloud->Colors[i] : FColor::White;
-#if ENGINE_MAJOR_VERSION >= 5
-		FVector3f Point = FVector3f(SpecklePointCloud->Points[i]);
-#else
-		FVector Point = SpecklePointCloud->Points[i];
-#endif
-		
-		FLidarPointCloudPoint p(Point, c, true, 0);
-		LidarPoints.Add(p);
-	}
-	
-	ULidarPointCloud* PointCloud = NewObject<ULidarPointCloud>();
-	
-	PointCloud->Initialize(FBox(SpecklePointCloud->Points));
-
-	PointCloud->InsertPoints(LidarPoints, ELidarPointCloudDuplicateHandling::Ignore, false, FVector::ZeroVector);
-	
-	PointCloud->CenterPoints();
-	PointCloud->RefreshBounds();
-
-	return CreateActor(World, PointCloud);
-	
-}
-
-
-ALidarPointCloudActor* UPointCloudConverter::CreateActor(UWorld* World, ULidarPointCloud* PointCloudData)
-{
-	ALidarPointCloudActor* Actor = World->SpawnActor<ALidarPointCloudActor>(PointCloudActorType);
-	Actor->SetPointCloud(PointCloudData);
-	Actor->GetRootComponent()->SetMobility(ActorMobility);
-	return Actor;
-}
-
-
-UBase* UPointCloudConverter::ConvertToSpeckle_Implementation(const UObject* Object)
-{
-	const ULidarPointCloudComponent* P = Cast<ULidarPointCloudComponent>(Object);
-
-	if(P == nullptr)
-	{
-		const AActor* A = Cast<AActor>(Object);
-		if(A != nullptr)
-		{
-			P = A->FindComponentByClass<ULidarPointCloudComponent>();
-		}
-	}
-	if(P == nullptr) return nullptr;
-	
-	return PointCloudToSpeckle(P);
-}
-
-
-UPointCloud* UPointCloudConverter::PointCloudToSpeckle(const ULidarPointCloudComponent* Object)
-{
-	return nullptr; //TODO implement ToSpeckle function
-}
-
-

Source/SpeckleUnreal/Private/Conversion/Converters/ProceduralMeshConverter.cpp

@@ -1,142 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#include "Conversion/Converters/ProceduralMeshConverter.h"
-
-#include "ProceduralMeshComponent.h"
-#include "Conversion/Converters/MaterialConverter.h"
-#include "Materials/MaterialInstance.h"
-#include "Objects/DisplayValueElement.h"
-#include "Objects/Geometry/Mesh.h"
-#include "Objects/Other/RenderMaterial.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-
-UProceduralMeshConverter::UProceduralMeshConverter()
-{
-    SpeckleTypes.Add(UMesh::StaticClass());
-    SpeckleTypes.Add(UDisplayValueElement::StaticClass());
-    
-    MeshActorType = AActor::StaticClass();
-    ActorMobility = EComponentMobility::Static;
-}
-
-UObject* UProceduralMeshConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>& AvailableConverters )
-{
-    const UMesh* m = Cast<UMesh>(SpeckleBase);
-    if(m != nullptr)	
-        return MeshToNative(m, World, AvailableConverters);
-    
-    const UDisplayValueElement* d = Cast<UDisplayValueElement>(SpeckleBase);
-    if(d)
-    {
-        AActor* Parent = CreateEmptyActor(World, FTransform());
-        for(const UMesh* Child : d->DisplayValue)
-        {
-            AActor* ChildActor = MeshToNative(Child, World, AvailableConverters);
-            if(IsValid(ChildActor))
-            {
-#if WITH_EDITOR
-                ChildActor->SetActorLabel(FString::Printf(TEXT("%s - %s"), *Child->SpeckleType, *Child->Id));
-#endif
-                ChildActor->GetRootComponent()->SetMobility(ActorMobility);
-                ChildActor->AttachToActor(Parent, FAttachmentTransformRules::KeepRelativeTransform);
-                ChildActor->SetOwner(Parent);
-            }
-        }
-        return Parent;
-    }
-    return nullptr;
-}
-
-AActor* UProceduralMeshConverter::MeshToNative(const UMesh* SpeckleMesh, UWorld* World, TScriptInterface<ISpeckleConverter>& MaterialConverter)
-{
-    AActor* MeshActor = CreateEmptyActor(World, USpeckleObjectUtils::CreateTransform(SpeckleMesh->Transform));
-    UProceduralMeshComponent* MeshComponent = NewObject<UProceduralMeshComponent>(MeshActor, FName("SpeckleMeshComponent"));
-    MeshComponent->SetupAttachment(MeshActor->GetRootComponent());
-    MeshComponent->RegisterComponent();
-    
-    TArray<int32> Faces;
-
-    int32 i = 0;
-    while (i < SpeckleMesh->Faces.Num())
-    {
-        int32 n = SpeckleMesh->Faces[i];
-        if(n < 3) n += 3; // 0 -> 3, 1 -> 4
-        
-        if (n == 3) //Triangles
-        {
-            Faces.Add(SpeckleMesh->Faces[i + 3]);
-            Faces.Add(SpeckleMesh->Faces[i + 2]);
-            Faces.Add(SpeckleMesh->Faces[i + 1]);
-        }
-        else if(n == 4) // Quads
-        {
-            Faces.Add(SpeckleMesh->Faces[i + 4]);
-            Faces.Add(SpeckleMesh->Faces[i + 3]);
-            Faces.Add(SpeckleMesh->Faces[i + 1]);
-
-            Faces.Add(SpeckleMesh->Faces[i + 3]);
-            Faces.Add(SpeckleMesh->Faces[i + 2]);
-            Faces.Add(SpeckleMesh->Faces[i + 1]);
-        }
-        else
-        {
-            // n-gons shall be ignored
-        }
-        
-        i += n + 1;
-    }
-    
-    const TArray<FVector> Normals;
-    const TArray<FProcMeshTangent> Tangents;
-    
-    MeshComponent->CreateMeshSection(
-        0,
-        SpeckleMesh->Vertices,
-        Faces,
-        Normals,
-        SpeckleMesh->TextureCoordinates,
-        SpeckleMesh->VertexColors,
-        Tangents,
-        true);
-
-    UMaterialInterface* Material = Cast<UMaterialInstance>(Execute_ConvertToNative(MaterialConverter.GetObject(), SpeckleMesh->RenderMaterial, World, MaterialConverter));
-    ensure(Material != nullptr);
-    
-    MeshComponent->SetMaterial(0, Material);
-    
-    return MeshActor;
-}
-
-AActor* UProceduralMeshConverter::CreateEmptyActor(UWorld* World, const FTransform& Transform, const FActorSpawnParameters& SpawnParameters)
-{
-    AActor* Actor = World->SpawnActor<AActor>(MeshActorType, Transform, SpawnParameters);
-    USceneComponent* Scene = NewObject<USceneComponent>(Actor, "Root");
-    Actor->SetRootComponent(Scene);
-    Scene->RegisterComponent();
-    Scene->SetMobility(ActorMobility);
-    return Actor;
-}
-
-
-UBase* UProceduralMeshConverter::ConvertToSpeckle_Implementation(const UObject* Object)
-{
-    const UProceduralMeshComponent* M = Cast<UProceduralMeshComponent>(Object);
-
-    if(M == nullptr)
-    {
-        const AActor* A = Cast<AActor>(Object);
-        if(A != nullptr)
-        {
-            M = A->FindComponentByClass<UProceduralMeshComponent>();
-        }
-    }
-    if(M == nullptr) return nullptr;
-	
-    return MeshToSpeckle(M);
-}
-
-
-UMesh* UProceduralMeshConverter::MeshToSpeckle(const UProceduralMeshComponent* Object)
-{
-    return nullptr; //TODO implement ToSpeckle function
-}

Source/SpeckleUnreal/Private/Conversion/Converters/StaticMeshConverter.cpp

@@ -1,471 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#include "Conversion/Converters/StaticMeshConverter.h"
-
-#include "MeshDescriptionBase.h"
-#include "StaticMeshDescription.h"
-#include "MeshTypes.h"
-#include "StaticMeshOperations.h"
-#include "AssetRegistry/AssetRegistryModule.h"
-#include "Engine/StaticMeshActor.h"
-#include "Objects/Geometry/Mesh.h"
-#include "LogSpeckle.h"
-#include "API/SpeckleSerializer.h"
-#include "Conversion/Converters/MaterialConverter.h"
-#include "Misc/ScopedSlowTask.h"
-#include "Objects/DisplayValueElement.h"
-#include "Objects/Other/RenderMaterial.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
-
-UStaticMeshConverter::UStaticMeshConverter()
-{
-	SpeckleTypes.Add(UMesh::StaticClass());
-	SpeckleTypes.Add(UDisplayValueElement::StaticClass());
-	
-#if WITH_EDITORONLY_DATA
-	UseFullBuild = true;
-	DisplayBuildProgressBar = true;
-	AllowCancelBuild = false;
-#endif
-	Transient = false;
-	BuildSimpleCollision = true;
-	
-	BuildReversedIndexBuffer = true;
-	UseFullPrecisionUVs = false;
-	RemoveDegeneratesOnBuild = true;
-	MinLightmapResolution = 64;
-		
-	MeshActorType = AStaticMeshActor::StaticClass();
-	ActorMobility = EComponentMobility::Static;
-}
-
-AActor* UStaticMeshConverter::CreateEmptyActor(UWorld* World, const FTransform& Transform, const FActorSpawnParameters& SpawnParameters)
-{
-	AActor* Actor = World->SpawnActor<AActor>(MeshActorType, Transform, SpawnParameters);
-	if(Actor->HasValidRootComponent())
-		Actor->GetRootComponent()->SetMobility(EComponentMobility::Movable); //Create actor as movable for now, we will change it later to the desired mobility
-	return Actor;
-}
-
-UObject* UStaticMeshConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>& AvailableConverters)
-{
-	const UMesh* m = Cast<UMesh>(SpeckleBase);
-	if(m != nullptr)
-	{
-		//Handle Single Mesh
-		return MeshToNativeActor(m, World, AvailableConverters);
-	}
-	
-	const UDisplayValueElement* d = Cast<UDisplayValueElement>(SpeckleBase);
-	if(d != nullptr)
-	{
-		//Handle Element with Display Values
-		return MeshesToNativeActor(d, d->DisplayValue, World, AvailableConverters);
-	}
-	
-	return nullptr;
-}
-
-
-AActor* UStaticMeshConverter::MeshToNativeActor(const UMesh* SpeckleMesh, UWorld* World, TScriptInterface<ISpeckleConverter>& MaterialConverter)
-{
-	TArray<UMesh*> Meshes = {const_cast<UMesh*>(SpeckleMesh)};
-	return MeshesToNativeActor(SpeckleMesh, Meshes, World, MaterialConverter);
-}
-
-AActor* UStaticMeshConverter::MeshesToNativeActor(const UBase* Parent, const TArray<UMesh*>& SpeckleMeshes, UWorld* World, TScriptInterface<ISpeckleConverter>& RenderMaterialConverter)
-{
-	check(RenderMaterialConverter.GetInterface() != nullptr);
-	ensureMsgf(Execute_CanConvertToNative(RenderMaterialConverter.GetObject(), URenderMaterial::StaticClass()), TEXT("StaticMeshConverter expects a valid RenderMaterial converter to be avaiable"));
-
-	
-	const FString PackagePath = FPaths::Combine(TEXT("/Game/Speckle/Geometry"), Parent->Id);
-	UPackage* Package = CreatePackage(*PackagePath);
-	
-	//Find existing mesh
-	UStaticMesh* Mesh = Cast<UStaticMesh>(Package->FindAssetInPackage());
-	
-	if(!IsValid(Mesh))
-	{
-		//No existing mesh was found, try and convert SpeckleMesh
-		Mesh = MeshesToNativeMesh(Package, Parent, SpeckleMeshes, RenderMaterialConverter);
-	}
-
-	FMatrix Transform = FMatrix::Identity;
-	// For single mesh, we check for transform
-	//TODO figure out how to handle DisplayValueElement with transform. Maybe we just grab transform from parent unconditionally? How does this affect blocks?
-	if(Parent == SpeckleMeshes[0])
-	{
-		Transform = SpeckleMeshes[0]->Transform;
-	}
-	
-	AActor* Actor = CreateEmptyActor(World, USpeckleObjectUtils::CreateTransform(Transform));
-	TInlineComponentArray<UStaticMeshComponent*> Components;
-	Actor->GetComponents<UStaticMeshComponent>(Components);
-	
-	UStaticMeshComponent* MeshComponent;
-	if(Components.Num() > 0) MeshComponent = Components[0];
-	else
-	{
-		// MeshActorType doesn't have a UStaticMeshComponent, so we will add one
-		MeshComponent = NewObject<UStaticMeshComponent>(Actor, FName("SpeckleMeshComponent"));
-		MeshComponent->SetupAttachment(Actor->GetRootComponent());
-		MeshComponent->RegisterComponent();
-	}
-
-	MeshComponent->SetStaticMesh(Mesh);
-	
-	int i = 0;
-	for(const UMesh* DisplayMesh : SpeckleMeshes)
-	{
-		URenderMaterial* MaterialToConvert = DisplayMesh->RenderMaterial;
-		if(!MaterialToConvert)
-		{
-		    //Try and grab a material from the parent
-		 	const auto* MaterialProperty = Parent->DynamicProperties.Find("renderMaterial");
-			const TSharedPtr<FJsonObject>* MaterialObject;
-		 	if(MaterialProperty && (*MaterialProperty)->TryGetObject(MaterialObject))
-		 	{
-		 		//TODO giving a nullptr transport is pretty unsafe and relies on the deserializer not to have to dereference a detached property.
-		 	    MaterialToConvert = Cast<URenderMaterial>(USpeckleSerializer::DeserializeBase(*MaterialObject, nullptr));
-		    }
-		}
-		UMaterialInterface* Material = GetMaterial(MaterialToConvert, World, RenderMaterialConverter);
-		
-		ensure(IsValid(Material));
-		MeshComponent->SetMaterial(i, Material);
-
-		i++;
-	}
-
-	if(Actor->HasValidRootComponent())
-		Actor->GetRootComponent()->SetMobility(ActorMobility);
-	
-	return Actor;
-}
-
-
-UMaterialInterface* UStaticMeshConverter::GetMaterial(const URenderMaterial* SpeckleMaterial, UWorld* World, TScriptInterface<ISpeckleConverter>& MaterialConverter) const
-{
-	if(!SpeckleMaterial)
-	{
-		// Create a fake render material,  (since nullptr doesn't have a type, speckle converters don't know how to convert it)
-		// If the converter wants to handle this specially, The material has an empty Id
-		SpeckleMaterial = NewObject<URenderMaterial>(GetTransientPackage(), "NullSpeckleMaterial");
-	}
-	return Cast<UMaterialInterface>(Execute_ConvertToNative(MaterialConverter.GetObject(), SpeckleMaterial, World, MaterialConverter));
-}
-
-
-UStaticMesh* UStaticMeshConverter::MeshToNativeMesh(UObject* Outer,  const UMesh* SpeckleMesh, TScriptInterface<ISpeckleConverter>& MaterialConverter)
-{
-	TArray<UMesh*> Meshes;
-	Meshes.Add(const_cast<UMesh*>(SpeckleMesh));
-	return MeshesToNativeMesh(Outer, SpeckleMesh, Meshes, MaterialConverter);
-}
-
-
-UStaticMesh* UStaticMeshConverter::MeshesToNativeMesh(UObject* Outer, const UBase* Parent, const TArray<UMesh*>& SpeckleMeshes, TScriptInterface<ISpeckleConverter>& MaterialConverter)
-{
-	if(SpeckleMeshes.Num() == 0) return nullptr;
-	
-	EObjectFlags ObjectFags = Transient? RF_Transient | RF_Public : RF_Public;
-
-#if ENGINE_MAJOR_VERSION >= 5
-	ObjectFags |= RF_Standalone; //TODO maybe all versions should have RF_Standalone?
-#endif
-	
-	UStaticMesh* Mesh = NewObject<UStaticMesh>(Outer, FName(Parent->Id), ObjectFags);
-
-	Mesh->InitResources();
-	Mesh->SetLightingGuid();
-
-	UStaticMeshDescription* StaticMeshDescription = Mesh->CreateStaticMeshDescription(Outer);
-	FMeshDescription& BaseMeshDescription = StaticMeshDescription->GetMeshDescription();
-
-	//Build Settings
-#if WITH_EDITOR
-	{
-		FStaticMeshSourceModel& SrcModel = Mesh->AddSourceModel();
-		SrcModel.BuildSettings.bRecomputeNormals = true;
-		SrcModel.BuildSettings.bRecomputeTangents = true;
-		SrcModel.BuildSettings.bRemoveDegenerates = RemoveDegeneratesOnBuild;
-		SrcModel.BuildSettings.bUseHighPrecisionTangentBasis = false;
-		SrcModel.BuildSettings.bBuildReversedIndexBuffer = BuildReversedIndexBuffer;
-		SrcModel.BuildSettings.bUseFullPrecisionUVs = UseFullPrecisionUVs;
-		SrcModel.BuildSettings.bGenerateLightmapUVs = GenerateLightmapUV;
-		SrcModel.BuildSettings.SrcLightmapIndex = 0;
-		SrcModel.BuildSettings.DstLightmapIndex = 1;
-		SrcModel.BuildSettings.MinLightmapResolution = MinLightmapResolution;
-	}
-#endif
-
-	UStaticMesh::FBuildMeshDescriptionsParams MeshParams;
-	GenerateMeshParams(MeshParams);
-
-	for(const UMesh* SpeckleMesh : SpeckleMeshes)
-	{
-		const size_t NumberOfVertices = SpeckleMesh->Vertices.Num();
-		const size_t NumberOfFacesIndices = SpeckleMesh->Faces.Num();
-		
-		// Convert Vertices
-		if(NumberOfVertices == 0 || NumberOfFacesIndices == 0) continue;
-		
-		StaticMeshDescription->ReserveNewVertices(NumberOfVertices);
-		
-		TArray<FVertexID> Vertices;
-		Vertices.Reserve(NumberOfVertices);
-
-		for(const FVector VertexPosition : SpeckleMesh->Vertices)
-		{
-			const FVertexID VertID = StaticMeshDescription->CreateVertex();
-			StaticMeshDescription->SetVertexPosition(VertID, VertexPosition);
-			Vertices.Add(VertID);
-		}
-		
-		// Convert Material
-		UMaterialInterface* Material = GetMaterial(SpeckleMesh->RenderMaterial, GetWorld(), MaterialConverter);
-	
-		const FName MaterialSlotName = Mesh->AddMaterial(Material);;
-		BaseMeshDescription.PolygonGroupAttributes().RegisterAttribute<FName>(MeshAttribute::PolygonGroup::ImportedMaterialSlotName, 1, MaterialSlotName,  EMeshAttributeFlags::None);
-
-		// Convert Faces
-		const FPolygonGroupID PolygonGroupID = StaticMeshDescription->CreatePolygonGroup();
-
-		StaticMeshDescription->SetPolygonGroupMaterialSlotName(PolygonGroupID, MaterialSlotName);
-
-#if ENGINE_MAJOR_VERSION >= 5
-		StaticMeshDescription->VertexInstanceAttributes().RegisterAttribute<FVector2f>(MeshAttribute::VertexInstance::TextureCoordinate, 2, FVector2f::ZeroVector, EMeshAttributeFlags::None);
-#else
-		StaticMeshDescription->VertexInstanceAttributes().RegisterAttribute<FVector2D>(MeshAttribute::VertexInstance::TextureCoordinate, 2, FVector2D::ZeroVector, EMeshAttributeFlags::None);
-#endif
-		{
-			// Reserve space assuming faces will all be triangles //TODO (maybe it's better to assume something higher?)
-			const int32 EstimatedNumberOfFaces = SpeckleMesh->Faces.Num() / 4 * 3;
-			StaticMeshDescription->ReserveNewTriangles(EstimatedNumberOfFaces); 
-			StaticMeshDescription->ReserveNewPolygons(EstimatedNumberOfFaces);
-			StaticMeshDescription->ReserveNewVertexInstances(FGenericPlatformMath::Max(EstimatedNumberOfFaces * 3, SpeckleMesh->Vertices.Num()));
-		}
-
-		int32 i = 0;
-		while (i < NumberOfFacesIndices)
-		{
-			int32 n = SpeckleMesh->Faces[i];
-			if(n < 3) n += 3; // 0 -> 3, 1 -> 4
-			
-			TArray<FVertexInstanceID> VertexInstances;
-			VertexInstances.Reserve(n);
-			TSet<FVertexID> Verts;
-			Verts.Reserve(n);
-			for(int j = 0; j < n; j ++)
-			{
-				int32 VertIndex = SpeckleMesh->Faces[i + 1 + j];
-				FVertexID Vert = Vertices[VertIndex];
-				bool AlreadyInSet;
-				Verts.Add(Vert, &AlreadyInSet);
-	
-				if(AlreadyInSet)
-				{
-					UE_LOG(LogSpeckle, Warning, TEXT("Invalid Polygon while creating mesh %s - vertex at index %d appears more than once in a face, duplicate vertices will be ignored"), *SpeckleMesh->Id, VertIndex);
-					continue;
-				}
-				FVertexInstanceID VertexInstance = StaticMeshDescription->CreateVertexInstance(Vert);
-				
-				VertexInstances.Add(VertexInstance);
-			
-				if(SpeckleMesh->TextureCoordinates.Num() > VertIndex)
-					StaticMeshDescription->SetVertexInstanceUV(VertexInstance, SpeckleMesh->TextureCoordinates[VertIndex]);
-			
-				//if(SpeckleMesh->VertexColors.Num() > VertIndex)
-				//	//TODO set vertex colors
-			}
-			
-			i += n + 1;
-			if(VertexInstances.Num() < 3)
-			{
-				UE_LOG(LogTemp, Warning, TEXT("Invalid Polygon while creating mesh %s - face has fewer than 3 verts, this face will be ignored"), *SpeckleMesh->Id);
-				continue;
-			}
-		
-		
-			TArray<FEdgeID> Edges;
-			Edges.Reserve(n);
-	
-			const FPolygonID PolygonID = StaticMeshDescription->CreatePolygon(PolygonGroupID, VertexInstances, Edges);
-
-			for (const FEdgeID EdgeID : Edges)
-			{
-				StaticMeshDescription->GetEdgeHardnesses()[EdgeID] = true;
-			}
-		}
-	}
-
-	if(StaticMeshDescription->Vertices().Num() == 0
-		|| StaticMeshDescription->VertexInstances().Num() == 0
-		|| StaticMeshDescription->Triangles().Num() == 0)
-	{
-		UE_LOG(LogSpeckle, Warning, TEXT("Skipping %s $s, converted mesh is empty!"), *Parent->SpeckleType, *Parent->Id);
-		return nullptr;
-	}
-			
-	BaseMeshDescription.TriangulateMesh();
-
-#if ENGINE_MAJOR_VERSION >= 5
-	FStaticMeshOperations::ComputeTriangleTangentsAndNormals(BaseMeshDescription);
-#else
-	BaseMeshDescription.PolygonAttributes().RegisterAttribute<FVector>(MeshAttribute::Polygon::Normal, 1, FVector::ZeroVector, EMeshAttributeFlags::Transient);
-	BaseMeshDescription.PolygonAttributes().RegisterAttribute<FVector>(MeshAttribute::Polygon::Tangent, 1, FVector::ZeroVector, EMeshAttributeFlags::Transient);
-	BaseMeshDescription.PolygonAttributes().RegisterAttribute<FVector>(MeshAttribute::Polygon::Binormal, 1, FVector::ZeroVector, EMeshAttributeFlags::Transient);
-	BaseMeshDescription.PolygonAttributes().RegisterAttribute<FVector>(MeshAttribute::Polygon::Center, 1, FVector::ZeroVector, EMeshAttributeFlags::Transient);
-	FStaticMeshOperations::ComputePolygonTangentsAndNormals(BaseMeshDescription);
-#endif
-	
-	FStaticMeshOperations::ComputeTangentsAndNormals(BaseMeshDescription, EComputeNTBsFlags::Normals | EComputeNTBsFlags::Tangents);
-	
-	
-	//Mesh->PreEditChange(nullptr);
-	
-#if ENGINE_MAJOR_VERSION >= 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION >= 27 )
-	Mesh->SetLightMapCoordinateIndex(1);
-#else
-	Mesh->LightMapCoordinateIndex = 1;
-#endif
-	
-	Mesh->BuildFromMeshDescriptions(TArray<const FMeshDescription*>{&BaseMeshDescription}, MeshParams);
-
-#if WITH_EDITOR
-	if(UseFullBuild)
-	{
-		FScopeLock Lock(&Lock_StaticMeshesToBuild);
-		StaticMeshesToBuild.Add(Mesh);
-	}
-
-	if (!FApp::IsGame())
-	{
-		Mesh->MarkPackageDirty();
-		FAssetRegistryModule::AssetCreated(Mesh);
-	}
-#endif
-	//Mesh->PostEditChange(); //This doesn't seem to be required
-
-	return Mesh;
-}
-
-void UStaticMeshConverter::GenerateMeshParams(UStaticMesh::FBuildMeshDescriptionsParams& MeshParams) const
-{
-	MeshParams.bBuildSimpleCollision = BuildSimpleCollision;
-	MeshParams.bCommitMeshDescription = true;
-	MeshParams.bMarkPackageDirty = true;
-	MeshParams.bUseHashAsGuid = false;
-
-#if !WITH_EDITOR && ENGINE_MAJOR_VERSION >= 5
-	MeshParams.bFastBuild = true;
-#endif
-}
-
-
-void UStaticMeshConverter::ConvertToSpeckle_Implementation(const UObject* Object, UBase* SpeckleObject)
-{
-	const UStaticMeshComponent* M = Cast<UStaticMeshComponent>(Object);
-
-	if(M == nullptr)
-	{
-		const AActor* A = Cast<AActor>(Object);
-		if(A != nullptr)
-		{
-			M = A->FindComponentByClass<UStaticMeshComponent>();
-		}
-	}
-	if(M == nullptr) return;
-	
-	//SpeckleObject->DynamicProperties.Add(TEXT("@displayValue"), MeshToSpeckle(M));
-	
-}
-
-
-TArray<UMesh*> UStaticMeshConverter::MeshToSpeckle(const UStaticMeshComponent* MeshComponent)
-{
-	
-	UStaticMeshDescription* StaticMeshDescription = NewObject<UStaticMeshDescription>(GetTransientPackage(), NAME_None, RF_Transient);
-	const FMeshDescription* MeshDescription = MeshComponent->GetStaticMesh()->GetMeshDescription(0);;
-	StaticMeshDescription->SetMeshDescription(*MeshDescription);
-	StaticMeshDescription->RegisterAttributes();
-	
-	const FVertexArray& nVertices = StaticMeshDescription->Vertices();
-	TArray<FVector> sVertices;
-	sVertices.Reserve(nVertices.Num()); // * 3));
-	
-	TMap<FVertexID, int32> VertexIdToIndex;
-	VertexIdToIndex.Reserve(nVertices.Num() * 3);
-
-	int32 i = 0;
-	for (const FVertexID& VertexId : nVertices.GetElementIDs())
-	{
-		const FVector Vert = StaticMeshDescription->GetVertexPosition(VertexId);
-		sVertices.Add(Vert);
-		
-		VertexIdToIndex.Add(VertexId, i);
-		i++;
-	}
-
-
-	FTriangleArray& nTriangles = StaticMeshDescription->Triangles();
-	TArray<int32> sFaces;
-	sFaces.Reserve(nTriangles.Num());
-
-	for (const FTriangleID& TriangleId : nTriangles.GetElementIDs())
-	{
-		TArray<FVertexID> Tri;
-		StaticMeshDescription->GetTriangleVertices(TriangleId, Tri);
-
-		sFaces.Add(3);
-		sFaces.Add(VertexIdToIndex[Tri[0]]);
-		sFaces.Add(VertexIdToIndex[Tri[1]]);
-		sFaces.Add(VertexIdToIndex[Tri[2]]);		
-	}
-
-	//TODO colors
-
-	//TODO tex-coords
-
-	//TODO split mesh by material
-	UMesh* Mesh = NewObject<UMesh>(GetTransientPackage(), NAME_None, RF_Transient);
-      
-	Mesh->Vertices = sVertices;
-	Mesh->Faces = sFaces;
-	//Mesh->Colors = sColors;
-	//Mesh->TextureCoordinates = sTexCoords;
-	Mesh->Units = "cm";
-
-	return TArray<UMesh*>{Mesh};
-}
-
-
-void UStaticMeshConverter::FinishConversion_Implementation()
-{
-
-	FScopeLock Lock(&Lock_StaticMeshesToBuild);
-
-#if WITH_EDITOR
-	
-	FFormatNamedArguments Args;
-	Args.Add( TEXT("Path"), FText::FromString( GetPathName() ) );
-	const FText StatusUpdate = FText::Format( LOCTEXT("BeginStaticMeshBuildingTask", "({Path}) Building"), Args );
-	FScopedSlowTask Progress(StaticMeshesToBuild.Num(), StatusUpdate, DisplayBuildProgressBar);
-
-	Progress.MakeDialog(AllowCancelBuild);
-	auto ProgressAction = [&Progress](UStaticMesh*) -> bool
-	{
-		Progress.EnterProgressFrame(1);
-		return !Progress.ShouldCancel();
-	};
-	
-	UStaticMesh::BatchBuild(StaticMeshesToBuild, !DisplayBuildProgressBar,  ProgressAction);
-#endif
-
-	StaticMeshesToBuild.Empty();
-}
-
-#undef LOCTEXT_NAMESPACE

Source/SpeckleUnreal/Private/Conversion/SpeckleConverterComponent.ToNative.cpp

@@ -1,179 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Conversion/SpeckleConverterComponent.h"
-
-#include "ActorEditorUtils.h"
-#include "API/SpeckleSerializer.h"
-#include "Conversion/Converters/AggregateConverter.h"
-#include "Conversion/Converters/BlockConverter.h"
-#include "Conversion/Converters/PointCloudConverter.h"
-#include "Conversion/Converters/StaticMeshConverter.h"
-#include "Conversion/Converters/MaterialConverter.h"
-#include "Misc/ScopedSlowTask.h"
-#include "UObject/ConstructorHelpers.h"
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
-
-// Sets default values for this component's properties
-USpeckleConverterComponent::USpeckleConverterComponent()
-{
-	//TODO consider using an object library for default converters
-	static ConstructorHelpers::FObjectFinder<UStaticMeshConverter> MeshConverter(TEXT("StaticMeshConverter'/SpeckleUnreal/Converters/DefaultStaticMeshConverter.DefaultStaticMeshConverter'"));
-	static ConstructorHelpers::FObjectFinder<UPointCloudConverter> PointCloudConverter(TEXT("PointCloudConverter'/SpeckleUnreal/Converters/DefaultPointCloudConverter.DefaultPointCloudConverter'"));
-	static ConstructorHelpers::FObjectFinder<UBlockConverter> BlockConverter(TEXT("BlockConverter'/SpeckleUnreal/Converters/DefaultBlockConverter.DefaultBlockConverter'"));
-	static ConstructorHelpers::FObjectFinder<UMaterialConverter> MaterialConverter(TEXT("MaterialConverter'/SpeckleUnreal/Converters/DefaultMaterialConverter.DefaultMaterialConverter'"));
-	static ConstructorHelpers::FObjectFinder<UObject> CameraConverter(TEXT("CameraConverter'/SpeckleUnreal/Converters/DefaultCameraConverter.DefaultCameraConverter'"));
-	//static ConstructorHelpers::FObjectFinder<ULightConverter> LightConverter(TEXT("LightConverter'/SpeckleUnreal/Converters/DefaultLightConverter.DefaultLightConverter'"));
-
-	SpeckleConverter = CreateDefaultSubobject<UAggregateConverter>(TEXT("Objects Converter"));
-	
-	SpeckleConverter->SpeckleConverters.Add(MeshConverter.Object);
-	SpeckleConverter->SpeckleConverters.Add(PointCloudConverter.Object);
-	SpeckleConverter->SpeckleConverters.Add(BlockConverter.Object);
-	SpeckleConverter->SpeckleConverters.Add(MaterialConverter.Object);
-	SpeckleConverter->SpeckleConverters.Add(CameraConverter.Object);
-	//SpeckleConverter->SpeckleConverters.Add(LightConverter.Object);
-	
-	PrimaryComponentTick.bCanEverTick = false;
-}
-
-AActor* USpeckleConverterComponent::RecursivelyConvertToNative(AActor* AOwner, const UBase* Base,
-	const TScriptInterface<ITransport>& LocalTransport, bool DisplayProgressBar, TArray<AActor*>& OutActors)
-{
-	float ObjectsToConvert{};
-	Base->TryGetDynamicNumber("totalChildrenCount", ObjectsToConvert);
-	FScopedSlowTask Progress(ObjectsToConvert + 2, LOCTEXT("SpeckleConvertoNative","Converting Speckle Objects to Native"), DisplayProgressBar);
-#if WITH_EDITOR
-	Progress.MakeDialog(true, false);
-#endif
-	
-	AActor* RootActor = RecursivelyConvertToNative_Internal(AOwner, Base, LocalTransport, &Progress, OutActors);
-	
-	FinishConversion();
-	return RootActor;
-}
-
-AActor* USpeckleConverterComponent::RecursivelyConvertToNative_Internal(AActor* AOwner, const UBase* Base,
-                                                                        const TScriptInterface<ITransport>& LocalTransport,
-                                                                        FSlowTask* Task,
-                                                                        TArray<AActor*>& OutActors)
-{
-	check(IsValid(AOwner));
-	if(!IsValid(Base)) return nullptr;
-	
-	// Convert Speckle Object
-	UObject* Converted = SpeckleConverter->ConvertToNativeInternal(Base, AOwner->GetWorld());
-	AttachConvertedToOwner(AOwner, Base, Converted);
-
-	// Handle new actors
-	AActor* ConvertedAsActor = Cast<AActor>(Converted);
-	AActor* NextOwner =  IsValid(ConvertedAsActor) ? ConvertedAsActor : AOwner;
-	if(NextOwner != AOwner)
-	{
-		OutActors.Add(NextOwner);
-		OutActors.Append(NextOwner->Children);
-	}
-
-	Task->EnterProgressFrame(1);
-	if(Task->ShouldCancel()) return AOwner;
-	
-	//Convert Children
-	TMap<FString, TSharedPtr<FJsonValue>> PotentialChildren = Base->DynamicProperties;
-	
-	for (const auto& Kvp : PotentialChildren)
-	{
-		if(Task->ShouldCancel()) break;
-		
-		ConvertChild(Kvp.Value, AOwner, LocalTransport, Task, OutActors);
-	}
-	return AOwner;
-}
-
-void USpeckleConverterComponent::ConvertChild(const TSharedPtr<FJsonValue> Object, AActor* AOwner,
-                                              const TScriptInterface<ITransport>& LocalTransport, FSlowTask* Task,
-                                              TArray<AActor*>& OutActors)
-{
-	//Handle child object
-	const TSharedPtr<FJsonObject>* ChildObj;
-	if (Object->TryGetObject(ChildObj))
-	{
-		const UBase* Child = USpeckleSerializer::DeserializeBase(*ChildObj, LocalTransport);
-		RecursivelyConvertToNative_Internal(AOwner, Child, LocalTransport, Task, OutActors);
-		return;
-	}
-
-	//Handle child array object
-	const TArray<TSharedPtr<FJsonValue>>* ChildArr;
-	if (Object->TryGetArray(ChildArr))
-	{
-		for (const auto& v : *ChildArr)
-		{
-			ConvertChild(v, AOwner, LocalTransport, Task, OutActors);
-		}
-	}
-};
-	
-
-void USpeckleConverterComponent::AttachConvertedToOwner(AActor* AOwner, const UBase* Base, UObject* Converted)
-{
-	
-	// Case Actor
-	{
-		AActor* NativeActor = Cast<AActor>(Converted);
-		if(IsValid(NativeActor))
-		{
-	#if WITH_EDITOR
-			{
-				FString Name;
-				FText _Discard;
-				if( !(Base->TryGetDynamicString("name", Name) && FActorEditorUtils::ValidateActorName(FText::FromString(Name), _Discard)) )
-				{
-					Name = FString::Printf(TEXT("%s - %s"), *Base->SpeckleType, *Base->Id);
-				}
-				NativeActor->SetActorLabel(Name);
-			}
-	#endif
-		
-			// Ensure actor has a valid mobility for its owner
-			if(NativeActor->HasValidRootComponent())
-			{
-				uint8 CurrentMobility = NativeActor->GetRootComponent()->Mobility;
-				uint8 OwnerMobility = AOwner->GetRootComponent()->Mobility;
-			
-				if(CurrentMobility < OwnerMobility)
-				{
-					NativeActor->GetRootComponent()->SetMobility(AOwner->GetRootComponent()->Mobility);
-				}
-			}
-		
-			NativeActor->AttachToActor(AOwner, FAttachmentTransformRules::KeepRelativeTransform);
-			NativeActor->SetOwner(AOwner);
-			return;
-		}
-	}
-
-	// Case ActorComponent
-	{
-		UActorComponent* NativeComponent = Cast<UActorComponent>(Converted);
-		if(IsValid(NativeComponent))
-		{
-			if(!AOwner->HasValidRootComponent()) AOwner->SetRootComponent(NewObject<USceneComponent>(AOwner));
-
-			USceneComponent* SceneComponent = Cast<USceneComponent>(Converted);
-			if(IsValid(SceneComponent)) SceneComponent->SetupAttachment(AOwner->GetRootComponent());
-
-			NativeComponent->RegisterComponent();
-			return;
-		}
-	}
-	
-}
-
-
-void USpeckleConverterComponent::FinishConversion()
-{
-	SpeckleConverter->FinishConversion_Internal();
-}
-
-#undef LOCTEXT_NAMESPACE

Source/SpeckleUnreal/Private/Conversion/SpeckleConverterComponent.ToSpeckle.cpp

@@ -1,60 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Conversion/SpeckleConverter.h"
-#include "Conversion/SpeckleConverterComponent.h"
-#include "Conversion/Converters/AggregateConverter.h"
-
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
-
-
-UBase* USpeckleConverterComponent::RecursivelyConvertToSpeckle(const TArray<AActor*>& RootActors, FActorPredicate& Predicate)
-{
-	TArray<UBase*> ConvertedRootActors;
-	for(const AActor* RootActor : RootActors)
-	{
-		RecurseTreeToSpeckle(RootActor, Predicate, ConvertedRootActors);
-	}
-
-	UBase* Wrapper = NewObject<UBase>(GetTransientPackage(), NAME_None, RF_Transient);
-
-	//Converted->DynamicProperties["objects"] = ConvertedRootActors; //TODO set children
-	
-	return Wrapper;
-}
-
-void USpeckleConverterComponent::RecurseTreeToSpeckle(const AActor* RootActor, FActorPredicate& Predicate, TArray<UBase*>& OutConverted)
-{
-	// Convert children first
-	TArray<UBase*> ConvertedChildren;
-	ConvertedChildren.Reserve(RootActor->Children.Num());
-	for (const AActor* Child : RootActor->Children)
-	{
-		RecurseTreeToSpeckle(Child, Predicate, ConvertedChildren);
-	}
-
-	bool ShouldConvert; 
-	Predicate.Execute(RootActor, ShouldConvert);
-	if(ISpeckleConverter::Execute_CanConvertToSpeckle(SpeckleConverter, RootActor) && ShouldConvert)
-	{
-		// Convert and output
-		UBase* Converted = NewObject<UBase>(GetTransientPackage(), NAME_None, RF_Transient);
-		//Converted->DynamicProperties["name"] = RootActor->GetName(),
-		//["transform"] = TransformToSpeckle(go.Transform), //TODO set common props
-		//Converted->DynamicProperties["tag"] = go.tag,
-		//Converted->DynamicProperties["layer"] = go.layer,
-		//Converted->DynamicProperties["isStatic"] = go.isStatic,
-		
-		ISpeckleConverter::Execute_ConvertToSpeckle(SpeckleConverter, RootActor, Converted);
-		//Converted->DynamicProperties["objects"] = ConvertedChildren; //TODO set children
-		OutConverted.Add(Converted);
-	}
-	else
-	{
-		// Skip this object, and output any children
-		OutConverted.Append(ConvertedChildren);
-	}
-	
-}
-#undef LOCTEXT_NAMESPACE

Source/SpeckleUnreal/Private/LogSpeckle.cpp

@@ -1,4 +0,0 @@
-#include "LogSpeckle.h"
-#include "Logging/LogMacros.h"
-
-DEFINE_LOG_CATEGORY(LogSpeckle);

Source/SpeckleUnreal/Private/Objects/DisplayValueElement.cpp

@@ -1,58 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Objects/DisplayValueElement.h"
-
-#include "API/SpeckleSerializer.h"
-#include "Objects/Geometry/Mesh.h"
-
-
-TArray<FString> UDisplayValueElement::DisplayValueAliasStrings = {
-	"displayValue",
-	"@displayValue",
-	"displayMesh"
-	"@displayMesh"
-};
-
-
-bool UDisplayValueElement::AddDisplayValue(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	UMesh* DisplayMesh = Cast<UMesh>(USpeckleSerializer::DeserializeBase(Obj, ReadTransport));
-	const bool Valid = IsValid(DisplayMesh);
-	if(Valid)
-		this->DisplayValue.Add(DisplayMesh);
-	return Valid;
-}
-
-bool UDisplayValueElement::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	if(!Super::Parse(Obj, ReadTransport)) return false;
-
-	//Find display values
-	for(const FString& Alias : DisplayValueAliasStrings)
-	{
-		const TSharedPtr<FJsonObject>* SubObjectPtr;
-		if (Obj->TryGetObjectField(Alias, SubObjectPtr))
-		{
-			AddDisplayValue(*SubObjectPtr, ReadTransport);
-			DynamicProperties.Remove(Alias);
-			continue;
-		}
-
-		const TArray<TSharedPtr<FJsonValue>>* SubArrayPtr;
-		if (Obj->TryGetArrayField(Alias, SubArrayPtr))
-		{
-			for (const auto& ArrayElement : *SubArrayPtr)
-			{
-				const TSharedPtr<FJsonObject>* ArraySubObjPtr;
-				if (ArrayElement->TryGetObject(ArraySubObjPtr))
-				{
-					AddDisplayValue(*ArraySubObjPtr, ReadTransport);
-				}
-			}
-			DynamicProperties.Remove(Alias);
-		}
-	}
-
-	return DisplayValue.Num() > 0;
-}

Source/SpeckleUnreal/Private/Objects/DynamicBase.cpp

@@ -1,80 +0,0 @@
-// Copyright AEC Systems Ltd
-
-#include "Objects/DynamicBase.h"
-#include "Misc/Variant.h"
-
-template <typename T>
-bool UDynamicBase::TryGetDynamicProperty(const FString& Key, T& OutValue) const
-{
-	const auto Wrapper = DynamicProperties.FindRef(Key);
-	if(Wrapper.IsValid()) return false;
-
-	if(Wrapper->GetType() != TVariantTraits<T>::GetType()) return false;
-	
-	OutValue = Wrapper->GetValue<T>();
-	return true;
-}
-
-template <typename T>
-void UDynamicBase::SetDynamicProperty(const FString& Key, T Value)
-{
-	DynamicProperties.Add(Key, MakeShareable(new FVariant(Value)));
-}
-
-int32 UDynamicBase::RemoveDynamicProperty(const FString& Key)
-{
-	return DynamicProperties.Remove(Key);
-}
-
-//-------------------
-
-bool UDynamicBase::TryGetDynamicStringProperty(const FString& Key, FString& OutValue) const
-{
-	return TryGetDynamicProperty(Key, OutValue);
-}
-
-bool UDynamicBase::TryGetDynamicIntProperty(const FString& Key, int32& OutValue) const
-{
-	return TryGetDynamicProperty(Key, OutValue);
-}
-
-bool UDynamicBase::TryGetDynamicFloatProperty(const FString& Key, float& OutValue) const
-{
-	return TryGetDynamicProperty(Key, OutValue);
-}
-
-bool UDynamicBase::TryGetDynamicBoolProperty(const FString& Key, bool& OutValue) const
-{
-	return TryGetDynamicProperty(Key, OutValue);
-}
-
-bool UDynamicBase::TryGetDynamicBaseProperty(const FString& Key, UBase*& OutValue) const
-{
-	return TryGetDynamicProperty(Key, OutValue);
-}
-
-void UDynamicBase::SetDynamicStringProperty(const FString& Key, FString& OutValue)
-{
-	SetDynamicProperty(Key, OutValue);
-}
-
-void UDynamicBase::SetDynamicIntProperty(const FString& Key, int32& OutValue)
-{
-	SetDynamicProperty(Key, OutValue);
-}
-
-void UDynamicBase::SetDynamicFloatProperty(const FString& Key, float& OutValue)
-{
-	SetDynamicProperty(Key, OutValue);
-}
-
-void UDynamicBase::SetDynamicBoolProperty(const FString& Key, bool& OutValue)
-{
-	SetDynamicProperty(Key, OutValue);
-}
-
-void UDynamicBase::SetDynamicBaseProperty(const FString& Key, UBase*& OutValue)
-{
-	SetDynamicProperty(Key, OutValue);
-}
-

Source/SpeckleUnreal/Private/Objects/Geometry/Mesh.cpp

@@ -1,212 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Objects/Geometry/Mesh.h"
-
-#include "Objects/Other/RenderMaterial.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-#include "Transports/Transport.h"
-
-bool UMesh::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	if(!Super::Parse(Obj, ReadTransport)) return false;
-	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
-
-	//Parse optional Transform
-	if(USpeckleObjectUtils::TryParseTransform(Obj, Transform))
-	{
-		Transform.ScaleTranslation(FVector(ScaleFactor));
-		DynamicProperties.Remove("transform");
-	}
-	else
-	{
-		Transform = FMatrix::Identity;
-	}
-	
-
-	//Parse Vertices
-	{
-		TArray<TSharedPtr<FJsonValue>> ObjectVertices = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("vertices"), ReadTransport);
-		const int32 NumberOfVertices = ObjectVertices.Num() / 3;
-
-		Vertices.Reserve(NumberOfVertices);
-
-		for (size_t i = 0, j = 0; i < NumberOfVertices; i++, j += 3)
-		{
-			Vertices.Add(Transform.InverseTransformPosition(FVector
-			(
-				ObjectVertices[j].Get()->AsNumber(),
-				-ObjectVertices[j + 1].Get()->AsNumber(),
-				ObjectVertices[j + 2].Get()->AsNumber()
-			) * ScaleFactor ));
-		}
-		DynamicProperties.Remove("vertices");
-	}
-
-	//Parse Faces
-	{
-		const TArray<TSharedPtr<FJsonValue>> FaceVertices = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("faces"), ReadTransport);
-		Faces.Reserve(FaceVertices.Num());
-		for(const auto& VertIndex : FaceVertices)
-		{
-			Faces.Add(VertIndex->AsNumber());
-		}
-		DynamicProperties.Remove("faces");
-	}
-
-	//Parse TextureCoords
-	{
-		const TArray<TSharedPtr<FJsonValue>>* TextCoordArray;
-		if(Obj->TryGetArrayField("textureCoordinates", TextCoordArray))
-		{
-			TArray<TSharedPtr<FJsonValue>> TexCoords = USpeckleObjectUtils::CombineChunks(*TextCoordArray, ReadTransport);
-	
-			TextureCoordinates.Reserve(TexCoords.Num() / 2);
-	
-			for (int32 i = 0; i + 1 < TexCoords.Num(); i += 2)
-			{
-				TextureCoordinates.Add(FVector2D
-				(
-					TexCoords[i].Get()->AsNumber(),
-					TexCoords[i + 1].Get()->AsNumber()
-				)); 
-			}
-			DynamicProperties.Remove("textureCoordinates");
-		}
-	}
-
-	//Parse VertexColors
-	{
-		const TArray<TSharedPtr<FJsonValue>>* ColorArray;
-		if(Obj->TryGetArrayField("colors", ColorArray))
-		{
-			TArray<TSharedPtr<FJsonValue>> Colors = USpeckleObjectUtils::CombineChunks(*ColorArray, ReadTransport);
-	
-			VertexColors.Reserve(Colors.Num());
-	
-			for (int32 i = 0; i + 1 < Colors.Num(); i ++)
-			{
-				VertexColors.Add(FColor(Colors[i].Get()->AsNumber()));
-			}
-			DynamicProperties.Remove("colors");
-		}
-	}
-
-	//Parse Optional RenderMaterial
-	if (Obj->HasField("renderMaterial"))
-	{
-		RenderMaterial = NewObject<URenderMaterial>();
-		RenderMaterial->Parse(Obj->GetObjectField("renderMaterial"), ReadTransport);
-		DynamicProperties.Remove("renderMaterial");
-	}
-	
-	AlignVerticesWithTexCoordsByIndex();
-
-	return Vertices.Num() > 0 && Faces.Num() > 0;
-}
-
-void UMesh::ToJson(TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> Writer)
-{
-	Super::ToJson(Writer);
-
-	// Serialize Transform
-	// TODO todo transform
-
-	// Serialize Vertices
-	{
-		TArray<double> FlattenedVertices;
-		FlattenedVertices.Reserve(Vertices.Num() * 3);
-		for(size_t i = 0, j = 0; i < Vertices.Num(); i++)
-		{
-			const FVector& v = Vertices[i];
-			FlattenedVertices[j++] = v.X;
-			FlattenedVertices[j++] = -v.Y;
-			FlattenedVertices[j++] = v.Z;
-		}
-		Writer.WriteValue(TEXT("vertices"), FlattenedVertices);
-	}
-	
-	// Serialize Faces
-	Writer.WriteValue(TEXT("faces"), Faces);
-	
-
-	//Parse TextureCoords
-	{
-		TArray<double> FlattenedTexCoords;
-		FlattenedTexCoords.Reserve(TextureCoordinates.Num() * 2);
-		for(size_t i = 0, j = 0; i < TextureCoordinates.Num(); i++)
-		{
-			const FVector2D& c = TextureCoordinates[i];
-			FlattenedTexCoords[j++] = c.X;
-			FlattenedTexCoords[j++] = -c.Y;
-		}
-		Writer.WriteValue(TEXT("textureCoordinates"), FlattenedTexCoords);
-	}
-	
-	//Parse VertexColors
-	{
-		TArray<int32> ArgbColors;
-		ArgbColors.Reserve(VertexColors.Num());
-		for(size_t i = 0; i < VertexColors.Num(); i++)
-		{
-			ArgbColors[i] = VertexColors[i].ToPackedARGB();
-		}
-		Writer.WriteValue(TEXT("colors"), ArgbColors);
-	}
-	
-
-	// Parse Optional RenderMaterial
-	//if (RenderMaterial != nullptr)
-	{
-		//TODO renderMaterial
-	}
-	
-}
-
-
-/**
- * If not already so, this method will align vertices
- * such that a vertex and its corresponding texture coordinates have the same index.
- * See "https://github.com/specklesystems/speckle-sharp/blob/main/Objects/Objects/Geometry/Mesh.cs"
- */
-void UMesh::AlignVerticesWithTexCoordsByIndex()
-{
-	if(TextureCoordinates.Num() == 0) return;
-	if(TextureCoordinates.Num() == Vertices.Num()) return; //Tex-coords already aligned as expected
-
-	TArray<int> FacesUnique;
-	FacesUnique.Reserve(Faces.Num());
-	TArray<FVector> VerticesUnique;
-	VerticesUnique.Reserve(TextureCoordinates.Num());
-	const bool HasColor = VertexColors.Num() > 0;
-	TArray<FColor> ColorsUnique;
-	if(HasColor) ColorsUnique.Reserve(TextureCoordinates.Num());
-
-	int32 NIndex = 0;
-	while(NIndex < Faces.Num())
-	{
-		int32 n = Faces[NIndex];
-		if (n < 3) n += 3; // 0 -> 3, 1 -> 4
-
-		if (NIndex + n >= Faces.Num()) break; //Malformed face list
-
-		FacesUnique.Add(n);
-
-		for (int32 i = 1; i <= n; i++)
-		{
-			const int32 VertIndex = Faces[NIndex + i];
-			const int32 NewVertIndex = VerticesUnique.Num();
-			
-			VerticesUnique.Add(Vertices[VertIndex]);
-
-			if(HasColor) ColorsUnique.Add(VertexColors[NewVertIndex]);
-			FacesUnique.Add(NewVertIndex);
-		}
-		NIndex += n + 1;
-	}
-	
-	Vertices = VerticesUnique;
-	VertexColors = ColorsUnique;
-	Faces = FacesUnique;
-	
-}

Source/SpeckleUnreal/Private/Objects/Geometry/PointCloud.cpp

@@ -1,59 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Objects/Geometry/PointCloud.h"
-
-#include "Objects/Utils/SpeckleObjectUtils.h"
-#include "Transports/Transport.h"
-
-bool UPointCloud::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	if(!Super::Parse(Obj, ReadTransport)) return false;
-	
-	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
-
-	//Parse Points
-	{
-		TArray<TSharedPtr<FJsonValue>> ObjectPoints = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("points"), ReadTransport);
-		
-		Points.Reserve(ObjectPoints.Num() / 3);
-		for (int32 i = 2; i < ObjectPoints.Num(); i += 3) 
-		{
-			Points.Add(FVector
-			(
-				ObjectPoints[i - 2].Get()->AsNumber(),
-				ObjectPoints[i - 1].Get()->AsNumber(),
-				ObjectPoints[i].Get()->AsNumber()
-			) * ScaleFactor);
-		}
-		DynamicProperties.Remove("points");
-	}
-
-	
-	//Parse Colors
-	{
-		TArray<TSharedPtr<FJsonValue>> ObjectColors = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("colors"), ReadTransport);
-		
-		Colors.Reserve(ObjectColors.Num());
-		for (int32 i = 0; i < ObjectColors.Num(); i += 1) 
-		{
-			Colors.Add( FColor(ObjectColors[i].Get()->AsNumber()) );
-		}
-		DynamicProperties.Remove("colors");
-	}
-
-	//Parse Sizes
-	{
-		TArray<TSharedPtr<FJsonValue>> ObjectSizes = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("sizes"), ReadTransport);
-		
-		Sizes.Reserve(ObjectSizes.Num());
-		for (int32 i = 0; i < ObjectSizes.Num(); i += 1) 
-		{
-			Sizes.Add( ObjectSizes[i].Get()->AsNumber() * ScaleFactor);
-		}
-		DynamicProperties.Remove("sizes");
-	}
-
-	return Points.Num() >= 0;
-}
-

Source/SpeckleUnreal/Private/Objects/ObjectModelRegistry.cpp

@@ -1,84 +0,0 @@
-#include "Objects/ObjectModelRegistry.h"
-
-#include "Objects/Base.h"
-#include "Templates/SubclassOf.h"
-#include "UObject/UObjectIterator.h"
-
-TMap<FString, TSubclassOf<UBase>> UObjectModelRegistry::TypeRegistry;
-
-void UObjectModelRegistry::GenerateTypeRegistry()
-{
-	//TypeRegistry.Reset();
-	TypeRegistry.Empty();
-	//TypeRegistry = TMap<FString, TSubclassOf<UBase>>();
-	//check(TypeRegistry.IsSet());
-	
-	//Find every class : UBase and add to Registry
-	for (TObjectIterator<UClass> It; It; ++It)
-	{
-		const UClass* Class = *It;
-		if (Class->IsChildOf(UBase::StaticClass()) &&
-			!Class->HasAnyClassFlags(CLASS_Abstract))
-		{
-			const FString& SpeckleType = Class->GetDefaultObject<UBase>()->SpeckleType;;
-
-			ensureAlwaysMsgf(!TypeRegistry.Contains(SpeckleType),
-				TEXT("Base class: %s conflicts with: %s for SpeckleType: %s"),
-				*Class->GetName(),
-				*TypeRegistry[SpeckleType]->GetName(),
-				*SpeckleType);
-
-			TypeRegistry.Add(SpeckleType, *It);
-		}
-	}
-}
-
-
-
-TSubclassOf<UBase> UObjectModelRegistry::FindClosestType(const FString& SpeckleType)
-{
-	FString TypeString(SpeckleType);
-	TSubclassOf<UBase> Type = nullptr;
-
-	while(!TryGetRegisteredType(TypeString, Type))
-	{
-		if(!ParentType(TypeString, TypeString)) return nullptr;
-	}
-		
-	return Type;
-	
-}
-
-bool UObjectModelRegistry::ParentType(const FString& Type, FString& NextType)
-{
-	int32 DotSplitIndex;
-	Type.FindLastChar('.', DotSplitIndex);
-	int32 ColonSplitIndex;
-	Type.FindLastChar(':', ColonSplitIndex);
-	const int32 SplitIndex = FGenericPlatformMath::Max(DotSplitIndex, ColonSplitIndex);
-
-	if(SplitIndex <= 0) return false;
-		
-	NextType = Type.Left(SplitIndex);
-	return true;
-}
-
-TSubclassOf<UBase> UObjectModelRegistry::GetRegisteredType(const FString& SpeckleType)
-{
-	TSubclassOf<UBase> Type = nullptr;
-	TryGetRegisteredType(SpeckleType, Type);
-	return Type;
-}
-
-bool UObjectModelRegistry::TryGetRegisteredType(const FString& SpeckleType, TSubclassOf<UBase>& OutType)
-{
-	if(TypeRegistry.Num() == 0) GenerateTypeRegistry();
-
-
-	const bool Contains = TypeRegistry.Contains(SpeckleType);
-	if(Contains)
-	{
-		OutType = *TypeRegistry.Find(SpeckleType);
-	}
-	return Contains;
-}

Source/SpeckleUnreal/Private/Objects/Other/BlockInstance.cpp

@@ -1,61 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Objects/Other/BlockInstance.h"
-#include "LogSpeckle.h"
-
-#include "API/SpeckleSerializer.h"
-#include "Objects/Utils/SpeckleObjectUtils.h"
-#include "Transports/Transport.h"
-
-bool UBlockInstance::Parse(const TSharedPtr<FJsonObject> Obj,  const TScriptInterface<ITransport> ReadTransport)
-{
-	if(!Super::Parse(Obj, ReadTransport)) return false;
-	
-	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
-
-	//Transform
-	if(!USpeckleObjectUtils::TryParseTransform(Obj, Transform)) return false;
-	Transform.ScaleTranslation(FVector(ScaleFactor));
-	DynamicProperties.Remove("Transform");
-	
-
-	//Geometries
-	const TSharedPtr<FJsonObject>* BlockDefinitionPtr;
-	if(!Obj->TryGetObjectField("blockDefinition", BlockDefinitionPtr)) return false;
-	
-	const FString RefID = BlockDefinitionPtr->operator->()->GetStringField("referencedId");
-	const TSharedPtr<FJsonObject> BlockDefinition = ReadTransport->GetSpeckleObject(RefID);
-	
-	if(BlockDefinition->TryGetStringField("name", Name)) DynamicProperties.Remove("Name");
-
-	const auto Geometries = BlockDefinition->GetArrayField("geometry");
-
-	if(Geometries.Num() <= 0)
-	{
-		UE_LOG(LogSpeckle, Warning, TEXT("Block definition has no geometry. id: %s"), *RefID)
-		return false;
-	}
-	
-	for(const auto& Geo : Geometries)
-	{
-		const TSharedPtr<FJsonObject> MeshReference = Geo->AsObject();
-		const FString ChildId = MeshReference->GetStringField("referencedId");
-
-		if(ReadTransport->HasObject(ChildId))
-		{
-			UBase* Child = USpeckleSerializer::DeserializeBase(ReadTransport->GetSpeckleObject(ChildId), ReadTransport);
-			if(IsValid(Child))
-				Geometry.Add(Child);
-		}
-		else UE_LOG(LogSpeckle, Warning, TEXT("Block definition references an unknown object id: %s"), *ChildId)
-	}
-	DynamicProperties.Remove("geometry");
-	
-	// Intentionally don't remove blockDefinition from dynamic properties,
-	// because we want the converter to create the child geometries for us
-	//DynamicProperties.Remove("blockDefinition");
-	
-	return true;
-	
-}

Source/SpeckleUnreal/Private/Objects/Other/View3D.cpp

@@ -1,37 +0,0 @@
-// Copyright AEC Systems Ltd
-
-
-#include "Objects/Other/View3D.h"
-
-#include "Objects/Utils/SpeckleObjectUtils.h"
-
-bool UView3D::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-{
-	if(!Super::Parse(Obj, ReadTransport)) return false;
-
-	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
-
-	// Parse optional Name property
-	if(Obj->TryGetStringField("name", Name)) DynamicProperties.Remove("name");
-	
-	// Parse Origin
-	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "origin", ReadTransport, Origin)) return false;
-	Origin *= ScaleFactor;
-	DynamicProperties.Remove("origin");
-
-	// Parse UpDirection
-	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "upDirection", ReadTransport, UpDirection)) return false;
-	UpDirection *= ScaleFactor;
-	DynamicProperties.Remove("upDirection");
-	
-	// Parse ForwardDirection
-	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "forwardDirection", ReadTransport, ForwardDirection)) return false;
-	ForwardDirection *= ScaleFactor;
-	DynamicProperties.Remove("forwardDirection");
-
-	// Parse IsOrthogonal
-	if(!Obj->TryGetBoolField("isOrthogonal", IsOrthogonal)) return false;
-	DynamicProperties.Remove("isOrthogonal");
-	
-	return true;
-}

Source/SpeckleUnreal/Private/Objects/Utils/SpeckleObjectUtils.cpp

@@ -1,164 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Objects/Utils/SpeckleObjectUtils.h"
-
-#include "API/SpeckleSerializer.h"
-#include "Engine/World.h"
-#include "Objects/Geometry/Mesh.h"
-#include "Transports/Transport.h"
-
-
-TArray<TSharedPtr<FJsonValue>> USpeckleObjectUtils::CombineChunks(const TArray<TSharedPtr<FJsonValue>>& ArrayField, const TScriptInterface<ITransport> Transport)
-{
-	TArray<TSharedPtr<FJsonValue>> ObjectPoints;
-		
-	for(int32 i = 0; i < ArrayField.Num(); i++) 
-	{
-		FString Index;
-		if(ArrayField[i]->AsObject()->TryGetStringField("referencedId", Index))
-		{
-			if(!ensureAlwaysMsgf(Transport->HasObject(Index), TEXT("Failed to Dechunk array, Could not find chunk %s in transport"), *Index))
-				continue;
-			
-			const auto Chunk = Transport->GetSpeckleObject(Index)->GetArrayField("data");;
-			ObjectPoints.Append(Chunk);
-		}
-		else
-		{
-			return ArrayField; //Array was never chunked to begin with
-		}
-	}
-	return ObjectPoints;
-}
-
-bool USpeckleObjectUtils::ResolveReference(const TSharedPtr<FJsonObject> Object, const TScriptInterface<ITransport> Transport, TSharedPtr<FJsonObject>& OutObject)
-{
-	FString SpeckleType;	
-	FString ReferenceID;
-
-	if (Object->TryGetStringField("speckle_type", SpeckleType)
-		&& SpeckleType == "reference"
-		&& Object->TryGetStringField("referencedId",ReferenceID))
-	{
-		check(Transport != nullptr && Transport.GetObject() != nullptr)
-		
-		OutObject = Transport->GetSpeckleObject(ReferenceID);
-		return OutObject != nullptr;
-	}
-	return false;
-}
-
-float USpeckleObjectUtils::ParseScaleFactor(const FString& UnitsString)
-{
-	static const auto ParseUnits = [](const FString& LUnits) -> float
-	{
-		if (LUnits == "millimeters" || LUnits == "millimeter" || LUnits == "millimetres" || LUnits == "millimetre" || LUnits == "mm")
-			return 0.1;
-		if (LUnits == "centimeters" || LUnits == "centimeter" ||LUnits == "centimetres" || LUnits == "centimetre" || LUnits == "cm")
-			return 1;
-		if (LUnits == "meters" || LUnits == "meter" || LUnits == "metres" || LUnits == "metre" || LUnits == "m")
-			return 100;
-		if (LUnits == "kilometers" || LUnits == "kilometres" || LUnits == "km")
-			return 100000;
-
-		if (LUnits == "inches" || LUnits == "inch" || LUnits == "in")
-			return 2.54;
-		if (LUnits == "feet" || LUnits == "foot" || LUnits == "ft")
-			return 30.48;
-		if (LUnits == "yards" || LUnits == "yard"|| LUnits == "yd")
-			return 91.44;
-		if (LUnits == "miles" || LUnits == "mile" || LUnits == "mi")
-			return 160934.4;
-
-		return 100;
-	};
-
-	return ParseUnits(UnitsString.ToLower()); // * WorldToCentimeters; //TODO take into account world units
-}
-
-FTransform USpeckleObjectUtils::CreateTransform(UPARAM(ref) const FMatrix& TransformMatrix)
-{
-	FTransform Transform(TransformMatrix);
-	Transform.ScaleTranslation(FVector(1,-1,1));
-	FVector Rot = Transform.GetRotation().Euler();
-	FVector NewRot(-Rot.X, Rot.Y, -Rot.Z);
-	Transform.SetRotation(FQuat::MakeFromEuler(NewRot));
-	return Transform;
-}
-
-bool USpeckleObjectUtils::TryParseTransform(const TSharedPtr<FJsonObject> SpeckleObject, FMatrix& OutMatrix)
-{
-	const TSharedPtr<FJsonObject>* TransformObject;
-	const TArray<TSharedPtr<FJsonValue>>* TransformData;
-		
-	if(SpeckleObject->TryGetArrayField("transform", TransformData)) //Handle transform as array
-	{ }
-	else if(SpeckleObject->TryGetObjectField("transform", TransformObject)
-		&& (*TransformObject)->TryGetArrayField("value", TransformData)) //Handle transform as object
-	{ }
-	else return false;
-		
-	FMatrix TransformMatrix;
-	for(int32 Row = 0; Row < 4; Row++)
-		for(int32 Col = 0; Col < 4; Col++)
-		{
-			TransformMatrix.M[Row][Col] = TransformData->operator[](Row * 4 + Col)->AsNumber();
-		}
-	OutMatrix = TransformMatrix.GetTransposed();
-	return true;
-}
-
-bool USpeckleObjectUtils::ParseVectorProperty(const TSharedPtr<FJsonObject> Base, const FString& PropertyName,
-	const TScriptInterface<ITransport> ReadTransport, FVector& OutObject)
-{
-	const TSharedPtr<FJsonObject>* OriginObject;
-	if(Base->TryGetObjectField(PropertyName, OriginObject)
-		&& ParseVector(*OriginObject, ReadTransport, OutObject))
-	{
-		return true;
-	}
-	
-	return false;
-}
-
-bool USpeckleObjectUtils::ParseVector(const TSharedPtr<FJsonObject> Object,
-	const TScriptInterface<ITransport> Transport, FVector& OutObject)
-{
-	if(!ensure(Object != nullptr)) return false;
-	
-	TSharedPtr<FJsonObject> Obj;
-	if(!ResolveReference(Object, Transport, Obj)) Obj = Object;
-	
-	double x = 0, y = 0, z = 0;
-	
-	if(!(Obj->TryGetNumberField("x", x)
-		&& Obj->TryGetNumberField("y", y)
-		&& Obj->TryGetNumberField("z", z))) return false;
-
-	OutObject = FVector(x,y,z);
-	//return true;
-
-	UMesh* Mesh;
-	return ParseSpeckleObject<UMesh>(Obj, Transport, Mesh);
-}
-
-template <typename TBase>  
-bool USpeckleObjectUtils::ParseSpeckleObject(const TSharedPtr<FJsonObject> Object,
-	const TScriptInterface<ITransport> Transport, TBase*& OutObject)
-{
-	static_assert(TIsDerivedFrom<TBase, UBase>::IsDerived, "Type TBase must inherit UBase");
-
-	TSharedPtr<FJsonObject> Obj;
-	if(!ResolveReference(Object, Transport, Obj)) Obj = Object;
-	
-	UBase* b = USpeckleSerializer::DeserializeBase(Object, Transport);
-	OutObject = Cast<TBase>(b);
-	return OutObject == nullptr;
-}
-
-
-AActor* USpeckleObjectUtils::SpawnActorInWorld(const TSubclassOf<AActor> Class, UWorld* World, const FTransform& Transform)
-{
-	return World->SpawnActor(Class, &Transform, FActorSpawnParameters());
-}

Source/SpeckleUnreal/Private/SpeckleUnrealManager.cpp

@@ -1,132 +0,0 @@
-#include "SpeckleUnrealManager.h"
-
-#include "API/Operations/ReceiveOperation.h"
-#include "Transports/MemoryTransport.h"
-#include "Transports/ServerTransport.h"
-#include "LogSpeckle.h"
-#include "API/SpeckleSerializer.h"
-#include "Conversion/SpeckleConverterComponent.h"
-#include "Misc/ScopedSlowTask.h"
-#include "Objects/Base.h"
-#include "Mixpanel.h"
-#include "Engine/Engine.h"
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
-
-
-// Sets default values
-ASpeckleUnrealManager::ASpeckleUnrealManager()
-{
-	SetRootComponent(CreateDefaultSubobject<USceneComponent>(TEXT("Root")));
-	RootComponent->SetRelativeScale3D(FVector(1,1,1));
-    RootComponent->SetMobility(EComponentMobility::Static);
-
-	Converter = CreateDefaultSubobject<USpeckleConverterComponent>(FName("Converter"));
-	
-	KeepCache = true;
-	DisplayProgressBar = true;
-	ServerUrl = "https://speckle.xyz";
-}
-
-void ASpeckleUnrealManager::BeginPlay()
-{
-	Super::BeginPlay();
-
-	if(ImportAtRuntime) Receive();
-}
-
-void ASpeckleUnrealManager::Receive()
-{
-	DeleteObjects();
-
-	// Trim parameters
-	ServerUrl.TrimEndInline();
-	while(ServerUrl.RemoveFromEnd("/")) { }
-	StreamID.TrimEndInline();
-	ObjectID.TrimEndInline();
-	AuthToken.TrimEndInline();
-
-	FAnalytics::TrackEvent("unknown", "unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }, {"worldType", FString::FromInt(GetWorld()->WorldType)}});
-
-	if(!KeepCache && LocalObjectCache.GetObjectRef() != nullptr)
-	{
-		LocalObjectCache.GetObjectRef()->ConditionalBeginDestroy();
-		LocalObjectCache = UMemoryTransport::CreateEmptyMemoryTransport();
-	}
-	if(LocalObjectCache.GetObjectRef() == nullptr)
-	{
-		LocalObjectCache = UMemoryTransport::CreateEmptyMemoryTransport();
-	}
-	
-	UServerTransport* ServerTransport = UServerTransport::CreateServerTransport(ServerUrl,StreamID,AuthToken);
-
-	FString Message = FString::Printf(TEXT("Fetching Objects from Speckle Server: %s"), *ServerUrl);
-	PrintMessage(Message);
-
-	FTransportErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindUObject(this, &ASpeckleUnrealManager::HandleError);
-	FTransportCopyObjectCompleteDelegate CompleteDelegate;
-	CompleteDelegate.BindUObject(this, &ASpeckleUnrealManager::HandleReceive, DisplayProgressBar);
-	
-	
-	//Receive 
-	ServerTransport->CopyObjectAndChildren(ObjectID, LocalObjectCache, CompleteDelegate, ErrorDelegate);
-}
-
-
-
-void ASpeckleUnrealManager::HandleReceive(TSharedPtr<FJsonObject> RootObject, bool DisplayProgress)
-{
-	if(RootObject == nullptr) return;
-	
-	const UBase* Res = USpeckleSerializer::DeserializeBase(RootObject, LocalObjectCache);
-	if(IsValid(Res))
-	{
-		Converter->RecursivelyConvertToNative(this, Res, LocalObjectCache, DisplayProgress, Actors);
-		
-		FString Message = FString::Printf(TEXT("Converted %d Actors"), Actors.Num());
-		PrintMessage(Message);
-	}
-	else
-	{
-		FString Id;
-		RootObject->TryGetStringField("id", Id);
-		FString Message = FString::Printf(TEXT("Failed to deserialise root object: %s"), *Id);
-		HandleError(Message);
-	}
-}
-
-void ASpeckleUnrealManager::HandleError(FString& Message)
-{
-	PrintMessage(Message, true);
-}
-
-void ASpeckleUnrealManager::PrintMessage(FString& Message, bool IsError) const
-{
-	if(IsError)
-	{
-		UE_LOG(LogSpeckle, Error, TEXT("%s"), *Message);
-	}
-	else
-	{
-		UE_LOG(LogSpeckle, Log, TEXT("%s"), *Message);
-	}
-
-	FColor Color = IsError? FColor::Red : FColor::Green;
-	GEngine->AddOnScreenDebugMessage(0, 5.0f, Color, Message);
-}
-
-
-void ASpeckleUnrealManager::DeleteObjects()
-{
-	Converter->FinishConversion();
-	
-	for (AActor* a : Actors)
-	{
-		if(IsValid(a)) a->Destroy();
-	}
-
-	Actors.Empty();
-}
-
-#undef LOCTEXT_NAMESPACE

Source/SpeckleUnreal/Private/Tests/Transports/MemoryTransportTest.cpp

@@ -1,62 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "Misc/AutomationTest.h"
-#include "Objects/Base.h"
-#include "Transports/MemoryTransport.h"
-
-
-#if WITH_DEV_AUTOMATION_TESTS
-
-IMPLEMENT_SIMPLE_AUTOMATION_TEST(FMemoryTransportTest, "SpeckleUnreal.Transports.MemoryTransport", EAutomationTestFlags::EditorContext | EAutomationTestFlags::SmokeFilter)
-
-
-bool FMemoryTransportTest::RunTest(const FString& Parameters)
-{
-	UMemoryTransport* Transport = UMemoryTransport::CreateEmptyMemoryTransport();
-	// Test Construction
-	{
-		TestNotNull(TEXT("Constructed object"), Transport);
-		TestTrue(TEXT("Constructed object is valid"), IsValid(Transport));
-	}
-	
-	TSharedPtr<FJsonObject> MockObj = MakeShareable(new FJsonObject());
-	FString TestId = TEXT("testidlalalala");
-	FString TestPayloadName = TEXT("Playload");
-	FString TestPayload = TEXT("MyPayloadValue!");
-	MockObj->SetStringField(TestPayloadName, TestPayload);
-	
-	// Test Save
-	{
-		Transport->SaveObject(TestId, MockObj);
-		TestTrue(TEXT("Transport with save object to HasObject"), Transport->HasObject(TestId));
-		
-		auto Value = Transport->GetSpeckleObject(TestId);
-		TestNotNull(TEXT("Return of getting saved object"), Value.Get());
-		TestEqual(TEXT("Return of getting saved object"), Value, MockObj);
-		TestTrue(TEXT("Returned object to have payload"), Value->HasField(TestPayloadName));
-		TestEqual(TEXT("Returned object's playload"), Value->GetStringField(TestPayloadName), TestPayload);
-	}
-
-	// Test Ids are missing
-	{
-		TArray<FString> MissingIds = {
-			TEXT("NoObjectsWithThisId"),
-			TEXT("testidla"),
-			TEXT("testidlalalalaextrala"),
-			TEXT("testidrararara"),
-			TEXT(""),
-		};
-		
-		for(const FString& Id : MissingIds)
-		{
-			TestFalse(TEXT("transport has unknown id -") + Id, Transport->HasObject(Id));
-			auto ValueM = Transport->GetSpeckleObject(Id);
-			TestNull(TEXT("return of unknown id -") + Id, ValueM.Get());
-		}
-	}
-	
-	return true;
-}
-
-
-#endif

Source/SpeckleUnreal/Private/Tests/Transports/ServerTransportTest.cpp

@@ -1,25 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "Misc/AutomationTest.h"
-#include "Objects/Base.h"
-#include "Transports/ServerTransport.h"
-
-
-#if WITH_DEV_AUTOMATION_TESTS
-
-IMPLEMENT_SIMPLE_AUTOMATION_TEST(FServerTransportTest, "SpeckleUnreal.Transports.ServerTransport", EAutomationTestFlags::EditorContext | EAutomationTestFlags::ProductFilter)
-
-
-bool FServerTransportTest::RunTest(const FString& Parameters)
-{
-	FString ServerUrl = TEXT("https://example.com");
-	FString StreamId = TEXT("1234");
-	FString Token = TEXT("MyAuthToken");
-	auto Transport = UServerTransport::CreateServerTransport(ServerUrl, StreamId, Token);
-	
-	
-	return true;
-}
-
-
-#endif

Source/SpeckleUnreal/Private/Transports/FBatchSender.cpp

@@ -1,79 +0,0 @@
-#include "FBatchSender.h"
-
-FBatchSender::FBatchSender(FString& ServerUrl, FString& StreamId, FString& AuthToken, int32 MaxBatchSizeMb,
-	int32 MaxBufferLength, int32 ThreadCount)
-	: ServerUrl(ServerUrl)
-	, StreamId(StreamId)
-	, AuthToken(AuthToken)
-	, MaxBatchSizeMb(MaxBatchSizeMb)
-	, MaxBufferLength(MaxBufferLength)
-	, ThreadCount(ThreadCount)
-{
-	SendingThread = FRunnableThread::Create(this, TEXT("Speckle Transport Send Thread"), 0);
-	ensure(SendingThread != nullptr);
-}
-
-FBatchSender::~FBatchSender()
-{
-	if (SendingThread)
-	{
-		SendingThread->Kill();
-		delete SendingThread;
-		SendingThread = nullptr;
-	}
-}
-
-
-uint32 FBatchSender::Run()
-{
-	while(true)
-	{
-		if(!ShouldSendThreadRun) return 0;
-
-		TArray<TTuple<FString, FString>> Buffer;
-		FScopeLock Lock(&Lock_SendBuffer);
-		if(SendBuffer.Num() > 0)
-		{
-			Buffer.Append(SendBuffer);
-			SendBuffer.Empty();
-		}
-		else
-		{
-			IsWriteComplete = true;
-		}
-
-		if(Buffer.Num() <= 0)
-		{
-			FPlatformProcess::Sleep(0.1);
-			continue;
-		}
-
-		TArray<FString> ObjectIds;
-		ObjectIds.Reserve(Buffer.Num());
-		for(const auto& Item: Buffer)
-		{
-			ObjectIds.Add(Item.Key);
-		}
-
-		//TODO only send objects that aren't already on the server.
-		//TMap<FString, bool> HasObjects = API.HasObjects(StreamId, ObjectIds);
-
-		//TODO api upload
-		//API.UploadObjects(StreamId, Buffer);
-
-
-		
-	}
-}
-
-void FBatchSender::Stop()
-{
-	ShouldSendThreadRun = false;
-}
-
-void FBatchSender::EnqueueSend(const FString& Id, const FString& Object)
-{
-	FScopeLock Lock(&Lock_SendBuffer);
-	SendBuffer.Emplace(Id, Object);
-	IsWriteComplete = false;
-}

Source/SpeckleUnreal/Private/Transports/FBatchSender.h

@@ -1,40 +0,0 @@
-#pragma once
-
-/**
- * 
- */
-class SPECKLEUNREAL_API FBatchSender : public FRunnable
-{
-
-protected:
-
-	FString ServerUrl;
-	FString StreamId;
-	FString AuthToken;
-	int32 MaxBatchSizeMb;
-	int32 MaxBufferLength;
-	int32 ThreadCount;
-
-	bool ShouldSendThreadRun = false;
-	bool IsWriteComplete = false;
-	FRunnableThread* SendingThread;
-	FCriticalSection Lock_SendBuffer;
-	TArray<TTuple<const FString, const FString>> SendBuffer;
-	
-public:
-
-	FBatchSender(FString& ServerUrl, FString& StreamId, FString& AuthToken, int32 MaxBatchSizeMb=1, int32 MaxBufferLength = 10, int32 ThreadCount = 4);
-
-	virtual ~FBatchSender() override;
-	
-	virtual uint32 Run() override;
-	virtual void Stop() override;
-
-
-	virtual void EnqueueSend(const FString& Id, const FString& Object);
-	virtual void Flush();
-
-protected:
-	
-	virtual void SendingThreadMain();
-};

Source/SpeckleUnreal/Private/Transports/MemoryTransport.cpp

@@ -1,19 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Transports/MemoryTransport.h"
-
-bool UMemoryTransport::HasObject(const FString& ObjectId) const
-{
-	return SpeckleObjects.Contains(ObjectId);
-}
-
-TSharedPtr<FJsonObject> UMemoryTransport::GetSpeckleObject(const FString& ObjectId) const
-{
-	return SpeckleObjects.FindRef(ObjectId);
-}
-
-void UMemoryTransport::SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> SerializedObject)
-{
-	SpeckleObjects.Add(ObjectId, SerializedObject);
-}

Source/SpeckleUnreal/Private/Transports/ServerTransport.cpp

@@ -1,264 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Transports/ServerTransport.h"
-
-#include "FBatchSender.h"
-#include "LogSpeckle.h"
-#include "HttpModule.h"
-#include "JsonObjectConverter.h"
-#include "Interfaces/IHttpRequest.h"
-#include "Interfaces/IHttpResponse.h"
-#include "Mixpanel.h"
-#include "Policies/CondensedJsonPrintPolicy.h"
-
-
-
-
-TSharedPtr<FJsonObject> UServerTransport::GetSpeckleObject(const FString& ObjectId) const
-{
-	unimplemented();
-	return nullptr;
-}
-
-void UServerTransport::SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> Object)
-{
-	FString SerializedObject;
-	{
-		auto Writer = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&SerializedObject);
-		FJsonSerializerWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> SerializerWriter(Writer);
-		FJsonSerializer::Serialize(Object.ToSharedRef(), Writer);
-	}
-
-	BatchSender.EnqueueSend(ObjectId, SerializedObject);
-}
-
-void UServerTransport::BeginWrite()
-{
-	
-}
-
-void UServerTransport::EndWrite()
-{
-	BatchSender.Flush();
-}
-
-bool UServerTransport::HasObject(const FString& ObjectId) const
-{
-	unimplemented();
-	return false;
-}
-
-void UServerTransport::CopyObjectAndChildren(const FString& ObjectId,
-											 TScriptInterface<ITransport> TargetTransport,
-											 const FTransportCopyObjectCompleteDelegate& OnCompleteAction,
-											 const FTransportErrorDelegate& OnErrorAction)
-{
-	this->OnComplete = OnCompleteAction;
-	this->OnError = OnErrorAction;
-	
-	// Create Request for Root Object
-	const FHttpRequestRef Request = FHttpModule::Get().CreateRequest();
-	const FString Endpoint = FString::Printf(TEXT("%s/objects/%s/%s/single"), *ServerUrl, *StreamId, *ObjectId);
-	Request->SetVerb("GET");
-	Request->SetURL(Endpoint);
-	Request->SetHeader("Accept", TEXT("text/plain"));
-	Request->SetHeader("Authorization", "Bearer " + AuthToken);
-	
-	
-	// Response Callback
-	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
-	{
-		if(!bWasSuccessful)
-		{
-			FString Message = FString::Printf(TEXT("Request for root object at %s was unsuccessful: %s"), *Response->GetURL(), *Response->GetContentAsString());
-			InvokeOnError(Message);
-			return;
-		}
-		
-		const int32 ResponseCode = Response->GetResponseCode();
-		if (ResponseCode != 200)
-		{
-			FString Message = FString::Printf(TEXT("Request for root object at %s failed with HTTP response %d"), *Response->GetURL(), ResponseCode);
-			InvokeOnError(Message);
-			return;
-		}
-
-		HandleRootObjectResponse(Response->GetContentAsString(), TargetTransport, ObjectId);
-
-	};
-	
-	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
-	
-	// Send request
-	const bool RequestSent = Request->ProcessRequest();
-
-	if(!RequestSent)
-	{
-		FString Message = FString::Printf(TEXT("Request for root object at %s failed: \nHTTP request failed to start"), *Endpoint);
-		InvokeOnError(Message);
-		return;
-	}
-	UE_LOG(LogSpeckle, Verbose, TEXT("GET Request sent for root object at %s, awaiting response"), *Endpoint );
-	FAnalytics::TrackEvent("unknown", ServerUrl, "Receive");
-}
-
-
-
-
-void UServerTransport::FetchChildren(TScriptInterface<ITransport> TargetTransport, const FString& ObjectId, const TArray<FString>& ChildrenIds, int32 CStart) const
-{
-	// Check if all children have been fetched
-	if(ChildrenIds.Num() <= CStart)
-	{
-		ensureAlwaysMsgf(this->OnComplete.ExecuteIfBound(TargetTransport->GetSpeckleObject(ObjectId)), TEXT("Complete handler was not bound properly"));
-		return;
-	}
-	
-	// Assemble list of ids to ask for in this request
-	// We want to avoid making requests too large
-	const int32 CEnd = FGenericPlatformMath::Min(ChildrenIds.Num(), CStart + MaxNumberOfObjectsPerRequest);
-	FString ChildrenIdsString;
-	{
-		auto Writer = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&ChildrenIdsString);
-		Writer->WriteArrayStart();
-		for (int32 i = CStart; i < CEnd; i++)
-		{
-			Writer->WriteValue(ChildrenIds[i]);
-		}
-		Writer->WriteArrayEnd();
-		Writer->Close();
-	}
-
-	FString Body;
-	{
-		auto Writer = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&Body);
-		Writer->WriteObjectStart();
-		Writer->WriteValue(TEXT("objects"), ChildrenIdsString);
-		Writer->WriteObjectEnd();
-		Writer->Close();
-	}
-	
-	// Create Request
-	const FHttpRequestRef Request = FHttpModule::Get().CreateRequest();
-	{
-		const FString EndPoint = FString::Printf(TEXT("%s/api/getobjects/%s"), *ServerUrl, *StreamId);
-		Request->SetVerb("POST");
-		Request->SetURL(EndPoint);
-		Request->SetHeader("Accept", TEXT("text/plain"));
-		Request->SetHeader("Authorization", "Bearer " + AuthToken);
-		Request->SetHeader("Content-Type", "application/json");
-		Request->SetContentAsString(Body);
-	}
-	
-	// Response Callback
-	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
-	{
-		if(!bWasSuccessful)
-		{
-			FString Message = FString::Printf(TEXT("Request for children of root object %s/%s failed: %s"), *StreamId,  *ObjectId, *Response->GetContentAsString());
-			InvokeOnError(Message);
-			return;
-		}
-		
-		const int32 ResponseCode = Response->GetResponseCode();
-		if (ResponseCode != 200)
-		{
-			FString Message = FString::Printf(TEXT("Request for children of root object %s/%s failed:\nHTTP response %d"), *StreamId,  *ObjectId, ResponseCode);
-			InvokeOnError(Message);
-			return;
-		}
-
-		TArray<FString> Lines;
-		const int32 LineCount = SplitLines(Response->GetContentAsString(), Lines);
-		
-		UE_LOG(LogSpeckle, Verbose, TEXT("Parsing %d downloaded objects..."), LineCount)
-		if(LineCount != CEnd - CStart)
-		{
-			UE_LOG(LogSpeckle, Warning, TEXT("Requested %d objects, but recieved %d"), CEnd - CStart, LineCount);
-		}
-		
-		for (const FString& Line : Lines)
-		{
-			FString Id, ObjectJson;
-			if (!Line.Split("\t", &Id, &ObjectJson))
-				continue;
-			
-			TSharedPtr<FJsonObject> JsonObject;
-			if(!LoadJson(ObjectJson, JsonObject)) continue;
-
-
-			TargetTransport->SaveObject(Id, JsonObject);
-		}
-
-		UE_LOG(LogSpeckle, Log, TEXT("Processed %d/%d Child objects"), CEnd, ChildrenIds.Num())
-		
-		//Iterate again for any missing children
-		FetchChildren(TargetTransport, ObjectId, ChildrenIds , CEnd);
-	};
-	
-	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
-	
-	// Send request for children
-	const bool RequestSent = Request->ProcessRequest();
-
-	if(!RequestSent)
-	{
-		FString Message = FString::Printf(TEXT("Failed to fetch children of root object %s/%s:\nHTTP request failed to start"), *StreamId, *ObjectId);
-		InvokeOnError(Message);
-		return;
-	}
-	
-	UE_LOG(LogSpeckle, Verbose, TEXT("Requesting %d child objects"), CEnd - CStart);
-}
-
-void UServerTransport::HandleRootObjectResponse(const FString& RootObjSerialized, TScriptInterface<ITransport> TargetTransport, const FString& ObjectId) const
-{
-	TSharedPtr<FJsonObject> RootObj;
-	if(!LoadJson(RootObjSerialized, RootObj))
-	{
-		FString Message = FString::Printf( TEXT("A Root Object %s was recieved but was invalid and could not be deserialied"), *ObjectId);
-		InvokeOnError(Message);
-		return;
-	}
-	
-	TargetTransport->SaveObject(ObjectId, RootObj);	
-	
-	// Find children are not already in the target transport
-	const auto Closures = RootObj->GetObjectField("__closure")->Values;
-	
-	TArray<FString> ChildrenIds; 
-	Closures.GetKeys(ChildrenIds);
-	TArray<FString> NewChildrenIds;
-	for(const FString& Id : ChildrenIds)
-	{
-		if(TargetTransport->HasObject(Id)) continue;
-		
-		NewChildrenIds.Add(Id);
-	}
-	
-	FetchChildren(TargetTransport, ObjectId, NewChildrenIds);	
-}
-
-int32 UServerTransport::SplitLines(const FString& Content, TArray<FString>& OutLines)
-{
-	int32 LineCount = 0;
-	for (const TCHAR* ptr = *Content; *ptr; ptr++)
-		if (*ptr == '\n')
-			LineCount++;
-	OutLines.Reserve(LineCount);
-	Content.ParseIntoArray(OutLines, TEXT("\n"), true);
-	return LineCount;
-}
-
-bool UServerTransport::LoadJson(const FString& ObjectJson, TSharedPtr<FJsonObject>& OutJsonObject)
-{
-	TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(ObjectJson);
-	return FJsonSerializer::Deserialize(Reader, OutJsonObject);
-}
-
-void UServerTransport::InvokeOnError(FString& Message) const
-{
-	ensureAlwaysMsgf(this->OnError.ExecuteIfBound(Message), TEXT("ServerTransport: Unhandled error - %s"), *Message);
-}
-

Source/SpeckleUnreal/Public/API/Client.h

@@ -1,29 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-//#pragma once
-
-
-//#include "CoreMinimal.h"
-
-//#include "Client.generated.h"
-//
-// /**
-//  * 
-//  */
-// UCLASS()
-// class SPECKLEUNREAL_API UClient : public UClass
-// {
-// 	GENERATED_BODY()
-// 	
-// public:
-//
-// 	static int DefaultBranchLimit = 10;
-// 	
-// 	//UFUNCTION(BlueprintCallable, Category="Speckle")
-// 	//void GetAccounts();
-// 	
-// 	//UFUNCTION(BlueprintCallable, Category="Speckle")
-//     //Branch StreamGetBranches(FString StreamID, int BranchesLimit = DefaultBranchLimit, int CommitLimit = DefaultBranchLimit);
-// 	
-//  
-// };

Source/SpeckleUnreal/Public/API/Operations/ReceiveOperation.h

@@ -1,58 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintAsyncActionBase.h"
-
-#include "ReceiveOperation.generated.h"
-
-class ITransport;
-class UBase;
-class FJsonObject;
-
-DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FRecieveOperationHandler, UBase*, RootBase, FString, ErrorMessage);
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UReceiveOperation : public UBlueprintAsyncActionBase
-{
-	GENERATED_BODY()
-	
-public:
-	
-    UPROPERTY(BlueprintAssignable)
-    FRecieveOperationHandler OnReceiveSuccessfully;
-
-	/// Called when the total number of children is known
-    //UPROPERTY(BlueprintAssignable)
-    //FRecieveOperationHandler OnChildrenCountKnown;
-
-	/// Called when some deserilization progress is made and TotalConverted has changed
-    //UPROPERTY(BlueprintAssignable)
-    //FRecieveOperationHandler OnProgress;
-
-	/// Called when receive operation has aborted due to some error
-    UPROPERTY(BlueprintAssignable)
-    FRecieveOperationHandler OnError;
-
-	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations", meta = (WorldContext = "WorldContextObject"))
-	static UReceiveOperation* ReceiveOperation(UObject* WorldContextObject, const FString& ObjectId, TScriptInterface<ITransport> RemoteTransport, TScriptInterface<ITransport> LocalTransport);
-
-
-	virtual void Activate() override;
-
-	
-protected:
-	void Receive();
-	
-	FString ObjectId;
-	TScriptInterface<ITransport> RemoteTransport;
-	TScriptInterface<ITransport> LocalTransport;
-
-	void HandleReceive(TSharedPtr<FJsonObject> Object);
-	
-	void HandleError(FString& Message);
-};

Source/SpeckleUnreal/Public/API/Operations/SendOperation.h

@@ -1,48 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
- #pragma once
-
- #include "CoreMinimal.h"
- #include "Kismet/BlueprintAsyncActionBase.h"
-
- #include "SendOperation.generated.h"
-
-
- class ITransport;
- class UBase;
-
- DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FSendOperationHandler, const FString&, Id, const FString&, ErrorMessage);
-
- /**
-  * 
-  */
- UCLASS()
- class SPECKLEUNREAL_API USendOperation : public UBlueprintAsyncActionBase
- {
- 	GENERATED_BODY()
- 	
- public:
- 	
- 	UPROPERTY(BlueprintAssignable)
- 	FSendOperationHandler OnSendSuccessfully;
- 	
- 	
- 	UPROPERTY(BlueprintAssignable)
- 	FSendOperationHandler OnErrorAction;
-
-
- 	UFUNCTION(BlueprintCallable, Category = "Speckle|Operations", meta = (WorldContext = "WorldContextObject"))
- 	static USendOperation* SendOperation(UObject* WorldContextObject, UBase* Base, TArray<TScriptInterface<ITransport>> Transports);
- 	
- 	virtual void Activate() override;
-    void Send();
-
-protected:
-
- 	
- 	TWeakObjectPtr<UBase> Base;
- 	
- 	TArray<TScriptInterface<ITransport>> Transports;
-
- 	
- };

Source/SpeckleUnreal/Public/API/SpeckleSerializer.h

@@ -1,26 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintFunctionLibrary.h"
-
-#include "SpeckleSerializer.generated.h"
-
-class UBase;
-class ITransport;
-class FJsonObject;
-
-UCLASS()
-class USpeckleSerializer : public UBlueprintFunctionLibrary
-{
-	GENERATED_BODY()
-public:
-
-	UFUNCTION(BlueprintPure, Category="Speckle|Serialization")
-	static UBase* DeserializeBaseById(const FString& ObjectId, const TScriptInterface<ITransport> ReadTransport);
-
-	static UBase* DeserializeBase(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport);
-
-
-};

Source/SpeckleUnreal/Public/Conversion/Converters/AggregateConverter.h

@@ -1,59 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "UObject/Object.h"
-#include "Conversion/SpeckleConverter.h"
-
-#include "AggregateConverter.generated.h"
-
-/**
- *  An Aggregate Converter stores multiple ISpeckleConverter instances.
- *  This allows you to use many converters as one
- */
-UCLASS()
-
-class SPECKLEUNREAL_API UAggregateConverter : public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-
-protected:
-	
-	// A lazily initialised mapping of SpeckleType -> converters.
-	TMap<TSubclassOf<UBase>, TScriptInterface<ISpeckleConverter>> SpeckleTypeMap;
-
-public:
-	
-	// Array of converters, must be of type ISpeckleConverter
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle|Conversion")
-	TArray<UObject*> SpeckleConverters;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
-	virtual UObject* ConvertToNativeInternal(const UBase* Object, UWorld* World);
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>&) override;
-
-	virtual bool CanConvertToNative_Implementation(TSubclassOf<UBase> BaseType) override;
-
-	
-	virtual void ConvertToSpeckle_Implementation(const UObject* Object, UBase* SpeckleObject) override;
-
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
-	virtual TScriptInterface<ISpeckleConverter> GetConverter(const TSubclassOf<UBase> BaseType);
-
-	// Validates a given object is a valid ISpeckleConverter
-	static bool CheckValidConverter(const UObject* Converter, bool LogWarning = true);
-
-	void FinishConversion_Internal();
-	virtual void FinishConversion_Implementation() override;
-
-	// Validates changes to SpeckleConverters property, Should be called after modifying SpeckleConverters
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
-	virtual void OnConvertersChangeHandler();
-	
-#if WITH_EDITOR
-	virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
-#endif
-	
-};

Source/SpeckleUnreal/Public/Conversion/Converters/BlockConverter.h

@@ -1,44 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "UObject/Object.h"
-#include "Conversion/SpeckleConverter.h"
-#include "Engine/EngineTypes.h"
-#include "Engine/World.h"
-
-#include "BlockConverter.generated.h"
-
-class UBlockInstance;
-
-/**
- *  Converts Speckle Block Instance objects empty native actors with transform.
- *  The Block Definition can then be converted by other converters
- */
-UCLASS()
-class SPECKLEUNREAL_API UBlockConverter : public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-	
-	CONVERTS_SPECKLE_TYPES()
-public:
-
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TSubclassOf<AActor> BlockInstanceActorType;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TEnumAsByte<EComponentMobility::Type> ActorMobility;
-	
-	UBlockConverter();
-	
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>& AvailableConverters) override;
-	virtual UBase* ConvertToSpeckle_Implementation(const UObject* Object) override;
-
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual AActor* BlockToNative(const UBlockInstance* Block, UWorld* World);
-	
-protected:
-	virtual AActor* CreateEmptyActor(UWorld* World, const FTransform& Transform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());
-};

Source/SpeckleUnreal/Public/Conversion/Converters/MaterialConverter.h

@@ -1,99 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Conversion/SpeckleConverter.h"
-#include "UObject/Object.h"
-
-#include "MaterialConverter.generated.h"
-
-class URenderMaterial;
-class UMaterialInterface;
-
-UENUM()
-enum EConstMaterialOptions
-{
-	  Never UMETA(DisplayName = "Never"),
-	  NotPlay UMETA(DisplayName = "Editor Not Playing"),
-	  Always UMETA(DisplayName = "Editor And PIE"),
-};
-
-
-/**
- *  Converts Speckle RenderMaterial objects into native Materials
- */
-UCLASS(BlueprintType, Blueprintable)
-class SPECKLEUNREAL_API UMaterialConverter : public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-
-	CONVERTS_SPECKLE_TYPES()
-	
-public:
-
-	/// Material to be applied to meshes when no RenderMaterial can be converted
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	UMaterialInterface* DefaultMeshMaterial;
-
-	/// Material Parent for converted opaque materials*/
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	UMaterialInterface* BaseMeshOpaqueMaterial;
-
-	/// Material Parent for converted materials with an opacity less than one
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	UMaterialInterface* BaseMeshTransparentMaterial;
-
-#if WITH_EDITORONLY_DATA
-	/// Specify when to create Constant materials that can only be created with Editor.
-	/// Otherwise will create dynamic materials
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TEnumAsByte<EConstMaterialOptions> UseConstMaterials;
-#endif
-	
-	/// When generating meshes, materials in this TMap will be used
-	/// instead of converted ones if the key matches the ID of the Object's RenderMaterial. (Takes priority over name matching)
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ToNative|Overrides", DisplayName = "By Speckle ID")
-	TMap<FString, UMaterialInterface*> MaterialOverridesById;
-
-	/// When generating meshes, materials in this TSet will be used instead of converted ones if the material name matches the name of the Object's RenderMaterial
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ToNative|Overrides", DisplayName = "By Name")
-	TSet<UMaterialInterface*> MaterialOverridesByName;
-
-public:
-
-	UMaterialConverter();
-	
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld*, TScriptInterface<ISpeckleConverter>&) override;
-
-	UFUNCTION(BlueprintCallable, Category="ToNative|Overrides")
-	virtual bool TryGetOverride(const URenderMaterial* SpeckleMaterial, UMaterialInterface*& OutMaterial) const;
-
-	
-
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UMaterialInterface* GetMaterial(const URenderMaterial* SpeckleMaterial);
-	
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UMaterialInterface* RenderMaterialToNative(const URenderMaterial* SpeckleMaterial, UPackage* Package);
-	
-	virtual void FinishConversion_Implementation() override;
-	
-protected:
-	
-	/** Transient cache of materials converted from stream RenderMaterial objects */
-	UPROPERTY(AdvancedDisplay, BlueprintReadOnly, Transient, Category="ToNative|Cache")
-	TMap<FString, UMaterialInterface*> ConvertedMaterials;
-	
-	UFUNCTION(BlueprintCallable, BlueprintPure, Category="ToNative")
-	virtual UPackage* GetPackage(const FString& ObjectID) const;
-	
-	UFUNCTION(BlueprintCallable, BlueprintPure, Category="ToNative")
-	virtual FString RemoveInvalidFileChars(const FString& InString) const;
-
-#if WITH_EDITOR
-	UFUNCTION(BlueprintCallable, BlueprintPure, Category="ToNative")
-	static bool ShouldCreateConstMaterial(TEnumAsByte<EConstMaterialOptions> Options);
-#endif
-	
-};

Source/SpeckleUnreal/Public/Conversion/Converters/PointCloudConverter.h

@@ -1,48 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Conversion/SpeckleConverter.h"
-#include "Engine/EngineTypes.h"
-
-#include "PointCloudConverter.generated.h"
-
-class ULidarPointCloudComponent;
-class ALidarPointCloudActor;
-class ULidarPointCloud;
-class UPointCloud;
-
-/**
- * Converts Speckle Point Cloud objects into LidarPointClouds
- */
-UCLASS()
-class SPECKLEUNREAL_API UPointCloudConverter :  public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-	
-	CONVERTS_SPECKLE_TYPES()
-	
-	
-public:
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TSubclassOf<ALidarPointCloudActor> PointCloudActorType;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TEnumAsByte<EComponentMobility::Type> ActorMobility;
-	
-	UPointCloudConverter();
-	
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>&) override;
-	virtual UBase* ConvertToSpeckle_Implementation(const UObject* Object) override;
-
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual ALidarPointCloudActor* PointCloudToNative(const UPointCloud* SpecklePointCloud, UWorld* World);
-	
-	UFUNCTION(BlueprintCallable, Category="ToSpeckle")
-	virtual UPointCloud* PointCloudToSpeckle(const ULidarPointCloudComponent* Object);
-
-protected:
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual ALidarPointCloudActor* CreateActor(UWorld* World, ULidarPointCloud* PointCloudData);
-};

Source/SpeckleUnreal/Public/Conversion/Converters/ProceduralMeshConverter.h

@@ -1,55 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Conversion/SpeckleConverter.h"
-#include "Engine/EngineTypes.h"
-#include "Engine/World.h"
-
-#include "ProceduralMeshConverter.generated.h"
-
-class UMaterialConverter;
-class UProceduralMeshComponent;
-class UMesh;
-class URenderMaterial;
-
-
-/**
- * Converts Speckle Mesh objects into native actors with a procedural mesh component.
- * 
- * Compared with the StaticMeshConverter, this converter has some serious limitations
- * - Cannot convert displayValues,
- * - N-gon faces will be ignored,
- * - Meshes are transient, and won't persist on level reload
- */
-UCLASS()
-class SPECKLEUNREAL_API UProceduralMeshConverter :  public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-
-	CONVERTS_SPECKLE_TYPES()
-	
-public:
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TSubclassOf<AActor> MeshActorType;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TEnumAsByte<EComponentMobility::Type> ActorMobility;
-	
-	// Sets default values for this actor's properties
-	UProceduralMeshConverter();
-	
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>& AvailableConverters) override;
-	virtual UBase* ConvertToSpeckle_Implementation(const UObject* Object) override;
-	
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual AActor* MeshToNative(const UMesh* SpeckleMesh, UWorld* World, TScriptInterface<ISpeckleConverter>& MaterialConverter);
-	
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UMesh* MeshToSpeckle(const UProceduralMeshComponent* Object);
-	
-	virtual AActor* CreateEmptyActor(UWorld* World, const FTransform& Transform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());
-	
-};

Source/SpeckleUnreal/Public/Conversion/Converters/StaticMeshConverter.h

@@ -1,115 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Conversion/SpeckleConverter.h"
-#include "Engine/EngineTypes.h"
-#include "Engine/World.h"
-#include "Engine/StaticMesh.h"
-
-#include "StaticMeshConverter.generated.h"
-
-class UMaterialConverter;
-class AStaticMeshActor;
-class UMesh;
-class URenderMaterial;
-
-
-/**
- * Converts Speckle Mesh objects into native Actors with a StaticMesh component
- *
- * Can convert multiple Speckle Mesh objects (eg with different materials) in one StaticMesh  
- */
-UCLASS()
-class SPECKLEUNREAL_API UStaticMeshConverter : public UObject, public ISpeckleConverter
-{
-	GENERATED_BODY()
-
-	CONVERTS_SPECKLE_TYPES()
-
-public:
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TSubclassOf<AActor> MeshActorType;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	TEnumAsByte<EComponentMobility::Type> ActorMobility;
-
-#if WITH_EDITORONLY_DATA
-	// If true, will use the full Editor Only build process
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	bool UseFullBuild;
-
-	// When true, will display FSlowTask progress of editor only build process
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative|EditorOnly")
-	bool DisplayBuildProgressBar;
-
-	// When true, will allow cancellation of FSlowTask progress of editor only build process
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative|EditorOnly")
-	bool AllowCancelBuild;
-#endif
-	
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	bool BuildSimpleCollision;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="ToNative")
-	bool Transient;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative")
-	bool GenerateLightmapUV;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative")
-	int32 MinLightmapResolution;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative")
-	bool BuildReversedIndexBuffer;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative")
-    bool UseFullPrecisionUVs;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category="ToNative")
-	bool RemoveDegeneratesOnBuild;
-public:
-	// Sets default values for this actor's properties
-	UStaticMeshConverter();
-	
-	virtual UObject* ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World, TScriptInterface<ISpeckleConverter>& AvailableConverters) override;
-	virtual void ConvertToSpeckle_Implementation(const UObject* Object, UBase* SpeckleObject) override;
-	virtual void FinishConversion_Implementation() override;
-	
-	// Converts a multiple Speckle Meshes to a native actor of type MeshActorType
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual AActor* MeshesToNativeActor(const UBase* Parent, const TArray<UMesh*>& SpeckleMeshes, UWorld* World, TScriptInterface<ISpeckleConverter>& RenderMaterialConverter);
-
-	// Converts a single Speckle Mesh to a native actor of type MeshActorType
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual AActor* MeshToNativeActor(const UMesh* SpeckleMesh, UWorld* World, TScriptInterface<ISpeckleConverter>& MaterialConverter);
-	
-	virtual AActor* CreateEmptyActor(UWorld* World, const FTransform& Transform = FTransform::Identity, const FActorSpawnParameters& SpawnParameters =
-		                                 FActorSpawnParameters());
-	
-	UFUNCTION(BlueprintCallable, Category="ToSpeckle")
-	virtual TArray<UMesh*> MeshToSpeckle(const UStaticMeshComponent* Object);
-
-	
-protected:
-
-	FCriticalSection Lock_StaticMeshesToBuild;
-	
-	UPROPERTY(BlueprintReadWrite, Transient, Category="ToNative")
-	TArray<UStaticMesh*> StaticMeshesToBuild;
-	
-	virtual void GenerateMeshParams(UStaticMesh::FBuildMeshDescriptionsParams& MeshParams) const;
-	
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UMaterialInterface* GetMaterial(const URenderMaterial* SpeckleMaterial, UWorld* World,
-	                                        TScriptInterface<ISpeckleConverter>& MaterialConverter) const;
-	
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UStaticMesh* MeshesToNativeMesh(UObject* Outer, const UBase* Parent, const TArray<UMesh*>& SpeckleMeshes, TScriptInterface<ISpeckleConverter>
-	                                        & MaterialConverter);
-	UFUNCTION(BlueprintCallable, Category="ToNative")
-	virtual UStaticMesh* MeshToNativeMesh(UObject* Outer, const UMesh* SpeckleMesh, TScriptInterface<ISpeckleConverter>& MaterialConverter);
-};

Source/SpeckleUnreal/Public/Conversion/SpeckleConverter.h

@@ -1,62 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-#include "UObject/Interface.h"
-#include "Templates/SubclassOf.h"
-
-#include "SpeckleConverter.generated.h"
-
-
-UINTERFACE()
-class SPECKLEUNREAL_API USpeckleConverter : public UInterface
-{
-	GENERATED_BODY()
-};
-
-/**
- *  Interface for conversion functions (ToSpeckle and ToNative) of a specific speckle type(s).
- *
- *  Implementors of this interface provide conversion functions of specific types : Base
- */
-class SPECKLEUNREAL_API ISpeckleConverter
-{
-	GENERATED_BODY()
-
-public:
-	/// Will return true if this converter can convert a given BaseType
-	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="ToNative")
-	bool CanConvertToNative(TSubclassOf<UBase> BaseType);
-	
-	/// Tries to convert a given SpeckleBase into a native Actor
-	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="ToNative")
-	UObject* ConvertToNative(const UBase* SpeckleBase, UWorld* World, UPARAM(ref) TScriptInterface<ISpeckleConverter>& AvailableConverters);
-
-	/// Clean up cached resources, and finish any pending build tasks to complete ToNative conversion.
-	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="ToNative")
-	void FinishConversion();
-
-	
-	/// Will return true if this converter can convert a given 
-	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="ToSpeckle")
-	void CanConvertToSpeckle(const AActor* Actor);
-	
-	/// Tries to convert a given Actor or Component into a Speckle Base
-	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="ToSpeckle")
-	void ConvertToSpeckle(const UObject* Object, UBase* SpeckleObject);
-
-
-
-	
-	
-};
-
-#define CONVERTS_SPECKLE_TYPES() \
-protected: \
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Conversion") \
-	TSet<TSubclassOf<UBase>> SpeckleTypes; \
-public: \
-	virtual bool CanConvertToNative_Implementation(TSubclassOf<UBase> BaseType) override { return SpeckleTypes.Contains(BaseType); } \
-private:

Source/SpeckleUnreal/Public/Conversion/SpeckleConverterComponent.h

@@ -1,62 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Components/ActorComponent.h"
-
-#include "SpeckleConverterComponent.generated.h"
-
-DECLARE_DYNAMIC_DELEGATE_TwoParams(FActorPredicate, const AActor*, Actor, bool&, OutShouldConvert); 
-
-class ITransport;
-class ISpeckleConverter;
-class UBase;
-class UAggregateConverter;
-struct FSlowTask;
-
-/**
- * An Actor Component for encapsulating recursive conversion of Speckle Objects
- */
-UCLASS(ClassGroup=(Speckle), meta=(BlueprintSpawnableComponent))
-class SPECKLEUNREAL_API USpeckleConverterComponent : public UActorComponent
-{
-	GENERATED_BODY()
-
-public:
-	
-	// Array of converters
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle|Conversion")
-	UAggregateConverter* SpeckleConverter;
-	
-	// Sets default values for this component's properties
-	USpeckleConverterComponent();
-	
-	// Converts the given Base and all children into native actors.
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion|ToNative")
-	UPARAM(DisplayName = "RootActor") AActor* RecursivelyConvertToNative(AActor* AOwner, const UBase* Base, const TScriptInterface<ITransport>& LocalTransport, bool DisplayProgressBar, TArray<AActor*>& OutActors);
-
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion|ToNative")
-	virtual void FinishConversion();
-
-	// Converts the given Base and all children into native actors.
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion|ToSpeckle")
-	virtual UBase* RecursivelyConvertToSpeckle(const TArray<AActor*>& RootActors, FActorPredicate& Predicate);
-
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion|ToSpeckle")
-	virtual void RecurseTreeToSpeckle(const AActor* RootActor, FActorPredicate& Predicate, TArray<UBase*>& OutConverted);
-	
-	
-
-protected:
-
-	virtual AActor* RecursivelyConvertToNative_Internal(AActor* AOwner, const UBase* Base, const TScriptInterface<ITransport>& LocalTransport, FSlowTask* Task, TArray<AActor*>& OutActors);
-
-	
-	virtual void ConvertChild(const TSharedPtr<FJsonValue> Object, AActor* AOwner, const TScriptInterface<ITransport>& LocalTransport, FSlowTask* Task, TArray<AActor*>& OutActors);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
-	virtual void AttachConvertedToOwner(AActor* AOwner, const UBase* Base, UObject* Converted);
-};
-
-

Source/SpeckleUnreal/Public/LogSpeckle.h

@@ -1,6 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-#include "CoreMinimal.h"
-
-DECLARE_LOG_CATEGORY_EXTERN(LogSpeckle, Log, All);

Source/SpeckleUnreal/Public/Mixpanel.h

@@ -1,20 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-
-///  Anonymous telemetry to help us understand how to make a better Speckle.
-///  This really helps us to deliver a better open source project and product!
-class FAnalytics
-{
-protected:
-	static const FString MixpanelToken;
-	static const FString MixpanelServer;
-	static const FString VersionedApplicationName;
-
-public:
-	static void TrackEvent(const FString& Email, const FString& Server, const FString& EventName);
-	static void TrackEvent(const FString& Email, const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties);
-	static FString Hash(const FString& Input);
-};

Source/SpeckleUnreal/Public/Objects/Base.h

@@ -1,78 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "DynamicBase.h"
-#include "Dom/JsonObject.h"
-
-#include "Base.generated.h"
-
-class ITransport;
-class ASpeckleUnrealManager;
-
-/**
- * Base type that all Object Models inherit from
- */
-UCLASS(BlueprintType, meta=(ScriptName="Base (Speckle.Objects)"))
-class SPECKLEUNREAL_API UBase : public UDynamicBase
-{
-public:
-
-	GENERATED_BODY()
-	
-protected:
-	
-	explicit UBase(const TCHAR* SpeckleType): SpeckleType(FString(SpeckleType)) {}
-	explicit UBase(const FString& SpeckleType) : SpeckleType(SpeckleType) {}
-	
-public:
-
-	UBase() : SpeckleType("Base") {}
-
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category="Speckle|Objects")
-	FString Id;
-	
-	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category="Speckle|Objects")
-	FString Units;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category="Speckle|Objects")
-	FString SpeckleType;
-	
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
-	{
-		bool IsValid = false;
-		DynamicProperties.Reserve(Obj->Values.Num());
-		for(const auto kvp : Obj->Values)
-		{
-			SetDynamicProperty(kvp.Key, kvp.Value->Type);
-		}
-
-		if(Obj->TryGetStringField("id", Id))
-		{
-			IsValid = true;
-			DynamicProperties.Remove("id");
-		}
-		
-		if(Obj->TryGetStringField("units", Units)) DynamicProperties.Remove("units");
-		if(Obj->TryGetStringField("speckle_type", SpeckleType)) DynamicProperties.Remove("speckle_type");
-
-		return IsValid;
-	}
-
-
-	virtual void ToJson(TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> Writer)
-	{
-		Writer.WriteValue(TEXT("units"), Units);
-		Writer.WriteValue(TEXT("speckle_type"), SpeckleType);
-
-		for(const auto& p : DynamicProperties)
-		{
-			//Writer.WriteValue(p.Key, p.Value.mmmmmm));
-		}
-	}
-	
-
-
-};

Source/SpeckleUnreal/Public/Objects/DisplayValueElement.h

@@ -1,32 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Base.h"
-
-#include "DisplayValueElement.generated.h"
-
-
-class UMesh;
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UDisplayValueElement : public UBase
-{
-	GENERATED_BODY()
-protected:
-	static TArray<FString> DisplayValueAliasStrings;
-	bool AddDisplayValue(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport);
-	
-public:
-	
-	UDisplayValueElement() : UBase(TEXT("Objects.BuiltElements")) {}
-	
-    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-    TArray<UMesh*> DisplayValue;
-	
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
-};

Source/SpeckleUnreal/Public/Objects/DynamicBase.h

@@ -1,66 +0,0 @@
-// Copyright AEC Systems Ltd
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "UObject/Object.h"
-#include "DynamicBase.generated.h"
-
-
-
-class UBase;
-/**
- * 
- */
-UCLASS(Abstract)
-class SPECKLEUNREAL_API UDynamicBase : public UObject
-{
-	GENERATED_BODY()
-
-protected:
-	
-	TMap<FString, TSharedPtr<FVariant>> DynamicProperties;
-
-public:
-	
-	template <typename T>
-	bool TryGetDynamicProperty(const FString& Key, T& OutValue) const;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	bool TryGetDynamicStringProperty(UPARAM(ref) const FString& Key, FString& OutValue) const;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	bool TryGetDynamicIntProperty(UPARAM(ref) const FString& Key, int32& OutValue) const;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	bool TryGetDynamicFloatProperty(UPARAM(ref) const FString& Key, float& OutValue) const;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	bool TryGetDynamicBoolProperty(UPARAM(ref) const FString& Key, bool& OutValue) const;
-
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	bool TryGetDynamicBaseProperty(UPARAM(ref) const FString& Key, UBase*& OutValue) const;
-
-	
-	template <typename T>
-	void SetDynamicProperty(const FString& Key, T Value);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	void SetDynamicStringProperty(UPARAM(ref) const FString& Key, FString& OutValue);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	void SetDynamicIntProperty(UPARAM(ref) const FString& Key, int32& OutValue);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	void SetDynamicFloatProperty(UPARAM(ref) const FString& Key, float& OutValue);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	void SetDynamicBoolProperty(UPARAM(ref) const FString& Key, bool& OutValue);
-
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	void SetDynamicBaseProperty(UPARAM(ref) const FString& Key, UBase*& OutValue);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	int32 RemoveDynamicProperty(UPARAM(ref) const FString& Key);
-
-};

Source/SpeckleUnreal/Public/Objects/Geometry/Mesh.h

@@ -1,48 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-
-#include "Mesh.generated.h"
-
-class URenderMaterial;
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UMesh : public UBase
-{
-	GENERATED_BODY()
-	
-public:
-
-	UMesh() : UBase(TEXT("Objects.Geometry.Mesh")) {}
-	
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<FVector> Vertices;
-	
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<int32> Faces;
-	
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<FVector2D> TextureCoordinates;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<FColor> VertexColors;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	FMatrix Transform;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	URenderMaterial* RenderMaterial;
-	
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
-
-	virtual void ToJson(TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> Writer) override;
-
-protected:
-	virtual void AlignVerticesWithTexCoordsByIndex();
-};

Source/SpeckleUnreal/Public/Objects/Geometry/PointCloud.h

@@ -1,32 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-
-#include "PointCloud.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UPointCloud : public UBase
-{
-	GENERATED_BODY()
-
-public:
-
-	UPointCloud() : UBase(TEXT("Objects.Geometry.Pointcloud")) {}
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<FVector> Points;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<FColor> Colors;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<float> Sizes;
-
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
-};

Source/SpeckleUnreal/Public/Objects/ObjectModelRegistry.h

@@ -1,52 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintFunctionLibrary.h"
-#include "Templates/SubclassOf.h"
-
-#include "ObjectModelRegistry.generated.h"
-
-class UBase;
-
-/**
- * Handles the mapping of Speckle type to Object Model 
- */
-UCLASS()
-class SPECKLEUNREAL_API UObjectModelRegistry : public UBlueprintFunctionLibrary
-{
-	GENERATED_BODY()
-	
-private:
-
-	static TMap<FString, TSubclassOf<UBase>> TypeRegistry;
-
-	static void GenerateTypeRegistry();
-
-
-public:
-
-	/// Attempts to find the closest registered TSubclassOf<UBase>
-	/// by recursively stripping away a the most specific name specifier from the given SpeckleType
-	/// until a UBase type is found or the FString is exhausted.
-	///  
-	/// Eg. with an input of "Objects.Elements.Wall"
-	/// Will first look for a registered type of "Objects.Elements.Wall"
-	///	If one is not found, will look for "Objects.Elements" etc.
-	///	Returns nullptr if none found.
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	static TSubclassOf<UBase> FindClosestType(const FString& SpeckleType);
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	static bool ParentType(const FString& Type, FString& NextType);
-
-	/// Attempts to find a TSubclassOf<UBase> with a UBase::SpeckleType matching the given SpeckleType param
-	///	Returns nullptr if none found.
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	static TSubclassOf<UBase> GetRegisteredType(const FString& SpeckleType);
-
-	/// Attempts to find a TSubclassOf<UBase> with a UBase::SpeckleType matching the given SpeckleType param
-	UFUNCTION(BlueprintCallable, Category="Speckle|Objects")
-	static bool TryGetRegisteredType(const FString& SpeckleType, TSubclassOf<UBase>& OutType);
-};

Source/SpeckleUnreal/Public/Objects/Other/BlockInstance.h

@@ -1,33 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-
-#include "BlockInstance.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UBlockInstance : public UBase
-{
-	GENERATED_BODY()
-	
-public:
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	FString Name;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	TArray<UBase*> Geometry;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
-	FMatrix Transform;
-	
-	UBlockInstance() : UBase(TEXT("Objects.Other.BlockInstance")) {}
-
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
-
-};	

Source/SpeckleUnreal/Public/Objects/Other/RenderMaterial.h

@@ -1,69 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-
-#include "RenderMaterial.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API URenderMaterial : public UBase
-{
-	GENERATED_BODY()
-
-public:
-	
-	URenderMaterial() : UBase(TEXT("Objects.Other.RenderMaterial")) {}
-
-	UPROPERTY()
-	FString Name;
-	
-	UPROPERTY()
-	double Opacity = 1;
-	
-	UPROPERTY()
-	double Metalness = 0;
-	
-	UPROPERTY()
-	double Roughness = 1;
-	
-	UPROPERTY()
-	FLinearColor Diffuse = FColor{221,221,221};
-	
-	UPROPERTY()
-	FLinearColor Emissive = FLinearColor::Black;
-
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override
-	{
-		if(!Super::Parse(Obj, ReadTransport)) return false;
-	
-		if(Obj->TryGetStringField("name", Name)) DynamicProperties.Remove("name");
-		if(Obj->TryGetNumberField("opacity", Opacity)) DynamicProperties.Remove("opacity");
-		if(Obj->TryGetNumberField("metalness", Metalness)) DynamicProperties.Remove("metalness");
-		if(Obj->TryGetNumberField("roughness", Roughness)) DynamicProperties.Remove("roughness");
-
-		bool IsValid = false;
-		
-		int32 ARGB;
-		if(Obj->TryGetNumberField("diffuse", ARGB))
-		{
-			Diffuse = FColor(ARGB);
-			DynamicProperties.Remove("diffuse");
-			IsValid = true;
-		}
-		
-		if(Obj->TryGetNumberField("emissive", ARGB))
-		{
-			Emissive = FColor(ARGB);
-			DynamicProperties.Remove("emissive");
-		}
-
-		return IsValid;
-	}
-
-	
-};

Source/SpeckleUnreal/Public/Objects/Other/View3D.h

@@ -1,38 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Objects/Base.h"
-
-#include "View3D.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API UView3D : public UBase
-{
-	GENERATED_BODY()
-
-public:
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|Objects")
-	FString Name;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|Objects")
-	FVector Origin;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|Objects")
-	FVector UpDirection;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|Objects")
-	FVector ForwardDirection;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|Objects")
-	bool IsOrthogonal;
-
-	UView3D() : UBase(TEXT("Objects.BuiltElements.View")) {}
-	
-	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
-};

Source/SpeckleUnreal/Public/Objects/Utils/SpeckleObjectUtils.h

@@ -1,49 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintFunctionLibrary.h"
-#include "Templates/SubclassOf.h"
-#include "SpeckleObjectUtils.generated.h"
-
-class ITransport;
-class UBase;
-class FJsonValue;
-class FJsonObject;
-class UWorld;
-class AActor;
-
-/**
- *  Several helper functions useful for handling JSON Speckle Objects
- */
-UCLASS()
-class SPECKLEUNREAL_API USpeckleObjectUtils : public UBlueprintFunctionLibrary
-{
-	GENERATED_BODY()
-	
-public:
-    static TArray<TSharedPtr<FJsonValue>> CombineChunks(const TArray<TSharedPtr<FJsonValue>>& ArrayField, const TScriptInterface<ITransport> Transport);
-    
-    static bool ResolveReference(const TSharedPtr<FJsonObject> Object, const TScriptInterface<ITransport> Transport, TSharedPtr<FJsonObject>& OutObject);
-
-	static bool TryParseTransform(const TSharedPtr<FJsonObject> SpeckleObject, FMatrix& OutMatrix);
-
-	
-	static bool ParseVector(const TSharedPtr<FJsonObject> Object, const TScriptInterface<ITransport> Transport, FVector& OutObject);
-	static bool ParseVectorProperty(const TSharedPtr<FJsonObject> Base, const FString& PropertyName, const TScriptInterface<ITransport> ReadTransport, FVector& OutObject);
-
-	template <typename T>
-	static bool ParseSpeckleObject(const TSharedPtr<FJsonObject> Object, const TScriptInterface<ITransport> Transport, T*& OutObject);
-
-
-	UFUNCTION(BlueprintCallable, Category="Speckle/ObjectUtils")
-	static float ParseScaleFactor(const FString& UnitsString);
-
-	// Given a Right Handed Z-up transformation matrix (Speckle's system), will create an equivalent Left Handed Z-up FTransform (UE's system)
-	UFUNCTION(BlueprintPure, Category="Speckle/ObjectUtils")
-	static FTransform CreateTransform(UPARAM(ref) const FMatrix& TransformMatrix);
-
-	UFUNCTION(BlueprintCallable, meta = (DeterminesOutputType = "Class"), Category="Speckle/ObjectUtils")
-	static AActor* SpawnActorInWorld(const TSubclassOf<AActor> Class, UWorld* World, UPARAM(ref) const FTransform& Transform);
-};

Source/SpeckleUnreal/Public/SpeckleUnrealManager.h

@@ -1,83 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "GameFramework/Actor.h"
-#include "SpeckleUnrealManager.generated.h"
-
-class UServerTransport;
-class ITransport;
-class USpeckleConverterComponent;
-class FJsonObject;
-
-/**
- * An Actor to handle the receiving of Speckle objects into a level
- */
-UCLASS(ClassGroup=(Speckle), AutoCollapseCategories=("Speckle|Conversion"), BlueprintType)
-class SPECKLEUNREAL_API ASpeckleUnrealManager : public AActor
-{
-	GENERATED_BODY()
-	
-public:
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
-	FString ServerUrl;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
-	FString StreamID;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
-	FString ObjectID;
-
-	// A Personal Access Token can be created from your Speckle Profile page (Treat tokens like passwords, do not share publicly) - Required for receiving private streams
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", meta=(PasswordField = true))
-	FString AuthToken;
-
-	// When true, will call `Receive` on BeginPlay
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay)
-	bool ImportAtRuntime;
-
-	// When true, will maintain an in-memory (transient) cache of received speckle objects
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay)
-	bool KeepCache;
-	
-	// The Conversion component to convert received speckle objects into native Actors
-	UPROPERTY(VisibleAnywhere, Category="Speckle", BlueprintReadWrite)
-	USpeckleConverterComponent* Converter;
-	
-	// Used to stagger transport requests, useful when making requests for a large number of child objects
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay)
-	bool DisplayProgressBar;
-	
-	// Sets default values for this actor's properties
-	ASpeckleUnrealManager();
-
-	// Receives specified object from specified Speckle server
-	UFUNCTION(BlueprintCallable, CallInEditor, Category="Speckle", meta=(DisplayPriority=0))
-	virtual void Receive();
-
-	// Deletes the Actors created by the previous receive operation
-	UFUNCTION(BlueprintCallable, CallInEditor, Category="Speckle" , meta=(DisplayAfter="Receive"))
-	virtual void DeleteObjects();
-	
-	virtual void BeginPlay() override;
-
-	
-protected:
-
-	// Cache received Speckle objects
-	UPROPERTY(BlueprintReadWrite, Category="Speckle")
-	TScriptInterface<ITransport> LocalObjectCache;
-
-	// Array of Actors created by the previous receive operation
-	UPROPERTY(BlueprintReadWrite, Category="Speckle")
-	TArray<AActor*> Actors;
-
-	// Callback when JSON has been received
-	virtual void HandleReceive(TSharedPtr<FJsonObject> RootObject, bool DisplayProgress = false);
-	
-	// Callback when error
-	virtual void HandleError(FString& Message);
-	
-	virtual void PrintMessage(FString& Message, bool IsError = false) const;
-};

Source/SpeckleUnreal/Public/Transports/MemoryTransport.h

@@ -1,34 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Transport.h"
-
-#include "MemoryTransport.generated.h"
-
-/**
- * An in memory storage of speckle objects.
- */
-UCLASS(Transient, BlueprintType)
-class SPECKLEUNREAL_API UMemoryTransport : public UObject, public ITransport
-{
-	GENERATED_BODY()
-	
-	TMap<FString, TSharedPtr<FJsonObject>> SpeckleObjects;
-
-public:
-	
-	virtual TSharedPtr<FJsonObject> GetSpeckleObject(const FString& ObjectId) const override;
-	virtual void SaveObject(const FString& ObjectId, const FString& SerializedObject) override;
-	
-	virtual bool HasObject(const FString& ObjectId) const override;
-	virtual void CopyObjectAndChildren(const FString& ObjectId, TScriptInterface<ITransport> TargetTransport, const FTransportCopyObjectCompleteDelegate& OnCompleteAction, const FTransportErrorDelegate& OnErrorAction) override { unimplemented(); }
-
-	UFUNCTION(BlueprintPure, Category = "Speckle|Transports")
-	static UMemoryTransport* CreateEmptyMemoryTransport()
-	{
-		UMemoryTransport* Transport = NewObject<UMemoryTransport>();
-		return Transport;
-	}
-};

Source/SpeckleUnreal/Public/Transports/ServerTransport.h

@@ -1,103 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Transport.h"
-
-#include "ServerTransport.generated.h"
-
-class FBatchSender;
-class FHttpModule;
-
-// Data for graphQL request for object ids.
-USTRUCT()
-struct FObjectIdRequest
-{
-	GENERATED_BODY()
-		
-	UPROPERTY()
-	TArray<FString> Ids;
-};
-
-/**
- *  Transport for receiving objects from a Speckle Server
- */
-UCLASS(BlueprintType)
-class SPECKLEUNREAL_API UServerTransport : public UObject, public ITransport
-{
- GENERATED_BODY()
-	
-protected:
-	
-	UPROPERTY()
-	FString ServerUrl;
-	UPROPERTY()
-	FString StreamId;
-	UPROPERTY(meta=(PasswordField))
-	FString AuthToken;
-
-	UPROPERTY()
-	int32 MaxNumberOfObjectsPerRequest = 20000;
-
-	
-	FTransportCopyObjectCompleteDelegate OnComplete;
-	FTransportErrorDelegate OnError;
-	
-public:
-
-
-	virtual ~UServerTransport() override;
-	
-	UFUNCTION(BlueprintPure, Category = "Speckle|Transports")
-	static UServerTransport* CreateServerTransport(UPARAM(ref) FString& _ServerUrl, UPARAM(ref)  FString& _StreamId, UPARAM(ref) FString& _AuthToken)
-	{
-		UServerTransport* Transport = NewObject<UServerTransport>();
-		Transport->ServerUrl = _ServerUrl;
-		Transport->StreamId = _StreamId;
-		Transport->AuthToken = _AuthToken;
-		return Transport;
-	}
-	
-	virtual TSharedPtr<FJsonObject> GetSpeckleObject(const FString& ObjectId) const override;
-	
-	virtual void SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> SerializedObject) override;
-	virtual void BeginWrite() override;
-	virtual void EndWrite() override;
-	
-	virtual bool HasObject(const FString& ObjectId) const override;
-	
- 	virtual void CopyObjectAndChildren(const FString& ObjectId,
- 		TScriptInterface<ITransport> TargetTransport,
- 		const FTransportCopyObjectCompleteDelegate& OnCompleteAction,
- 		const FTransportErrorDelegate& OnErrorAction) override;
-
-
-protected:
-	virtual void HandleRootObjectResponse(const FString& RootObjSerialized, TScriptInterface<ITransport> TargetTransport, const FString& ObjectId) const;
-
-    /**
-	 * Iteratively fetches chunks of children
-	 * @param TargetTransport the transport to store the fetched objects
-	 * @param RootObjectId the id of the root object
-	 * @param ChildrenIds array of all children to be fetched
-	 * @param CStart the index in ChildrenIds of the start point of the current chunk
-	 */
-    virtual void FetchChildren(TScriptInterface<ITransport> TargetTransport,
-	                            const FString& RootObjectId,
-	                            const TArray<FString>& ChildrenIds,
-	                            int32 CStart = 0) const;
-	
-	virtual void InvokeOnError(FString& Message) const;
-
-	static bool LoadJson(const FString& ObjectJson, TSharedPtr<FJsonObject>& OutJsonObject);
-	static int32 SplitLines(const FString& Content, TArray<FString>& OutLines);
-
-	FBatchSender BatchSender;
-	
-	// FCriticalSection Lock_SendBuffer;
-	// TArray<TTuple<const FString, const FString>> SendBuffer;
-	// FRunnableThread* SendingThread;
-};
-
-

Source/SpeckleUnreal/Public/Transports/Transport.h

@@ -1,47 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "UObject/Interface.h"
-#include "Dom/JsonObject.h"
-
-#include "Transport.generated.h"
-
-DECLARE_DELEGATE_OneParam(FTransportCopyObjectCompleteDelegate, TSharedPtr<FJsonObject>);
-DECLARE_DELEGATE_OneParam(FTransportErrorDelegate, FString&);
-//DECLARE_DELEGATE_OneParam(FTransportTotalChildrenCountKnownDelegate, int32);
-//DECLARE_DELEGATE_OneParam(FTransportProgressDelegate, int32);
-
-// This class does not need to be modified.
-UINTERFACE(Blueprintable)
-class UTransport : public UInterface
-{
-	GENERATED_BODY()
-};
-
-/**
- * 
- */
-class SPECKLEUNREAL_API ITransport
-{
-	GENERATED_BODY()
-
-public:
-	//TODO consider changing SerializedObject to FString&
-	virtual void SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> SerializedObject) = 0;
-
- 	//virtual void SaveObjectFromTransport(FString& ObjectID, TScriptInterface<ITransport> SourceTransport) = 0;
-
- 	virtual TSharedPtr<FJsonObject> GetSpeckleObject(const FString& ObjectId) const = 0;
-	virtual bool HasObject(const FString& ObjectId) const; 
-	
-	virtual void BeginWrite();
-	virtual void EndWrite();
-	
- 	virtual void CopyObjectAndChildren(const FString& ObjectId,
- 		TScriptInterface<ITransport> TargetTransport,
- 		const FTransportCopyObjectCompleteDelegate& OnCompleteAction,
- 		const FTransportErrorDelegate& OnErrorAction) = 0;
-
-};

Source/SpeckleUnrealEditor/Private/Conversion/ConverterFactory.cpp

@@ -1,88 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Conversion/ConverterFactory.h"
-
-#include "Conversion/SpeckleConverter.h"
-#include "ClassViewerModule.h"
-#include "InterfaceClassFilter.h"
-#include "SpeckleUnrealEditorModule.h"
-#include "Kismet2/SClassPickerDialog.h"
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealEditorModule"
-
-UConverterFactory::UConverterFactory(UClass* SClass)
-	: UConverterFactory()
-{
-	SupportedClass = SClass;
-	ConverterClass = SClass;
-}
-
-UConverterFactory::UConverterFactory()
-{
-	bCreateNew = true;
-	bEditAfterNew = true;
-	SupportedClass = USpeckleConverter::StaticClass(); //This is not super valid, but it doesn't matter
-	
-	ConverterClass = nullptr;
-}
-
-uint32 UConverterFactory::GetMenuCategories() const
-{
-	static const uint32 SpeckleCategory = FModuleManager::LoadModuleChecked<FSpeckleUnrealEditorModule>("SpeckleUnrealEditor").GetSpeckleAssetCategory();
-	return SpeckleCategory;
-}
-
-bool UConverterFactory::ConfigureProperties()
-{
-	// Null the CurveClass so we can get a clean class
-	ConverterClass = nullptr;
-
-	// Load the classviewer module to display a class picker
-	FClassViewerModule& ClassViewerModule = FModuleManager::LoadModuleChecked<FClassViewerModule>("ClassViewer");
-
-	// Fill in options
-	FClassViewerInitializationOptions Options;
-	Options.Mode = EClassViewerMode::ClassPicker;
-
-	TSharedPtr<FInterfaceClassFilter> Filter = MakeShareable(new FInterfaceClassFilter);
-#if ENGINE_MAJOR_VERSION >= 5
-	Options.ClassFilters.Emplace(Filter.ToSharedRef());
-#else
-	Options.ClassFilter = Filter;
-#endif
-
-	Filter->InterfaceThatMustBeImplemented = USpeckleConverter::StaticClass();
-	Filter->bAllowAbstract = false;
-	Filter->ClassPropertyMetaClass = UObject::StaticClass();
-	Filter->AllowedClassFilters = {UObject::StaticClass()};
-	const FText TitleText = LOCTEXT("CreateConverterOptions", "Pick Converter Class");
-	UClass* ChosenClass = nullptr;
-	const bool bPressedOk = SClassPickerDialog::PickClass(TitleText, Options, ChosenClass, UObject::StaticClass());
-
-	if ( bPressedOk )
-	{
-		ConverterClass = ChosenClass;
-	}
-
-	return bPressedOk;
-}
-
-
-UObject* UConverterFactory::FactoryCreateNew(UClass* Class, UObject* InParent, FName Name, EObjectFlags Flags,
-                                             UObject* Context, FFeedbackContext* Warn)
-{
-	UObject* NewObjectAsset = nullptr;
-	if(ConverterClass != nullptr)
-	{
-		NewObjectAsset = NewObject<UObject>(InParent, ConverterClass, Name, Flags);
-	}
-	return NewObjectAsset;
-}
-
- FText UConverterFactory::GetDisplayName() const
- {
- 	return LOCTEXT("ConverterFactoryDisplayName", "Speckle Converter");
- }
-
-#undef LOCTEXT_NAMESPACE

Source/SpeckleUnrealEditor/Private/SpeckleUnrealEditorModule.cpp

@@ -1,58 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#include "SpeckleUnrealEditorModule.h"
-
-#include "AssetToolsModule.h"
-#include "IAssetTools.h"
-
-#include "Conversion/ConverterActions.h"
-#include "Conversion/SpeckleConverter.h"
-
-#define LOCTEXT_NAMESPACE "FSpeckleUnrealEditorModule"
-
-uint32 FSpeckleUnrealEditorModule::GetSpeckleAssetCategory() const
-{
-	return SpeckleAssetCategoryBit;
-}
-
-void FSpeckleUnrealEditorModule::StartupModule()
-{
-	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
-#if WITH_EDITOR
-	if (GIsEditor)
-	{
-		IAssetTools& AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();
-
-		// Register Speckle Category
-		SpeckleAssetCategoryBit = AssetTools.RegisterAdvancedAssetCategory(FName(TEXT("Speckle")), LOCTEXT("SpeckleCategoryText","Speckle"));
-
-		
-		// See UAssetToolsImpl::GetNewAssetFactories() for reference
-		for (TObjectIterator<UClass> It; It; ++It)
-		{
-			UClass* Class = *It;
-
-			// Create FConverterActions for USpeckleConverter types
-			if ( Class->ImplementsInterface(USpeckleConverter::StaticClass())
-				&& !Class->HasAnyClassFlags(CLASS_Abstract))
-			{
-				AssetTools.RegisterAssetTypeActions(MakeShareable(new FConverterActions(Class, SpeckleAssetCategoryBit)));
-			}
-		}
-
-		AssetTools.RegisterAssetTypeActions(MakeShareable(new FConverterActions(USpeckleConverter::StaticClass(), SpeckleAssetCategoryBit)));
-
-		
-	}
-#endif
-}
-
-void FSpeckleUnrealEditorModule::ShutdownModule()
-{
-	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
-	// we call this function before unloading the module.
-}
-
-#undef LOCTEXT_NAMESPACE
-	
-IMPLEMENT_MODULE(FSpeckleUnrealEditorModule, SpeckleUnrealEditor)

Source/SpeckleUnrealEditor/Public/Conversion/ConverterActions.h

@@ -1,33 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "AssetTypeActions_Base.h"
-
-
-/**
- * Asset action for ISpeckleConverter implementors.
- */
-class FConverterActions : public FAssetTypeActions_Base
-{
-private:
-	UClass* SupportedClass;
-	uint32 Category;
-	
-public:
-	explicit FConverterActions(UClass* SupportedClass, uint32 Category)
-	{
-		this->SupportedClass = SupportedClass;
-		this->Category = Category;
-	}
-	
-	// IAssetTypeActions Implementation
-	virtual FText GetName() const override { return SupportedClass->GetDisplayNameText(); }
-	virtual UClass* GetSupportedClass() const override { return SupportedClass; }
-	virtual FColor GetTypeColor() const override { return FColor(59, 130, 246); }
-	virtual bool CanLocalize() const override { return false; }
-	
-	virtual uint32 GetCategories() override { return Category; }
-	
-};

Source/SpeckleUnrealEditor/Public/Conversion/ConverterFactory.h

@@ -1,31 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Factories/Factory.h"
-
-#include "ConverterFactory.generated.h"
-
-/**
- * Factory for ISpeckleConverter classes to appear in the asset creation context menu.
- */
-UCLASS()
-class SPECKLEUNREALEDITOR_API UConverterFactory : public UFactory
-{
-	GENERATED_BODY()
-protected:
-	explicit UConverterFactory(UClass* SupportedClass);
-public:
-	UPROPERTY(EditAnywhere, Category="Speckle|Factories", meta = (MustImplement = USpeckleConverter))
-	UClass* ConverterClass;
-	
-	UConverterFactory();
-	
-	virtual uint32 GetMenuCategories() const override;
-
-	virtual bool ConfigureProperties() override;
-	virtual UObject* FactoryCreateNew(UClass* Class, UObject* InParent, FName Name, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn) override;
-	virtual FText GetDisplayName() const override;
-
-};

Source/SpeckleUnrealEditor/Public/InterfaceClassFilter.h

@@ -1,67 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#pragma once
-
-#include "ClassViewerModule.h"
-#include "ClassViewerFilter.h"
-
-
-/**
- * Class filter for classes that implement a given interface
- * based on FPropertyEditorClassFilter
- */
-class FInterfaceClassFilter : public IClassViewerFilter
-{
-public:
-	/** The meta class for the property that classes must be a child-of. */
-	const UClass* ClassPropertyMetaClass;
-
-	/** The interface that must be implemented. */
-	const UClass* InterfaceThatMustBeImplemented;
-
-	/** Whether or not abstract classes are allowed. */
-	bool bAllowAbstract;
-
-	/** Classes that can be picked */
-	TArray<UClass*> AllowedClassFilters;
-
-	/** Classes that can't be picked */
-	TArray<UClass*> DisallowedClassFilters;
-
-	virtual bool IsClassAllowed(const FClassViewerInitializationOptions& InInitOptions, const UClass* InClass, TSharedRef< FClassViewerFilterFuncs > InFilterFuncs ) override
-	{
-		return IsClassAllowedHelper(InClass);
-	}
-	
-	virtual bool IsUnloadedClassAllowed(const FClassViewerInitializationOptions& InInitOptions, const TSharedRef< const IUnloadedBlueprintData > InBlueprint, TSharedRef< FClassViewerFilterFuncs > InFilterFuncs) override
-	{
-		return IsClassAllowedHelper(InBlueprint);
-	}
-
-private:
-
-	template <typename TClass>
-	bool IsClassAllowedHelper(TClass InClass)
-	{
-		bool bMatchesFlags = !InClass->HasAnyClassFlags(CLASS_Hidden | CLASS_HideDropDown | CLASS_Deprecated) &&
-			(bAllowAbstract || !InClass->HasAnyClassFlags(CLASS_Abstract));
-
-		if (bMatchesFlags && InClass->IsChildOf(ClassPropertyMetaClass)
-			&& (!InterfaceThatMustBeImplemented || InClass->ImplementsInterface(InterfaceThatMustBeImplemented)))
-		{
-			auto PredicateFn = [InClass](const UClass* Class)
-			{
-				return InClass->IsChildOf(Class);
-			};
-
-			if (DisallowedClassFilters.FindByPredicate(PredicateFn) == nullptr &&
-				(AllowedClassFilters.Num() == 0 || AllowedClassFilters.FindByPredicate(PredicateFn) != nullptr))
-			{
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-};

Source/SpeckleUnrealEditor/Public/SpeckleUnrealEditorModule.h

@@ -1,25 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Modules/ModuleManager.h"
-
-class FSpeckleUnrealEditorModule : public IModuleInterface
-{
-	
-#if WITH_EDITORONLY_DATA
-protected:
-	uint32 SpeckleAssetCategoryBit = 0;
-#endif
-	
-#if WITH_EDITOR
-public:
-	virtual uint32 GetSpeckleAssetCategory() const;
-#endif
-	
-public:
-	/** IModuleInterface implementation */
-	virtual void StartupModule() override;
-	virtual void ShutdownModule() override;
-};

Source/SpeckleUnrealEditor/SpeckleUnrealEditor.Build.cs

@@ -1,56 +0,0 @@
-using UnrealBuildTool;
-
-public class SpeckleUnrealEditor : ModuleRules
-{
-	public SpeckleUnrealEditor(ReadOnlyTargetRules Target) : base(Target)
-	{
-		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
-		
-		PublicIncludePaths.AddRange(
-			new string[] {
-				// ... add public include paths required here ...
-			}
-		);
-				
-		
-		PrivateIncludePaths.AddRange(
-			new string[] {
-				// ... add other private include paths required here ...
-			}
-		);
-			
-		
-		PublicDependencyModuleNames.AddRange(
-			new string[]
-			{
-				"Core",
-				"HTTP", 
-				"Json", 
-				"JsonUtilities",
-				"UnrealEd", 
-				"SpeckleUnreal",
-				// ... add other public dependencies that you statically link with here ...
-			}
-		);
-			
-		
-		PrivateDependencyModuleNames.AddRange(
-			new string[]
-			{
-				"CoreUObject",
-				"Engine",
-				"Slate",
-				"SlateCore",
-				// ... add private dependencies that you statically link with here ...	
-			}
-		);
-		
-		
-		DynamicallyLoadedModuleNames.AddRange(
-			new string[]
-			{
-				// ... add any modules that your module loads dynamically here ...
-			}
-		);
-	}
-}

SpeckleUnrealProject/Config/DefaultEngine.ini

@@ -0,0 +1,16 @@
+
+
+[/Script/HardwareTargeting.HardwareTargetingSettings]
+TargetedHardwareClass=Desktop
+AppliedTargetedHardwareClass=Desktop
+DefaultGraphicsPerformance=Maximum
+AppliedDefaultGraphicsPerformance=Maximum
+
+[/Script/Engine.Engine]
++ActiveGameNameRedirects=(OldGameName="TP_Blank",NewGameName="/Script/SpeckleUnrealProject")
++ActiveGameNameRedirects=(OldGameName="/Script/TP_Blank",NewGameName="/Script/SpeckleUnrealProject")
++ActiveClassRedirects=(OldClassName="TP_BlankGameModeBase",NewClassName="SpeckleUnrealProjectGameModeBase")
+
+[/Script/IOSRuntimeSettings.IOSRuntimeSettings]
+RemoteServerName=
+

SpeckleUnrealProject/Config/DefaultGame.ini

@@ -0,0 +1,3 @@
+
+[/Script/EngineSettings.GeneralProjectSettings]
+ProjectID=F126DB004A50E31B2A69D284041A10E1

SpeckleUnrealProject/Plugins/SpeckleUnreal/Source/SpeckleUnreal/Private/SpeckleUnrealLayer.cpp

@@ -0,0 +1,20 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "SpeckleUnrealLayer.h"
+
+ASpeckleUnrealLayer::ASpeckleUnrealLayer()
+{
+	Scene = CreateDefaultSubobject<USceneComponent>("Root");
+	RootComponent = Scene;
+}
+
+void ASpeckleUnrealLayer::Init(FString NewLayerName, int32 NewStartIndex, int32 NewObjectCount)
+{
+	SetActorLabel(NewLayerName);
+
+	LayerName = NewLayerName;
+	LayerColor = FLinearColor(FMath::FRandRange(0, 1), FMath::FRandRange(0, 1), FMath::FRandRange(0, 1), 1);
+	StartIndex = NewStartIndex;
+	ObjectCount = NewObjectCount;
+}

SpeckleUnrealProject/Plugins/SpeckleUnreal/Source/SpeckleUnreal/Private/SpeckleUnrealManager.cpp

@@ -0,0 +1,256 @@
+#include "SpeckleUnrealManager.h"
+
+// Sets default values
+ASpeckleUnrealManager::ASpeckleUnrealManager()
+{
+	//When the object is constructed, Get the HTTP module
+	Http = &FHttpModule::Get();
+	// default conversion is millimeters to centimeters because streams tend to be in ml and unreal is in cm by defaults
+	ScaleFactor = 0.1; 
+}
+
+// Called when the game starts or when spawned
+void ASpeckleUnrealManager::BeginPlay()
+{
+	Super::BeginPlay();
+
+	World = GetWorld();
+	GetStream();
+}
+
+void ASpeckleUnrealManager::SetUpGetRequest(TSharedRef<IHttpRequest> Request)
+{
+	Request->SetVerb("GET");
+	Request->SetHeader("Content-Type", TEXT("application/json"));
+	Request->SetHeader("Authorization", AuthToken);
+}
+
+/*Http call*/
+void ASpeckleUnrealManager::GetStream()
+{
+	GEngine->AddOnScreenDebugMessage(0, 5.0f, FColor::Green, "Downloading: " + StreamID);
+
+	TSharedRef<IHttpRequest> Request = Http->CreateRequest();
+
+	SetUpGetRequest(Request);
+
+	Request->OnProcessRequestComplete().BindUObject(this, &ASpeckleUnrealManager::OnStreamResponseReceived);
+
+	//This is the url on which to process the request
+	Request->SetURL(ServerUrl + "streams/" + StreamID);
+
+	Request->ProcessRequest();
+}
+
+/*Assigned function on successfull http call*/
+void ASpeckleUnrealManager::OnStreamResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
+{
+	if (!bWasSuccessful)
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Stream Request failed");
+		return;
+	}
+
+	//Create a pointer to hold the json serialized data
+	TSharedPtr<FJsonObject> ResponseJsonObject;
+
+	//Create a reader pointer to read the json data
+	TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
+
+	//Deserialize the json data given Reader and the actual object to deserialize
+	if (FJsonSerializer::Deserialize(Reader, ResponseJsonObject))
+	{
+		//Get the value of the json object by field name
+		FString ResponseMessage = ResponseJsonObject->GetStringField("message");
+		TSharedPtr<FJsonObject> Stream = ResponseJsonObject->GetObjectField("resource");
+		FString StreamName = Stream->GetStringField("name");
+		FString StreamDescription = Stream->GetStringField("description");
+
+		FString Units = ResponseJsonObject->GetObjectField("baseProperties")->GetStringField("units").ToLower();
+
+		// unreal engine units are in cm by default but the conversion is editable by users so
+		// this needs to be accounted for later.
+		if (Units == "meters" || Units == "metres")
+			ScaleFactor = 100;
+
+		if (Units == "centimeters" || Units == "centimetres")
+			ScaleFactor = 1;
+
+		if (Units == "millimeters" || Units == "millimetres")
+			ScaleFactor = 0.1;
+
+		if (Units == "yards")
+			ScaleFactor = 91.4402757;
+
+		if (Units == "feet")
+			ScaleFactor = 30.4799990;
+
+		if (Units == "inches")
+			ScaleFactor = 2.5399986;
+
+		TArray<TSharedPtr<FJsonValue>> LayersInStream = Stream->GetArrayField("layers");
+		SpeckleUnrealLayers = TArray<ASpeckleUnrealLayer*>();
+
+		for (size_t i = 0; i < LayersInStream.Num(); i++)
+		{
+			TSharedPtr<FJsonObject> LayerObject = LayersInStream[i]->AsObject();
+
+			FString LayerName = LayerObject->GetStringField("name");
+			int32 StartIndex = LayerObject->GetIntegerField("startIndex");
+			int32 ObjectCount = LayerObject->GetIntegerField("objectCount");
+
+			//USpeckleUnrealLayer NewLayer = USpeckleUnrealLayer(LayerName, StartIndex, ObjectCount);
+			ASpeckleUnrealLayer* NewLayer = (ASpeckleUnrealLayer*)World->SpawnActor(ASpeckleUnrealLayer::StaticClass());
+			NewLayer->Init(LayerName, StartIndex, ObjectCount);
+			SpeckleUnrealLayers.Add(NewLayer);
+		}
+
+		//Output it to the engine
+		GEngine->AddOnScreenDebugMessage(0, 5.0f, FColor::Green, "Units: " + FString::SanitizeFloat(ScaleFactor));
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Green, "Status: " + ResponseMessage);
+		GEngine->AddOnScreenDebugMessage(2, 5.0f, FColor::Green, "Name: " + StreamName);
+		GEngine->AddOnScreenDebugMessage(3, 5.0f, FColor::Green, "Description: " + StreamDescription);
+
+		TArray<TSharedPtr<FJsonValue>> ObjectPlaceholderArray = Stream->GetArrayField("objects");
+
+		GetStreamObjects(ObjectPlaceholderArray.Num());
+	}
+	else
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Couldn't deserialize Json from stream response");
+		GEngine->AddOnScreenDebugMessage(2, 10.0f, FColor::Red, Response->GetContentAsString());
+	}
+}
+
+void ASpeckleUnrealManager::GetStreamObjects(int32 objectCount)
+{
+	int32 RequestLimit = 1;
+	CurrentObjectIndex = 0;
+	LayerIndex = 0;
+
+	for (size_t i = 0; i < objectCount; i += RequestLimit)
+	{
+		TSharedRef<IHttpRequest> Request = Http->CreateRequest();
+
+		SetUpGetRequest(Request);
+
+		Request->OnProcessRequestComplete().BindUObject(this, &ASpeckleUnrealManager::OnStreamObjectResponseReceived);
+
+		//This is the url on which to process the request
+		Request->SetURL(ServerUrl + "streams/" + StreamID + "/objects?limit=" + FString::FromInt(RequestLimit) + "&offset=" + FString::FromInt(i));
+
+		Request->ProcessRequest();
+	}
+}
+
+void ASpeckleUnrealManager::OnStreamObjectResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
+{
+	if (!bWasSuccessful)
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Object Request failed");
+		return;
+	}
+
+	//Create a pointer to hold the json serialized data
+	TSharedPtr<FJsonObject> ResponseJsonObject;
+
+	//Create a reader pointer to read the json data
+	TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
+
+	//Deserialize the json data given Reader and the actual object to deserialize
+	if (FJsonSerializer::Deserialize(Reader, ResponseJsonObject))
+	{
+		
+		int32 Offset = FCString::Atoi (*Request->GetURLParameter("offset"));
+		//Get the value of the json object by field name
+		TArray<TSharedPtr<FJsonValue>> StreamObjects = ResponseJsonObject->GetArrayField("resources");
+
+		for (size_t i = 0; i < SpeckleUnrealLayers.Num(); i++)
+		{
+			if (Offset >= SpeckleUnrealLayers[i]->StartIndex)
+			{
+				if (Offset < (SpeckleUnrealLayers[i]->StartIndex + SpeckleUnrealLayers[i]->ObjectCount))
+					LayerIndex = i;
+			}
+		}
+
+		for (size_t i = 0; i < StreamObjects.Num(); i++)
+		{
+			TSharedPtr<FJsonObject> StreamObject = StreamObjects[i].Get()->AsObject();
+
+			TSharedPtr<FJsonObject> ObjectToConvert = StreamObject;
+
+			FString objectType = ObjectToConvert->GetStringField("type");
+
+			if (objectType.ToLower().Contains("brep"))
+			{
+				ObjectToConvert = StreamObject->GetObjectField("displayValue");
+
+				objectType = ObjectToConvert->GetStringField("type");
+			}
+
+			if (objectType.ToLower().Contains("mesh"))
+			{
+				AActor* ActorInstance = World->SpawnActor(MeshActor);
+				ASpeckleUnrealMesh* MeshInstance = (ASpeckleUnrealMesh*)ActorInstance;
+
+				TArray<TSharedPtr<FJsonValue>> ObjectVertices = ObjectToConvert->GetArrayField("vertices");
+				TArray<TSharedPtr<FJsonValue>> ObjectFaces = ObjectToConvert->GetArrayField("faces");
+
+				TArray<FVector> ParsedVerticies;
+
+				for (size_t j = 0; j < ObjectVertices.Num(); j += 3)
+				{
+					ParsedVerticies.Add(FVector
+					(
+						(float)(ObjectVertices[j].Get()->AsNumber()) * -1,
+						(float)(ObjectVertices[j + 1].Get()->AsNumber()),
+						(float)(ObjectVertices[j + 2].Get()->AsNumber())
+					) * ScaleFactor);
+				}
+
+				//convert mesh faces into triangle array regardless of whether or not they are quads
+				TArray<int32> ParsedTriangles;
+				int32 j = 0;
+				while (j < ObjectFaces.Num())
+				{
+					if (ObjectFaces[j].Get()->AsNumber() == 0)
+					{
+						//Triangles
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 2].Get()->AsNumber());
+						j += 4;
+					}
+					else
+					{
+						//Quads to triangles
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 2].Get()->AsNumber());
+
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 4].Get()->AsNumber());
+
+						j += 5;
+					}
+				}
+
+				if (RandomColorsPerLayer)
+					MeshInstance->SetMesh(ParsedVerticies, ParsedTriangles, DefaultMeshMaterial, SpeckleUnrealLayers[LayerIndex]->LayerColor);
+				else
+					MeshInstance->SetMesh(ParsedVerticies, ParsedTriangles, DefaultMeshMaterial, FLinearColor::White);
+
+				UE_LOG(LogTemp, Warning, TEXT("%d"), Offset);
+				UE_LOG(LogTemp, Warning, TEXT("%s"), *SpeckleUnrealLayers[LayerIndex]->LayerName);
+
+			}
+		}
+	}
+	else
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Couldn't deserialize Json from object response");
+		GEngine->AddOnScreenDebugMessage(2, 10.0f, FColor::Red, Response->GetContentAsString());
+	}
+}

SpeckleUnrealProject/Plugins/SpeckleUnreal/Source/SpeckleUnreal/Private/SpeckleUnrealMesh.cpp

@@ -0,0 +1,66 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "SpeckleUnrealMesh.h"
+
+// Sets default values
+ASpeckleUnrealMesh::ASpeckleUnrealMesh()
+{
+	Scene = CreateDefaultSubobject<USceneComponent>("Root");
+	RootComponent = Scene;
+
+	ProceduralMesh = CreateDefaultSubobject<UProceduralMeshComponent>("Mesh");
+	ProceduralMesh->SetupAttachment(RootComponent);
+}
+
+void ASpeckleUnrealMesh::SetMesh(TArray<FVector> Vertices, TArray<int32> Triangles, UMaterialInterface* Material, FLinearColor Color)
+{
+	ProceduralMesh->ClearAllMeshSections();
+
+	TArray<FVector> Normals;
+	TArray<FProcMeshTangent> Tangents;
+	TArray<FVector2D> UVs;
+	TArray<FColor> Colors;
+
+	// for each triangle
+	for (size_t i = 0; i < Triangles.Num(); i += 3)
+	{
+		// get a normal direction for this triangle
+		FVector Normal = FVector::CrossProduct(Vertices[Triangles[i]], Vertices[Triangles[i + 2]]).GetSafeNormal();
+
+		// get a tangent direction perpendicular to the normal
+		FVector TangentVector = FVector::CrossProduct(Vertices[Triangles[i]], Normal);
+		FProcMeshTangent Tangent = FProcMeshTangent(TangentVector.X, TangentVector.Y, TangentVector.Z);
+
+		// for each vertex in a triangle
+		for (size_t j = 0; j < 3; j++)
+		{
+			Normals.Add(Normal);
+			Tangents.Add(Tangent);
+			Colors.Add(FColor::White);
+		}
+	}
+
+	ProceduralMesh->CreateMeshSection(0, Vertices, Triangles, Normals, UVs, Colors, Tangents, true);
+
+	UMaterialInstanceDynamic* DynMaterial = UMaterialInstanceDynamic::Create(Material, this);
+	
+	DynMaterial->SetVectorParameterValue("BaseColor", Color);
+
+	ProceduralMesh->SetMaterial(0, DynMaterial);
+}
+
+// Called when the game starts or when spawned
+void ASpeckleUnrealMesh::BeginPlay()
+{
+	Super::BeginPlay();
+
+}
+
+// Called every frame
+void ASpeckleUnrealMesh::Tick(float DeltaTime)
+{
+	Super::Tick(DeltaTime);
+
+}
+

SpeckleUnrealProject/Plugins/SpeckleUnreal/Source/SpeckleUnreal/Private/SpeckleUnrealReceiver.cpp

@@ -0,0 +1,304 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "SpeckleUnrealReceiver.h"
+
+
+// Sets default values
+USpeckleUnrealReceiver::USpeckleUnrealReceiver()
+{
+	//When the object is constructed, Get the HTTP module
+	Http = &FHttpModule::Get();
+	// default conversion is millimeters to centimeters because streams tend to be in ml and unreal is in cm by defaults
+	ScaleFactor = 0.1;
+}
+
+void USpeckleUnrealReceiver::SetUpGetRequest(TSharedRef<IHttpRequest> Request)
+{
+	Request->SetVerb("GET");
+	Request->SetHeader("Content-Type", TEXT("application/json"));
+	Request->SetHeader("Authorization", AuthToken);
+}
+
+/*Http call*/
+void USpeckleUnrealReceiver::ReceiveStream()
+{
+	World = GetWorld();
+
+	GEngine->AddOnScreenDebugMessage(0, 5.0f, FColor::Green, "Downloading: " + StreamID);
+
+	TSharedRef<IHttpRequest> Request = Http->CreateRequest();
+
+	SetUpGetRequest(Request);
+
+	Request->OnProcessRequestComplete().BindUObject(this, &USpeckleUnrealReceiver::OnStreamResponseReceived);
+
+	//This is the url on which to process the request
+	Request->SetURL(ServerUrl + "streams/" + StreamID);
+
+	Request->ProcessRequest();
+}
+
+/*Assigned function on successfull http call*/
+void USpeckleUnrealReceiver::OnStreamResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
+{
+	if (!bWasSuccessful)
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Stream Request failed");
+		return;
+	}
+
+	//Create a pointer to hold the json serialized data
+	TSharedPtr<FJsonObject> ResponseJsonObject;
+
+	//Create a reader pointer to read the json data
+	TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
+
+	//Deserialize the json data given Reader and the actual object to deserialize
+	if (FJsonSerializer::Deserialize(Reader, ResponseJsonObject))
+	{
+		//Get the value of the json object by field name
+		FString ResponseMessage = ResponseJsonObject->GetStringField("message");
+		TSharedPtr<FJsonObject> Stream = ResponseJsonObject->GetObjectField("resource");
+		FString StreamName = Stream->GetStringField("name");
+		FString StreamDescription = Stream->GetStringField("description");
+
+		FString Units = ResponseJsonObject->GetObjectField("baseProperties")->GetStringField("units").ToLower();
+
+		// unreal engine units are in cm by default but the conversion is editable by users so
+		// this needs to be accounted for later.
+		if (Units == "meters" || Units == "metres")
+			ScaleFactor = 100;
+
+		if (Units == "centimeters" || Units == "centimetres")
+			ScaleFactor = 1;
+
+		if (Units == "millimeters" || Units == "millimetres")
+			ScaleFactor = 0.1;
+
+		if (Units == "yards")
+			ScaleFactor = 91.4402757;
+
+		if (Units == "feet")
+			ScaleFactor = 30.4799990;
+
+		if (Units == "inches")
+			ScaleFactor = 2.5399986;
+
+		TArray<TSharedPtr<FJsonValue>> LayersInStream = Stream->GetArrayField("layers");
+		SpeckleUnrealLayers = TArray<ASpeckleUnrealLayer*>();
+
+		for (size_t i = 0; i < LayersInStream.Num(); i++)
+		{
+			TSharedPtr<FJsonObject> LayerObject = LayersInStream[i]->AsObject();
+
+			ASpeckleUnrealLayer* NewLayer = (ASpeckleUnrealLayer*)World->SpawnActor(ASpeckleUnrealLayer::StaticClass());
+
+			FString LayerName = LayerObject->GetStringField("name");
+			
+			if (LayerName.Contains("::"))
+			{
+				TArray<FString> Parsed = TArray<FString> ();
+				int32 heirarchySize = LayerName.ParseIntoArray(Parsed, TEXT("::"), true);
+
+				LayerName = Parsed[heirarchySize - 1];
+				FString ParentLayerName = Parsed[heirarchySize - 2];
+
+				for (size_t j = 0; j < SpeckleUnrealLayers.Num(); j++)
+				{
+					if (SpeckleUnrealLayers[j]->LayerName == ParentLayerName)
+					{
+						EAttachmentRule rule = EAttachmentRule();
+						FAttachmentTransformRules rules = FAttachmentTransformRules(rule, false);
+						NewLayer->AttachToActor(SpeckleUnrealLayers[j], rules);
+
+						break;
+					}
+				}
+			}
+
+
+
+			int32 StartIndex = LayerObject->GetIntegerField("startIndex");
+			int32 ObjectCount = LayerObject->GetIntegerField("objectCount");
+
+			NewLayer->Init(LayerName, StartIndex, ObjectCount);
+			SpeckleUnrealLayers.Add(NewLayer);
+		}
+
+		//Output it to the engine
+		GEngine->AddOnScreenDebugMessage(0, 5.0f, FColor::Green, "Units: " + FString::SanitizeFloat(ScaleFactor));
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Green, "Status: " + ResponseMessage);
+		GEngine->AddOnScreenDebugMessage(2, 5.0f, FColor::Green, "Name: " + StreamName);
+		GEngine->AddOnScreenDebugMessage(3, 5.0f, FColor::Green, "Description: " + StreamDescription);
+
+		TArray<TSharedPtr<FJsonValue>> ObjectPlaceholderArray = Stream->GetArrayField("objects");
+
+		GetStreamObjects(ObjectPlaceholderArray.Num());
+	}
+	else
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Couldn't deserialize Json from stream response");
+		GEngine->AddOnScreenDebugMessage(2, 10.0f, FColor::Red, Response->GetContentAsString());
+	}
+}
+
+void USpeckleUnrealReceiver::GetStreamObjects(int32 objectCount)
+{
+	ObjectsReceived = TArray<bool>();
+
+	int32 RequestLimit = 1;
+	CurrentObjectIndex = 0;
+	LayerIndex = 0;
+
+	for (size_t i = 0; i < objectCount; i += RequestLimit)
+	{
+		TSharedRef<IHttpRequest> Request = Http->CreateRequest();
+
+		SetUpGetRequest(Request);
+
+		Request->OnProcessRequestComplete().BindUObject(this, &USpeckleUnrealReceiver::OnStreamObjectResponseReceived);
+
+		//This is the url on which to process the request
+		Request->SetURL(ServerUrl + "streams/" + StreamID + "/objects?limit=" + FString::FromInt(RequestLimit) + "&offset=" + FString::FromInt(i));
+
+		ObjectsReceived.Add(false);
+
+		Request->ProcessRequest();
+	}
+}
+
+void USpeckleUnrealReceiver::OnStreamObjectResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
+{
+	int32 Offset = FCString::Atoi(*Request->GetURLParameter("offset"));
+
+	if (!bWasSuccessful)
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Object Request failed");
+		return;
+	}
+
+	//Create a pointer to hold the json serialized data
+	TSharedPtr<FJsonObject> ResponseJsonObject;
+
+	//Create a reader pointer to read the json data
+	TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
+
+	//Deserialize the json data given Reader and the actual object to deserialize
+	if (FJsonSerializer::Deserialize(Reader, ResponseJsonObject))
+	{
+		//Get the value of the json object by field name
+		TArray<TSharedPtr<FJsonValue>> StreamObjects = ResponseJsonObject->GetArrayField("resources");
+
+		for (size_t i = 0; i < SpeckleUnrealLayers.Num(); i++)
+		{
+			if (Offset >= SpeckleUnrealLayers[i]->StartIndex)
+			{
+				if (Offset < (SpeckleUnrealLayers[i]->StartIndex + SpeckleUnrealLayers[i]->ObjectCount))
+					LayerIndex = i;
+			}
+		}
+
+		for (size_t i = 0; i < StreamObjects.Num(); i++)
+		{
+			TSharedPtr<FJsonObject> StreamObject = StreamObjects[i].Get()->AsObject();
+
+			TSharedPtr<FJsonObject> ObjectToConvert = StreamObject;
+
+			FString objectType = ObjectToConvert->GetStringField("type");
+
+			if (objectType.ToLower().Contains("brep"))
+			{
+				ObjectToConvert = StreamObject->GetObjectField("displayValue");
+
+				objectType = ObjectToConvert->GetStringField("type");
+			}
+
+			if (objectType.ToLower().Contains("mesh"))
+			{
+				EAttachmentRule rule = EAttachmentRule();
+				FAttachmentTransformRules rules = FAttachmentTransformRules(rule, false);
+
+				ASpeckleUnrealMesh* MeshInstance = World->SpawnActor<ASpeckleUnrealMesh>(ASpeckleUnrealMesh::StaticClass());
+
+				TArray<TSharedPtr<FJsonValue>> ObjectVertices = ObjectToConvert->GetArrayField("vertices");
+				TArray<TSharedPtr<FJsonValue>> ObjectFaces = ObjectToConvert->GetArrayField("faces");
+
+				TArray<FVector> ParsedVerticies;
+
+				for (size_t j = 0; j < ObjectVertices.Num(); j += 3)
+				{
+					ParsedVerticies.Add(FVector
+					(
+						(float)(ObjectVertices[j].Get()->AsNumber()) * -1,
+						(float)(ObjectVertices[j + 1].Get()->AsNumber()),
+						(float)(ObjectVertices[j + 2].Get()->AsNumber())
+					) * ScaleFactor);
+				}
+
+				//convert mesh faces into triangle array regardless of whether or not they are quads
+				TArray<int32> ParsedTriangles;
+				int32 j = 0;
+				while (j < ObjectFaces.Num())
+				{
+					if (ObjectFaces[j].Get()->AsNumber() == 0)
+					{
+						//Triangles
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 2].Get()->AsNumber());
+						j += 4;
+					}
+					else
+					{
+						//Quads to triangles
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 2].Get()->AsNumber());
+
+						ParsedTriangles.Add(ObjectFaces[j + 3].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 1].Get()->AsNumber());
+						ParsedTriangles.Add(ObjectFaces[j + 4].Get()->AsNumber());
+
+						j += 5;
+					}
+				}
+
+				if (RandomColorsPerLayer)
+					MeshInstance->SetMesh(ParsedVerticies, ParsedTriangles, DefaultMeshMaterial, SpeckleUnrealLayers[LayerIndex]->LayerColor);
+				else
+					MeshInstance->SetMesh(ParsedVerticies, ParsedTriangles, DefaultMeshMaterial, FLinearColor::White);
+
+				MeshInstance->AttachToActor(SpeckleUnrealLayers[LayerIndex], rules);
+
+				UE_LOG(LogTemp, Warning, TEXT("%d"), Offset);
+				UE_LOG(LogTemp, Warning, TEXT("%s"), *SpeckleUnrealLayers[LayerIndex]->LayerName);
+
+			}
+		}
+	}
+	else
+	{
+		GEngine->AddOnScreenDebugMessage(1, 5.0f, FColor::Red, "Couldn't deserialize Json from object response");
+		GEngine->AddOnScreenDebugMessage(2, 10.0f, FColor::Red, Response->GetContentAsString());
+	}
+
+	
+	ObjectsReceived[Offset] = true;
+}
+
+float USpeckleUnrealReceiver::GetStreamProgress()
+{
+	if (ObjectsReceived.Num() == 0)
+		return 0;
+
+	float ProgressMade = 0;
+
+	for (size_t i = 0; i < ObjectsReceived.Num(); i++)
+	{
+		if (ObjectsReceived[i])
+			ProgressMade++;
+	}
+
+	return ProgressMade / ObjectsReceived.Num();
+}