D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/DXGfxManager.cs

Go to the documentation of this file.

//BSD License
//DXGfx® - http://www.eteractions.com
//Copyright (c) 2005
//by Guillaume Randon
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software
//and associated documentation files (the "Software"), to deal in the Software without restriction,
//including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
//and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions:
//The above copyright notice and this permission notice shall be included in all copies or substantial
//portions of the Software.
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
//INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
//AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
//DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.IO;
using System.Drawing;
using System.Diagnostics;
using System.Reflection;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Microsoft.Samples.DirectX.UtilityToolkit;
using System.Xml;
using System.Windows.Forms;

namespace DXGfxLib
{
    public class DXGfxManager
    {
        public int height = 640;
        public int width = 480;

        public Framework frameworkInUse;

        public Device d3dDevice;

        public SurfaceDescription backBufferDescription;

        public EffectGroup defaultEffectGroup = null;

        public string defaultEffectGroupBaseFile = "base.fx";

        public bool cullNodes = true;

        public ScriptManager scriptManager = null;

        public DXGfxLib.Serialization.Manager serializationManager = null;

        public string currentSceneName = "Default Scene";

        private OutDoorScene outdoorScene = null;

        public string sceneFile;

        public string mediaFolderPath;

        private string skyFile;

        private string waterFile;

        private string heigthMapFile;

        //private ShaderFlags shaderFlags = ShaderFlags.Debug | ShaderFlags.SkipOptimization;
        private ShaderFlags shaderFlags = ShaderFlags.NoPreShader;

        public Avatar CurrentAvatar
        {
            get
            {
                if (outdoorScene == null)
                    return null;
                return outdoorScene.CurrentAvatar;
            }
            set
            {
                if (outdoorScene == null)
                    return;
                outdoorScene.CurrentAvatar = value;
            }
        }

        public ThirdPersonCamera CurrentCamera
        {
            get 
            {
                if (outdoorScene == null)
                    return null;
                return outdoorScene.CurrentCamera; 
            }
            set
            {
                if (outdoorScene == null)
                    return;
                outdoorScene.CurrentCamera = value; 
            }
        }

        public Matrix MatView
        {
            get
            {
                if (outdoorScene == null)
                    return Matrix.Identity;
                return outdoorScene.matView;
            }
            set
            {
                if (outdoorScene == null)
                    return;
                outdoorScene.matView = value;
            }
        }

        public Matrix MatProj
        {
            get
            {
                if (outdoorScene == null)
                    return Matrix.Identity;
                return outdoorScene.matProj;
            }
            set
            {
                if (outdoorScene == null)
                    return;
                outdoorScene.matProj = value;
            }
        }

        public IInputHandler CurrentInputHandler
        {
            get
            {
                if (outdoorScene == null)
                    return null;
                return outdoorScene.CurrentInputHandler;
            }
            set
            {
                if (outdoorScene == null)
                    return;
                outdoorScene.CurrentInputHandler = value;
            }
        }

        private static DXGfxManager globalInstance = null;

        public DXGfxManager()
        {
            if (globalInstance == null)
            {
                globalInstance = this;
            }
            else
            {
                throw new Exception("This is inapropriate! Only one instance of DXGfxManager should exist per process! Use GetGlobalInstance() instead!");
            }
        }

        public static DXGfxManager GetGlobalInstance()
        {
            if (globalInstance == null)
            {
                globalInstance = new DXGfxManager();
            }

            return globalInstance;
        }

        public void Init()
        {
            scriptManager = new ScriptManager();

            //currentInputHandler = new PointAndClickHandler();

            //currentCamera = new ThirdPersonCamera(); // A model viewing camera
            //currentCamera.SetViewParameters(new Vector3(0.0f, 0.0f, -5.0f), Vector3.Empty);

            serializationManager = new DXGfxLib.Serialization.Manager();
        }

