添加URL格式的加载

Assets.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1d48ac5a4038bf741a0022d20d024eaf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9a1b612b2d63af94bb600ad2dab28911
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Platform.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3d4294976f3254043aab44b464012021
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8d2210aea6a923f4d86da56fcde2dfaa
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/LoadSample.cs

@@ -0,0 +1,50 @@
+using System.Collections;
+using System.Collections.Generic;
+using TriLibCore;
+using UnityEngine;
+
+public class LoadSample : MonoBehaviour
+{/// <summary>
+ /// The Model URL.
+ /// </summary>
+     string ModelURL = "https://ricardoreis.net/trilib/demos/sample/TriLibSampleModel.zip";/// <summary>
+                                                                                                 /// The Model URL.
+                                                                                                 /// </summary>
+     string ModelfILE = "D:\\JiHe\\MMD20230728021557 (1)\\Unity2GLTF.gltf";
+    // Start is called before the first frame update
+    void Start()
+    {
+        TriLibModelLoad.Load(ModelURL, (AssetLoaderContext ac) => {
+            Debug.Log("模型加载完成");
+        }, (AssetLoaderContext ac) => {
+            Debug.Log("载材质加完成");
+            ac.RootGameObject.transform.position = Camera.main.transform.forward;
+
+        }, (AssetLoaderContext ac, float f) => {
+
+            Debug.Log("加载中==》" + f);
+        }, (IContextualizedError error) => {
+
+            Debug.Log("加载失败" + error);
+        });
+        TriLibModelLoad.Load(ModelfILE, (AssetLoaderContext ac) => {
+            Debug.Log("模型加载完成");
+        }, (AssetLoaderContext ac) => {
+            Debug.Log("载材质加完成");
+            ac.RootGameObject.transform.position = Camera.main.transform.forward;
+
+        }, (AssetLoaderContext ac, float f) => {
+
+            Debug.Log("加载中==》" + f);
+        }, (IContextualizedError error) => {
+
+            Debug.Log("加载失败" + error);
+        });
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+    }
+}

Samples~/trilibSDK/LoadSample.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8dd87accf6661746bec546e809c5bca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/Scenes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6ea315d0fd7389c41b19996891e99ae3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/Scenes/SampleScene.unity

@@ -0,0 +1,317 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 705507994}
+  m_IndirectSpecularColor: {r: 0.18028378, g: 0.22571412, b: 0.30692285, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 500
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 2
+    m_PVRDenoiserTypeDirect: 0
+    m_PVRDenoiserTypeIndirect: 0
+    m_PVRDenoiserTypeAO: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 0
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &705507993
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 705507995}
+  - component: {fileID: 705507994}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &705507994
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 705507993}
+  m_Enabled: 1
+  serializedVersion: 10
+  m_Type: 1
+  m_Shape: 0
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+    m_CullingMatrixOverride:
+      e00: 1
+      e01: 0
+      e02: 0
+      e03: 0
+      e10: 0
+      e11: 1
+      e12: 0
+      e13: 0
+      e20: 0
+      e21: 0
+      e22: 1
+      e23: 0
+      e30: 0
+      e31: 0
+      e32: 0
+      e33: 1
+    m_UseCullingMatrixOverride: 0
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingLayerMask: 1
+  m_Lightmapping: 1
+  m_LightShadowCasterMode: 0
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_UseBoundingSphereOverride: 0
+  m_UseViewFrustumForShadowCasterCull: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &705507995
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 705507993}
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!1 &963194225
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 963194228}
+  - component: {fileID: 963194227}
+  - component: {fileID: 963194226}
+  - component: {fileID: 963194229}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &963194226
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 963194225}
+  m_Enabled: 1
+--- !u!20 &963194227
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 963194225}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &963194228
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 963194225}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &963194229
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 963194225}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d8dd87accf6661746bec546e809c5bca, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ModelURL: https://ricardoreis.net/trilib/demos/sample/TriLibSampleModel.zip

Samples~/trilibSDK/Scenes/SampleScene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9fc0d4010bbf28b4594072e72b8655ab
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/AssemblyDefinitions.zip.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 74ee13942fd5ebf458e8557d17bb0581
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b8b64140ddec434b9ed4abe6a36c0a0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8e0c0a32eb8819f4cb8869483da839ee
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d678ca13b18d6c14da3d0f0f31d422a9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/AssetLoaderOptionsEditor.cs

