public static bool GetCurrentScene(SceneController rootSceneController, out SceneBase currentScene) { SceneController sceneController; SceneBase scene = rootSceneController.currentScene; bool isSub = (scene is SceneWithSubBase); if (isSub) { sceneController = ((SceneWithSubBase)scene).GetSubSceneController(); if (sceneController != null) { if (sceneController.currentScene != null) { return(GetCurrentScene(sceneController, out currentScene)); } else { currentScene = scene; return(true); } } } currentScene = scene; return(true); }
public static void openNextScene(SceneBase scene) { Tools.Log("===> openNextScene!"); if (m_busy) { Tools.Log("next scene is busy now!"); return; } //MgrPanel.disposeAllPanel(); if (m_curScene != null) { MgrResLoader.insertRemoving(m_curScene.getResList()); m_curScene.onLeave(); m_curScene = null; } m_busy = true; PanelLoading.open(); MgrResLoader.insertLoading(scene.getResList()); m_nextScene = scene; MgrPanel.disposeAllPanel(); MgrRes.clearObjectCacheAll(); Util.ClearMemory(); MgrResLoader.start(executeSceneDown); }
public void SwitchToScene(SceneId sceneId, object param = null) { if (sceneId == CurrentSceneId) { LogModule.WarningLog("switch to current scene: " + sceneId); } LogModule.DebugLog("SceneMgr SwitchToScene sceneId:" + sceneId.ToString() + " " + System.DateTime.Now.ToString()); mParam = param; if (mCurScene != null) { mCurScene.OnWillExit(); //App.EventMgr.Post(EventId.SceneWillExit, mCurScene.Id); } if (mSceneTypeDict.ContainsKey(sceneId)) { mNextScene = Activator.CreateInstance(mSceneTypeDict[sceneId]) as SceneBase; if (mNextScene != null) { mNextScene.OnWillEnter(param); } } if (hdlSceneWillSwitch != null) { hdlSceneWillSwitch.Invoke(mCurrentSceneId, sceneId, param); } SceneManager.LoadScene(sceneId.ToString()); }
public void SetSceneCross(int sceneId) { SceneBase scene = scenes [sceneId]; nextScene = scene; if (currentScene != null) { if (currentScene == scene) { Debug.Log("Same Scene"); return; } currentScene.eventCloseComplete += HandleCurrentSceneEventEndCrossComplete; CloseScene(currentScene); // set nextScene if (nextScene != null) { OpenScene(nextScene); } } else { OpenScene(nextScene); } }
void OpenScene(SceneBase scene) { Log("Open: " + scene); if (scene == null) { Log("Wrong Scene"); return; } if (!scene.gameObject.activeSelf) { scene.gameObject.SetActive(true); } if (!scene.enabled) { scene.enabled = true; } scene.Initialization(); // シーンの初期化 // EVENT / 遷移開始 if (eventTransition != null) { eventTransition(scene, TransitionType.OPEN_START); } openTransitionScene = scene; // 遷移中のシーン currentScene = null; scene.eventOpenComplete += SceneOpenComplete; scene.OpenScene(); }
void SceneClearComplete(SceneBase scene) { scene.eventCloseComplete -= SceneClearComplete; // 現在のシーンのクローズが完了。 closeTransitionScene = null; CloseSceneComplete(scene); }
public void SwitchScene(SceneType sceneType, params object[] sceneArgs) { string name = sceneType.ToString(); GameObject scene = new GameObject(name); SceneBase baseObj = scene.AddComponent(Type.GetType(name)) as SceneBase; //baseObj.Init(sceneArgs); baseObj.OnInit(sceneArgs); if (parentObj != null) { parentObj = GameObject.Find("UI Root").transform; } scene.transform.parent = parentObj; LayerMgr.GetInstance().SetLayer(baseObj.gameObject, LayerType.Scene); scene.transform.localEulerAngles = Vector3.zero; scene.transform.localScale = Vector3.one; scene.transform.localPosition = Vector3.zero; if (name.Equals("SceneHome")) { switchRecorder.Clear(); } switchRecorder.Add(new SwitchRecorder(sceneType, sceneArgs)); if (current != null) { GameObject.Destroy(current); } current = scene; }
public void PopTill(Type sceneType, bool destroy = false, bool include = false) { while (_stack.Count > 1) { var scene = pop(false); if (scene != null) { if (scene.GetType() == sceneType) { if (!include) { push(scene, false); } else { SceneBase.Destroy(scene); } break; } else { SceneBase.Destroy(scene); } } } SwitchScenesActivity(); }
public void Update(SceneBase scene, float dt) { foreach (var entity in scene.Entities) { var camera = entity.GetComponent <CameraFree>(); // var cameraRenderable = entity.GetComponent<CameraRenderable>(); if (camera != null) { //if (camera.CamType == Cam_Type.CA_CHARACTER) //{ // // move the camera smoothly to the goal // Vector3 goalOffset = camera.CameraGoal.WorldPosition - camera.CameraNode.Position; // camera.CameraNode.Translate(goalOffset * dt * 9.0f); // // always look at the pivot // camera.CameraNode.LookAt(camera.CameraPivot.WorldPosition); //}else if(camera.CamType == Cam_Type.CA_FREE) //{ //bool speedmodifier = false; //Vector3 camMovementDir = camera.Camera_GetMove(); //camMovementDir = Vector3.Vector3_Normalize(camMovementDir); //camMovementDir *= dt * 10.0f * (1);// + speedmodifier * 5); //camera.Camera_MoveRelative(camMovementDir); // } } } }
/// <summary> /// 弹出栈顶场景,并将当前场景销毁 /// </summary> public void PopScene() { if (sceneStack.Count <= 0 || sceneStack.Last == null) { return; } SceneBase last = currentScene; SceneBase bePoped = sceneStack.Last.Value; if (currentScene != null) { currentScene.OnDestroy(); } if (bePoped != null) { bePoped.OnPoped(last); bePoped.LoadScene(); bePoped.UpdateAudioState(); bePoped.UpdateGlobalLight(); currentScene = bePoped; } sceneStack.RemoveLast(); }
/// <summary> /// 将当前场景入栈,并加载新场景 /// </summary> /// <param name="next">待加载的场景</param> public void PushScene(SceneBase next) { if (next == null) { Debug.LogWarning("SceneManager.PushScene : Null GameScene."); return; } if (currentScene != null) { if (currentScene.SNode == next.SNode) { Debug.LogWarning("SceneManager.PushScene : The Same GameScene."); return; } currentScene.OnPushed(next); sceneStack.AddLast(currentScene); } next.LoadScene(); next.UpdateAudioState(); next.UpdateGlobalLight(); currentScene = next; }
protected IEnumerator SceneLoadCorountine(GameObject sceneObj) { bool isFade = true; StartCoroutine(FadeScene.Instance.FadeOut(() => isFade = false)); while (isFade) { yield return(null); } if (NowScene != null) { NowScene.Destroy(); } float elapsedTime = Time.time; NowScene = Instantiate(sceneObj, SceneRoot.transform).GetComponent <SceneBase>(); NowScene.Initilize(); yield return(StartCoroutine(NowScene.DoInitialize())); elapsedTime = Time.time - elapsedTime; // フェードアニメーションの間隔を最低限あける if (elapsedTime < FadeSpaceTime) { yield return(new WaitForSeconds(FadeSpaceTime - elapsedTime)); } StartCoroutine(FadeScene.Instance.FadeIn(() => isFade = false)); while (isFade) { yield return(null); } NowScene.OnCompleteInitialize(); }
public void Process(SceneBase world, int ci, int ri, int hres, int vres) { Vec2 s = world.ViewPlane.PixelSize / zoom; int numSamples = world.ViewPlane.NumSamples; Vec3 pixelColor = ColorUtils.BLACK; Ray ray = new Ray(eye, null); Vec2 pp = new Vec2(); Vec2 sp; for (int r = ri; r < vres; r++) //up - y height { for (int c = ci; c < hres; c++) //across - x width { pixelColor = ColorUtils.BLACK; for (int j = 0; j < numSamples; j++) { sp = world.ViewPlane.Sampler.SampleUnitSquare(); pp.X = s.X * (c - 0.5 * world.ViewPlane.Hres + sp.X); pp.Y = s.Y * (r - 0.5 * world.ViewPlane.Vres + sp.Y); ray.D = RayDirection(pp); pixelColor += world.Tracer.TraceRay(ray, 0); } pixelColor /= numSamples; pixelColor *= exposureTime; world.DisplayPixel(c, r, pixelColor); } } }
public void Update(SceneBase scene, float dt) { foreach (var ent in scene.Entities) { UpdateActionMap(ent, dt); } }
void InitScene(SceneBase sceneBase) { //创建主角 //初始化主角 //var behaviour = LogicMM.mainRole.AddMainRole(); //behaviour.transform.position = sceneBase.player_pos; }
private void Update() { for (int i = 0; i < sceneLoaderList.Count; i++) { SceneLoader loader = sceneLoaderList[i]; bool loaded = loader.Update(); if (loaded) { SceneDefine.SCENE_ID id = loader.SceneID; UnityScene unityScene = UnitySceneManager.GetSceneByName(loader.Name); SceneBase scene = GameObject.Find(unityScene.name).GetComponent <SceneBase>(); sceneList.Add(scene); sceneLoaderList.RemoveAt(i); UnitySceneManager.SetActiveScene(unityScene); scene.Setup(id, unityScene); break; } } for (int i = 0; i < sceneList.Count; i++) { // アンロード処理 if (sceneList[i] == null) { sceneList.RemoveAt(i); break; } } }
/// <summary> /// 打开指定场景 /// </summary> /// <param name="sceneType"></param> /// <param name="sceneArgs">场景参数</param> private void ShowScene(SceneType sceneType, params object[] sceneArgs) { if (scenes.ContainsKey(sceneType)) { current = scenes[sceneType]; current.OnShowing(); current.OnResetArgs(sceneArgs); current.gameObject.SetActive(true); current.OnShowed(); } else { if (sceneType == SceneType.None) { current = null; return; } GameObject go = new GameObject(sceneType.ToString()); Type mType = Type.GetType(sceneType.ToString()); current = go.AddComponent(mType) as SceneBase; current.OnInit(sceneArgs); scenes.Add(current.type, current); current.OnShowing(); LayerMgr.GetInstance.SetLayer(current.gameObject, LayerType.Scene); go.transform.localPosition(Vector3.zero).localRotation(Quaternion.identity).localScale(1); current.OnShowed(); } }
/// <summary> /// シーンロード /// </summary> private static void LoadSceneAsync(SceneDataPackBase dataPack) { //Header非表示 ※次のシーンでも表示が続くなら非表示にしない方が良いか? SharedUI.Instance.HideHeader(); //ロード開始 SceneManager.LoadSceneAsync(dataPack.toSceneName).completed += (op) => { //シーン取得 currentSceneName = dataPack.toSceneName; currentScene = SceneManager .GetSceneByName(currentSceneName) .GetRootGameObjects() .Select(g => g.GetComponent <SceneBase>()) .First(s => s != null); if (IsAutoHideLoading) { //シーン移動アニメーション終了 SharedUI.Instance.HideSceneChangeAnimation(); } //ロード完了通知 IsLoading = false; currentScene.OnSceneLoaded(dataPack); }; }
public void ChangeScene(eScene scene) { SceneBase change = null; switch (scene) { case eScene.None: break; case eScene.MainTown: change = new MainScene(); break; case eScene.Battle: break; default: break; } if (change != null) { SceneSwitch(change); } }
// private SceneBase m_scene; public SceneBanner(SceneBase scene, List<string> banList) { scene.EventManager.OnClientConnect += EventManager_OnClientConnect; bans = banList; // m_scene = scene; }
// Update is called once per frame void Update() { //arrayPos = i; scene = GameObject.FindGameObjectWithTag("Scenery"); sceneC = scene.GetComponent <SceneBase> (); Actualizar(); }
public window() { Thread.CurrentThread.Name = "Primary - "; InitializeComponent(); sf = new SceneFactory(); //scene = new SingleSphere(this); //scene = sf.CreateMultipleSphere(this); //scene = sf.CreateBallsScene2(this); //scene = sf.CreateAmbientOcclusion(this); //scene = sf.CreateAreaLighting(this); //scene = sf.CreateObjectTest(this); //scene = sf.CreateEnvironmentLight(this); //scene = sf.CreateObjectsSSFloat(this); //scene = sf.CreateTriangleScene(this); //scene = sf.CreateTorusScene(this); //scene = sf.CreateSolidCylinderScene(this); //scene = sf.CreateSolidConeScene(this); //scene = sf.CreateAnnulusScene(this); //scene = sf.CreateBowlScene(this); //scene = sf.CreateInstanceScene(this); //scene = sf.CreateBeveledCylinderScene(this); //scene = sf.CreateRandomSpheres(this); //scene = sf.CreateGridAndTransformedObject1(this); //scene = sf.CreateGridAndTransformedObject2(this); //scene = sf.CreateTessellateSphere(this); //scene = sf.CreateReflectiveObjects(this); //scene = sf.CreateGlossyReflectorTest1(this); //scene = sf.CreatePathTracingTest(this); //scene = sf.CreatePerfectTransmitterTest(this); //scene = sf.CreateGlobalTraceTest(this); //scene = sf.CreateGlassWithLiquid(this); scene = sf.CreateEarthScene(this); }
private void ShowScene(SceneType sceneType, params object[] sceneArgs) { if (scenes.ContainsKey(sceneType)) { currentSceneBase = scenes[sceneType]; currentSceneBase.OnShowing(); currentSceneBase.OnResetArgs(sceneArgs); currentSceneBase.gameObject.SetActive(true); currentSceneBase.OnShowed(); } else { if (parentObj == null) { parentObj = UIRoot; } string name = sceneType.ToString(); GameObject scene = new GameObject(name); UnityHelper.AddUIChildNodeToParentNode(parentObj, scene.transform); SceneBase currentScene = scene.AddComponent(Type.GetType(name)) as SceneBase; currentSceneBase = currentScene; CurrentSceneType = sceneType; currentSceneBase.OnInit(sceneArgs); currentSceneBase.OnShowing(); SetLayer(currentSceneBase.gameObject, LayerType.Scene); currentSceneBase.OnShowed(); scenes.Add(sceneType, currentSceneBase); switchRecoders.Add(new SwitchRecorder(sceneType, sceneArgs)); } }
public void GotoScene(string scneneType, Type t = null, Func <SceneBase> func = null, object param = null) { FairyGUI.GRoot.inst.touchable = false; SceneBase scene = GetScnene(scneneType); if (func == null) { func = () => { return(Activator.CreateInstance(t) as SceneBase); }; } if (scene == null) { scene = func(); scene.SceneName = scneneType; mScenes.Add(scneneType, scene); } if (currentScene != null && scneneType == currentScene.SceneName) { Debug.LogError("当前场景和要到的目标场景重复" + scneneType); currentScene.Enter(param); } else { if (currentScene != null) { currentScene.Leave(); oldScenes.Enqueue(currentScene); } currentScene = mScenes[scneneType]; currentScene.Enter(param); } }
public SceneBanner(SceneBase scene, List <string> banList) { scene.EventManager.OnClientConnect += EventManager_OnClientConnect; bans = banList; m_scene = scene; }
/// <summary> /// UI를 만드는 함수 /// UI를 만들고 Scene과 UI를 서로 연결 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="scene"></param> /// <returns></returns> public T CreateUI <T>(SceneBase scene) where T : UIBase, new() { var newUI = new T(); scene.CurrentUI = newUI; newUI.CurrentScene = scene; newUI.Start(); switch (newUI.Type()) { case UI_TYPE.PAGE: { _currentPage = newUI; _mapPageStack.Add(_currentPage, new List <UIBase>()); } break; case UI_TYPE.STACK: { _mapPageStack[_currentPage].Add(newUI); } break; case UI_TYPE.POPUP: { _listPopup.Add(newUI); } break; default: break; } return(newUI); }
public IEnumerator LoadScene(string nextScene) { Scene curScene = SceneManager.GetActiveScene(); if (string.IsNullOrEmpty(nextScene) || m_isLoading || curScene.name.Equals(nextScene)) { yield break; } m_isLoading = true; SceneManager.LoadScene(SceneConst.SceneName, LoadSceneMode.Additive); yield return(StartCoroutine(AsyncLoadScene(nextScene))); FreshProcessEvent.Invoke(SceneConst.LOADSCENEPROCESS); m_unloadAsync = SceneManager.UnloadSceneAsync(curScene); /* * //使用LoadSceneMode.Additive进行场景切换,无法完全释放资源。即使使用Resources.UnloadUnusedAssets()也不行 * //可能出现如下情况: * //1.资源没有引用了,但是还没有回收 * //2.被UnityEngine.EventSystems.StandaloneInputModule和UnityEngine.EventSystems引用 * //当然如果单纯从一个场景切换另外一个场景,直接使用UnityEngine.SceneManagement.SceneManager.LoadScene("xxx") * //直接切换场景,这个会进行内存回收 */ yield return(m_unloadAsync); FreshProcessEvent.Invoke(SceneConst.UNSCENEPROCESS); //场景中必须有一个对象挂载SceneBase SceneBase sceneLoader = UnityTool.GetTopObject("SceneLoader").GetComponent <SceneBase>(); if (sceneLoader == null) { Debug.LogError("lack of gameobject of name 'SceneLoader'"); yield break; } yield return(new WaitUntil(sceneLoader.FinishConfigRes)); FreshProcessEvent.Invoke(SceneConst.INITNETPROCESS); yield return(new WaitUntil(sceneLoader.FinishGetData)); FreshProcessEvent.Invoke(SceneConst.INITCONFIGPROCESS); yield return(new WaitUntil(sceneLoader.FinishInit)); FreshProcessEvent.Invoke(SceneConst.INITSCENEPROCESS); yield return(new WaitForSeconds(1f)); FreshProcessEvent.Invoke(1f); m_loadAsync = SceneManager.UnloadSceneAsync(SceneConst.SceneName); yield return(m_loadAsync); m_isLoading = false; }
/// <summary> /// 同ReplaceScene,但将栈清空 /// </summary> /// <param name="target"></param> public void SetScene(SceneBase target) { if (target != null) { ReplaceScene(target); sceneStack.Clear(); } }
public void ChangeScene <T>() where T : SceneBase { Assembly assembly = Assembly.GetExecutingAssembly(); // 获取当前程序集 m_curScene = (T)assembly.CreateInstance(typeof(T).ToString()); m_curScene.Init(); }
public void LoadScene(int sceneNo) { SceneBase scene; switch (sceneNo) { case 0: scene = new SceneRandom(); break; case 1: scene = new SceneFire(); break; case 2: scene = new SceneTwinkle(); break; case 3: scene = new SceneOcean(); break; case 4: scene = new SceneRainbow(); break; case 5: scene = new SceneJuly(); break; case 6: scene = new SceneHoliday(); break; case 7: scene = new ScenePop(); break; case 8: scene = new SceneForest(); break; default: scene = null; break; } if (scene == null) { return; } CurrentScene = scene; colors = scene.GetColors(); animationTime = scene.AnimationTime; mode = scene.Mode; startInt = 0; RefreshColors(colors); }
public void Pop(SceneBase scene) { if (_stack.Contains(scene)) { _stack.Remove(scene); scene.Enabled = false; SwitchScenesActivity(); } }
public void Add(SceneBase scene, bool initializeAndLoadContent = false) { if (initializeAndLoadContent) { scene.Initialize(context); scene.LoadContent(); } Scenes.Add(scene); }
public virtual void initialize() { // base initialization currentSceneGameObject = gameObject; currentSceneClass = this; // add audio listner gameObject.AddComponent<AudioListener>(); // create UI Manager uiManager = UIManager.createNewInstance(); }
public void AddChild(SceneBase parent, SceneBase child, bool initializeAndLoadContent = false) { child.Parent = parent; if (initializeAndLoadContent) { child.Initialize(context); child.LoadContent(); } parent.SceneChildren.Add(child); }
public void Remove(SceneBase scene) { // Remove a root scenes if (scene.Parent == null) { for (int i = 0; i < Scenes.Count; i++) { var currentScene = Scenes[i]; // Remove the scene if (scene == currentScene) { scene.UnloadContent(); Scenes.Remove(scene); break; } } } // Remove a child scene else { for (int i = 0; i < Scenes.Count; i++) { var currentScene = Scenes[i]; // Remove the scene if found as a child-scene to the current scene for (int j = 0; j < currentScene.SceneChildren.Count; j++) { var child = currentScene.SceneChildren[j]; if (scene == child) { scene.UnloadContent(); currentScene.SceneChildren.Remove(scene); break; } } } } }
/// <summary> /// 场景入栈时操作 /// </summary> /// <param name="next">下一个场景</param> public virtual void OnPushed(SceneBase next) { }
/// <summary> /// 场景出栈时操作 /// </summary> /// <param name="last">上一个场景</param> public virtual void OnPoped(SceneBase last) { }
/// <summary> /// Show assigned scene /// </summary> private void ShowScene(SceneType sceneType, params object[] sceneArgs) { if(scenes.ContainsKey(sceneType)){ current = scenes[sceneType]; current.OnShowing(); current.OnResetArgs(sceneArgs); NGUITools.SetActive(current.gameObject, true); current.OnShowed(); } else{ GameObject go = new GameObject(sceneType.ToString()); //sceneType.tostring = classname for current scene current = UnityEngineInternal.APIUpdaterRuntimeServices.AddComponent(go, "Assets/Script/Core/View/SceneMgr.cs (120,14)", sceneType.ToString()) as SceneBase; current.OnInit(sceneArgs); scenes.Add(current.type, current); current.OnShowing(); LayerMgr.GetInstance().SetLayer(current.gameObject, LayerType.Scene); go.transform.localScale = Vector3.one; go.transform.localRotation = Quaternion.identity; current.OnShowed(); } }
private static SceneItem LoadCompositeEntity(XmlNode node, SceneBase scene) { TraceLogger.TraceInfo("Beginning LoadCompositeAnimation"); _storedScene = scene as IceScene; CompositeEntity _compositeEntity = new CompositeEntity(); LoadBaseSceneItem(node, _compositeEntity); XmlNode _node = node.SelectSingleNode("CompositeEntityData"); SetProperty("SceneItemBank", _compositeEntity, _node); SetProperty("RootBone", _compositeEntity, _node); SetProperty("Animations", _compositeEntity, _node); SetIAnimationDirectorProperties(_node, _compositeEntity as IAnimationDirector); TraceLogger.TraceInfo("Ending LoadCompositeEntity"); return _compositeEntity; }
private static SceneItem LoadParticleEffect(XmlNode node, SceneBase scene) { TraceLogger.TraceInfo("Beginning LoadParticleEffect"); ParticleEffect _particle = new ParticleEffect(); LoadBaseSceneItem(node, _particle); XmlNode emitterNode = node.SelectSingleNode("Emitter"); if (emitterNode != null) { LoadEmitter(emitterNode, _particle, scene); } SetProperty("EditorBackgroundColor", _particle, node); SetIAnimationProperties(node, _particle); TraceLogger.TraceInfo("Ending LoadParticleEffect"); return _particle; }
private static XmlNode WriteSceneComponents(XmlDocument doc, SceneBase scene) { XmlNode _componentsNode = doc.CreateElement(NodeNames.COMPONENTS); foreach (var comp in scene.SceneComponents) { XmlNode _componentNode = doc.CreateElement(comp.GetType().FullName); WriteSceneComponent(_componentNode, comp, doc); _componentsNode.AppendChildIfNotNull(_componentNode); } return _componentsNode; }
private static Material GetMaterialAssetFromNode(XmlNode node, SceneBase scene) { string _materialSource = node.Attributes["materialSource"].InnerText; string _matRef = ""; if (node.Attributes["materialRef"] != null) _matRef = node.Attributes["materialRef"].InnerText; else _matRef = node.InnerText; if (_materialSource.ToUpper() == "LOCAL") return scene.GetMaterial(_matRef); else if (_materialSource.ToUpper() == "GLOBAL") return SceneManager.GlobalDataHolder.GetMaterial(_matRef); else if (_materialSource.ToUpper() == "EMBEDDED") return SceneManager.GetEmbeddedMaterial(_matRef); else return null; }
public static void DeSerializeScene(String filename, String contentRoot, SceneBase scene) { Console.WriteLine("**************************************************"); Console.WriteLine("Deserializing scene"); Console.WriteLine(filename); Console.WriteLine("**************************************************"); _loadingScene = scene; scene.SceneComponents.Clear(); scene.Fonts.Clear(); scene.SceneItems.Clear(); scene.Materials.Clear(); scene.TemplateItems.Clear(); FireStatusUpdate("Loading File", 50); StreamReader _sr = new StreamReader(filename); XmlDocument doc = new XmlDocument(); doc.Load(_sr); if (scene is GlobalDataHolder) { GlobalDataHolder gdh = scene as GlobalDataHolder; XmlNode _resNode = doc.SelectSingleNode("IceScene/NativeResolution"); if (_resNode != null) { gdh.NativeResolution = new Point( Int32.Parse(_resNode.SelectSingleNode("X").InnerText, CultureInfo.InvariantCulture), Int32.Parse(_resNode.SelectSingleNode("Y").InnerText, CultureInfo.InvariantCulture)); } } TraceLogger.TraceInfo("LOADING ASSETS"); FireStatusUpdate("Loading Assets", 100); LoadAssets(doc, scene); TraceLogger.TraceInfo("LOADING SCENE COMPONENTS"); FireStatusUpdate("Loading Scene Components", 0); LoadSceneComponents(doc, scene); TraceLogger.TraceInfo("LOADING SCENE ITEMS"); FireStatusUpdate("Loading Scene Items", 0); LoadSceneItems(doc, scene); TraceLogger.TraceInfo("LOADING SCENE TEMPLATE ITEMS"); FireStatusUpdate("Loading Scene Templates", 0); LoadTemplateItems(doc, scene); FireStatusUpdate("Loading Scene Templates", 100); _sr.Close(); _sr.Dispose(); _sr = null; doc = null; }
private static XmlNode WriteTemplateItems(XmlDocument doc, SceneBase scene) { XmlNode _templatesNode = doc.CreateElement(NodeNames.TEMPLATES); WritesSceneCollection(doc, _templatesNode, scene.TemplateItems); return _templatesNode; }
public static void SerializeScene(SceneBase scene, string filename) { try { XmlDocument _doc = new XmlDocument(); XmlNode _rootNode = _doc.CreateElement(NodeNames.ICESCENE); _doc.AppendChild(_rootNode); if (scene.Equals(SceneManager.GlobalDataHolder)) { GlobalDataHolder globalDataHolder = scene as GlobalDataHolder; XmlNode _res = _doc.CreateElement("NativeResolution"); _res.AppendChild(_doc.CreateElement("X")).InnerText = globalDataHolder.NativeResolution.X.ToString(); _res.AppendChild(_doc.CreateElement("Y")).InnerText = globalDataHolder.NativeResolution.Y.ToString(); _rootNode.AppendChild(_res); } _rootNode.AppendChildIfNotNull(WriteAssets(_doc, scene)); _rootNode.AppendChildIfNotNull(WriteSceneComponents(_doc, scene)); _rootNode.AppendChildIfNotNull(WriteSceneItems(_doc, scene)); _rootNode.AppendChildIfNotNull(WriteTemplateItems(_doc, scene)); _doc.Save(filename); _doc = null; } catch (Exception err) { throw err; } }
private static TileSheet LoadTileSheet(XmlNode _node, SceneBase scene) { TileSheet tileSheet = new TileSheet(); tileSheet.Material = GetMaterialAssetFromNode(_node, scene); SetProperty("EnableCollisionByDefault", tileSheet, _node); SetProperty("TileSize", tileSheet, _node); SetProperty("Polygons", tileSheet, _node); tileSheet.CreateFlippedPolygons(); return tileSheet; }
private static XmlNode WriteSceneItems(XmlDocument doc, SceneBase scene) { XmlNode _sceneItemsNode = doc.CreateElement(NodeNames.SCENEITEMS); WritesSceneCollection(doc, _sceneItemsNode, scene.SceneItems); return _sceneItemsNode; }
private static void LoadAssets(XmlDocument doc, SceneBase scene) { string _lastValidName = ""; try { XmlNode _el = doc.SelectSingleNode("IceScene/Assets"); int _count = _el.ChildNodes.Count; int _current = 0; foreach (XmlNode _node in _el.ChildNodes) { _current++; int perc = (int)((double)_current / (double)_count * 100); ; FireStatusUpdate(string.Format("Loading Asset {0}/{1}", _current, _count), perc); IceAsset asset = null; if (_node.Name.ToUpper() == "MATERIAL") { Material newMat = new Material(); asset = newMat; scene.Materials.Add(newMat); TraceLogger.TraceInfo("Loading Material"); if (_node.Attributes.GetNamedItem("areas_definition") != null) { newMat.AreasDefinitionFilename = _node.Attributes["areas_definition"].InnerText; String definitionPath = Path.Combine(SceneSerializer.RootPath, newMat.AreasDefinitionFilename); TraceLogger.TraceVerbose("Loading AreasDefinitionFilename: " + newMat.AreasDefinitionFilename); newMat.LoadAreasDefinition(definitionPath); } } else if (_node.Name.ToUpper() == "FONT") { asset = new IceFont(); scene.Fonts.Add(asset as IceFont); TraceLogger.TraceInfo("Loading Font"); } else if (_node.Name.ToUpper() == "EFFECT") { #if !XNATOUCH asset = CreateEffectInstance(_node.Attributes["type"].InnerText); scene.Effects.Add(asset as IceEffect); TraceLogger.TraceInfo("Loading Effect"); #endif } else if (_node.Name.ToUpper() == "TILESHEET") { TileSheet newTileSheet = LoadTileSheet(_node, scene); asset = newTileSheet; scene.TileSheets.Add(newTileSheet); TraceLogger.TraceInfo("Loading TileSheet"); } asset.Scope = AssetScope.Local; if (scene == SceneManager.GlobalDataHolder) { asset.Scope = AssetScope.Global; } asset.Parent = scene; asset.Name = _node.Attributes["name"].InnerText; _lastValidName = asset.Name; if (_node.Attributes.GetNamedItem("location") != null) { asset.Filename = _node.Attributes["location"].InnerText; } else { asset.Filename = ""; } TraceLogger.TraceInfo("Name : " + asset.Name); TraceLogger.TraceVerbose("FileName : " + asset.Filename); TraceLogger.TraceVerbose("Scope : " + asset.Scope.ToString()); } } catch (Exception err) { if (err != null) { #if(WINDOWS) Trace.TraceError("ERROR In Load Assets - " + _lastValidName); #endif throw new ArgumentException("Error in load materials: " + err.Message); } } }
/// <summary> /// 场景被替换时操作 /// </summary> /// <param name="next"></param> public virtual void OnReplaced(SceneBase next) { }
private static TileSheet LoadTileSheetFromNode(XmlNode _node, SceneBase scene, SceneItem item) { if (_node.Attributes.GetNamedItem("tileSheetSource") != null && _node.Attributes.GetNamedItem("tileSheetRef") != null) { String tileScope = _node.Attributes["tileSheetSource"].InnerText; String tileRef = _node.Attributes["tileSheetRef"].InnerText; TileSheet returnTilesheet = null; if (tileScope.ToUpper() == "LOCAL") { returnTilesheet = scene.GetTileSheet(tileRef); } else if (tileScope.ToUpper() == "GLOBAL") { returnTilesheet = SceneManager.GlobalDataHolder.GetTileSheet(tileRef); } if (returnTilesheet != null) { return returnTilesheet; } else { throw new Exception("The SceneItem \"" + item.Name + "\" is trying to use an invalid TileSheet: [" + tileScope.ToUpper() + "] \"" + tileRef + "\""); } } else { return null; } }
private static XmlNode WriteAssets(XmlDocument doc, SceneBase scene) { XmlNode assetsNode = doc.CreateElement(NodeNames.ASSETS); XmlNode assetNode = null; foreach (Material mat in scene.Materials) { assetNode = doc.CreateElement(NodeNames.MATERIAL); WriteMaterial(doc, assetNode, mat); assetsNode.AppendChildIfNotNull(assetNode); } foreach (IceFont font in scene.Fonts) { assetNode = doc.CreateElement(NodeNames.FONT); SerializeAsset(doc, assetNode, font); assetsNode.AppendChildIfNotNull(assetNode); } #if !XNATOUCH foreach (IceEffect mat in scene.Effects) { assetNode = doc.CreateElement("Effect"); SerializeAsset(doc, assetNode, mat); string name = mat.Effects[0].GetType().Name; assetNode.Attributes.Append(doc.CreateAttribute("type")).InnerText = mat.GetType().FullName; assetsNode.AppendChildIfNotNull(assetNode); } #endif foreach (TileSheet tileSheet in scene.TileSheets) { assetNode = doc.CreateElement(NodeNames.TILESHEET); WriteTileSheet(assetNode, doc, tileSheet); assetsNode.AppendChildIfNotNull(assetNode); } return assetsNode; }
private static Material LoadMaterialFromNode(XmlNode _node, SceneBase scene, SceneItem item) { String _materialSource = _node.Attributes["materialSource"].InnerText; String _materialRef = _node.Attributes["materialRef"].InnerText; Material _returnMaterial = null; if (_materialSource.ToUpper() == "LOCAL") { _returnMaterial = scene.GetMaterial(_materialRef); } else if (_materialSource.ToUpper() == "GLOBAL") { _returnMaterial = SceneManager.GlobalDataHolder.GetMaterial(_materialRef); } else if (_materialSource.ToUpper() == "EMBEDDED") { _returnMaterial = SceneManager.GetEmbeddedMaterial(_materialRef); } if (_returnMaterial != null) { return _returnMaterial; } else { throw new Exception("The SceneItem \"" + item.Name + "\" is trying to use an invalid material: [" + _materialSource.ToUpper() + "] \"" + _materialRef + "\""); } }
private static void LoadSceneComponents(XmlDocument doc, SceneBase scene) { XmlNode _componentsNode = doc.SelectSingleNode("IceScene/Components"); if (_componentsNode == null) return; List<IceSceneComponent> _components = new List<IceSceneComponent>(); foreach (XmlNode _compNode in _componentsNode.ChildNodes) { TraceLogger.TraceInfo("Loading Scene Component Of Type" + _compNode.Name); IceSceneComponent _comp = CreateSceneComponentInstance(_compNode.Name); if (_comp != null) { foreach (XmlNode nd1 in _compNode) { SetProperty(nd1.Name, _comp, _compNode); } _comp.SetOwner(scene as IceScene); _components.Add(_comp); } } scene.SceneComponents = _components; }
private static void LoadEmitter(XmlNode emitterNode, ParticleEffect particle, SceneBase scene) { try { TraceLogger.TraceInfo("Beginning LoadEmitter"); particle.Emitter = new IceCream.SceneItems.ParticlesClasses.Emitter(); XmlDocument doc = new XmlDocument(); doc.LoadXml(emitterNode.OuterXml); XmlReaderSettings sett = new XmlReaderSettings(); StringReader stringReader = new StringReader(emitterNode.OuterXml); XmlTextReader xmlReader = new XmlTextReader(stringReader); XmlSerializer ser = new XmlSerializer(typeof(Emitter)); particle.Emitter = (Emitter)ser.Deserialize(xmlReader); XmlNode _types = emitterNode.SelectSingleNode("ParticleTypes"); if (_types != null) { int i = 0; foreach (XmlNode _type in _types.ChildNodes) { ParticleType ptype = particle.Emitter.ParticleTypes[i]; XmlNode _matNode = _type.SelectSingleNode("Material"); if (_matNode != null) { ptype.Material = GetMaterialAssetFromNode(_matNode, scene); if (ptype.Material == null) throw new Exception("Material Not Found For " + particle.Name); } else { ptype.Material = SceneManager.GetEmbeddedParticleMaterial(); TraceLogger.TraceWarning("Particle Effect Node Type Has No Material Set"); } i++; } } TraceLogger.TraceInfo("Ending LoadEmitter"); } catch (Exception err) { TraceLogger.TraceError("Error Occurred In LoadEmitter" + Environment.NewLine + err.ToString()); throw err; } }
private static void LoadSceneItems(XmlDocument doc, SceneBase scene) { try { XmlNode _el = doc.SelectSingleNode("IceScene/SceneItems"); LoadSceneCollection(scene, _el, scene.SceneItems); } catch (Exception err) { throw new ArgumentException("Error in load scene items: " + err); } }
private static void LoadSceneCollection(SceneBase scene, XmlNode _el, List<SceneItem> sceneitems) { try { int _count = _el.ChildNodes.Count; int _current = 0; foreach (XmlNode _node in _el.ChildNodes) { _current++; int perc = (int)((double)_current / (double)_count * 100); FireStatusUpdate(string.Format("Loading Scene Item {0}/{1}", _current, _count), perc); SceneItem _item = null; //string _type = _node.Name; _item = LoadSceneItem(_node, scene as IceScene); sceneitems.Add(_item); } } catch (Exception e) { TraceLogger.TraceError("Error occurred in LoadSceneCollection" + Environment.NewLine + e.ToString()); throw; } }
private static TextItem LoadTextItem(XmlNode node, SceneBase scene) { TraceLogger.TraceInfo("Loading TextItem"); TextItem _textItem = new TextItem(); LoadBaseSceneItem(node, _textItem); _textItem.Font = LoadFontFromNode(node, scene); SetProperty("Text", _textItem, node); SetProperty("AutoCenterPivot", _textItem, node); SetProperty("Shadow", _textItem, node); SetProperty("Tint", _textItem, node); return _textItem; }
private static AnimatedSprite LoadAnimatedSprite(XmlNode _node, SceneBase scene) { try { TraceLogger.TraceInfo("Beginning Serialize AnimatedSprite"); AnimatedSprite _sprite = new AnimatedSprite(); LoadBaseSceneItem(_node, _sprite); SetIAnimationDirectorProperties(_node, _sprite); _sprite.Material = GetMaterialAssetFromNode(_node, scene); TraceLogger.TraceInfo("Loading AnimationInfo Data"); XmlNode _anList = _node.SelectSingleNode("Animations"); if (_anList != null) { foreach (XmlNode item in _anList.ChildNodes) { _sprite.AddAnimation(GetAnimationInfoFromNode(item)); } } TraceLogger.TraceInfo("Ending Serialize AnimatedSprite"); return _sprite; } catch (Exception err) { string errMessage = "Error Occurred In LoadAnimatedSprite"; errMessage += Environment.NewLine + _node.InnerText; TraceLogger.TraceError(errMessage); throw new InvalidOperationException(errMessage, err); } }
private static Sprite LoadSprite(XmlNode _node, SceneBase scene) { TraceLogger.TraceInfo("Loading Sprite"); Sprite _sprite = new Sprite(); LoadBaseSceneItem(_node, _sprite); _sprite.Material = LoadMaterialFromNode(_node, scene, _sprite); if (_node.Attributes.GetNamedItem("materialArea") != null) { _sprite.MaterialArea = _node.Attributes["materialArea"].InnerText; } else { SetProperty("SourceRectangle", _sprite, _node); } return _sprite; }
private static IceFont LoadFontFromNode(XmlNode _node, SceneBase scene) { string _materialSource = _node.Attributes["fontSource"].InnerText; if (_materialSource.ToUpper() == "LOCAL") return scene.GetFont(_node.Attributes["fontRef"].InnerText); else if (_materialSource.ToUpper() == "GLOBAL") return SceneManager.GlobalDataHolder.GetFont(_node.Attributes["fontRef"].InnerText); else if (_materialSource.ToUpper() == "EMBEDDED") return SceneManager.GetEmbeddedFont(_node.Attributes["fontRef"].InnerText); else return null; }