        public void Reset()
        {
            if (scriptManager != null)
            {
                scriptManager.Dispose();
                scriptManager = null;
            }
            if (serializationManager != null)
            {
                serializationManager.Dispose();
                serializationManager = null;
            }
        }

        public void Init(Framework framework)
        {
            frameworkInUse = framework;

            // Add handlers for specific device events.
            // If Init method is called directly it is the outside code responsability
            // to call the appropriate DXGfxManager methods on specific device events.
            framework.Disposing += new EventHandler(OnDestroyDevice);
            framework.DeviceLost += new EventHandler(OnLostDevice);
            framework.DeviceCreated += new DeviceEventHandler(OnCreateDevice);
            framework.DeviceReset += new DeviceEventHandler(OnDeviceReset);

            Init();
        }

        public void OnDeviceReset(object sender, DeviceEventArgs e)
        {
            if (outdoorScene != null)
            {
                if (outdoorScene.CurrentCamera != null)
                {
                    // Setup the camera's view parameters
                    outdoorScene.CurrentCamera.SetViewParameters(new Vector3(0.0f, 0.0f, -5.0f), Vector3.Empty);
                    // Setup the camera's projection parameters
                    float aspectRatio = (float)e.BackBufferDescription.Width / (float)e.BackBufferDescription.Height;
                    outdoorScene.CurrentCamera.SetProjectionParameters((float)Math.PI / 4, aspectRatio, 0.1f, 1000.0f);
                    outdoorScene.CurrentCamera.SetViewParameters(new Vector3(0.0f, 5.0f, -30.0f), new Vector3(0.0f, 0.0f, 0.0f));
                    outdoorScene.CurrentCamera.IsPositionMovementEnabled = true;
                }
            }

            d3dDevice = e.Device;
            backBufferDescription = e.BackBufferDescription;
        }

        public void OnLostDevice(object sender, EventArgs e)
        {
        }

        public void OnDestroyDevice(object sender, EventArgs e)
        {
        }

        public void OnCreateDevice(object sender, DeviceEventArgs e)
        {
            d3dDevice = e.Device;
            backBufferDescription = e.BackBufferDescription;

            defaultEffectGroup = new EffectGroup();
            defaultEffectGroup.Set(d3dDevice, defaultEffectGroupBaseFile);
        }

        public void UpdateOutdoorScene(float elapsedTime, double appTime)
        {
            if (outdoorScene == null)
            {
                return;
            }

            outdoorScene.Update(d3dDevice, appTime, elapsedTime);
        }

        public void DrawOutdoorScene()
        {
            //bool beginSceneCalled = false;
            
            if (outdoorScene == null)
            {
                return;
            }

            //try
            //{
                // Clear the render target and the zbuffer 
                d3dDevice.Clear(ClearFlags.ZBuffer | ClearFlags.Target, 0x00424B79, 1.0f, 0);

                //d3dDevice.BeginScene();
                //beginSceneCalled = true;

                outdoorScene.RenderScene(d3dDevice, outdoorScene.currentFrustrum);
            //}
            //finally
            //{
            //    if (beginSceneCalled)
            //        d3dDevice.EndScene();
            //}
        }

        public FrameworkMesh FrameworkMeshFromFile(string fileName)
        {
            if (d3dDevice == null)
            {
                throw new Exception("d3dDevice is null, loading of a FrameworkMesh is impossible without a valid device!");
            }
            return new FrameworkMesh(d3dDevice, fileName);
        }

        public OutDoorScene NewScene(string name, float size, int quadtreeLevels)
        {
            AABBox desiredBBox = new AABBox(new BBox(new Vector3(0.0f, 0.0f, 0.0f), size));
            outdoorScene = new OutDoorScene(desiredBBox, quadtreeLevels);

            outdoorScene.sceneContent.Remove(currentSceneName);
            outdoorScene.sceneContent.Add(name, outdoorScene);
            currentSceneName = name;

            outdoorScene.name = StringUtil.GetName(name);

            return outdoorScene;
        }