@@ -0,0 +1,221 @@
+using TriLibCore.General;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    [CustomEditor(typeof(AssetLoaderOptions))]
+    public class AssetLoaderOptionsEditor : UnityEditor.Editor
+    {
+        private int _currentTab;
+
+        public override void OnInspectorGUI()
+        {
+            ShowInspectorGUI(serializedObject, ref _currentTab);
+        }
+
+        public static void ShowInspectorGUI(SerializedObject serializedObject, ref int currentTab)
+        {
+            serializedObject.Update();
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Toggle(currentTab == 0, "Model", "LargeButtonLeft"))
+            {
+                currentTab = 0;
+            }
+            if (GUILayout.Toggle(currentTab == 1, "Rig", "LargeButtonMid"))
+            {
+                currentTab = 1;
+            }
+            if (GUILayout.Toggle(currentTab == 2, "Animations", "LargeButtonMid"))
+            {
+                currentTab = 2;
+            }
+            if (GUILayout.Toggle(currentTab == 3, "Materials", "LargeButtonMid"))
+            {
+                currentTab = 3;
+            }
+            if (GUILayout.Toggle(currentTab == 4, "Textures", "LargeButtonMid"))
+            {
+                currentTab = 4;
+            }
+            if (GUILayout.Toggle(currentTab == 5, "Misc.", "LargeButtonRight"))
+            {
+                currentTab = 5;
+            }
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.BeginVertical();
+            switch (currentTab)
+            {
+                case 0:
+                    GUILayout.Label(new GUIContent("Scene", "Scene import settings"), "BoldLabel");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ScaleFactor"), new GUIContent("Scale Factor", "Model scale multiplier."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("UseFileScale"), new GUIContent("Use File Scale", "Turn on this flag to use the file original scale."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ImportVisibility"), new GUIContent("Import Visibility", "Turn on this field to apply the visibility property to Mesh Renderers/Skinned Mesh Renderers."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ImportCameras"), new GUIContent("Import Cameras", "Turn on this field to enable Cameras importing."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ImportLights"), new GUIContent("Import Lights", "Turn on this field to enable Lights importing."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("Static"), new GUIContent("Import as Static", "Turn on this field to import the Model as a static Game Object."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("SortHierarchyByName"), new GUIContent("Sort Hierarchy by Name", "Turn on this field to sort the Model hierarchy by name."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("AddAssetUnloader"), new GUIContent("Add Asset Unloader", "Turn on this field to add the Asset Unloader Component to the loaded Game Object."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ShowLoadingWarnings"), new GUIContent("Show Loading Warnings", "Turn on this field to display Model loading warnings on the Console."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("CloseStreamAutomatically"), new GUIContent("Close Stream Automatically", "Turn on this field to close the Model loading Stream automatically."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("DestroyOnError"), new GUIContent("Destroy on Error", "Turn on this field to destroy the loaded Game Object automatically when there is any loading error."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("Timeout"), new GUIContent("Timeout", "Model loading timeout in seconds (0=disabled)."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("PivotPosition"), new GUIContent("Pivot Position", "Use this field to realign the Model pivot based on the given value."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("DisableObjectsRenaming"), new GUIContent("Disable Objects Renaming", "Turn on this field to disable objects renaming."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("MergeSingleChild"), new GUIContent("Merge Single Child", "Turn on this field to merge single child models into a single GameObject."));
+
+                    EditorGUILayout.Space();
+                    GUILayout.Label(new GUIContent("Meshes", "Global settings for generated meshes"), "BoldLabel");
+                    var importMeshesProperty = serializedObject.FindProperty("ImportMeshes");
+                    EditorGUILayout.PropertyField(importMeshesProperty, new GUIContent("Import Meshes", "Turn on this field to import Model Meshes."));
+                    if (importMeshesProperty.boolValue)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("MarkMeshesAsDynamic"), new GUIContent("Mark Meshes as Dynamic", "Turn on this field to mark created meshes as dynamic."));
+                        var generateCollidersProperty = serializedObject.FindProperty("GenerateColliders");
+                        EditorGUILayout.PropertyField(generateCollidersProperty, new GUIContent("Generate Colliders", "Turn on this field to generate Colliders for imported Meshes."));
+                        if (generateCollidersProperty.boolValue)
+                        {
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("ConvexColliders"), new GUIContent("Convex Colliders", "Turn on this field to generate convex Colliders when the GenerateColliders field is enabled."));
+                        }
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("KeepQuads"), new GUIContent("Keep Quads", "Turn on this field to mantain Mesh quads. (Useful for DX11 tesselation)"));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("MergeVertices"), new GUIContent("Merge Vertices", "Turn on this field to merge model duplicated vertices where possible."));
+                        var importNormalsProperty = serializedObject.FindProperty("ImportNormals");
+                        EditorGUILayout.PropertyField(importNormalsProperty, new GUIContent("Import Normals", "Turn on this field to import Mesh normals. If not enabled, normals will be calculated instead."));
+                        var generateNormalsProperty = serializedObject.FindProperty("GenerateNormals");
+                        if (generateNormalsProperty.boolValue)
+                        {
+                            EditorGUILayout.PropertyField(generateNormalsProperty, new GUIContent("Generate Normals", "Turn off this field to disable Mesh normals generation."));
+                            var useUnityNativeNormalCalculatorProperty = serializedObject.FindProperty("UseUnityNativeNormalCalculator");
+                            EditorGUILayout.PropertyField(useUnityNativeNormalCalculatorProperty, new GUIContent("Use Unity Native Normal Calculator", "Turn on this field to use the builtin Unity normal calculator."));
+                            if (!useUnityNativeNormalCalculatorProperty.boolValue)
+                            {
+                                EditorGUILayout.Slider(serializedObject.FindProperty("SmoothingAngle"), 0f, 180f, new GUIContent("Smoothing Angle", "Normals calculation smoothing angle."));
+                            }
+                        }
+                        var importBlendShapesProperty = serializedObject.FindProperty("ImportBlendShapes");
+                        EditorGUILayout.PropertyField(importBlendShapesProperty, new GUIContent("Import Blend Shapes", "Turn on this field to import Mesh Blend Shapes."));
+                        if (importBlendShapesProperty.boolValue)
+                        {
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("ImportBlendShapeNormals"), new GUIContent("Import Blend Shape Normals", "Turn on this field to import Mesh Blend Shape normals."));
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("CalculateBlendShapeNormals"), new GUIContent("Calculate Blend Shape Normals", "Turn on this field to calculate Mesh Blend Shape normals when none can be imported."));
+                        }
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ImportColors"), new GUIContent("Import Colors", "Turn on this field to import Mesh Colors."));
+                        var importTangentsProperty = serializedObject.FindProperty("ImportTangents");
+                        EditorGUILayout.PropertyField(importTangentsProperty, new GUIContent("Import Tangents", "Turn on this field to import Mesh tangents. If not enabled, tangents will be calculated instead."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("GenerateTangents"), new GUIContent("Generate Tangents", "Turn off this field to disable Mesh tangents generation."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("SwapUVs"), new GUIContent("Swap UVs", "Turn on this field to swap Mesh UVs. (uv1 into uv2)"));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("LODScreenRelativeTransitionHeightBase"), new GUIContent("LOD Screen Relative Transition Height Base", "Defines the initial screen relative transition height when creating LOD Groups."));
+                        //todo: deprecated
+                        //EditorGUILayout.PropertyField(serializedObject.FindProperty("CreateVerticesAsNativeLists"), new GUIContent("Create Vertices as Native Lists", "Turn on this field to load Mesh vertices using Native Lists (Experimental)."));
+                        //todo: future update
+                        //EditorGUILayout.PropertyField(serializedObject.FindProperty("CompressMeshes"), new GUIContent("Compress Meshes", "Turn on this field to compress meshes \"normal\", \"tangent\", \"uv0\", \"uv1\", \"uv2\", \"uv4\" and \"color\" values to 16 bits."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ReadEnabled"), new GUIContent("Read Enabled", "Turn on this field to make mesh CPU data readable."));
+                    }
+                    var loadPointCloudsProperty = serializedObject.FindProperty("LoadPointClouds");
+                    EditorGUILayout.PropertyField(loadPointCloudsProperty, new GUIContent("Load Point Clouds", "TTurn on this field to load the model as a Point Cloud (PLY and OBJ only)"));
+                    if (!loadPointCloudsProperty.boolValue)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("OptimizeMeshes"), new GUIContent("Optimize Meshes", "Turn on this field to optimize imported Meshes for GPU access."));
+                    }
+                    break;
+                case 1:
+                    var animationTypeProperty = serializedObject.FindProperty("AnimationType");
+                    EditorGUILayout.PropertyField(animationTypeProperty, new GUIContent("Animation Type", "Model rigging type."));
+                    var animationType = (AnimationType)animationTypeProperty.intValue;
+                    switch (animationType)
+                    {
+                        case AnimationType.Generic:
+                        case AnimationType.Humanoid:
+
+                            var avatarDefinitionTypeProperty = serializedObject.FindProperty("AvatarDefinition");
+                            EditorGUILayout.PropertyField(avatarDefinitionTypeProperty, new GUIContent("Avatar Definition", "Type of avatar creation for the Model."));
+                            var avatarDefinitionType = (AvatarDefinitionType)avatarDefinitionTypeProperty.intValue;
+                            switch (avatarDefinitionType)
+                            {
+                                case AvatarDefinitionType.CreateFromThisModel:
+                                    if (animationType == AnimationType.Humanoid)
+                                    {
+                                        EditorGUILayout.PropertyField(serializedObject.FindProperty("HumanDescription"), new GUIContent("Human Description", "Human Description used to create the humanoid Avatar, when the humanoid rigging type is selected."));
+                                        EditorGUILayout.PropertyField(serializedObject.FindProperty("SampleBindPose"), new GUIContent("Sample Bind Pose", "Turn on this field to enforce the loaded Model to the bind-pose when rigging."));
+                                        EditorGUILayout.PropertyField(serializedObject.FindProperty("EnforceTPose"), new GUIContent("Enforce T-Pose", "Turn on this field to enforce the loaded Model to the t-pose when rigging."));
+                                        EditorGUILayout.PropertyField(serializedObject.FindProperty("HumanoidAvatarMapper"), new GUIContent("Humanoid Avatar Mapper", "Mapper used to map the humanoid Avatar, when the humanoid rigging type is selected."));
+                                    }
+                                    break;
+                                case AvatarDefinitionType.CopyFromOtherAvatar:
+                                    EditorGUILayout.PropertyField(serializedObject.FindProperty("Avatar"), new GUIContent("Source", "Source Avatar to use when copying from other Avatar."));
+                                    break;
+                            }
+                            break;
+                        case AnimationType.Legacy:
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("AutomaticallyPlayLegacyAnimations"), new GUIContent("Play Legacy Animations Automatically", "Turn on this field to play Legacy Animation Clips automatically (The first available Clip will be played)."));
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("EnforceAnimatorWithLegacyAnimations"), new GUIContent("Enforce Animator with Legacy Animations", "Turn on this field to add an Animator when the AnimationType is set to Legacy."));
+                            break;
+                    }
+                    if (animationType != AnimationType.None)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("RootBoneMapper"), new GUIContent("Root Bone Mapper", "Mapper used to find the Model root bone."));
+                    }
+                    break;
+                case 2:
+                    animationTypeProperty = serializedObject.FindProperty("AnimationType");
+                    animationType = (AnimationType)animationTypeProperty.intValue;
+                    //todo: constraints
+                    if (animationType != AnimationType.None)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("EnsureQuaternionContinuity"), new GUIContent("Ensure Quaternion Continuity", "Turn on this field to realign quaternion keys to ensure shortest interpolation paths."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ResampleFrequency"), new GUIContent("Resample Frequency", "Defines the FBX Rotation Animation Curve resampling frequency. (1 = every frame, 2 = every 2 frames, 3 = every 3 frames and so on)"));
+                        //todo: keyframe reduction
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("AnimationWrapMode"), new GUIContent("Wrap Mode", "Default wrap-mode to apply to Animations."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("AnimationClipMappers"), new GUIContent("Animation Clip Mappers", "Mappers used to process Animation Clips."));
+                    }
+                    break;
+                case 3:
+                    var importMaterialsProperty = serializedObject.FindProperty("ImportMaterials");
+                    EditorGUILayout.PropertyField(importMaterialsProperty, new GUIContent("Import Materials", "Turn on this field to import Materials."));
+                    if (importMaterialsProperty.boolValue)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("UseMaterialKeywords"), new GUIContent("Use Material Keywords", "Turn on this field to enable/disable created Material Keywords based on the source native Materials."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("AlphaMaterialMode"), new GUIContent("Alpha Material Mode", "Chooses the way TriLib creates alpha materials."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("MaterialMappers"), new GUIContent("Material Mappers", "Mappers used to create suitable Unity Materials from original Materials."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("DoubleSidedMaterials"), new GUIContent("Double Sided Materials", "Turn on this field to create double-sided Materials (TriLib does that by duplicating the original Meshes)."));
+                         EditorGUILayout.PropertyField(serializedObject.FindProperty("SetUnusedTexturePropertiesToNull"), new GUIContent("Set unused Texture Properties to Null", "Turn on this field to set the unused Material Texture Properties to null."));
+                    }
+                    break;
+                case 4:
+                    var importTexturesProperty = serializedObject.FindProperty("ImportTextures");
+                    EditorGUILayout.PropertyField(importTexturesProperty, new GUIContent("Import Textures", "Turn on this field to import Textures."));
+                    if (importTexturesProperty.boolValue)
+                    {
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureMapper"), new GUIContent("Deprecated: Texture Mapper", "Mapper used to find native Texture Streams from custom sources."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureMappers"), new GUIContent("Texture Mappers", "Mappers used to find native Texture Streams from custom sources."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureCompressionQuality"), new GUIContent("Texture Compression Quality", "Texture compression to apply on loaded Textures."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("GenerateMipmaps"), new GUIContent("Generate Mipmaps", "Turn on this field to enable Textures mip-map generation."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("FixNormalMaps"), new GUIContent("Fix Normal Maps", "Turn on this field to change normal map channels order to ABBR instead of RGBA."));
+                        var alphaMaterialModeProperty = serializedObject.FindProperty("AlphaMaterialMode");
+                        if (alphaMaterialModeProperty.enumValueIndex > 0)
+                        {
+                            EditorGUILayout.PropertyField(serializedObject.FindProperty("ScanForAlphaPixels"), new GUIContent("Scan for Alpha Pixels", "Turn on this field to scan Textures for alpha-blended pixels in order to generate transparent Materials."));
+                        }
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("LoadTexturesAsSRGB"), new GUIContent("Load Textures as sRGB", "Turn off this field to load textures as linear, instead of sRGB."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ApplyGammaCurveToMaterialColors"), new GUIContent("Apply Gamma Curve to Material Colors", "When this field is on, TriLib will also apply the gamma curve to the material colors."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ApplyTexturesOffsetAndScaling"), new GUIContent("Apply Textures Offset and Scaling", "Turn on this field to apply Textures offset and scaling."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("DiscardUnusedTextures"), new GUIContent("Discard Unused Textures", "Turn off this field to keep unused Textures."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ForcePowerOfTwoTextures"), new GUIContent("Force Power of Two Textures", "Turn on this field to enforce power of two resolution when loading textures (needed for texture compression and in some platforms)."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("UseUnityNativeTextureLoader"), new GUIContent("Use Unity Native Texture Loader", "Turn on this field to use Unity builtin Texture loader instead of stb_image."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("MaxTexturesResolution"), new GUIContent("Max Textures Resolution", "Use this field to limit textures resolution. Textures with resolutions higher than this value (when the value is not zero) will not be loaded."));
+                        EditorGUILayout.PropertyField(serializedObject.FindProperty("ConvertMaterialTexturesUsingHalfRes"), new GUIContent("Convert Material Textures using Half Res", "Turn off this field to generate the \"Metallic/Smoothness/Specular/Roughness\" textures with the full original resolution."));
+
+                        
+                    }
+                    break;
+                case 5:
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("ExternalDataMapper"), new GUIContent("External Data Mapper", "Mapper used to find data Streams on external sources."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("UserPropertiesMapper"), new GUIContent("User Properties Mapper", " Mapper used to process User Properties from Models."));
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("LipSyncMappers"), new GUIContent("Lip Sync Mappers", "Mappers used to configure Lip-Sync Blend Shapes."));
+                    break;
+            }
+            EditorGUILayout.EndVertical();
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/AssetLoaderOptionsEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e964c5e158b24dc6ad03b0a14c2ef811
+timeCreated: 1573053965

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/BuildProcessor.cs

@@ -0,0 +1,61 @@
+using System;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+
+namespace TriLibCore.Editor
+{
+    public class BuildProcessor : IPreprocessBuildWithReport
+    {
+        public int callbackOrder => -1000;
+
+        public void OnPreprocessBuild(BuildReport report)
+        {
+#if TRILIB_ENABLE_WEBGL_THREADS
+            PlayerSettings.WebGL.threadsSupport = true;
+#else
+            PlayerSettings.WebGL.threadsSupport = false;
+#endif
+#if UNITY_WSA
+            if (!Application.isBatchMode && !PlayerSettings.WSA.GetCapability(PlayerSettings.WSACapability.RemovableStorage) && EditorUtility.DisplayDialog(
+                    "TriLib", "TriLib cache system needs the [RemovableStorage] WSA Capacity enabled. Do you want to enable it?", "Yes", "No"))
+            {
+                PlayerSettings.WSA.SetCapability(PlayerSettings.WSACapability.RemovableStorage, true);
+            }
+#endif
+            var waitingMappers = false;
+            string materialMapper = null;
+            var arguments = Environment.GetCommandLineArgs();
+            for (var i = 0; i < arguments.Length; i++)
+            {
+                var argument = arguments[i];
+                if (waitingMappers)
+                {
+                    materialMapper = argument;
+                    continue;
+                }
+
+                switch (argument)
+                {
+                    case "-trilib_mappers":
+                        {
+                            waitingMappers = true;
+                            break;
+                        }
+                }
+            }
+
+            if (materialMapper is object)
+            {
+                Debug.Log($"Using the given material mapper:{materialMapper}.");
+                CheckMappers.SelectMapper(materialMapper);
+            }
+            else
+            {
+                CheckMappers.Initialize();
+            }
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/BuildProcessor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d556beac2d22e38459a0060666d79950
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/CheckMappers.cs

@@ -0,0 +1,76 @@
+using TriLibCore.Mappers;
+using TriLibCore.Utils;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    public static class CheckMappers
+    {
+        [InitializeOnEnterPlayMode]
+        [InitializeOnLoadMethod]
+        public static void Initialize()
+        {
+            var hasAnyMapper = false;
+            for (var i = 0; i < MaterialMapper.RegisteredMappers.Count; i++)
+            {
+                var materialMapperName = MaterialMapper.RegisteredMappers[i];
+                if (TriLibSettings.GetBool(materialMapperName))
+                {
+                    hasAnyMapper = true;
+                    break;
+                }
+            }
+
+            if (!hasAnyMapper)
+            {
+                string materialMapper;
+                if (GraphicsSettingsUtils.IsUsingHDRPPipeline)
+                {
+                    materialMapper = "HDRPMaterialMapper";
+                }
+                else if (GraphicsSettingsUtils.IsUsingUniversalPipeline)
+                {
+                    materialMapper = "UniversalRPMaterialMapper";
+                }
+                else
+                {
+                    materialMapper = "StandardMaterialMapper";
+                }
+                Debug.Log($"TriLib is configured to use the '{materialMapper}' Material Mapper. If you want to use different Material Mappers, you can change this setting on the Project Settings/TriLib area.");
+                TriLibSettings.SetBool(materialMapper, true);
+            }
+        }
+
+        [MenuItem("Tools/TriLib/Select Material Mappers based on Rendering Pipeline")]
+        public static void AutoSelect()
+        {
+            for (var i = 0; i < MaterialMapper.RegisteredMappers.Count; i++)
+            {
+                var materialMapperName = MaterialMapper.RegisteredMappers[i];
+                TriLibSettings.SetBool(materialMapperName, false);
+            }
+
+            string materialMapper;
+            if (GraphicsSettingsUtils.IsUsingHDRPPipeline)
+            {
+                materialMapper = "HDRPMaterialMapper";
+            }
+            else if (GraphicsSettingsUtils.IsUsingUniversalPipeline)
+            {
+                materialMapper = "UniversalRPMaterialMapper";
+            }
+            else
+            {
+                materialMapper = "StandardMaterialMapper";
+            }
+            SelectMapper(materialMapper);
+        }
+
+        public static void SelectMapper(string materialMapper)
+        {
+            Debug.Log($"TriLib is configured to use the '{materialMapper}' Material Mapper. If you want to use different Material Mappers, you can change this setting on the Project Settings/TriLib area.");
+            TriLibSettings.SetBool(materialMapper, true);
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/CheckMappers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 19aa55894ca34a84db70e98de607f5da
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/ImporterOption.cs

@@ -0,0 +1,17 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    public class ImporterOption : GUIContent
+    {
+        public readonly string Namespace;
+        public readonly PluginImporter PluginImporter;
+
+        public ImporterOption(string name, string @namespace, PluginImporter pluginImporter) : base(name)
+        {
+            Namespace = @namespace;
+            PluginImporter = pluginImporter;
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/ImporterOption.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c201497c49b244e8a7ae0152eb5ad027
+timeCreated: 1573070165

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/LipSyncMappingEditor.cs

@@ -0,0 +1,38 @@
+using TriLibCore.General;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    [CustomEditor(typeof(LipSyncMapping))]
+    public class LipSyncMappingEditor : UnityEditor.Editor
+    {
+        private SkinnedMeshRenderer _skinnedMeshRenderer;
+
+        private void OnEnable()
+        {
+            _skinnedMeshRenderer = ((LipSyncMapping) target).GetComponent<SkinnedMeshRenderer>();
+        }
+
+        private void OnDisable()
+        {
+            _skinnedMeshRenderer = null;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (_skinnedMeshRenderer == null)
+            {
+                base.OnInspectorGUI();
+                return;
+            }
+            GUI.enabled = false;
+            var visemeToBlendShapeTargets = serializedObject.FindProperty("VisemeToBlendTargets");
+            for (var i = 0; i < 14; i++)
+            {
+                EditorGUILayout.TextField(((LipSyncViseme) i).ToString(), _skinnedMeshRenderer.sharedMesh.GetBlendShapeName(visemeToBlendShapeTargets.GetArrayElementAtIndex(i).intValue));
+            }
+            GUI.enabled = true;
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/LipSyncMappingEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4660b91c10b46834391a27f679f07187
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/MapperContextActions.cs

@@ -0,0 +1,44 @@
+using TriLibCore.Mappers;
+using TriLibCore.Utils;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    public class MapperContextActions : MonoBehaviour
+    {
+        [MenuItem("Assets/Create Mapper Instance")]
+        private static void CreateInstance()
+        {
+            var monoScript = Selection.activeObject as MonoScript;
+            if (monoScript != null)
+            {
+                var scriptableObject = ScriptableObject.CreateInstance(monoScript.GetClass());
+                var assetPath = AssetDatabase.GetAssetPath(monoScript);
+                var directory = FileUtils.GetFileDirectory(assetPath);
+                var name = FileUtils.GetFilenameWithoutExtension(assetPath);
+                AssetDatabase.CreateAsset(scriptableObject, $"{directory}/{name}.asset");
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        [MenuItem("Assets/Create Mapper Instance", true)]
+        private static bool Validate()
+        {
+            if (Selection.activeObject is MonoScript monoScript)
+            {
+                var @class = monoScript.GetClass();
+                return
+                    typeof(AnimationClipMapper).IsAssignableFrom(@class) ||
+                    typeof(MaterialMapper).IsAssignableFrom(@class) ||
+                    typeof(TextureMapper).IsAssignableFrom(@class) ||
+                    typeof(HumanoidAvatarMapper).IsAssignableFrom(@class) ||
+                    typeof(RootBoneMapper).IsAssignableFrom(@class) ||
+                    typeof(LipSyncMapper).IsAssignableFrom(@class) ||
+                    typeof(UserPropertiesMapper).IsAssignableFrom(@class) ||
+                    typeof(ExternalDataMapper).IsAssignableFrom(@class);
+            }
+            return false;
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/MapperContextActions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 222f79d3cf134a44483e2a2122cec110
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/PreBuiltResources.cs

@@ -0,0 +1,83 @@
+using TriLibCore.General;
+using TriLibCore.Mappers;
+using TriLibCore.Utils;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+using HumanLimit = TriLibCore.General.HumanLimit;
+
+namespace TriLibCore.Editor
+{
+    public class PreBuiltResources : UnityEditor.Editor
+    {
+
+        [MenuItem("Assets/Create/TriLib/Asset Loader Options/Pre-built Asset Loader Options")]
+        public static void CreatePreBuiltAssetLoaderOptions()
+        {
+            var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
+            AssetDatabase.CreateAsset(assetLoaderOptions, $"{FileUtils.GetFileDirectory(AssetDatabase.GetAssetPath(Selection.activeObject))}/AssetLoaderOptions.asset");
+        }
+        
+        [MenuItem("Assets/Create/TriLib/Mappers/Humanoid/Mixamo and Biped By Name Humanoid Avatar Mapper")]
+        public static void CreateMixamoAndBipedMapper()
+        {
+            var humanLimit = new HumanLimit();
+            var mapper = CreateInstance<ByNameHumanoidAvatarMapper>();
+            mapper.AddMapping(HumanBodyBones.Head, humanLimit, "Head", "Head1");
+            mapper.AddMapping(HumanBodyBones.Neck, humanLimit, "Neck", "Neck1");
+            mapper.AddMapping(HumanBodyBones.Chest, humanLimit, "Spine1");
+            mapper.AddMapping(HumanBodyBones.UpperChest, humanLimit, "Spine4", "Spine3", "Spine2", "Spine1");
+            mapper.AddMapping(HumanBodyBones.Spine, humanLimit, "Spine");
+            mapper.AddMapping(HumanBodyBones.Hips, humanLimit, "Hips", "Bip01", "Pelvis");
+            mapper.AddMapping(HumanBodyBones.LeftShoulder, humanLimit, "LeftShoulder", "L Clavicle", "L_Clavicle");
+            mapper.AddMapping(HumanBodyBones.LeftUpperArm, humanLimit, "LeftArm", "L UpperArm", "L_UpperArm");
+            mapper.AddMapping(HumanBodyBones.LeftLowerArm, humanLimit, "LeftForeArm", "L Forearm", "L_Forearm");
+            mapper.AddMapping(HumanBodyBones.LeftHand, humanLimit, "LeftHand", "L Hand", "L_Hand", "LeftWrist");
+            mapper.AddMapping(HumanBodyBones.RightShoulder, humanLimit, "RightShoulder", "R Clavicle", "R_Clavicle");
+            mapper.AddMapping(HumanBodyBones.RightUpperArm, humanLimit, "RightArm", "R UpperArm", "R_UpperArm");
+            mapper.AddMapping(HumanBodyBones.RightLowerArm, humanLimit, "RightForeArm", "R Forearm", "R_Forearm");
+            mapper.AddMapping(HumanBodyBones.RightHand, humanLimit, "RightHand", "R Hand", "R_Hand", "RightWrist");
+            mapper.AddMapping(HumanBodyBones.LeftUpperLeg, humanLimit, "LeftUpLeg", "L Thigh", "L_Thigh");
+            mapper.AddMapping(HumanBodyBones.LeftLowerLeg, humanLimit, "LeftLeg", "L Calf", "L_Calf");
+            mapper.AddMapping(HumanBodyBones.LeftFoot, humanLimit, "LeftFoot", "L Foot", "L_Foot");
+            mapper.AddMapping(HumanBodyBones.LeftToes, humanLimit, "LeftToeBase", "L Toe0", "L_Toe0");
+            mapper.AddMapping(HumanBodyBones.RightUpperLeg, humanLimit, "RightUpLeg", "R Thigh", "R_Thigh");
+            mapper.AddMapping(HumanBodyBones.RightLowerLeg, humanLimit, "RightLeg", "R Calf", "R_Calf");
+            mapper.AddMapping(HumanBodyBones.RightFoot, humanLimit, "RightFoot", "R Foot", "R_Foot");
+            mapper.AddMapping(HumanBodyBones.RightToes, humanLimit, "RightToeBase", "R Toe0", "R_Toe0");
+            mapper.AddMapping(HumanBodyBones.LeftThumbProximal, humanLimit, "LeftHandThumb1", "L Finger0", "L_Finger0");
+            mapper.AddMapping(HumanBodyBones.LeftThumbIntermediate, humanLimit, "LeftHandThumb2", "L Finger01", "L_Finger01");
+            mapper.AddMapping(HumanBodyBones.LeftThumbDistal, humanLimit, "LeftHandThumb3", "L Finger02", "L_Finger02");
+            mapper.AddMapping(HumanBodyBones.LeftIndexProximal, humanLimit, "LeftHandIndex1", "L Finger1", "L_Finger1");
+            mapper.AddMapping(HumanBodyBones.LeftIndexIntermediate, humanLimit, "LeftHandIndex2", "L Finger11", "L_Finger11");
+            mapper.AddMapping(HumanBodyBones.LeftIndexDistal, humanLimit, "LeftHandIndex3", "L Finger12", "L_Finger12");
+            mapper.AddMapping(HumanBodyBones.LeftMiddleProximal, humanLimit, "LeftHandMiddle1", "L Finger2", "L_Finger2");
+            mapper.AddMapping(HumanBodyBones.LeftMiddleIntermediate, humanLimit, "LeftHandMiddle2", "L Finger21", "L_Finger21");
+            mapper.AddMapping(HumanBodyBones.LeftMiddleDistal, humanLimit, "LeftHandMiddle3", "L Finger22", "L_Finger22");
+            mapper.AddMapping(HumanBodyBones.LeftRingProximal, humanLimit, "LeftHandRing1", "L Finger3", "L_Finger3");
+            mapper.AddMapping(HumanBodyBones.LeftRingIntermediate, humanLimit, "LeftHandRing2", "L Finger31", "L_Finger31");
+            mapper.AddMapping(HumanBodyBones.LeftRingDistal, humanLimit, "LeftHandRing3", "L Finger32", "L_Finger32");
+            mapper.AddMapping(HumanBodyBones.LeftLittleProximal, humanLimit, "LeftHandPinky1", "L Finger4", "L_Finger4");
+            mapper.AddMapping(HumanBodyBones.LeftLittleIntermediate, humanLimit, "LeftHandPinky2", "L Finger41", "L_Finger41");
+            mapper.AddMapping(HumanBodyBones.LeftLittleDistal, humanLimit, "LeftHandPinky3", "L Finger42", "L_Finger42");
+            mapper.AddMapping(HumanBodyBones.RightThumbProximal, humanLimit, "RightHandThumb1", "R Finger0", "R_Finger0");
+            mapper.AddMapping(HumanBodyBones.RightThumbIntermediate, humanLimit, "RightHandThumb2", "R Finger01", "R_Finger01");
+            mapper.AddMapping(HumanBodyBones.RightThumbDistal, humanLimit, "RightHandThumb3", "R Finger02", "R_Finger02");
+            mapper.AddMapping(HumanBodyBones.RightIndexProximal, humanLimit, "RightHandIndex1", "R Finger1", "R_Finger1");
+            mapper.AddMapping(HumanBodyBones.RightIndexIntermediate, humanLimit, "RightHandIndex2", "R Finger11", "R_Finger11");
+            mapper.AddMapping(HumanBodyBones.RightIndexDistal, humanLimit, "RightHandIndex3", "R Finger12", "R_Finger12");
+            mapper.AddMapping(HumanBodyBones.RightMiddleProximal, humanLimit, "RightHandMiddle1", "R Finger2", "R_Finger2");
+            mapper.AddMapping(HumanBodyBones.RightMiddleIntermediate, humanLimit, "RightHandMiddle2", "R Finger21", "R_Finger21");
+            mapper.AddMapping(HumanBodyBones.RightMiddleDistal, humanLimit, "RightHandMiddle3", "R Finger22", "R_Finger22");
+            mapper.AddMapping(HumanBodyBones.RightRingProximal, humanLimit, "RightHandRing1", "R Finger3", "R_Finger3");
+            mapper.AddMapping(HumanBodyBones.RightRingIntermediate, humanLimit, "RightHandRing2", "R Finger31", "R_Finger31");
+            mapper.AddMapping(HumanBodyBones.RightRingDistal, humanLimit, "RightHandRing3", "R Finger32", "R_Finger32");
+            mapper.AddMapping(HumanBodyBones.RightLittleProximal, humanLimit, "RightHandPinky1", "R Finger4", "R_Finger4");
+            mapper.AddMapping(HumanBodyBones.RightLittleIntermediate, humanLimit, "RightHandPinky2", "R Finger41", "R_Finger41");
+            mapper.AddMapping(HumanBodyBones.RightLittleDistal, humanLimit, "RightHandPinky3", "R Finger42", "R_Finger42");
+            mapper.CaseInsensitive = true;
+            mapper.stringComparisonMode = StringComparisonMode.LeftEndsWithRight;
+            AssetDatabase.CreateAsset(mapper, $"{FileUtils.GetFileDirectory(AssetDatabase.GetAssetPath(Selection.activeObject))}/MixamoAndBipedByNameHumanoidAvatarMapper.asset");
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/PreBuiltResources.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26256a5ba4a8395469486a528ea78955
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/SimpleAnimationPlayerEditor.cs

@@ -0,0 +1,27 @@
+using TriLibCore.Playables;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    [CustomEditor(typeof(SimpleAnimationPlayer))]
+    public class SimpleAnimationPlayerEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            var simpleAnimationPlayer = (SimpleAnimationPlayer) target;
+            if (simpleAnimationPlayer.AnimationClips != null)
+            {
+                for (var i = 0; i < simpleAnimationPlayer.AnimationClips.Count; i++)
+                {
+                    var animationClip = simpleAnimationPlayer.AnimationClips[i];
+                    if (animationClip != null && GUILayout.Button(animationClip.name))
+                    {
+                        simpleAnimationPlayer.PlayAnimation(i);
+                    }
+                }
+            }
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/SimpleAnimationPlayerEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f2d92827e4bc43d68ac3a39cbdee0da3
+timeCreated: 1589229113

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLib3MFScriptedImporter.cs

@@ -0,0 +1,48 @@
+#pragma warning disable CS0105
+using System;
+using UnityEditor;
+using Object = UnityEngine.Object;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+namespace TriLibCore.Editor
+{
+#if !TRILIB_DISABLE_EDITOR_3MF_IMPORT
+    [ScriptedImporter(2, new[] { "3mf" })]
+#endif
+    public class TriLib3MFScriptedImporter : TriLibScriptedImporter
+    {
+
+    }
+	
+	[CustomEditor(typeof(TriLib3MFScriptedImporter))]
+    public class TriLib3MFImporterEditor : ScriptedImporterEditor
+    {
+        private int _currentTab;
+
+        protected override Type extraDataType => typeof(AssetLoaderOptions);
+
+        protected override void InitializeExtraDataInstance(Object extraData, int targetIndex)
+        {
+            var scriptedImporter = (TriLib3MFScriptedImporter) target;
+            var existingAssetLoaderOptions = scriptedImporter.AssetLoaderOptions;
+            EditorUtility.CopySerializedIfDifferent(existingAssetLoaderOptions, extraData);
+        }
+
+        protected override void Apply()
+        {
+            base.Apply();
+            var assetLoaderOptions = (AssetLoaderOptions) extraDataTarget;
+            var scriptedImporter = (TriLib3MFScriptedImporter) target;
+            scriptedImporter.AssetLoaderOptions = assetLoaderOptions;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            AssetLoaderOptionsEditor.ShowInspectorGUI(extraDataSerializedObject, ref _currentTab);
+            ApplyRevertGUI();
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLib3MFScriptedImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 860acb1e6b6c07e4c927af41c4fe20aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibDefineSymbolsHelper.cs

@@ -0,0 +1,54 @@
+using UnityEditor;
+
+namespace TriLibCore.Editor
+{
+    public static class TriLibDefineSymbolsHelper
+    {
+        public static bool IsSymbolDefined(string targetDefineSymbol)
+        {
+            var defineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+            var defineSymbolsArray = defineSymbols.Split(';');
+            for (var i = 0; i < defineSymbolsArray.Length; i++)
+            {
+                var defineSymbol = defineSymbolsArray[i];
+                var trimmedDefineSymbol = defineSymbol.Trim();
+                if (trimmedDefineSymbol == targetDefineSymbol)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static void UpdateSymbol(string targetDefineSymbol, bool value)
+        {
+            var defineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+            var defineSymbolsArray = defineSymbols.Split(';');
+            var newDefineSymbols = string.Empty;
+            var isDefined = false;
+            for (var i = 0; i < defineSymbolsArray.Length; i++)
+            {
+                var defineSymbol = defineSymbolsArray[i];
+                var trimmedDefineSymbol = defineSymbol.Trim();
+                if (trimmedDefineSymbol == targetDefineSymbol)
+                {
+                    if (!value)
+                    {
+                        continue;
+                    }
+
+                    isDefined = true;
+                }
+
+                newDefineSymbols += string.Format("{0};", trimmedDefineSymbol);
+            }
+
+            if (value && !isDefined)
+            {
+                newDefineSymbols += string.Format("{0};", targetDefineSymbol);
+            }
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, newDefineSymbols);
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibDefineSymbolsHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 125b4cfbcb29baa49830ec7c04854c32
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibDeprecationWarnings.cs

@@ -0,0 +1,7 @@
+namespace TriLibCore.Editor
+{
+    public static class TriLibDeprecationWarnings
+    {
+       
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibDeprecationWarnings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ea65d7911ef789442ada2b330273ae66
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibGLTFScriptedImporter.cs

@@ -0,0 +1,48 @@
+#pragma warning disable CS0105
+using System;
+using UnityEditor;
+using Object = UnityEngine.Object;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+namespace TriLibCore.Editor
+{
+#if !TRILIB_DISABLE_EDITOR_GLTF_IMPORT
+    [ScriptedImporter(2, new[] { "gltf", "glb"})]
+#endif
+    public class TriLibGLTFScriptedImporter : TriLibScriptedImporter
+    {
+
+    }
+	
+	[CustomEditor(typeof(TriLibGLTFScriptedImporter))]
+    public class TriLibGLTFImporterEditor : ScriptedImporterEditor
+    {
+        private int _currentTab;
+
+        protected override Type extraDataType => typeof(AssetLoaderOptions);
+
+        protected override void InitializeExtraDataInstance(Object extraData, int targetIndex)
+        {
+            var scriptedImporter = (TriLibGLTFScriptedImporter) target;
+            var existingAssetLoaderOptions = scriptedImporter.AssetLoaderOptions;
+            EditorUtility.CopySerializedIfDifferent(existingAssetLoaderOptions, extraData);
+        }
+
+        protected override void Apply()
+        {
+            base.Apply();
+            var assetLoaderOptions = (AssetLoaderOptions) extraDataTarget;
+            var scriptedImporter = (TriLibGLTFScriptedImporter) target;
+            scriptedImporter.AssetLoaderOptions = assetLoaderOptions;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            AssetLoaderOptionsEditor.ShowInspectorGUI(extraDataSerializedObject, ref _currentTab);
+            ApplyRevertGUI();
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibGLTFScriptedImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b41132147e7df9498566a67dbd40543
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibPLYScriptedImporter.cs

@@ -0,0 +1,48 @@
+#pragma warning disable CS0105
+using System;
+using UnityEditor;
+using Object = UnityEngine.Object;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+namespace TriLibCore.Editor
+{
+#if !TRILIB_DISABLE_EDITOR_PLY_IMPORT
+    [ScriptedImporter(2, new[] { "ply" })]
+#endif
+    public class TriLibPLYScriptedImporter : TriLibScriptedImporter
+    {
+
+    }
+	
+	[CustomEditor(typeof(TriLibPLYScriptedImporter))]
+    public class TriLibPLYImporterEditor : ScriptedImporterEditor
+    {
+        private int _currentTab;
+
+        protected override Type extraDataType => typeof(AssetLoaderOptions);
+
+        protected override void InitializeExtraDataInstance(Object extraData, int targetIndex)
+        {
+            var scriptedImporter = (TriLibPLYScriptedImporter) target;
+            var existingAssetLoaderOptions = scriptedImporter.AssetLoaderOptions;
+            EditorUtility.CopySerializedIfDifferent(existingAssetLoaderOptions, extraData);
+        }
+
+        protected override void Apply()
+        {
+            base.Apply();
+            var assetLoaderOptions = (AssetLoaderOptions) extraDataTarget;
+            var scriptedImporter = (TriLibPLYScriptedImporter) target;
+            scriptedImporter.AssetLoaderOptions = assetLoaderOptions;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            AssetLoaderOptionsEditor.ShowInspectorGUI(extraDataSerializedObject, ref _currentTab);
+            ApplyRevertGUI();
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibPLYScriptedImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 649469c6a3fb99e49a8b3ed0ff48d866
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSTLScriptedImporter.cs

@@ -0,0 +1,48 @@
+#pragma warning disable CS0105
+using System;
+using UnityEditor;
+using Object = UnityEngine.Object;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+namespace TriLibCore.Editor
+{
+#if !TRILIB_DISABLE_EDITOR_STL_IMPORT
+    [ScriptedImporter(2, new[] { "stl" })]
+#endif
+    public class TriLibSTLScriptedImporter : TriLibScriptedImporter
+    {
+
+    }
+	
+	[CustomEditor(typeof(TriLibSTLScriptedImporter))]
+    public class TriLibSTLImporterEditor : ScriptedImporterEditor
+    {
+        private int _currentTab;
+
+        protected override Type extraDataType => typeof(AssetLoaderOptions);
+
+        protected override void InitializeExtraDataInstance(Object extraData, int targetIndex)
+        {
+            var scriptedImporter = (TriLibSTLScriptedImporter) target;
+            var existingAssetLoaderOptions = scriptedImporter.AssetLoaderOptions;
+            EditorUtility.CopySerializedIfDifferent(existingAssetLoaderOptions, extraData);
+        }
+
+        protected override void Apply()
+        {
+            base.Apply();
+            var assetLoaderOptions = (AssetLoaderOptions) extraDataTarget;
+            var scriptedImporter = (TriLibSTLScriptedImporter) target;
+            scriptedImporter.AssetLoaderOptions = assetLoaderOptions;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            AssetLoaderOptionsEditor.ShowInspectorGUI(extraDataSerializedObject, ref _currentTab);
+            ApplyRevertGUI();
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSTLScriptedImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3053bb072954bb644a4a34101e211a63
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibScriptedImporter.cs

@@ -0,0 +1,64 @@
+#pragma warning disable CS0105
+using UnityEngine;
+using TriLibCore.Interfaces;
+using UnityEditor;
+using TriLibCore.Utils;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+namespace TriLibCore.Editor
+{
+    public class TriLibScriptedImporter : ScriptedImporter
+    {
+        public AssetLoaderOptions AssetLoaderOptions
+        {
+            get
+            {
+                var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions(true);
+                if (userData != null && userData != "null")
+                {
+                    EditorJsonUtility.FromJsonOverwrite(userData, assetLoaderOptions);
+                }
+                return assetLoaderOptions;
+            }
+            set => userData = EditorJsonUtility.ToJson(value);
+        }
+
+        public override void OnImportAsset(AssetImportContext assetImportContext)
+        {
+            var assetLoaderOptions = AssetLoaderOptions;
+            var assetLoaderContext = AssetLoader.LoadModelFromFileNoThread(assetImportContext.assetPath, OnError, null, assetLoaderOptions, CustomDataHelper.CreateCustomDataDictionaryWithData(assetImportContext));
+            if (assetLoaderContext.RootGameObject != null)
+            {
+                assetImportContext.AddObjectToAsset("Main", assetLoaderContext.RootGameObject);
+                assetImportContext.SetMainObject(assetLoaderContext.RootGameObject);
+                for (var i = 0; i < assetLoaderContext.Allocations.Count; i++)
+                {
+                    var allocation = assetLoaderContext.Allocations[i];
+                    if (string.IsNullOrWhiteSpace(allocation.name))
+                    {
+                        allocation.name = allocation.GetType().Name;
+                    }
+                    assetImportContext.AddObjectToAsset(allocation.name, allocation);
+                }
+            }
+        }
+
+        private static void OnError(IContextualizedError contextualizedError)
+        {
+            var exception = contextualizedError.GetInnerException();
+            if (contextualizedError.GetContext() is IAssetLoaderContext assetLoaderContext)
+            {
+                var assetImportContext = CustomDataHelper.GetCustomData<AssetImportContext>(assetLoaderContext.Context.CustomData);
+                if (assetImportContext != null)
+                {
+                    assetImportContext.LogImportError(exception.ToString());
+                    return;
+                }
+            }
+            Debug.LogError(exception.ToString());
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibScriptedImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6baa15879b9982542854c3ca3522da19
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSettingsProvider.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using TriLibCore.Mappers;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    public class TriLibSettingsProvider : SettingsProvider
+    {
+        private class Styles
+        {
+            public static readonly GUIStyle Group = new GUIStyle { padding = new RectOffset(10, 10, 5, 5) };
+        }
+
+        private static string _settingsFilePath;
+
+        public TriLibSettingsProvider(string path, SettingsScope scopes = SettingsScope.User, IEnumerable<string> keywords = null) : base(path, scopes, keywords)
+        {
+            var settingsAssetGuids = AssetDatabase.FindAssets("TriLibReaders");
+            if (settingsAssetGuids.Length > 0)
+            {
+                _settingsFilePath = AssetDatabase.GUIDToAssetPath(settingsAssetGuids[0]);
+            }
+            else
+            {
+                throw new Exception("Could not find TriLibReaders.cs file. Please re-import TriLib package.");
+            }
+        }
+
+        public override void OnGUI(string searchContext)
+        {
+            EditorGUILayout.Space();
+            var contentWidth = GUILayoutUtility.GetLastRect().width * 0.5f;
+            EditorGUIUtility.labelWidth = contentWidth;
+            EditorGUIUtility.fieldWidth = contentWidth;
+            GUILayout.BeginVertical(Styles.Group);
+            GUILayout.Label("Runtime Importing", EditorStyles.boldLabel);
+            GUILayout.Label("You can disable runtime file-formats importing here");
+            EditorGUILayout.Space();
+            ShowConditionalToggle("Disable runtime FBX importing", "TRILIB_DISABLE_FBX_IMPORT");
+            ShowConditionalToggle("Disable runtime gLTF2 importing", "TRILIB_DISABLE_GLTF_IMPORT");
+            ShowConditionalToggle("Disable runtime OBJ importing", "TRILIB_DISABLE_OBJ_IMPORT");
+            ShowConditionalToggle("Disable runtime STL importing", "TRILIB_DISABLE_STL_IMPORT");
+            ShowConditionalToggle("Disable runtime PLY importing", "TRILIB_DISABLE_PLY_IMPORT");
+            ShowConditionalToggle("Disable runtime 3MF importing", "TRILIB_DISABLE_3MF_IMPORT");
+            ShowConditionalToggle("Enable runtime DAE importing (Experimental)", "TRILIB_ENABLE_DAE_IMPORT");
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            GUILayout.Label("Editor Importing", EditorStyles.boldLabel);
+            GUILayout.Label("You can disable in editor file-formats importing to avoid conflicts with other editor importers");
+            EditorGUILayout.Space();
+            ShowConditionalToggle("Disable in editor gLTF2 importing", "TRILIB_DISABLE_EDITOR_GLTF_IMPORT");
+            ShowConditionalToggle("Disable in editor PLY importing", "TRILIB_DISABLE_EDITOR_PLY_IMPORT");
+            ShowConditionalToggle("Disable in editor 3MF importing", "TRILIB_DISABLE_EDITOR_3MF_IMPORT");
+            ShowConditionalToggle("Disable in editor STL importing", "TRILIB_DISABLE_EDITOR_STL_IMPORT");
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            GUILayout.Label("Material Mappers", EditorStyles.boldLabel);
+            GUILayout.Label("Select the material mappers according to your project rendering pipeline");
+            EditorGUILayout.Space();
+            for (var i = 0; i < MaterialMapper.RegisteredMappers.Count; i++)
+            {
+                var materialMapperName = MaterialMapper.RegisteredMappers[i];
+                var value = TriLibSettings.GetBool(materialMapperName);
+                var newValue = EditorGUILayout.Toggle(materialMapperName, value);
+                if (newValue != value)
+                {
+                    TriLibSettings.SetBool(materialMapperName, newValue);
+                }
+            }
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            GUILayout.Label("Misc Options", EditorStyles.boldLabel);
+            GUILayout.Label("Advanced and experimental options");
+            EditorGUILayout.Space();
+            //todo: future update
+            //ShowConditionalToggle("Use FBX SDK (Experimental)", "TRILIB_USE_FBXSDK", ShowFBXSDKDisclaimer);
+            //ShowConditionalToggle("Load Meshes on parallel Threads (Unity 2020.2 onwards)", "TRILIB_LOAD_MESHES_ON_PARALLEL_THREAD");
+            ShowConditionalToggle("Enable UWP threaded loading (Experimental)", "TRILIB_ENABLE_UWP_THREADS");
+            //ShowConditionalToggle("Enable WebGL threaded loading (Experimental)", "TRILIB_ENABLE_WEBGL_THREADS");
+            ShowConditionalToggle("Enable gLTF2 Draco decompression (Experimental)", "TRILIB_DRACO");
+            ShowConditionalToggle("Force synchronous loading", "TRILIB_FORCE_SYNC");
+            ShowConditionalToggle("Change thread names (Debug purposes only)", "TRILIB_USE_THREAD_NAMES");
+            ShowConditionalToggle("Disable asset loader options validations", "TRILIB_DISABLE_VALIDATIONS");
+            ShowConditionalToggle("Show advanced memory usage (Windows only)", "TRILIB_SHOW_MEMORY_USAGE");
+            EditorGUILayout.Space();
+            GUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("Version Notes"))
+            {
+                TriLibVersionNotes.ShowWindow();
+            }
+            if (GUILayout.Button("API Reference"))
+            {
+                Application.OpenURL("https://ricardoreis.net/trilib/trilib2/docs/");
+            }
+            if (GUILayout.Button("Wiki"))
+            {
+                Application.OpenURL("https://ricardoreis.net/trilibwiki");
+            }
+            if (GUILayout.Button("Support"))
+            {
+                Application.OpenURL("https://ricardoreis.net/contact/");
+            }
+            GUILayout.EndHorizontal();
+            GUILayout.EndVertical();
+            CheckMappers.Initialize();
+            base.OnGUI(searchContext);
+        }
+
+        private void ShowConditionalToggle(string label, string symbol, Action<bool> onChange = null)
+        {
+            var currentValue = TriLibDefineSymbolsHelper.IsSymbolDefined(symbol);
+            var newValue = EditorGUILayout.Toggle(label, currentValue);
+            if (newValue != currentValue)
+            {
+                TriLibDefineSymbolsHelper.UpdateSymbol(symbol, newValue);
+                onChange?.Invoke(newValue);
+            }
+        }
+
+        [SettingsProvider]
+        public static SettingsProvider TriLib()
+        {
+            var provider = new TriLibSettingsProvider("Project/TriLib", SettingsScope.Project)
+            {
+                keywords = GetSearchKeywordsFromGUIContentProperties<Styles>()
+            };
+            return provider;
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSettingsProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a5b653e1047e419fb6dc0d9b9d4d2c46
+timeCreated: 1573055735

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSplashScreen.cs

@@ -0,0 +1,23 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    [InitializeOnLoad]
+    public class TriLibSplashScreen
+    {
+        static TriLibSplashScreen()
+        {
+            EditorApplication.update += Update;
+        }
+
+        private static void Update()
+        {
+            EditorApplication.update -= Update;
+            if (!EditorApplication.isPlayingOrWillChangePlaymode && !EditorPrefs.GetBool(TriLibVersionInfo.Instance.SkipVersionInfoKey))
+            {
+                TriLibVersionNotes.ShowWindow();
+            }
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibSplashScreen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 11d5e1e8c2814ec46b6dac8c8c4b69bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibVersionInfo.cs

@@ -0,0 +1,34 @@
+namespace TriLibCore.Editor
+{
+    public class TriLibVersionInfo
+    {
+        private static TriLibVersionInfo _instance;
+
+        public string CurrentVersion
+        {
+            get
+            {
+                var assembly = System.Reflection.Assembly.GetAssembly(typeof(TriLibCore.ReaderBase));
+                var fileVersionInfo = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location);
+                return fileVersionInfo.ProductVersion;
+            }
+        }
+
+        public string SkipVersionInfoKey
+        {
+            get { return $"TriLibSkipVersionInfo{CurrentVersion}"; }
+        }
+
+        public static TriLibVersionInfo Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new TriLibVersionInfo();
+                }
+                return _instance;
+            }
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibVersionInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd2438f4fdd2cdb42b08cd9116118e21
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibVersionNotes.cs

@@ -0,0 +1,132 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace TriLibCore.Editor
+{
+    public class TriLibVersionNotes : EditorWindow
+    {
+        private class Styles
+        {
+            public const float WindowWidth = 0.75f;
+            public const float WindowHeight = 0.5f;
+            public static readonly GUIStyle HeaderStyle = new GUIStyle("label") { fontSize = 19, fontStyle = FontStyle.Bold, margin = new RectOffset(10, 10, 5, 5) };
+            public static readonly GUIStyle SubHeaderStyle = new GUIStyle("label") { margin = new RectOffset(10, 10, 5, 5), fontStyle = FontStyle.Bold };
+            public static readonly GUIStyle TextStyle = new GUIStyle("label") { margin = new RectOffset(20, 20, 5, 5) };
+            public static readonly GUIStyle TextAreaStyle = new GUIStyle(TextStyle) { wordWrap = true };
+            public static readonly GUIStyle ButtonStyle = new GUIStyle("button") { margin = new RectOffset(10, 10, 5, 5) };
+        }
+
+        private string _text;
+        private bool _loaded;
+        private Vector2 _changeLogScrollPosition;
+        private Vector2 _notesScrollPosition;
+
+        private static TriLibVersionNotes Instance
+        {
+            get
+            {
+                var window = GetWindow<TriLibVersionNotes>();
+                window.titleContent = new GUIContent("TriLib Version Notes");
+                window.minSize = new Vector2(Styles.WindowWidth * Screen.width, Styles.WindowHeight * Screen.height);
+                return window;
+            }
+        }
+
+
+        public static void ShowWindow()
+        {
+            Instance.Show();
+        }
+
+        private void OnDestroy()
+        {
+            EditorPrefs.SetBool(TriLibVersionInfo.Instance.SkipVersionInfoKey, true);
+        }
+
+        private void OnGUI()
+        {
+            if (!_loaded)
+            {
+                var guids = AssetDatabase.FindAssets("TriLibReleaseNotes");
+                if (guids.Length > 0)
+                {
+                    var guid = guids[0];
+                    var assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                    var textAsset = AssetDatabase.LoadAssetAtPath<TextAsset>(assetPath);
+                    if (textAsset == null || textAsset.text == null)
+                    {
+                        AssetDatabase.Refresh();
+                        textAsset = AssetDatabase.LoadAssetAtPath<TextAsset>(assetPath);
+                        if (textAsset == null)
+                        {
+                            Close();
+                        }
+                        return;
+                    }
+                    _text = textAsset.text.Replace("\\n", "\n");
+                }
+                else
+                {
+                    Close();
+                }
+                _loaded = true;
+            }
+            EditorGUILayout.BeginVertical();
+            using (var stringReader = new StringReader(_text))
+            {
+                var changeLogOpen = false;
+                var version = stringReader.ReadLine();
+                GUILayout.Label($"TriLib {version}", Styles.HeaderStyle);
+                for (; ; )
+                {
+                    var line = stringReader.ReadLine();
+                    if (line == null)
+                    {
+                        break;
+                    }
+                    if (line.ToLowerInvariant() == "changelog:")
+                    {
+                        EditorGUILayout.Space();
+                        GUILayout.Label("Changelog", Styles.SubHeaderStyle);
+                        _changeLogScrollPosition = GUILayout.BeginScrollView(_changeLogScrollPosition, GUILayout.Height(260f));
+                        changeLogOpen = true;
+                    }
+                    else if (line.ToLowerInvariant() == "version notes:")
+                    {
+                        if (changeLogOpen)
+                        {
+                            GUILayout.EndScrollView();
+                            changeLogOpen = false;
+                        }
+                        EditorGUILayout.Space();
+                        GUILayout.Label("Version Notes", Styles.SubHeaderStyle);
+                        var versionInfo = stringReader.ReadToEnd();
+                        _notesScrollPosition = EditorGUILayout.BeginScrollView(_notesScrollPosition);
+                        EditorGUILayout.TextArea(versionInfo, Styles.TextAreaStyle);
+                        EditorGUILayout.EndScrollView();
+                        break;
+                    }
+                    else
+                    {
+                        GUILayout.Label(line, Styles.TextStyle);
+                    }
+                }
+                if (changeLogOpen)
+                {
+                    GUILayout.EndScrollView();
+                }
+                EditorGUILayout.EndVertical();
+                EditorGUILayout.Space();
+                GUILayout.Label("You can show this window on the Project Settings/TriLib area", Styles.SubHeaderStyle);
+                EditorGUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+                if (GUILayout.Button("Close", Styles.ButtonStyle))
+                {
+                    Close();
+                }
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+    }
+}

Samples~/trilibSDK/TriLib/TriLibCore/Editor/Scripts/TriLibVersionNotes.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 538a5acbe6221b048b5cacdbd452cffd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/KnownIssues.txt

@@ -0,0 +1,7 @@
+- TriLib is not a Model exporter.
+- The FBX Importer does not import multiple texture layers yet.  
+- The FBX Importer can't load models created before FBX SDK 2012.
+- 3MF Beam Lattice format is not supported yet.
+- 3MF PBR Specular materials are not supported yet.
+- Blend-shape normals and tangents are not imported yet. They are instead, calculated.
+- The AssetViewer normals debug view has issues when the model has no normal textures.

Samples~/trilibSDK/TriLib/TriLibCore/KnownIssues.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ff4558089a8720148825b5c0660970d2
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 375d295d97de1c844b6cd67d70ae7d3e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/AndroidNativeFilePicker.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Süleyman Yasir KULA
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/AndroidNativeFilePicker.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4a44c9e9906ebab438d5c6aec01735be
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/IxMilia.ThreeMf.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) IxMilia.
+All rights reserved.
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/IxMilia.ThreeMf.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5b63d12c9ee3c484095f7de3fbc0ffa6
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/LibTessDotNet.txt

@@ -0,0 +1,25 @@
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** 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:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** 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 SILICON GRAPHICS, INC.
+** 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.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/LibTessDotNet.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d17d778b4d4a0004498c98ee00bdf67d
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/OpenSans.txt

@@ -0,0 +1,5 @@
+These fonts are licensed under the Apache License, Version 2.0.
+
+You can use them freely in your products & projects - print or digital, commercial or otherwise. However, you can't sell the fonts on their own.
+
+This isn't legal advice, please consider consulting a lawyer and see the full license for all details.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/OpenSans.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d9f24e4a225fe8440a6dafe265266acd
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/PCX.txt

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/PCX.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3a022dc1932183b4a8e686f2355cb3c3
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/SharpZipLib.txt

@@ -0,0 +1,17 @@
+Copyright © 2000-2018 SharpZipLib Contributors
+
+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:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+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.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/SharpZipLib.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e3d99dea0516b4a4185b26fd0e6da7c3
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/StandaloneFileBrowser.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Gökhan Gökçe
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/StandaloneFileBrowser.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e182f6b442e0c7e44b3a2a8c2b9e3469
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/draco.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "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 [yyyy] [name of copyright owner]
+
+   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.

Samples~/trilibSDK/TriLib/TriLibCore/Licenses/draco.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6c43d98305818b04ea589d5bc788eebd
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b1980c5733d0d6a499d495e729ab6973
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/Dependencies.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2ddbd3321fbc8c84bb85c56584fe811f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/Dependencies/IxMilia.ThreeMf.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 42fdff4ac5b2c6247bb2a8dd9f7aeb19
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/Dependencies/LibTessDotNet.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: f0b6e6e3fdcae0241966222fe9df5853
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/Dependencies/StbImageSharp.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 3c529507b41140540af41af1d842423b
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Dae.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 21c9d628b63be7449b1212a5e839709c
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Fbx.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 1a6b827e4456bbf48891787145b1682d
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Gltf.Draco.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 3d67ed11ddaf5e3499e24b7a969fc1f6
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Gltf.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 9a3ae6ca456d4c34fad2d5fa5fdd98d6
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.HDRLoader.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 2117dba588ee3544faab12a6c5c1b17f
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Obj.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: d4f79e1c03345614cbf4f76026b0cc3f
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Ply.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: fdde7ca17a0101d44ae5647088b95239
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Stl.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: c5f06250698fc084aa44143d83bc2e75
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.Textures.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 007f05d41d5e14c4a8a539019b7894bc
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples~/trilibSDK/TriLib/TriLibCore/Plugins/TriLibCore.ThreeMf.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 1da7b66c78a23c447816620fb6f9ef6b
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: