public static GameObject GetObject(SerializedGameObject serializedGameObject)
{
foreach (YanSaveIdentifier yanSaveIdentifier in YanSaveIdentifier.Identifiers)
{
if (yanSaveIdentifier.ObjectID == serializedGameObject.ObjectID)
{
return(yanSaveIdentifier.gameObject);
}
}
return(null);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value != null)
{
SerializedGameObject sGO = new SerializedGameObject((GameObject)value);
JToken.FromObject(JsonConvert.SerializeObject(sGO)).WriteTo(writer);
}
else
{
writer.WriteNull();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var token = JToken.Load(reader);
if (token.Value <string>() == null)
{
return(null);
}
SerializedGameObject sGO = JsonConvert.DeserializeObject <SerializedGameObject>(JToken.Load(reader).ToString());
return(GameObject.Find(sGO.objectName));
}
// Token: 0x06001E4B RID: 7755 RVA: 0x0017CD28 File Offset: 0x0017AF28
public static void SaveData(string targetSave)
{
YanSaveIdentifier[] array = Resources.FindObjectsOfTypeAll <YanSaveIdentifier>();
List <SerializedGameObject> list = new List <SerializedGameObject>();
foreach (YanSaveIdentifier yanSaveIdentifier in array)
{
List <SerializedComponent> list2 = new List <SerializedComponent>();
foreach (Component component in yanSaveIdentifier.gameObject.GetComponents(typeof(Component)))
{
if (yanSaveIdentifier.EnabledComponents.Contains(component))
{
SerializedComponent serializedComponent = default(SerializedComponent);
serializedComponent.TypePath = component.GetType().AssemblyQualifiedName;
serializedComponent.PropertyReferences = new ReferenceDict();
serializedComponent.PropertyValues = new ValueDict();
serializedComponent.FieldReferences = new ReferenceDict();
serializedComponent.FieldValues = new ValueDict();
serializedComponent.FieldReferenceArrays = new ReferenceArrayDict();
serializedComponent.PropertyReferenceArrays = new ReferenceArrayDict();
if (typeof(MonoBehaviour).IsAssignableFrom(component.GetType()))
{
serializedComponent.IsMonoBehaviour = true;
serializedComponent.IsEnabled = ((MonoBehaviour)component).enabled;
}
Type type = component.GetType();
foreach (PropertyInfo propertyInfo in YanSave.GetCachedProperties(type))
{
if (propertyInfo.CanWrite && !propertyInfo.IsDefined(typeof(ObsoleteAttribute), true))
{
bool flag = false;
foreach (DisabledYanSaveMember disabledYanSaveMember in yanSaveIdentifier.DisabledProperties)
{
if (disabledYanSaveMember.Component == component && disabledYanSaveMember.Name == propertyInfo.Name)
{
flag = true;
break;
}
}
if (!flag)
{
object value = propertyInfo.GetValue(component);
bool flag2 = typeof(Component).IsAssignableFrom(propertyInfo.PropertyType);
bool flag3 = propertyInfo.PropertyType == typeof(GameObject);
bool isArray = propertyInfo.PropertyType.IsArray;
bool flag4 = typeof(Component[]).IsAssignableFrom(propertyInfo.PropertyType);
bool flag5 = typeof(GameObject[]).IsAssignableFrom(propertyInfo.PropertyType);
if (value != null)
{
try
{
if (!flag2 && !flag3)
{
serializedComponent.PropertyValues.Add(propertyInfo.Name, value);
}
else if (isArray)
{
List <string> list3 = new List <string>();
if (flag4)
{
list3.AddRange(((Component[])value).Select(delegate(Component x)
{
if (!(x.GetComponent <YanSaveIdentifier>() != null))
{
return(string.Empty);
}
return(x.GetComponent <YanSaveIdentifier>().ObjectID);
}));
}
else if (flag5)
{
list3.AddRange(((GameObject[])value).Select(delegate(GameObject x)
{
if (!(x.GetComponent <YanSaveIdentifier>() != null))
{
return(string.Empty);
}
return(x.GetComponent <YanSaveIdentifier>().ObjectID);
}));
}
serializedComponent.PropertyReferenceArrays.Add(propertyInfo.Name, list3);
}
else
{
YanSaveIdentifier yanSaveIdentifier2 = flag2 ? ((Component)value).gameObject.GetComponent <YanSaveIdentifier>() : (flag3 ? ((GameObject)value).GetComponent <YanSaveIdentifier>() : null);
if (yanSaveIdentifier2 != null)
{
serializedComponent.PropertyReferences.Add(propertyInfo.Name, yanSaveIdentifier2.ObjectID);
}
else
{
serializedComponent.PropertyReferences.Add(propertyInfo.Name, null);
}
}
}
catch
{
}
}
}
}
}
foreach (FieldInfo fieldInfo in YanSave.GetCachedFields(type))
{
if (!fieldInfo.IsLiteral && !fieldInfo.IsDefined(typeof(ObsoleteAttribute), true))
{
bool flag6 = false;
foreach (DisabledYanSaveMember disabledYanSaveMember2 in yanSaveIdentifier.DisabledFields)
{
if (disabledYanSaveMember2.Component == component && disabledYanSaveMember2.Name == fieldInfo.Name)
{
flag6 = true;
break;
}
}
if (!flag6)
{
object value2 = fieldInfo.GetValue(component);
bool flag7 = typeof(Component).IsAssignableFrom(fieldInfo.FieldType);
bool flag8 = fieldInfo.FieldType == typeof(GameObject);
bool isArray2 = fieldInfo.FieldType.IsArray;
bool flag9 = typeof(Component[]).IsAssignableFrom(fieldInfo.FieldType);
bool flag10 = typeof(GameObject[]).IsAssignableFrom(fieldInfo.FieldType);
try
{
if (!flag7 && !flag8 && !flag9 && !flag10)
{
serializedComponent.FieldValues.Add(fieldInfo.Name, value2);
}
else if (isArray2)
{
List <string> list4 = new List <string>();
if (flag9)
{
list4.AddRange(((Component[])value2).Select(delegate(Component x)
{
if (!(x.GetComponent <YanSaveIdentifier>() != null))
{
return(string.Empty);
}
return(x.GetComponent <YanSaveIdentifier>().ObjectID);
}));
}
else if (flag10)
{
list4.AddRange(((GameObject[])value2).Select(delegate(GameObject x)
{
if (!(x.GetComponent <YanSaveIdentifier>() != null))
{
return(string.Empty);
}
return(x.GetComponent <YanSaveIdentifier>().ObjectID);
}));
}
serializedComponent.FieldReferenceArrays.Add(fieldInfo.Name, list4);
}
else
{
YanSaveIdentifier yanSaveIdentifier3 = flag7 ? ((Component)value2).gameObject.GetComponent <YanSaveIdentifier>() : (flag8 ? ((GameObject)value2).GetComponent <YanSaveIdentifier>() : null);
if (yanSaveIdentifier3 != null)
{
serializedComponent.FieldReferences.Add(fieldInfo.Name, yanSaveIdentifier3.ObjectID);
}
else
{
serializedComponent.FieldReferences.Add(fieldInfo.Name, null);
}
}
}
catch
{
}
}
}
}
serializedComponent.OwnerID = yanSaveIdentifier.ObjectID;
list2.Add(serializedComponent);
}
}
SerializedGameObject item = new SerializedGameObject
{
ActiveInHierarchy = yanSaveIdentifier.gameObject.activeInHierarchy,
ActiveSelf = yanSaveIdentifier.gameObject.activeSelf,
IsStatic = yanSaveIdentifier.gameObject.isStatic,
Layer = yanSaveIdentifier.gameObject.layer,
Tag = yanSaveIdentifier.gameObject.tag,
Name = yanSaveIdentifier.gameObject.name,
SerializedComponents = list2.ToArray(),
ObjectID = yanSaveIdentifier.ObjectID
};
list.Add(item);
}
object value3 = new YanSaveData
{
LoadedLevelName = SceneManager.GetActiveScene().name,
SerializedGameObjects = list.ToArray()
};
JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.ContractResolver = new YanSaveResolver();
jsonSerializerSettings.Error = delegate(object s, Newtonsoft.Json.Serialization.ErrorEventArgs e)
{
e.ErrorContext.Handled = true;
};
string contents = JsonConvert.SerializeObject(value3, jsonSerializerSettings);
if (!Directory.Exists(YanSave.SaveDataPath))
{
Directory.CreateDirectory(YanSave.SaveDataPath);
}
File.WriteAllText(Path.Combine(YanSave.SaveDataPath, targetSave + ".yansave"), contents);
Action onSave = YanSave.OnSave;
if (onSave == null)
{
return;
}
onSave();
}
// Token: 0x06001E4C RID: 7756 RVA: 0x0017D4BC File Offset: 0x0017B6BC
public static void LoadData(string targetSave, bool recreateMissing = false)
{
if (!File.Exists(Path.Combine(YanSave.SaveDataPath, targetSave + ".yansave")))
{
return;
}
YanSaveData yanSaveData = JsonConvert.DeserializeObject <YanSaveData>(File.ReadAllText(Path.Combine(YanSave.SaveDataPath, targetSave + ".yansave")));
if (SceneManager.GetActiveScene().name != yanSaveData.LoadedLevelName)
{
SceneManager.LoadScene(yanSaveData.LoadedLevelName);
}
SerializedGameObject[] serializedGameObjects = yanSaveData.SerializedGameObjects;
int i = 0;
while (i < serializedGameObjects.Length)
{
SerializedGameObject serializedGameObject = serializedGameObjects[i];
GameObject gameObject = YanSaveIdentifier.GetObject(serializedGameObject);
if (!(gameObject == null))
{
goto IL_BA;
}
if (recreateMissing)
{
gameObject = new GameObject();
gameObject.AddComponent <YanSaveIdentifier>().ObjectID = serializedGameObject.ObjectID;
gameObject.SetActive(serializedGameObject.ActiveSelf);
goto IL_BA;
}
IL_15D:
i++;
continue;
IL_BA:
gameObject.isStatic = serializedGameObject.IsStatic;
gameObject.layer = serializedGameObject.Layer;
gameObject.tag = serializedGameObject.Tag;
gameObject.name = serializedGameObject.Name;
gameObject.SetActive(serializedGameObject.ActiveSelf);
foreach (SerializedComponent serializedComponent in serializedGameObject.SerializedComponents)
{
if (gameObject != null)
{
Type type = YanSave.GetType(serializedComponent.TypePath);
if (recreateMissing && gameObject.GetComponent(type) == null)
{
gameObject.AddComponent(type);
}
}
}
goto IL_15D;
}
foreach (SerializedGameObject serializedGameObject2 in yanSaveData.SerializedGameObjects)
{
GameObject @object = YanSaveIdentifier.GetObject(serializedGameObject2);
if (!(@object == null))
{
foreach (SerializedComponent serializedComponent2 in serializedGameObject2.SerializedComponents)
{
Type type2 = YanSave.GetType(serializedComponent2.TypePath);
Component component = @object.GetComponent(type2);
@object.GetComponent <YanSaveIdentifier>();
if (!(component == null))
{
if (serializedComponent2.IsMonoBehaviour)
{
((MonoBehaviour)component).enabled = serializedComponent2.IsEnabled;
}
foreach (PropertyInfo propertyInfo in YanSave.GetCachedProperties(type2))
{
if (propertyInfo.CanWrite)
{
bool flag = typeof(Component).IsAssignableFrom(propertyInfo.PropertyType);
if (!flag && propertyInfo.PropertyType != typeof(GameObject))
{
if (serializedComponent2.PropertyValues.ContainsKey(propertyInfo.Name))
{
object obj = serializedComponent2.PropertyValues[propertyInfo.Name];
if (obj == null)
{
propertyInfo.SetValue(component, null);
}
else
{
if (obj.GetType() == typeof(JObject))
{
try
{
propertyInfo.SetValue(component, ((JObject)obj).ToObject(propertyInfo.PropertyType));
goto IL_522;
}
catch
{
goto IL_522;
}
}
if (obj.GetType() == typeof(JArray))
{
try
{
propertyInfo.SetValue(component, ((JArray)obj).ToObject(propertyInfo.PropertyType));
goto IL_522;
}
catch
{
goto IL_522;
}
}
bool isEnum = propertyInfo.PropertyType.IsEnum;
bool flag2 = typeof(IConvertible).IsAssignableFrom(obj.GetType());
propertyInfo.SetValue(component, isEnum ? Enum.ToObject(propertyInfo.PropertyType, obj) : (flag2 ? Convert.ChangeType(obj, propertyInfo.PropertyType) : obj));
}
}
}
else if (serializedComponent2.PropertyReferences.ContainsKey(propertyInfo.Name))
{
bool flag3 = propertyInfo.PropertyType == typeof(GameObject);
GameObject object2 = YanSaveIdentifier.GetObject(serializedComponent2.FieldReferences[propertyInfo.Name]);
if (!(object2 == null))
{
if (flag)
{
propertyInfo.SetValue(component, object2.GetComponent(propertyInfo.PropertyType));
}
else if (flag3)
{
propertyInfo.SetValue(component, object2);
}
}
}
else if (serializedComponent2.PropertyReferenceArrays.ContainsKey(propertyInfo.Name))
{
bool flag4 = typeof(Component[]).IsAssignableFrom(propertyInfo.PropertyType);
bool flag5 = typeof(GameObject[]).IsAssignableFrom(propertyInfo.PropertyType);
List <string> list = serializedComponent2.PropertyReferenceArrays[propertyInfo.Name];
Type elementType = propertyInfo.PropertyType.GetElementType();
if (flag4)
{
IList list2 = Array.CreateInstance(elementType, list.Count);
for (int l = 0; l < list.Count; l++)
{
YanSaveIdentifier.GetObject(list[l]);
Component value = (@object != null) ? @object.GetComponent(elementType) : null;
list2[l] = value;
}
propertyInfo.SetValue(component, list2);
}
else if (flag5)
{
IList list3 = Array.CreateInstance(elementType, list.Count);
for (int m = 0; m < list.Count; m++)
{
GameObject object3 = YanSaveIdentifier.GetObject(list[m]);
list3[m] = object3;
}
propertyInfo.SetValue(component, list3);
}
}
}
IL_522 :;
}
foreach (FieldInfo fieldInfo in YanSave.GetCachedFields(type2))
{
bool flag6 = typeof(Component).IsAssignableFrom(fieldInfo.FieldType);
bool flag7 = typeof(Component[]).IsAssignableFrom(fieldInfo.FieldType);
bool flag8 = typeof(GameObject[]).IsAssignableFrom(fieldInfo.FieldType);
if (!flag7 && !flag8 && !flag6 && fieldInfo.FieldType != typeof(GameObject))
{
if (serializedComponent2.FieldValues.ContainsKey(fieldInfo.Name))
{
object obj2 = serializedComponent2.FieldValues[fieldInfo.Name];
if (obj2 == null)
{
fieldInfo.SetValue(component, null);
}
else
{
if (obj2.GetType() == typeof(JObject))
{
try
{
fieldInfo.SetValue(component, ((JObject)obj2).ToObject(fieldInfo.FieldType));
goto IL_85E;
}
catch
{
goto IL_85E;
}
}
if (obj2.GetType() == typeof(JArray))
{
try
{
fieldInfo.SetValue(component, ((JArray)obj2).ToObject(fieldInfo.FieldType));
goto IL_85E;
}
catch
{
goto IL_85E;
}
}
bool isEnum2 = fieldInfo.FieldType.IsEnum;
bool flag9 = typeof(IConvertible).IsAssignableFrom(obj2.GetType());
fieldInfo.SetValue(component, isEnum2 ? Enum.ToObject(fieldInfo.FieldType, obj2) : (flag9 ? Convert.ChangeType(obj2, fieldInfo.FieldType) : obj2));
}
}
}
else if (serializedComponent2.FieldReferences.ContainsKey(fieldInfo.Name))
{
bool flag10 = fieldInfo.FieldType == typeof(GameObject);
GameObject object4 = YanSaveIdentifier.GetObject(serializedComponent2.FieldReferences[fieldInfo.Name]);
if (!(object4 == null))
{
if (flag6)
{
fieldInfo.SetValue(component, object4.GetComponent(fieldInfo.FieldType));
}
else if (flag10)
{
fieldInfo.SetValue(component, object4);
}
}
}
else if (serializedComponent2.FieldReferenceArrays.ContainsKey(fieldInfo.Name))
{
List <string> list4 = serializedComponent2.FieldReferenceArrays[fieldInfo.Name];
Type elementType2 = fieldInfo.FieldType.GetElementType();
if (flag7)
{
IList list5 = Array.CreateInstance(elementType2, list4.Count);
for (int n = 0; n < list4.Count; n++)
{
YanSaveIdentifier.GetObject(list4[n]);
Component value2 = (@object != null) ? @object.GetComponent(elementType2) : null;
list5[n] = value2;
}
fieldInfo.SetValue(component, list5);
}
else if (flag8)
{
IList list6 = Array.CreateInstance(elementType2, list4.Count);
for (int num = 0; num < list4.Count; num++)
{
GameObject object5 = YanSaveIdentifier.GetObject(list4[num]);
list6[num] = object5;
}
fieldInfo.SetValue(component, list6);
}
}
IL_85E :;
}
}
}
}
}
Action onLoad = YanSave.OnLoad;
if (onLoad == null)
{
return;
}
onLoad();
}
public GlitchDemo()
{
// Window & Graphics Device
// --------------------------------------------------
WindowCreateInfo windowCI = new WindowCreateInfo
{
X = 50,
Y = 50,
WindowWidth = 960,
WindowHeight = 540,
WindowInitialState = WindowState.Normal,
WindowTitle = "Glitch Demo"
};
GraphicsDeviceOptions gdOptions = new GraphicsDeviceOptions(false, null, false, ResourceBindingModel.Improved, true);
#if DEBUG
gdOptions.Debug = true;
#endif
VeldridStartup.CreateWindowAndGraphicsDevice(
windowCI,
gdOptions,
//GraphicsBackend.Metal,
//GraphicsBackend.Vulkan,
GraphicsBackend.OpenGL,
//GraphicsBackend.OpenGLES,
out _window,
out _gd);
_window.Resized += () => _windowResized = true;
// Project Manifest
// --------------------------------------------------
ProjectManifest projectManifest;
string currentDir = AppContext.BaseDirectory;
string manifestName = null;
foreach (var file in Directory.EnumerateFiles(currentDir + "Assets"))
{
if (file.EndsWith("manifest"))
{
if (manifestName != null)
{
string errorMessage = "Error: Multiple project manifests in this directory: " + currentDir;
Console.WriteLine(errorMessage);
throw new System.Exception(errorMessage);
}
manifestName = file;
}
}
using (var fs = File.OpenRead(manifestName))
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var js = new JsonSerializer();
try
{
projectManifest = js.Deserialize <ProjectManifest>(jtr);
}
catch (Exception e)
{
string errorMessage = "An error was encountered while loading the project manifest.";
Console.WriteLine(errorMessage);
Console.WriteLine(e);
throw new System.NullReferenceException(errorMessage);
}
}
// Initialize Game()
// --------------------------------------------------
_game = new Game();
// Assembly & Asset System
// --------------------------------------------------
AssemblyLoadSystem als = new AssemblyLoadSystem();
als.LoadFromProjectManifest(projectManifest, AppContext.BaseDirectory);
_game.SystemRegistry.Register(als);
AssetSystem assetSystem = new AssetSystem(Path.Combine(AppContext.BaseDirectory, projectManifest.AssetRoot), als.Binder);
_game.SystemRegistry.Register(assetSystem);
// Graphics System
// --------------------------------------------------
_gs = new GraphicsSystem(_gd);
_game.SystemRegistry.Register(_gs);
// Scene
// --------------------------------------------------
_scene = new Scene(_gd, _window.Width, _window.Height);
// [For Debugging] - Custom SceneAsset Serializer
// --------------------------------------------------
SceneAsset programaticSceneAsset = new SceneAsset();
programaticSceneAsset.Name = "MainMenu";
// Custom GameObject (for camera & skybox)
GameObject go1 = new GameObject();
go1.Name = "PlayerCamera";
go1.Enabled = true;
// Add custom camera to GameObject
Camera camera = new Camera();
camera.WindowHeight = _window.Height;
camera.WindowWidth = _window.Width;
go1.AddComponent(camera);
go1.Transform.LocalPosition = new Vector3(0f, 0f, 0f);
// Add custom skybox to GameObject
Skybox skybox = Skybox.LoadDefaultSkybox(_game.SystemRegistry);
go1.AddComponent(skybox);
// Custom GameObject (for sphere mesh)
GameObject go2 = new GameObject();
go2.Name = "My Sphere";
go2.Enabled = true;
// Add custom sphere MeshRenderer component to GameObject
Vector3 scale2 = new Vector3(1f);
Vector3 offset2 = new Vector3(0f, 0f, -5f);
Quaternion rotation2 = Quaternion.Identity;
var meshAssetID2 = new AssetID("Internal:SphereModel");
var meshAssetRef2 = new AssetRef <MeshData>(meshAssetID2);
var textureAssetID2 = new AssetID("Textures/rust.jpg");
var textureAssetRef2 = new AssetRef <ImageSharpTexture>(textureAssetID2);
go2.Transform.LocalPosition = offset2;
go2.Transform.LocalRotation = rotation2;
go2.Transform.LocalScale = scale2;
MeshRenderer meshrenderer2 = new MeshRenderer(meshAssetRef2, textureAssetRef2);
go2.AddComponent(meshrenderer2);
// Custom GameObject (for plane mesh)
GameObject go3 = new GameObject();
go3.Name = "My Plane Model";
go3.Enabled = true;
// Add custom Plane MeshRenderer component to GameObject
Vector3 scale3 = new Vector3(10f);
Vector3 offset3 = new Vector3(0f, -1f, -5f);
Quaternion rotation3 = Quaternion.Identity;
var meshAssetID3 = new AssetID("Internal:PlaneModel");
var meshAssetRef3 = new AssetRef <MeshData>(meshAssetID3);
var textureAssetID3 = new AssetID("Textures/Wood.png");
var textureAssetRef3 = new AssetRef <ImageSharpTexture>(textureAssetID3);
go3.Transform.LocalPosition = offset3;
go3.Transform.LocalRotation = rotation3;
go3.Transform.LocalScale = scale3;
MeshRenderer meshrenderer3 = new MeshRenderer(meshAssetRef3, textureAssetRef3);
go3.AddComponent(meshrenderer3);
// Custom GameObject (another sphere mesh)
GameObject go4 = new GameObject();
go4.Name = "Another Sphere";
go4.Enabled = true;
Vector3 scale4 = new Vector3(0.5f);
Vector3 offset4 = new Vector3(2f, -0.5f, -3f);
Quaternion rotation4 = Quaternion.Identity;
var meshAssetID4 = new AssetID("Internal:SphereModel");
var meshAssetRef4 = new AssetRef <MeshData>(meshAssetID4);
var textureAssetID4 = new AssetID("Textures/rust.jpg");
var textureAssetRef4 = new AssetRef <ImageSharpTexture>(textureAssetID4);
go4.Transform.LocalPosition = offset4;
go4.Transform.LocalRotation = rotation4;
go4.Transform.LocalScale = scale4;
MeshRenderer meshrenderer4 = new MeshRenderer(meshAssetRef4, textureAssetRef4);
go4.AddComponent(meshrenderer4);
// Add custom GameObject to SceneAsset
SerializedGameObject sgo1 = new SerializedGameObject(go1);
SerializedGameObject sgo2 = new SerializedGameObject(go2);
SerializedGameObject sgo3 = new SerializedGameObject(go3);
SerializedGameObject sgo4 = new SerializedGameObject(go4);
programaticSceneAsset.GameObjects = new SerializedGameObject[4];
programaticSceneAsset.GameObjects[0] = sgo1;
programaticSceneAsset.GameObjects[1] = sgo2;
programaticSceneAsset.GameObjects[2] = sgo3;
programaticSceneAsset.GameObjects[3] = sgo4;
// Serialize SceneAsset
LooseFileDatabase lfd = new LooseFileDatabase("/Assets");
StringWriter stringwriter = new StringWriter(new StringBuilder());
using (StreamWriter file = File.CreateText(@"DebugSceneAsset.json"))
{
JsonSerializer serializer = lfd.DefaultSerializer;
serializer.Serialize(file, programaticSceneAsset);
}
// Scene Assets
// --------------------------------------------------
SceneAsset sceneAsset;
AssetID mainSceneID = projectManifest.OpeningScene.ID;
if (mainSceneID.IsEmpty)
{
var scenes = assetSystem.Database.GetAssetsOfType(typeof(SceneAsset));
if (!scenes.Any())
{
Console.WriteLine("No scenes were available to load.");
throw new System.Exception("No scenes were available to load.");
}
else
{
mainSceneID = scenes.First();
}
}
var readSceneFromProgramaticAsset = true;
sceneAsset = assetSystem.Database.LoadAsset <SceneAsset>(mainSceneID);
_scene.LoadSceneAsset(readSceneFromProgramaticAsset ? programaticSceneAsset : sceneAsset);
_gs.SetCurrentScene(_scene);
// GUI
// --------------------------------------------------
_igRenderable = new ImGuiRenderable(_window.Width, _window.Height);
_resizeHandled += (w, h) => _igRenderable.WindowResized(w, h);
_scene.AddRenderable(_igRenderable);
_scene.AddUpdateable(_igRenderable);
// Duplicate Screen (for post-processing filters)
// --------------------------------------------------
ScreenDuplicator duplicator = new ScreenDuplicator();
_scene.AddRenderable(duplicator);
// TODO: rename FullScreenQuad to FinalBufferObject or something
_fsq = new FullScreenQuad();
_scene.AddRenderable(_fsq);
CreateAllObjects();
}