        public void SetScene(OutDoorScene outdoor)
        {
            this.outdoorScene = outdoor;
        }

        public void CloseScene()
        {
            if (outdoorScene != null)
            {
                outdoorScene.Dispose();
                outdoorScene = null;
            }

            // Let's do this, it is safer !!
            Reset();
            Init();
        }

        public Hashtable GetSceneContent()
        {
            return outdoorScene.sceneContent;
        }

        public void SetHeightMap(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            outdoorScene.LoadTerrain(fileName);

            heigthMapFile = fileName;
        }

        public Water2 SetWater(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            Water2 theWater = new Water2(1000);
            outdoorScene.SceneWater = theWater;
            theWater.name = "Water";
            theWater.fileName = fileName;

            waterFile = fileName;

            outdoorScene.sceneContent.Add(fileName, theWater);

            return theWater;
        }

        public SkyDome SetSky(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            SkyDome theSky = new SkyDome();
            theSky.LoadFromFile(this.d3dDevice, fileName);
            outdoorScene.SceneSky = theSky;
            theSky.name = "theSky";
            theSky.fileName = fileName;

            skyFile = fileName;

            outdoorScene.sceneContent.Add(fileName, theSky);

            return theSky;
        }

        public SceneObject LoadObject(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            MeshObject sceneObject = new MeshObject(d3dDevice, fileName);
            outdoorScene.Attach(sceneObject);

            if (outdoorScene.sceneContent.Contains(fileName))
            {
                // We already have one object with the same name so let's rename our object !!
                sceneObject.name += "I";
            }
            outdoorScene.sceneContent.Add(sceneObject.name, sceneObject);

            return sceneObject;
        }

        public SceneObject LoadObject(Type desiredType, string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            ConstructorInfo ctor = desiredType.GetConstructor(new Type[] { });
            Object[] args = new Object[] { };
            Object obj = ctor.Invoke(args);

            if (obj == null)
            {
                throw new Exception("Non creatable type !!");
            }

            SceneObject sobj = obj as SceneObject;

            if (sobj == null)
            {
                throw new Exception("Type doesn't derive from SceneObject this is wrong!!");
            }

            if (File.Exists(fileName))
            {
                sobj.LoadFromFile(d3dDevice, fileName);
            }
            outdoorScene.Attach(sobj);

            if (outdoorScene.sceneContent.Contains(fileName))
            {
                // We already have one object with the same name so let's rename our object !!
                sobj.name += "I";
            }
            outdoorScene.sceneContent.Add(sobj.name, sobj);

            return sobj;
        }

        public void LoadEffect(Device device, string file, ref Effect effOut)
        {
            // Read the D3DX effect file
            if (!File.Exists(file))
            {
                OpenFileDialog ofdlg = new OpenFileDialog();
                ofdlg.Title = file + " not found. Select it!";

                if (ofdlg.ShowDialog() == DialogResult.OK)
                {
                    file = ofdlg.FileName;
                }
            }
            
            string effError;

            effOut = ResourceCache.GetGlobalInstance().CreateEffectFromFile(device,
            file, null, null, shaderFlags, null, out effError);

            if (!effError.Equals(""))
            {
                MessageBox.Show(effError);
            }
        }

        public Effect LoadEffect(Device device, string file)
        {
            Effect newEff = null;
            LoadEffect(device, file, ref newEff);

            return newEff;
        }
        public Object GetObj(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            return outdoorScene.sceneContent[fileName];
        }

        public SceneObject GetSceneObject(string fileName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            SceneObject sceneObj = outdoorScene.sceneContent[fileName] as SceneObject;
            return sceneObj;
        }

        public Scene GetScene()
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            return outdoorScene;
        }

