private void handle(string str)
{
if (string.IsNullOrEmpty(str))
{
if (callback != null)
{
callback(false);
}
return;
}
List <Scene> updateList;
List <Scene> deleteList;
SceneSerializer.ToObjects(str, out updateList, out deleteList);
bool result = false;
if (updateList != null && updateList.Count != 0)
{
LogicController.ReplaceScenesIgnoreFavourite(updateList);
result = true;
}
if (deleteList != null && deleteList.Count != 0)
{
LogicController.DeleteScenes(deleteList);
result = true;
}
if (callback != null)
{
callback(result);
}
}
void Serialize()
{
var scene = SceneManager.GetActiveScene();
var data = SceneSerializer.Serialize(scene);
SceneSerializer.DeserializeGameObjects(data, transform);
}
public void RestoreToCurrent(string path)
{
DebugUtil.Log("[OGSerializer] Restoring scene from " + path);
XmlDocument doc = new XmlDocument();
try {
doc.Load(path);
}catch (Exception) {
DebugUtil.Log("[OGSerializer] failed to read XmlDocument");
throw;
}
// begin restore
OGActions.BeginRestoreExistingScene();
// restore scene objects
XMLInputStream stream = new XMLInputStream()
{
xml = doc
};
SceneSerializer serializer = new SceneSerializer()
{
SOFactory = new SOFactory()
};
serializer.Restore(stream, OG.Scene);
// restore datamodel
RestoreDataModel(doc);
}
/// <summary>
/// serialize scene, with SO filter
/// </summary>
protected virtual void StoreScene(IOutputStream o, FScene scene)
{
SceneSerializer serializer = new SceneSerializer();
serializer.SOFilterF = SerializeSOFilter;
serializer.Store(o, scene);
}
public static Scene Load(string path)
{
SceneFileEnvironment sfe;
JsonSerializer serializer = new JsonSerializer(JsonSerializerSettings.Default);
using (FileStream stream = new FileStream(path, FileMode.Open))
{
sfe = (SceneFileEnvironment)serializer.Deserialize(stream, typeof(SceneFileEnvironment));
}
string directory = Path.GetDirectoryName(path);
{
string[] assembliesPaths = Array.ConvertAll(File.ReadAllText(directory + sfe.AssembliesList)
.Trim('\n', ' ').Split("\n"),
str => str.Trim(' '))
.Where(str => !string.IsNullOrWhiteSpace(str))
.ToArray();
for (int i = 0; i < assembliesPaths.Length; i++)
{
AssemblyLoader.Load(assembliesPaths[i]);
}
}
Scene scene;
{
scene = SceneSerializer.DeserializeJson(File.ReadAllText(directory + sfe.Scene));
}
Log.Core.Info("loaded scene");
return(scene);
}
public static bool EmitScanSO(SceneSerializer s, IOutputStream o, SceneObject gso)
{
ScanSO so = gso as ScanSO;
o.AddAttribute(IOStrings.ASOType, so.Type.identifier);
SceneSerializerEmitTypesExt.EmitDMeshSO(s, o, so as DMeshSO);
return(true);
}
public static void OpenFile()
{
var path = EditorUtility.OpenFilePanel("Open a serialized scene file", "", "bin");
if (path.Length != 0)
{
var data = File.ReadAllBytes(path);
var parent = new GameObject(Path.GetFileName(path));
SceneSerializer.DeserializeGameObjects(data, parent.transform);
}
}
//-------------------------------------------------
#region Start method
private void Start()
{
if (this.cubes.Length != 0)
{
for (int i = 0; i < this.cubes.Length; i++)
{
cubes [i].position = new Vector3(Random.Range(-this.range, this.range), Random.Range(-this.range, this.range), Random.Range(-this.range, this.range));
cubes [i].eulerAngles = new Vector3(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
SceneSerializer.AddCube(cubes[i]);
}
}
}
public static bool EmitPlaneIntersectionCurveSO(SceneSerializer s, IOutputStream o, SceneObject gso)
{
PlaneIntersectionCurveSO so = gso as PlaneIntersectionCurveSO;
if (so == null)
{
throw new Exception("EmitPlaneIntersectionCurveSO: input so is not an PlaneIntersectionCurveSO!");
}
o.AddAttribute(IOStrings.ASOType, so.Type.identifier);
SceneSerializerEmitTypesExt.EmitPolyCurveSO(s, o, so as PolyCurveSO);
return(true);
}
public static bool Emit(SceneSerializer s, IOutputStream o, SceneObject gso)
{
PrintMeshSO so = gso as PrintMeshSO;
o.AddAttribute(IOStrings.ASOType, so.Type.identifier);
o.AddAttribute(AttrSourceFilePath, so.SourceFilePath);
EmitPrintMeshSettings(s, o, so.Settings);
SceneSerializerEmitTypesExt.EmitDMeshSO(s, o, so as DMeshSO);
return(true);
}
//-------------------------------------------------
#region OnRandomizeClicked method
public void OnRandomizeClicked()
{
if (this.cubes.Length != 0)
{
SceneSerializer.Collection.cubes.Clear();
for (int i = 0; i < this.cubes.Length; i++)
{
cubes [i].position = new Vector3(Random.Range(-this.range, this.range), Random.Range(-this.range, this.range), Random.Range(-this.range, this.range));
cubes [i].eulerAngles = new Vector3(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
SceneSerializer.AddCube(cubes[i]);
}
}
}
public static bool EmitLengthenPivotSO(SceneSerializer s, IOutputStream o, SceneObject gso)
{
LengthenPivotSO so = gso as LengthenPivotSO;
if (so == null)
{
throw new Exception("EmitLengthenPivotSO: input so is not an LengthenPivotSO!");
}
o.AddAttribute(IOStrings.ASOType, so.Type.identifier);
s.EmitFrame(o, PivotOriginalLegPoint, new Frame3f(so.InitialLegPtL));
SceneSerializerEmitTypesExt.EmitPivotSO(s, o, so as PivotSO);
return(true);
}
public async Task <FileStreamResult> PostDownloadScene(GamePlatform platform, GameVersion version, [FromBody] Scene sceneData)
{
if (platform != GamePlatform.PlatformType_PC || version != GameVersion.GameVersion_THUG)
{
throw new System.NotImplementedException();
}
IChecksumResolver checksumResolver = new THPS.API.Utils.ChecksumResolver(scriptKeyRepository, platform, version);
var writer = new SceneSerializer(checksumResolver);
var ms = await writer.WriteScene(sceneData);
return(new FileStreamResult(ms, "application/octet-stream")
{
FileDownloadName = "scene.mdl.xbx"
});
}
public static void Save(string path, Scene scene, SceneFileEnvironment sfe)
{
// save all other files
File.WriteAllText(sfe.AssembliesList, String.Join("\n", AssemblyLoader.LoadedAssemblies.Select(pair => pair.Path)));
File.WriteAllText(sfe.Scene, SceneSerializer.SertializeJson(scene));
JsonSerializer serializer = new JsonSerializer(JsonSerializerSettings.Default);
using (FileStream stream = new FileStream(path, FileMode.Create))
{
serializer.Serialize(sfe, stream);
}
Log.Core.Info("saved scene");
}
public static void EmitPrintMeshSettings(this SceneSerializer s, IOutputStream o, PrintMeshSettings settings)
{
o.BeginStruct(PrintSettingsStruct);
o.AddAttribute(AttrPrintSettingsVersion, settings.Version);
o.AddAttribute(AttrPrintSettingsObjectType, (int)settings.ObjectType);
o.AddAttribute(AttrPrintSettingsOpenMode, (int)settings.OpenMeshMode);
o.AddAttribute(AttrPrintSettingsNoVoids, settings.NoVoids);
o.AddAttribute(AttrPrintSettingsShellOnly, settings.OuterShellOnly);
o.AddAttribute(AttrPrintSettingsClearanceXY, (float)settings.Clearance);
o.AddAttribute(AttrPrintSettingsOffsetXY, (float)settings.OffsetXY);
o.EndStruct();
}
public async Task CanDeserializeAndReSerializeAsIs()
{
string sceneJson = GetSampleSceneJson();
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{
_scenePath,
new MockFileData(sceneJson)
},
});
var serializer = new SceneSerializer(fileSystem, new Throttler());
var scene = await serializer.DeserializeAsync(_scenePath);
await serializer.SerializeAsync(scene, _scenePath);
Assert.That(fileSystem.File.ReadAllText(_scenePath), Is.EqualTo(sceneJson));
}
public void SetUp()
{
_sceneFactory = Substitute.For <ISceneFactory>();
_sceneFactory.Create().Returns(ci => TestSceneFactory.Create());
_sceneBehaviorFactoryProvider = Substitute.For <ISceneBehaviorFactoryProvider>();
var emptySceneBehaviorFactory = Substitute.For <ISceneBehaviorFactory>();
emptySceneBehaviorFactory.BehaviorName.Returns(string.Empty);
emptySceneBehaviorFactory.Create(Arg.Any <Scene>())
.Returns(ci => SceneBehavior.CreateEmpty(ci.Arg <Scene>()));
_sceneBehaviorFactoryProvider.Get(string.Empty).Returns(emptySceneBehaviorFactory);
_componentFactoryProvider = Substitute.For <IComponentFactoryProvider>();
_assetStore = Substitute.For <IAssetStore>();
_sceneSerializer = new SceneSerializer(_sceneFactory, _sceneBehaviorFactoryProvider, _componentFactoryProvider, _assetStore);
}
public void StartPlaymode()
{
EditorApplication.Log.Info("starting playmode");
string json;
json = SceneSerializer.SertializeJson(Context.Scene);
//EditorApplication.Log.Debug($"\n{json}");
workingScene = Context.Scene;
ClearContext();
Context.Scene = SceneSerializer.DeserializeJson(json);
Context.Scene.Load();
Context.Scene.Start();
EditorApplication.Log.Info("playmode started");
}
public async Task CanGetScriptsFast()
{
string sceneJson = GetSampleSceneJson();
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{
_scenePath,
new MockFileData(sceneJson)
},
});
var serializer = new SceneSerializer(fileSystem, new Throttler());
var scripts = await serializer.FindScriptsFastAsync(_scenePath);
Assert.That(scripts, Is.EqualTo(new[]
{
"Saves/Script 1.cs"
}));
}
public static void ExportToHTML5()
{
var sceneData = SceneSerializer.Serialize();
var sceneJson = JsonConvert.SerializeObject(sceneData, Formatting.None, settings);
var sceneJs = $"window.sceneJson = '{sceneJson}'";
var targetPath = EditorUtility.SaveFolderPanel("Save HTML 5 build", Directory.GetCurrentDirectory(), "ThreeJS");
var distFiles = Directory.GetFiles(distPath).Where((file) => !new Regex(@"\.meta$").IsMatch(file));
foreach (var file in distFiles)
{
File.Copy(
Path.Combine(distPath, Path.GetFileName(file)),
Path.Combine(targetPath, Path.GetFileName(file)),
true);
}
File.WriteAllText(Path.Combine(targetPath, "scene.js"), sceneJs);
Debug.Log("Build complete!");
}
public void Export(int i = 0)
{
i++;
string save = "Content/LevelSave" + i + ".json";
if (File.Exists(save))
{
Export(i);
return;
}
Console.WriteLine("Saving in " + save);
SceneSerializer serializer = new SceneSerializer(save);
foreach (BodyEx body in world.Bodies)
{
serializer.AddBody(body);
}
File.WriteAllText(save, JsonConvert.SerializeObject(serializer.Scene, Formatting.Indented, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Ignore }));
}
//-------------------------------------------------
#region OnReceiveData method
public void OnReceiveData(string data)
{
if (SceneSerializer.Deserialize(data))
{
if (this.cubes.Length != 0)
{
Vector3 vector = new Vector3();
for (int i = 0; i < this.cubes.Length; i++)
{
vector.x = SceneSerializer.Collection.cubes[i].posX;
vector.y = SceneSerializer.Collection.cubes[i].posY;
vector.z = SceneSerializer.Collection.cubes[i].posZ;
cubes [i].position = vector;
vector.x = SceneSerializer.Collection.cubes[i].rotX;
vector.y = SceneSerializer.Collection.cubes[i].rotY;
vector.z = SceneSerializer.Collection.cubes[i].rotZ;
cubes [i].eulerAngles = vector;
}
}
}
}
public async Task <Scene> PostUploadScene(GamePlatform platform, GameVersion version)
{
if (platform != GamePlatform.PlatformType_PC || version != GameVersion.GameVersion_THUG)
{
throw new System.NotImplementedException();
}
IChecksumResolver checksumResolver = new THPS.API.Utils.ChecksumResolver(scriptKeyRepository, platform, version);
var files = HttpContext.Request.Form.Files;
using (MemoryStream ms = new MemoryStream())
{
var file = files.First();
using (BinaryReader bs = new BinaryReader(ms))
{
var reader = new SceneSerializer(checksumResolver);
await file.CopyToAsync(ms);
ms.Seek(0, SeekOrigin.Begin);
var results = await reader.ReadBuffer(bs);
return(results);
}
}
}
public unsafe override void OnRender()
{
Profiler.BeginScope($"{nameof(EditorLayer)}.{nameof(EditorLayer.OnRender)}");
Renderer.Clear();
ImGuiLayer.Instance.Begin();
SetupDockspace();
DrawModals();
DrawMainMenuBar();
ImGui.ShowDemoWindow(); // purely dev thing
// debug
ImGui.Begin("Debug");
if (Context.Scene != null)
{
Vector3 gr = (Context.Scene.RigidBodyWorld != null) ? Context.Scene.RigidBodyWorld.Gravity : default;
if (ImGui.DragFloat3("gravity", ref gr))
{
Context.Scene.RigidBodyWorld.Gravity = gr;
}
ImGui.Text("editor camera pos:");
if (EditorCamera != null)
{
ImGui.Text(EditorCamera.Position.ToString("0.00"));
}
ImGui.SliderInt("sleep", ref sleep, 0, 1000);
if (sleep > 0)
{
System.Threading.Thread.Sleep(sleep);
}
// test seri
if (ImGui.Button("seri test"))
{
string json;
json = SceneSerializer.SertializeJson(Context.Scene);
Log.App.Debug(json);
Context.Scene.Unload();
ClearContext();
Context.Scene = SceneSerializer.DeserializeJson(json);
Context.Scene.Load();
}
}
ImGui.End();
Profiler.BeginScope($"{nameof(EditorLayer)}.{nameof(EditorLayer.DrawPanels)}");
DrawPanels();
Profiler.EndScope();
EndDockspace();
ImGuiLayer.Instance.End();
Profiler.EndScope();
}
void handle(string res)
{
if (string.IsNullOrEmpty(res))
{
if (callback != null)
{
callback(false);
}
return;
}
JsonData jd = JsonMapper.ToObject(res);
if (jd.Contains(Param.SCENE))
{
List <Scene> updateList;
List <Scene> deleteList;
SceneSerializer.ToObjects(jd[Param.SCENE].ToJson(), out updateList, out deleteList);
if (updateList != null && updateList.Count != 0)
{
LogicController.ReplaceScenesIgnoreFavourite(updateList);
}
if (deleteList != null && deleteList.Count != 0)
{
LogicController.DeleteScenes(deleteList);
}
}
if (jd.Contains(Param.PRODUCT))
{
List <Product> updateList;
List <Product> deleteList;
ProductSerializer.ToObjects(jd[Param.PRODUCT].ToJson(), out updateList, out deleteList);
if (updateList != null && updateList.Count != 0)
{
LogicController.ReplaceProducts(updateList);
}
if (deleteList != null && deleteList.Count != 0)
{
LogicController.DeleteProducts(deleteList);
}
}
if (jd.Contains(Param.PICTURE))
{
List <Picture> list = PictureSerializer.ToObjects(jd[Param.PICTURE].ToJson());
if (list != null && list.Count != 0)
{
LogicController.ReplacePictures(list);
}
}
if (jd.Contains(Param.ASSET))
{
List <Asset> list = AssetSerializer.ToObjects(jd[Param.ASSET].ToJson());
if (list != null && list.Count != 0)
{
LogicController.ReplaceAssets(list);
}
}
if (callback != null)
{
callback(true);
}
}
//-------------------------------------------------
#region OnSaveClicked method
public void OnSaveClicked()
{
string serializedData = SceneSerializer.Serialize();
Application.ExternalCall("saveSceneToDisk", serializedData);
}
