/// <summary>
/// Load the scene in the given ScenePackage.
/// </summary>
/// <param name="scenePackage">The ScenePackage to load.</param>
public IEnumerable <SceneBuildStatus> loadScene(ScenePackage scenePackage, SceneBuildOptions options)
{
currentScenePackage = scenePackage;
yield return(new SceneBuildStatus()
{
Message = "Setting up Resources"
});
sceneResourceManager.changeResourcesToMatch(scenePackage.ResourceManager);
sceneResourceManager.initializeResources();
currentScene = scenePackage.SceneDefinition.createScene();
if (OnSceneLoading != null)
{
OnSceneLoading.Invoke(this, currentScene);
}
currentSimObjects = scenePackage.SimObjectManagerDefinition.createSimObjectManager(currentScene.getDefaultSubScene());
foreach (var status in currentScene.buildSceneStatus(options))
{
yield return(status);
}
if (OnSceneLoaded != null)
{
OnSceneLoaded.Invoke(this, currentScene);
}
}
public void build()
{
if (projectData.CreateSceneFile)
{
Log.ImportantInfo("Building project {0}", name);
ScenePackage scenePackage = new ScenePackage();
scenePackage.ResourceManager = PluginManager.Instance.createScratchResourceManager();
scenePackage.SceneDefinition = sceneFileInterface.getFileObject();
scenePackage.SimObjectManagerDefinition = new SimObjectManagerDefinition();
commonBuild(scenePackage);
String sceneFileName = Path.GetFullPath(Path.Combine(workingDirectory, projectData.SceneFileName));
try
{
using (var stream = File.Open(sceneFileName, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None))
{
saver.saveObject(scenePackage, stream);
Log.ImportantInfo("Finished building project {0} to {1}.", name, sceneFileName);
}
}
catch (Exception e)
{
Log.Error("Could not save project {0} to file {1} because:\n{2}", name, sceneFileName, e.Message);
}
}
}
public IEnumerable <SceneBuildStatus> loadSceneDefinitionCo(String fileName)
{
ScenePackage scenePackage;
using (var stream = VirtualFileSystem.Instance.openStream(fileName, Engine.Resources.FileMode.Open, Engine.Resources.FileAccess.Read))
{
scenePackage = saver.restoreObject <ScenePackage>(stream);
}
return(loadSceneCo(scenePackage));
}
internal void buildInstances(ScenePackage scenePackage)
{
foreach (InstanceFileInterface instanceFileInterface in instanceFiles.Values)
{
instanceFileInterface.buildInstance(scenePackage.SimObjectManagerDefinition);
}
foreach (InstanceGroup group in groups.Values)
{
group.buildInstances(scenePackage);
}
}
/// <summary>
/// Save the scene to the given filename.
/// </summary>
/// <param name="filename">The filename to save to.</param>
public void saveScene(String filename)
{
ScenePackage scenePackage = new ScenePackage();
scenePackage.SceneDefinition = sceneController.getSceneDefinition();
scenePackage.ResourceManager = resourceController.getResourceManager();
scenePackage.SimObjectManagerDefinition = simObjectController.getSimObjectManagerDefinition();
using (var stream = File.Open(filename, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None))
{
saver.saveObject(scenePackage, stream);
}
Log.ImportantInfo("Scene saved to {0}.", filename);
}
/// <summary>
/// 多线程翻译脚本语言
/// </summary>
/// <param name="threadId">线程id</param>
private void ParseHandler(object threadId)
{
while (true)
{
// 取队列中还未处理的场景
ScenePackage handleSp = null;
lock (this.splitQueue)
{
if (this.splitQueue.Count > 0)
{
handleSp = this.splitQueue.Dequeue();
}
}
if (handleSp == null)
{
break;
}
StringBuilder sceneBuilder = new StringBuilder();
// 处理主序列
sceneBuilder.AppendLine(this.ParseToScript(handleSp));
// 处理函数
foreach (var fp in handleSp.GetFunc())
{
sceneBuilder.AppendLine();
sceneBuilder.AppendLine(fp.functionDeclaration);
sceneBuilder.AppendLine(this.ParseToScript(fp));
sceneBuilder.AppendLine(fp.functionEndDeclaration);
}
// 生成代码加入结果向量
lock (this.resList)
{
this.resList.Add(new KeyValuePair <string, string>(handleSp.sceneName, sceneBuilder.ToString()));
}
lock (this.consoleMutex)
{
Console.WriteLine(String.Format("Finish Code Generation \"{0}\" At thread {1}", handleSp.sceneName, (int)threadId));
}
}
// 递增完成信号量
lock (consoleMutex)
{
this.finishedThread++;
Console.WriteLine(String.Format("Thread {0} is Finished", (int)threadId));
}
}
public void commonBuild(ScenePackage scenePackage)
{
scenePackage.ResourceManager.addResources(resourceFileInterface.getFileObject());
instanceGroup.buildInstances(scenePackage);
foreach (ProjectReference reference in projectData.ProjectReferences.ReferencedProjectNames)
{
Project refProject = solution.getProject(reference.ProjectName);
if (refProject != null)
{
Log.ImportantInfo("Building referenced project {0}.", refProject.Name);
refProject.commonBuild(scenePackage);
}
else
{
Log.Error("Could not find referenced project {0} for project {1}. Project could not be built.", reference.ProjectName, Name);
}
}
}
public IEnumerable <SceneBuildStatus> openScene(String filename, ResourceProvider resourceProvider)
{
medicalScene.destroyScene();
if (resourceProvider.exists(filename))
{
currentSceneFile = VirtualFileSystem.GetFileName(filename);
currentSceneDirectory = VirtualFileSystem.GetDirectoryName(filename);
using (Stream file = resourceProvider.openFile(filename))
{
XmlTextReader textReader = null;
ScenePackage scenePackage = null;
try
{
yield return(new SceneBuildStatus()
{
Message = "Loading Scene File"
});
textReader = new XmlTextReader(file);
scenePackage = xmlSaver.restoreObject(textReader) as ScenePackage;
}
finally
{
if (textReader != null)
{
textReader.Close();
}
}
if (scenePackage != null)
{
foreach (var status in medicalScene.loadScene(scenePackage, SceneBuildOptions.SingleUseDefinitions))
{
yield return(status);
}
}
}
}
else
{
Log.Error("Could not load scene {0}.", filename);
}
}
/// <summary>
/// Load the scene in the given ScenePackage.
/// </summary>
/// <param name="scenePackage">The ScenePackage to load.</param>
public IEnumerable <SceneBuildStatus> loadSceneCo(ScenePackage scenePackage, SceneBuildOptions options = SceneBuildOptions.SingleUseDefinitions)
{
this.scenePackage = scenePackage;
yield return(new SceneBuildStatus()
{
Message = "Setting up Resources"
});
sceneResourceManager.changeResourcesToMatch(scenePackage.ResourceManager);
sceneResourceManager.initializeResources();
scene = scenePackage.SceneDefinition.createScene();
scene.Scope = pluginManager.GlobalScope.ServiceProvider.CreateScope();
if (OnSceneLoading != null)
{
OnSceneLoading.Invoke(this, scene);
}
currentSimObjects = scenePackage.SimObjectManagerDefinition.createSimObjectManager(scene.getDefaultSubScene());
if (dynamicMode)
{
foreach (var status in scene.buildSceneStatus(options))
{
yield return(status);
}
}
else
{
scene.buildStaticScene();
}
if (OnSceneLoaded != null)
{
OnSceneLoaded.Invoke(this, scene);
}
foreach (DebugInterface debugInterface in pluginManager.DebugInterfaces)
{
debugInterface.createDebugInterface(pluginManager.RendererPlugin, scene.getDefaultSubScene());
}
}
public void loadScene(ScenePackage scenePackage, SceneBuildOptions options = SceneBuildOptions.SingleUseDefinitions)
{
foreach (var step in loadSceneCo(scenePackage, options))
{
}
}