        public void Save(string dstFullPathName)
        {
            if (outdoorScene == null)
            {
                throw new NullReferenceException("The is no outdoorScene at this stage so this method can not be called!");
            }

            //XmlWriter writer = XmlWriter.Create(dstFullPathName);

            //writer.WriteStartElement("Scene");
            //writer.WriteAttributeString("Name", "DefaultSceneName!");

            //writer.WriteElementString("HeigthMap", heigthMapFile);

            //IDictionaryEnumerator sceneEnumerator = outdoorScene.sceneContent.GetEnumerator();

            //writer.WriteStartElement("SceneContent");
            //while (sceneEnumerator.MoveNext())
            //{
            //    SceneObject sceneObj = sceneEnumerator.Value as SceneObject;

            //    if (sceneObj != null)
            //    {
            //        writer.WriteStartElement(StringUtil.GetName(sceneObj.name));
            //        writer.WriteAttributeString("Type", sceneObj.GetType().ToString());
            //        writer.WriteAttributeString("Name", sceneObj.name);
            //        writer.WriteAttributeString("FileName", sceneObj.fileName);
            //        writer.WriteAttributeString("X", sceneObj.X.ToString());
            //        writer.WriteAttributeString("Y", sceneObj.Y.ToString());
            //        writer.WriteAttributeString("Z", sceneObj.Z.ToString());
            //        writer.WriteAttributeString("Yaw", sceneObj.Yaw.ToString());
            //        writer.WriteAttributeString("Pitch", sceneObj.Pitch.ToString());
            //        writer.WriteAttributeString("Roll", sceneObj.Roll.ToString());
            //        string varSrc = "";
            //        string codeSrc = "";
            //        string onClickSrc = "";
            //        string onCollSrc = "";
            //        if (sceneObj.OurScript != null)
            //        {
            //            varSrc = sceneObj.OurScript.GetVarSrc();
            //            codeSrc = sceneObj.OurScript.GetCodeSrc();
            //            onClickSrc = sceneObj.OurScript.GetClickCodeSrc();
            //            onCollSrc = sceneObj.OurScript.GetCollisionCodeSrc();
            //        }
            //        writer.WriteAttributeString("VarSrc", varSrc);
            //        writer.WriteAttributeString("CodeSrc", codeSrc);
            //        writer.WriteAttributeString("OnClickSrc", onClickSrc);
            //        writer.WriteAttributeString("OnCollSrc", onCollSrc);
            //        writer.WriteEndElement();
            //    }
            //}
            //writer.WriteEndElement();
            //writer.WriteEndElement();
            //writer.Flush();
            //writer.Close();

            DXGfxLib.Serialization.Manager.GetGlobalInstance().SaveScene(outdoorScene, dstFullPathName);
        }

        public void Load(string fullPathName)
        {
            string mediaFolder = StringUtil.GetPath(fullPathName);
            mediaFolder += "Media";

            Load(fullPathName, mediaFolder);
        }

