protected override void OnSceneLoad(SceneOperationKind operation,
ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
Logger.DebugLogDebug($"{this.GetPrettyTypeFullName()}.{nameof(OnSceneLoad)}: {operation}");
if (!StudioSceneInitialCamera.Enabled.Value)
{
return;
}
if (operation == SceneOperationKind.Clear)
{
RemoveInitialCamera();
return;
}
// don't do anything on import
if (operation != SceneOperationKind.Load)
{
return;
}
StudioSceneInitialCamera.Hooks.EnableChangeCameraHook = false;
InitialCamera = null;
InitialCameraReady = false;
InitialCameraSavePending = false;
AddInitialCamera();
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
if (!Autosave.Autosaving)
{
Autosave.ResetStudioCoroutine();
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var data = GetExtendedData();
if (data == null)
{
return;
}
if (operation == SceneOperationKind.Load && data.data.TryGetValue(SavedLights, out var savedLightData))
{
var savedLights = MessagePackSerializer.Deserialize <List <SavedLight> >((byte[])savedLightData);
foreach (var savedLight in savedLights)
{
if (loadedItems.TryGetValue(savedLight.LightId, out var lightInfo) && lightInfo is OCILight ocilight)
{
if (loadedItems.TryGetValue(savedLight.TargetId, out var targetInfo) && targetInfo is OCIChar targetChara)
{
var tracker = ocilight.light.gameObject.AddComponent <TrackTransform>();
tracker.target = targetChara.charInfo.objBody.transform;
tracker.targetKey = targetInfo.objectInfo.dicKey;
tracker.rotationSpeed = savedLight.RotationSpeed;
tracker.targetName = savedLight.TargetName;
}
}
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
if (operation == SceneOperationKind.Clear || operation == SceneOperationKind.Load)
{
MaskingFolders = new Dictionary <int, OCIFolder>();
}
if (operation == SceneOperationKind.Clear)
{
return;
}
var data = GetExtendedData();
if (data != null)
{
if (data.data.TryGetValue(nameof(MaskingFolders), out var folders) && folders != null)
{
foreach (int folderIndex in MessagePackSerializer.Deserialize <List <int> >((byte[])folders))
{
if (loadedItems.TryGetValue(folderIndex, out ObjectCtrlInfo oci))
{
if (oci is OCIFolder ociFolder)
{
AddColliderToFolder(ociFolder);
}
}
}
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var data = GetExtendedData();
if (data == null)
{
return;
}
if (operation == SceneOperationKind.Load && data.data.TryGetValue(SaveId, out var saveDataBytes))
{
var saveData = MessagePackSerializer.Deserialize <List <LayerSaveData> >((byte[])saveDataBytes);
foreach (var layerData in saveData)
{
if (loadedItems.TryGetValue(layerData.ObjectId, out var itemInfo) && itemInfo is OCIItem item)
{
item.objectItem.AddComponent <LayerDataContainer>().DefaultLayer = layerData.DefaultLayer;
item.objectItem.layer = layerData.NewLayer;
foreach (Transform child in item.objectItem.transform)
{
child.gameObject.layer = layerData.NewLayer;
}
}
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
foreach (var controller in FindObjectsOfType <ColliderController>())
{
controller.ApplyColliders();
}
}
private static void OnSceneBeingLoaded(SceneOperationKind operation)
{
var readonlyDict = GetLoadedObjects(operation).ToReadOnlyDictionary();
foreach (var behaviour in _registeredHandlers)
{
try
{
behaviour.Key.OnSceneLoad(operation, readonlyDict);
}
catch (Exception e)
{
KoikatuAPI.Logger.LogError(e);
}
}
try
{
SceneLoad?.Invoke(KoikatuAPI.Instance, new SceneLoadEventArgs(operation, readonlyDict));
}
catch (Exception e)
{
KoikatuAPI.Logger.LogError(e);
}
}
private static Dictionary <int, ObjectCtrlInfo> GetLoadedObjects(SceneOperationKind operation)
{
Dictionary <int, ObjectCtrlInfo> results;
switch (operation)
{
case SceneOperationKind.Load:
results = global::Studio.Studio.Instance.dicObjectCtrl;
break;
case SceneOperationKind.Import:
results = global::Studio.Studio.Instance.dicObjectCtrl
.Join(Hooks.ImportDictionary, pair => pair.Key, pair => pair.Key, (current, idLookup) => new { originalId = idLookup.Value, obj = current.Value })
.ToDictionary(x => x.originalId, x => x.obj);
break;
case SceneOperationKind.Clear:
results = new Dictionary <int, ObjectCtrlInfo>();
break;
default:
throw new ArgumentOutOfRangeException(nameof(operation), operation, null);
}
return(results);
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
Studio.Studio studio = GetStudio();
AIGraphics parent = AIGraphics.Instance;
parent?.SkyboxManager?.SetupDefaultReflectionProbe();
parent?.PresetManager?.Load(GetExtendedData());
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var controllers = FindObjectsOfType <ColliderController>();
for (var i = 0; i < controllers.Length; i++)
{
controllers[i].ApplyColliders();
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
foreach (var kvp in loadedItems)
{
if (kvp.Value is OCIChar)
{
GetController(kvp.Value as OCIChar).LoadAnimations(kvp.Key, loadedItems);
}
}
}
/// <summary>
/// Read the extended save data and set the values of SliderSet or ToggleSet which will set the UI elements and trigger the setter method
/// </summary>
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
if (operation == SceneOperationKind.Load)
{
var data = GetExtendedData();
if (data?.data == null)
{
ResetAll();
}
else
{
if (data.data.TryGetValue("MapMasking", out var mapMasking) && mapMasking != null)
{
MapMasking.Value = (bool)mapMasking;
}
else
{
MapMasking.Reset();
}
if (data.data.TryGetValue("NearClipPlane", out var nearClipPlane) && nearClipPlane != null && (float)nearClipPlane != 0f)
{
NearClipPlane.Value = (float)nearClipPlane;
}
else
{
NearClipPlane.Reset();
}
if (data.data.TryGetValue("FarClipPlane", out var farClipPlane) && farClipPlane != null && (float)farClipPlane != 0f)
{
FarClipPlane.Value = (float)farClipPlane;
}
else
{
FarClipPlane.Reset();
}
if (data.data.TryGetValue("ShadowDistance", out var shadowDistance) && shadowDistance != null && (float)shadowDistance != 0f)
{
ShadowDistance.Value = (float)shadowDistance;
}
else
{
ShadowDistance.Reset();
}
}
}
else if (operation == SceneOperationKind.Clear)
{
ResetAll();
}
//Do not import saved data, keep current settings
}
private static void SceneLoadComplete(SceneOperationKind operation)
{
LoadInProgress = false;
ImportInProgress = false;
if (_loadOrImportSuccess || operation == SceneOperationKind.Clear)
{
_loadOrImportSuccess = false;
OnSceneBeingLoaded(operation);
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var extData = GetExtendedData();
if (extData == null)
{
return;
}
if (operation == SceneOperationKind.Load && extData.data.TryGetValue(DictID, out var povRawData))
{
RealPOV.EnablePov(MessagePackSerializer.Deserialize <ScenePovData>((byte[])povRawData));
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary<int, ObjectCtrlInfo> loadedItems)
{
if (operation == SceneOperationKind.Clear || operation == SceneOperationKind.Load)
MaskingFolders = new Dictionary<int, OCIFolder>();
if (operation == SceneOperationKind.Clear) return;
var data = GetExtendedData();
if (data != null)
if (data.data.TryGetValue(nameof(MaskingFolders), out var folders) && folders != null)
{
var folderList = MessagePackSerializer.Deserialize<List<int>>((byte[])folders);
for (var index = 0; index < folderList.Count; index++)
{
int folderIndex = folderList[index];
if (loadedItems.TryGetValue(folderIndex, out ObjectCtrlInfo oci))
if (oci is OCIFolder ociFolder)
AddColliderToFolder(ociFolder);
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
//Dispose of any Frame texture when resetting the scene
if (operation == SceneOperationKind.Clear)
{
FrameTex?.Dispose();
FrameTex = null;
return;
}
//On loading or importing a scene, check if the item has any patterns that exist in the pattern folder and use MaterialEditor to handle these textures instead
foreach (var loadedItem in loadedItems.Values)
{
if (loadedItem is OCIItem item)
{
if (item?.itemComponent != null)
{
for (int i = 0; i < 3; i++)
{
string filePath = item.GetPatternPath(i);
SavePatternTex(item, i, filePath);
}
}
if (item?.panelComponent != null)
{
if (!item.itemInfo.panel.filePath.IsNullOrEmpty())
{
Logger.LogInfo($"bg:{item.itemInfo.panel.filePath}");
}
SaveBGTex(item, item.itemInfo.panel.filePath);
}
}
}
//On loading a scene load the saved frame texture, if any
//Frames are not imported, only loaded
if (operation == SceneOperationKind.Load)
{
FrameTex?.Dispose();
FrameTex = null;
var data = GetExtendedData();
if (data?.data != null)
{
if (data.data.TryGetValue("FrameData", out var frameObj) && frameObj != null)
{
FrameTex = new TextureContainer((byte[])frameObj);
}
}
if (FrameTex != null)
{
var imageFrame = Traverse.Create(Studio.Studio.Instance.frameCtrl).Field("imageFrame").GetValue <RawImage>();
imageFrame.texture = FrameTex.Texture;
imageFrame.enabled = true;
var cameraUI = Traverse.Create(Studio.Studio.Instance.frameCtrl).Field("cameraUI").GetValue <Camera>();
cameraUI.enabled = true;
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
SceneConsole.Instance?.LoadPluginData(GetExtendedData());
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var data = GetExtendedData();
if (operation == SceneOperationKind.Clear || operation == SceneOperationKind.Load)
{
RendererPropertyList.Clear();
MaterialFloatPropertyList.Clear();
MaterialColorPropertyList.Clear();
MaterialTexturePropertyList.Clear();
MaterialShaderList.Clear();
TextureDictionary.Clear();
}
if (data == null)
{
return;
}
var importDictionary = new Dictionary <int, int>();
if (operation == SceneOperationKind.Load)
{
if (data.data.TryGetValue(nameof(TextureDictionary), out var texDic) && texDic != null)
{
TextureDictionary = MessagePackSerializer.Deserialize <Dictionary <int, byte[]> >((byte[])texDic);
}
}
if (operation == SceneOperationKind.Import)
{
if (data.data.TryGetValue(nameof(TextureDictionary), out var texDic) && texDic != null)
{
foreach (var x in MessagePackSerializer.Deserialize <Dictionary <int, byte[]> >((byte[])texDic))
{
importDictionary[x.Key] = SetAndGetTextureID(x.Value);
}
}
}
if (operation == SceneOperationKind.Clear)
{
return;
}
if (data.data.TryGetValue(nameof(MaterialShaderList), out var shaderProperties) && shaderProperties != null)
{
foreach (var loadedProperty in MessagePackSerializer.Deserialize <List <MaterialShader> >((byte[])shaderProperties))
{
if (loadedItems.TryGetValue(loadedProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
bool setShader = SetShader(ociItem.objectItem, loadedProperty.MaterialName, loadedProperty.ShaderName, ObjectType.StudioItem);
bool setRenderQueue = SetRenderQueue(ociItem.objectItem, loadedProperty.MaterialName, loadedProperty.RenderQueue, ObjectType.StudioItem);
if (setShader || setRenderQueue)
{
MaterialShaderList.Add(new MaterialShader(GetObjectID(objectCtrlInfo), loadedProperty.MaterialName, loadedProperty.ShaderName, loadedProperty.ShaderNameOriginal, loadedProperty.RenderQueue, loadedProperty.RenderQueueOriginal));
}
}
}
}
if (data.data.TryGetValue(nameof(RendererPropertyList), out var rendererProperties) && rendererProperties != null)
{
foreach (var loadedProperty in MessagePackSerializer.Deserialize <List <RendererProperty> >((byte[])rendererProperties))
{
if (loadedItems.TryGetValue(loadedProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
if (SetRendererProperty(ociItem.objectItem, loadedProperty.RendererName, loadedProperty.Property, int.Parse(loadedProperty.Value), ObjectType.StudioItem))
{
RendererPropertyList.Add(new RendererProperty(GetObjectID(objectCtrlInfo), loadedProperty.RendererName, loadedProperty.Property, loadedProperty.Value, loadedProperty.ValueOriginal));
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialFloatPropertyList), out var materialFloatProperties) && materialFloatProperties != null)
{
foreach (var loadedProperty in MessagePackSerializer.Deserialize <List <MaterialFloatProperty> >((byte[])materialFloatProperties))
{
if (loadedItems.TryGetValue(loadedProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
if (SetFloatProperty(ociItem.objectItem, loadedProperty.MaterialName, loadedProperty.Property, loadedProperty.Value, ObjectType.StudioItem))
{
MaterialFloatPropertyList.Add(new MaterialFloatProperty(GetObjectID(objectCtrlInfo), loadedProperty.MaterialName, loadedProperty.Property, loadedProperty.Value, loadedProperty.ValueOriginal));
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialColorPropertyList), out var materialColorProperties) && materialColorProperties != null)
{
foreach (var loadedProperty in MessagePackSerializer.Deserialize <List <MaterialColorProperty> >((byte[])materialColorProperties))
{
if (loadedItems.TryGetValue(loadedProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
if (SetColorProperty(ociItem.objectItem, loadedProperty.MaterialName, loadedProperty.Property, loadedProperty.Value, ObjectType.StudioItem))
{
MaterialColorPropertyList.Add(new MaterialColorProperty(GetObjectID(objectCtrlInfo), loadedProperty.MaterialName, loadedProperty.Property, loadedProperty.Value, loadedProperty.ValueOriginal));
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialTexturePropertyList), out var materialTextureProperties) && materialTextureProperties != null)
{
foreach (var loadedProperty in MessagePackSerializer.Deserialize <List <MaterialTextureProperty> >((byte[])materialTextureProperties))
{
if (loadedItems.TryGetValue(loadedProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
int?texID = null;
if (operation == SceneOperationKind.Import)
{
if (loadedProperty.TexID != null)
{
texID = importDictionary[(int)loadedProperty.TexID];
}
}
else
{
texID = loadedProperty.TexID;
}
MaterialTextureProperty newTextureProperty = new MaterialTextureProperty(GetObjectID(objectCtrlInfo), loadedProperty.MaterialName, loadedProperty.Property, texID, loadedProperty.Offset, loadedProperty.OffsetOriginal, loadedProperty.Scale, loadedProperty.ScaleOriginal);
bool setTex = false;
if (newTextureProperty.TexID != null)
{
setTex = SetTextureProperty(ociItem.objectItem, newTextureProperty.MaterialName, newTextureProperty.Property, newTextureProperty.Texture, ObjectType.StudioItem);
}
bool setOffset = SetTextureProperty(ociItem.objectItem, newTextureProperty.MaterialName, newTextureProperty.Property, TexturePropertyType.Offset, newTextureProperty.Offset, ObjectType.StudioItem);
bool setScale = SetTextureProperty(ociItem.objectItem, newTextureProperty.MaterialName, newTextureProperty.Property, TexturePropertyType.Scale, newTextureProperty.Scale, ObjectType.StudioItem);
if (setTex || setOffset || setScale)
{
MaterialTexturePropertyList.Add(newTextureProperty);
}
}
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var data = GetExtendedData();
if (operation == SceneOperationKind.Clear || operation == SceneOperationKind.Load)
{
StudioItemRendererPropertyList.Clear();
StudioItemMaterialFloatPropertyList.Clear();
StudioItemMaterialColorPropertyList.Clear();
}
if (data == null)
{
return;
}
if (data.data.TryGetValue("RendererProperties", out var rendererProperties) && rendererProperties != null)
{
var loadedRendererProperties = MessagePackSerializer.Deserialize <List <RendererProperty> >((byte[])rendererProperties);
foreach (var loadedRendererProperty in loadedRendererProperties)
{
if (loadedItems.TryGetValue(loadedRendererProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var renderer in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
if (renderer.NameFormatted() == loadedRendererProperty.RendererName)
{
StudioItemRendererPropertyList.Add(new RendererProperty(GetObjectID(objectCtrlInfo), loadedRendererProperty.RendererName, loadedRendererProperty.Property, loadedRendererProperty.Value, loadedRendererProperty.ValueOriginal));
SetRendererProperty(renderer, loadedRendererProperty.Property, int.Parse(loadedRendererProperty.Value));
}
}
}
}
}
if (data.data.TryGetValue("MaterialFloatProperties", out var materialFloatProperties) && materialFloatProperties != null)
{
var loadedMaterialFloatProperties = MessagePackSerializer.Deserialize <List <MaterialFloatProperty> >((byte[])materialFloatProperties);
foreach (var loadedMaterialFloatProperty in loadedMaterialFloatProperties)
{
if (loadedItems.TryGetValue(loadedMaterialFloatProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var rend in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
foreach (var mat in rend.materials)
{
if (mat.HasProperty($"_{loadedMaterialFloatProperty.Property}") && FloatProperties.Contains(loadedMaterialFloatProperty.Property))
{
var valueOriginal = mat.GetFloat($"_{loadedMaterialFloatProperty.Property}").ToString();
StudioItemMaterialFloatPropertyList.Add(new MaterialFloatProperty(GetObjectID(objectCtrlInfo), loadedMaterialFloatProperty.MaterialName, loadedMaterialFloatProperty.Property, loadedMaterialFloatProperty.Value, valueOriginal));
SetFloatProperty(ociItem.objectItem, mat, loadedMaterialFloatProperty.Property, loadedMaterialFloatProperty.Value);
}
}
}
}
}
}
if (data.data.TryGetValue("MaterialColorProperties", out var materialColorProperties) && materialColorProperties != null)
{
var loadedMaterialColorProperties = MessagePackSerializer.Deserialize <List <MaterialColorProperty> >((byte[])materialColorProperties);
foreach (var loadedMaterialColorProperty in loadedMaterialColorProperties)
{
if (loadedItems.TryGetValue(loadedMaterialColorProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var rend in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
foreach (var mat in rend.materials)
{
if (mat.HasProperty($"_{loadedMaterialColorProperty.Property}") && ColorProperties.Contains(loadedMaterialColorProperty.Property))
{
var valueOriginal = mat.GetColor($"_{loadedMaterialColorProperty.Property}");
StudioItemMaterialColorPropertyList.Add(new MaterialColorProperty(GetObjectID(objectCtrlInfo), loadedMaterialColorProperty.MaterialName, loadedMaterialColorProperty.Property, loadedMaterialColorProperty.Value, valueOriginal));
SetColorProperty(ociItem.objectItem, mat, loadedMaterialColorProperty.Property, loadedMaterialColorProperty.Value);
}
}
}
}
}
}
}
protected internal override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
Logger.Log(LogLevel.Warning | LogLevel.Message, $"OnSceneLoad {operation} - {loadedItems.Count}");
}
/// <summary> /// Fired when a scene is successfully changed, either by loading, importing or resetting. /// </summary> /// <param name="operation">Operation that caused this event</param> /// <param name="loadedItems">A dictionary of items loaded by this operation and their original IDs. /// The IDs are identical to the IDs at the time of saving the scene, even during import. /// Warning: The IDs here might not be the same as IDs of the objects in the scene! /// To get current scene ID of the object call <see cref="StudioObjectExtensions.GetSceneId(ObjectCtrlInfo)"/></param> protected internal abstract void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems);
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
//Dispose of any textures when resetting the scene
if (operation == SceneOperationKind.Clear)
{
FrameTex?.Dispose();
FrameTex = null;
BGTex?.Dispose();
BGTex = null;
return;
}
//On loading or importing a scene, check if the item has any patterns that exist in the pattern folder and use MaterialEditor to handle these textures instead
foreach (var loadedItem in loadedItems.Values)
{
if (loadedItem is OCIItem item)
{
if (item.itemComponent != null)
{
for (int i = 0; i < 3; i++)
{
string filePath = item.GetPatternPath(i);
SavePatternTex(item, i, filePath);
}
}
if (item.panelComponent != null)
{
SaveBGTex(item, item.itemInfo.panel.filePath);
}
}
}
//On loading a scene load the saved frame texture, if any
//Frames and BGs are not imported, only loaded
if (operation == SceneOperationKind.Load)
{
FrameTex?.Dispose();
FrameTex = null;
BGTex?.Dispose();
BGTex = null;
var data = GetExtendedData();
if (data?.data != null)
{
if (data.data.TryGetValue("FrameData", out var frameObj) && frameObj != null)
{
FrameTex = new TextureContainer((byte[])frameObj);
}
if (data.data.TryGetValue("BGData", out var bgObj) && bgObj != null)
{
BGTex = new TextureContainer((byte[])bgObj);
}
}
if (FrameTex != null)
{
var imageFrame = Traverse.Create(Studio.Studio.Instance.frameCtrl).Field("imageFrame").GetValue <RawImage>();
imageFrame.texture = FrameTex.Texture;
imageFrame.enabled = true;
var cameraUI = Traverse.Create(Studio.Studio.Instance.frameCtrl).Field("cameraUI").GetValue <Camera>();
cameraUI.enabled = true;
}
if (BGTex != null)
{
BackgroundCtrl m_BackgroundCtrl = Traverse.Create(Studio.Studio.Instance).Field("m_BackgroundCtrl").GetValue <BackgroundCtrl>();
MeshRenderer meshRenderer = Traverse.Create(m_BackgroundCtrl).Field("meshRenderer").GetValue <MeshRenderer>();
meshRenderer.material.SetTexture("_MainTex", BGTex.Texture);
m_BackgroundCtrl.isVisible = true;
}
}
}
protected override void OnSceneLoad(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedItems)
{
var data = GetExtendedData();
if (operation == SceneOperationKind.Clear || operation == SceneOperationKind.Load)
{
RendererPropertyList.Clear();
MaterialFloatPropertyList.Clear();
MaterialColorPropertyList.Clear();
MaterialTexturePropertyList.Clear();
TextureDictionary.Clear();
}
if (data == null)
{
return;
}
var importDictionary = new Dictionary <int, int>();
if (operation == SceneOperationKind.Load)
{
if (data.data.TryGetValue(nameof(TextureDictionary), out var texDic) && texDic != null)
{
TextureDictionary = MessagePackSerializer.Deserialize <Dictionary <int, byte[]> >((byte[])texDic);
}
}
else if (operation == SceneOperationKind.Import)
{
if (data.data.TryGetValue(nameof(TextureDictionary), out var texDic) && texDic != null)
{
Dictionary <int, byte[]> importTextureDictionary = MessagePackSerializer.Deserialize <Dictionary <int, byte[]> >((byte[])texDic);
foreach (var x in importTextureDictionary)
{
importDictionary[x.Key] = SetAndGetTextureID(x.Value);
}
}
}
else if (operation == SceneOperationKind.Clear)
{
return;
}
if (data.data.TryGetValue(nameof(RendererPropertyList), out var rendererProperties) && rendererProperties != null)
{
var loadedRendererProperties = MessagePackSerializer.Deserialize <List <RendererProperty> >((byte[])rendererProperties);
foreach (var loadedRendererProperty in loadedRendererProperties)
{
if (loadedItems.TryGetValue(loadedRendererProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var renderer in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
if (renderer.NameFormatted() == loadedRendererProperty.RendererName)
{
RendererPropertyList.Add(new RendererProperty(GetObjectID(objectCtrlInfo), loadedRendererProperty.RendererName, loadedRendererProperty.Property, loadedRendererProperty.Value, loadedRendererProperty.ValueOriginal));
SetRendererProperty(renderer, loadedRendererProperty.Property, int.Parse(loadedRendererProperty.Value));
}
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialFloatPropertyList), out var materialFloatProperties) && materialFloatProperties != null)
{
var loadedMaterialFloatProperties = MessagePackSerializer.Deserialize <List <MaterialFloatProperty> >((byte[])materialFloatProperties);
foreach (var loadedMaterialFloatProperty in loadedMaterialFloatProperties)
{
if (loadedItems.TryGetValue(loadedMaterialFloatProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var rend in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
foreach (var mat in rend.materials)
{
if (mat.NameFormatted() == loadedMaterialFloatProperty.MaterialName && mat.HasProperty($"_{loadedMaterialFloatProperty.Property}") && FloatProperties.Contains(loadedMaterialFloatProperty.Property))
{
var valueOriginal = mat.GetFloat($"_{loadedMaterialFloatProperty.Property}").ToString();
MaterialFloatPropertyList.Add(new MaterialFloatProperty(GetObjectID(objectCtrlInfo), loadedMaterialFloatProperty.MaterialName, loadedMaterialFloatProperty.Property, loadedMaterialFloatProperty.Value, valueOriginal));
SetFloatProperty(ociItem.objectItem, mat, loadedMaterialFloatProperty.Property, loadedMaterialFloatProperty.Value, ObjectType.StudioItem);
}
}
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialColorPropertyList), out var materialColorProperties) && materialColorProperties != null)
{
var loadedMaterialColorProperties = MessagePackSerializer.Deserialize <List <MaterialColorProperty> >((byte[])materialColorProperties);
foreach (var loadedMaterialColorProperty in loadedMaterialColorProperties)
{
if (loadedItems.TryGetValue(loadedMaterialColorProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var rend in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
foreach (var mat in rend.materials)
{
if (mat.NameFormatted() == loadedMaterialColorProperty.MaterialName && mat.HasProperty($"_{loadedMaterialColorProperty.Property}") && ColorProperties.Contains(loadedMaterialColorProperty.Property))
{
var valueOriginal = mat.GetColor($"_{loadedMaterialColorProperty.Property}");
MaterialColorPropertyList.Add(new MaterialColorProperty(GetObjectID(objectCtrlInfo), loadedMaterialColorProperty.MaterialName, loadedMaterialColorProperty.Property, loadedMaterialColorProperty.Value, valueOriginal));
SetColorProperty(ociItem.objectItem, mat, loadedMaterialColorProperty.Property, loadedMaterialColorProperty.Value, ObjectType.StudioItem);
}
}
}
}
}
}
if (data.data.TryGetValue(nameof(MaterialTexturePropertyList), out var materialTextureProperties) && materialTextureProperties != null)
{
var loadedMaterialTextureProperties = MessagePackSerializer.Deserialize <List <MaterialTextureProperty> >((byte[])materialTextureProperties);
foreach (var loadedMaterialTextureProperty in loadedMaterialTextureProperties)
{
if (loadedItems.TryGetValue(loadedMaterialTextureProperty.ID, out ObjectCtrlInfo objectCtrlInfo) && objectCtrlInfo is OCIItem ociItem)
{
foreach (var rend in ociItem.objectItem.GetComponentsInChildren <Renderer>())
{
foreach (var mat in rend.materials)
{
if (mat.NameFormatted() == loadedMaterialTextureProperty.MaterialName && mat.HasProperty($"_{loadedMaterialTextureProperty.Property}") && TextureProperties.Contains(loadedMaterialTextureProperty.Property))
{
int texID = operation == SceneOperationKind.Import ? importDictionary[loadedMaterialTextureProperty.TexID] : loadedMaterialTextureProperty.TexID;
MaterialTextureProperty newTextureProperty = new MaterialTextureProperty(GetObjectID(objectCtrlInfo), loadedMaterialTextureProperty.MaterialName, loadedMaterialTextureProperty.Property, texID);
MaterialTexturePropertyList.Add(newTextureProperty);
SetTextureProperty(ociItem.objectItem, mat, newTextureProperty.Property, newTextureProperty.Texture, ObjectType.StudioItem);
}
}
}
}
}
}
}
/// <inheritdoc />
/// <param name="operation">Operation that caused the event</param>
/// <param name="loadedObjects">Objects loaded by the event</param>
public SceneLoadEventArgs(SceneOperationKind operation, ReadOnlyDictionary <int, ObjectCtrlInfo> loadedObjects)
{
Operation = operation;
LoadedObjects = loadedObjects;
}