        public void Load(string fullPathName, string mediaFolder)
        {
            //string currentFolder = Directory.GetCurrentDirectory();
            //Directory.SetCurrentDirectory(mediaFolder);

            //XmlReader reader = XmlReader.Create(fullPathName);

            //reader.ReadStartElement("Scene");

            //NewScene(reader.Name, 1000, 4);

            //heigthMapFile = reader.ReadElementString("HeigthMap");
            //if (File.Exists(heigthMapFile))
            //{
            //    SetHeightMap(heigthMapFile);
            //}

            //reader.ReadStartElement("SceneContent");

            //do
            //{
            //    if (reader.HasAttributes)
            //    {

            //        reader.MoveToAttribute("Type");
            //        Type type = Type.GetType(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Name");
            //        string name = reader.Value;
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("FileName");
            //        string fileName = reader.Value;
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("X");
            //        float X = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Y");
            //        float Y = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Z");
            //        float Z = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Yaw");
            //        float Yaw = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Pitch");
            //        float Pitch = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("Roll");
            //        float Roll = float.Parse(reader.Value);
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("VarSrc");
            //        string VarSrc = reader.Value;
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("CodeSrc");
            //        string CodeSrc = reader.Value;
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("OnClickSrc");
            //        string onClickSrc = reader.Value;
            //        reader.MoveToElement();

            //        reader.MoveToAttribute("OnCollSrc");
            //        string onCollSrc = reader.Value;
            //        reader.MoveToElement();

            //        if (name == "theSky")
            //        {
            //            if (File.Exists(fileName))
            //            {
            //                SkyBox sky = SetSky(fileName);
            //                sky.Position = new Vector3(X, Y, Z);
            //                sky.Orientation = new Vector3(Yaw, Pitch, Roll);

            //                Script script = sky.GetScript();
            //                script.UpdateVarSrc(VarSrc);
            //                script.UpdateCodeSrc(CodeSrc);
            //                script.UpdateClickCodeSrc(onClickSrc);
            //                script.UpdateCollisionCodeSrc(onCollSrc);
            //            }
            //        }
            //        else if (name == "Water")
            //        {
            //            if (File.Exists(fileName))
            //            {
            //                Water water = SetWater(fileName);
            //                water.Position = new Vector3(X, Y, Z);
            //                water.Orientation = new Vector3(Yaw, Pitch, Roll);

            //                Script script = water.GetScript();
            //                script.UpdateVarSrc(VarSrc);
            //                script.UpdateCodeSrc(CodeSrc);
            //                script.UpdateClickCodeSrc(onClickSrc);
            //                script.UpdateCollisionCodeSrc(onCollSrc);
            //            }
            //        }
            //        else if (type != null)
            //        {
            //            if (File.Exists(fileName))
            //            {
            //                SceneObject sobj = LoadObject(type, fileName);

            //                sobj.Position = new Vector3(X, Y, Z);
            //                sobj.Orientation = new Vector3(Yaw, Pitch, Roll);

            //                Script script = sobj.GetScript();
            //                script.UpdateVarSrc(VarSrc);
            //                script.UpdateCodeSrc(CodeSrc);
            //                script.UpdateClickCodeSrc(onClickSrc);
            //                script.UpdateCollisionCodeSrc(onCollSrc);
            //            }
            //        }
            //    }
            //} while (reader.Read());
            //Directory.SetCurrentDirectory(currentFolder);

            sceneFile = fullPathName;
            mediaFolderPath = mediaFolder;

            outdoorScene = DXGfxLib.Serialization.Manager.GetGlobalInstance().LoadOutdoor(fullPathName);
            // We now have a fully functionnal outdoorscene. Let's really load the data.
            string currentFolder = Directory.GetCurrentDirectory();
            Directory.SetCurrentDirectory(mediaFolder);
            if (outdoorScene.SceneTerrain != null)
            {
                if (File.Exists(outdoorScene.SceneTerrain.heightmapFile))
                {
                    outdoorScene.SceneTerrain.LoadFromFile(DXGfxManager.GetGlobalInstance().d3dDevice, (OutDoorScene)DXGfxManager.GetGlobalInstance().GetScene(), outdoorScene.SceneTerrain.heightmapFile);
                }
            }
            // Let's ask the whole scene to get prepared !!
            outdoorScene.GetPrepared();

            Directory.SetCurrentDirectory(currentFolder);
        }

        public void CallEvaluation(double appTime, float elapsedTime)
        {
            IDictionaryEnumerator sceneEnum = outdoorScene.sceneContent.GetEnumerator();

            while (sceneEnum.MoveNext())
            {
                SceneObject sceneObj = sceneEnum.Value as SceneObject;

                if (sceneObj != null)
                {
                    sceneObj.Evaluate(appTime, elapsedTime);
                    continue;
                }

                Scene scene = sceneEnum.Value as Scene;

                if (scene != null)
                {
                    scene.Evaluate(appTime, elapsedTime);
                    continue;
                }
            }
        }
    }
}

---