D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/Scene.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.Text;
using System.Diagnostics;
using System.Drawing;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Microsoft.Samples.DirectX.UtilityToolkit;

namespace DXGfxLib
{
    public class Scene : IAmScriptable
    {
        protected static StateBlock defaultState = null;

        public Frustrum currentFrustrum = null;

        protected SceneNode rootNode = null;

        public SceneNode RootNode
        {
            get { return rootNode; }
        }

        public List<IDrawable> objectsToBeRendered;

        //public List<SceneSprite> spritesToBeRendered;

        public static Effect defaultEffect;

        public string name = "Scene";

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Hashtable sceneContent = null;

        public Scene()
        {
            Initialize();
        }

        public void Initialize()
        {
            
            rootNode = new SceneNode();
            rootNode.scene = this;
            rootNode.parent = rootNode;
            currentFrustrum = new Frustrum();
            objectsToBeRendered = new List<IDrawable>();
            sceneContent = new Hashtable();
            //spritesToBeRendered = new List<SceneSprite>();
        }

        public virtual void Dispose()
        {
        }

        public virtual void GetPrepared()
        {
            IDictionaryEnumerator sceneObjects = sceneContent.GetEnumerator();

            while (sceneObjects.MoveNext())
            {
                SceneObject currObj = sceneObjects.Value as SceneObject;
                if (currObj != null)
                {
                    currObj.GetPrepared();
                    Attach(currObj);
                }
            }
        }

        public void DetachAll()
        {
            rootNode.DetachAll();
        }

        public void CleanOnLostDevice()
        {
            if (defaultState != null)
            {
                defaultState.Dispose();
                defaultState = null;
            }
        }

        public void CleanOnDestroyDevice()
        {
            CleanOnLostDevice();

            // TODO : We should also clean everything which is in the managed pool.
        }

        public virtual void Update(double appTime, float elapsedTime, Frustrum frustrum, List<IDrawable> objectsToBeRendered)
        {
            rootNode.Update(frustrum, elapsedTime, appTime, objectsToBeRendered);
        }

        public void Update(Device d3ddevice, Matrix matview, Matrix matproj,double appTime, float elapsedTime)
        {
            objectsToBeRendered.Clear();
            currentFrustrum.ExtractFromMatrices(matview, matproj);
            Update(appTime, elapsedTime, currentFrustrum, objectsToBeRendered);
            objectsToBeRendered.Sort();
        }

        public virtual void RenderScene(Device d3ddevice, Matrix matView, Matrix matProj)
        {
            Frustrum frustrum = new Frustrum();
            frustrum.ExtractFromMatrices(matView, matProj);

            RenderScene(d3ddevice, frustrum);
        }

        public virtual void Draw(Device d3ddevice, Frustrum frustrum)
        {
            RenderScene(d3ddevice, frustrum);
        }

        public virtual void RenderScene(Device d3ddevice, Frustrum frustrum)
        {
            if (defaultState == null)
            {
                // Let's put some default settings  for the rendering of our scene
                d3ddevice.Lights[0].Enabled = true;
                // Turn on the zbuffer
                d3ddevice.RenderState.ZBufferEnable = true;

                // Turn on ambient lighting 
                d3ddevice.RenderState.Ambient = System.Drawing.Color.White;
                d3ddevice.RenderState.DitherEnable = true;
                d3ddevice.RenderState.SpecularEnable = false;
                d3ddevice.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;
                d3ddevice.TextureState[0].ColorArgument2 = TextureArgument.Diffuse;
                d3ddevice.TextureState[0].ColorOperation = TextureOperation.Modulate;
                d3ddevice.TextureState[0].AlphaArgument1 = TextureArgument.TextureColor;
                d3ddevice.TextureState[0].AlphaOperation = TextureOperation.SelectArg1;
                d3ddevice.SamplerState[0].MinFilter = TextureFilter.Linear;
                d3ddevice.SamplerState[0].MagFilter = TextureFilter.Linear;
                d3ddevice.SamplerState[1].MinFilter = TextureFilter.Linear;
                d3ddevice.SamplerState[1].MagFilter = TextureFilter.Linear;

                d3ddevice.RenderState.FogEnable = true;
                d3ddevice.RenderState.FogColor = Color.AntiqueWhite;
                d3ddevice.RenderState.FogTableMode = FogMode.Linear;
                d3ddevice.RenderState.FogStart = 30.0f;
                d3ddevice.RenderState.FogEnd = 400.0f;

                defaultState = new StateBlock(d3ddevice, StateBlockType.All);
                defaultState.Capture();
            }
            else
            {
                defaultState.Apply();
            }

            
            d3ddevice.SetTransform(TransformType.View, frustrum.matView);
            d3ddevice.SetTransform(TransformType.Projection, frustrum.matProj);

            if (objectsToBeRendered.Count > 0)
            {
                foreach (SceneObject obj in objectsToBeRendered)
                {
                    obj.Draw(d3ddevice);
                }
            }

            //List<Billboard> billboards = new List<Billboard>();
            //foreach (SceneObject obj in objectsToBeRendered)
            //{
            //    Billboard bb = obj as Billboard;
            //    if (bb == null)
            //    {
            //        obj.Draw(d3ddevice);
            //    }
            //    else
            //    {
            //        billboards.Add(bb);
            //    }
            //}

            //billboards.Sort();
            //if (Billboard.billboardRenderState!=null)
            //{
            //    Billboard.billboardRenderState.Apply();
            //    d3ddevice.SetTransform(TransformType.View, currentFrustrum.matView);
            //    d3ddevice.SetTransform(TransformType.Projection, currentFrustrum.matProj);
            //}

            //foreach (Billboard bb in billboards)
            //{
            //    bb.Draw(d3ddevice);
            //}

            //billboards.Clear();
        }

        public virtual SceneObject Attach(FrameworkMesh meshToAttach)
        {
            FrameworkMeshObject newSceneObject = new FrameworkMeshObject();
            newSceneObject.Attach(meshToAttach);

            Attach(newSceneObject);

            return newSceneObject;
        }

        public virtual SceneObject AttachWithLOD(Device d3ddevice, FrameworkMesh meshToAttach)
        {
            FrameworkMeshObject newSceneObject = new FrameworkMeshObject();
            newSceneObject.AttachWithLOD(d3ddevice, meshToAttach);

            Attach(newSceneObject);

            return newSceneObject;
        }

        public virtual void Attach(SceneObject sceneObj)
        {
            rootNode.AddChild(sceneObj);
        }

        public virtual void Detach(SceneNode sceneNodeToDetach)
        {
            if (sceneNodeToDetach == null)
            {
                throw new ArgumentNullException("sceneObjectToDetach is null, which is wrong!");
            }
            if (rootNode == null)
            {
                throw new NullReferenceException("rootNode is null which is not expected here!");
            }

            sceneNodeToDetach.DetachAll();

            rootNode.Detach(sceneNodeToDetach);
        }

        public virtual bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            return rootNode.Collide(sceneNode, ref collidingSceneObjects);
        }

        public virtual bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            return rootNode.CollideSolid(sceneNode, ref collidingSceneObjects);
        }

        public virtual bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            return rootNode.Collide(sceneNode, ref collidingSceneObjects, desiredType);
        }

        public virtual bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            return rootNode.CollideSolid(sceneNode, ref collidingSceneObjects, desiredType);
        }

        public virtual bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects)
        {
            return rootNode.Intersect(rayOri, rayDir, ref collidingSceneObjects);
        }

        public virtual bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObject, System.Type desiredType)
        {
            return rootNode.Intersect(rayOri, rayDir, ref collidingSceneObject, desiredType);
        }

        public virtual bool Pick(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos, ref SceneObject[] pickedObjects, ref IntersectInformation[] hits)
        {
            Vector3 rayOrig;
            Vector3 rayDir;
            MathUtil.RayFromScreenPos(viewport, proj, view, screenPos, out rayOrig, out rayDir);

            List<SceneObject> collidingSceneObjects = new List<SceneObject>();

            bool any = Intersect(rayOrig, rayDir, ref collidingSceneObjects);

            if (any)
            {
                if (pickedObjects == null)
                    pickedObjects = new SceneObject[collidingSceneObjects.Count];

                if (hits == null)
                    hits = new IntersectInformation[collidingSceneObjects.Count];

                int index = 0;

                foreach (SceneObject sceneObj in collidingSceneObjects)
                {
                    Microsoft.DirectX.Direct3D.IntersectInformation closestHit = new IntersectInformation();

                    sceneObj.Intersect(rayOrig, rayDir, out closestHit);

                    pickedObjects[index] = sceneObj;
                    hits[index] = closestHit;
                }
                return true;
            }
            else
                return false;
        }

        public virtual SceneObject PickObject(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos)
        {
            return PickObject(viewport, proj, view, screenPos, typeof(SceneObject));
        }

        public virtual SceneObject PickObject(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos, Type desiredType)
        {
            Vector3 rayOrig;
            Vector3 rayDir;
            MathUtil.RayFromScreenPos(viewport, proj, view, screenPos, out rayOrig, out rayDir);


            List<SceneObject> collidingSceneObjects = new List<SceneObject>();

            bool any = Intersect(rayOrig, rayDir, ref collidingSceneObjects, desiredType);

            SceneObject res = null;

            if (any)
            {
                float refVal = 10000.0f;

                foreach (SceneObject sceneObj in collidingSceneObjects)
                {
                    Microsoft.DirectX.Direct3D.IntersectInformation closestHit = new IntersectInformation();

                    sceneObj.Intersect(rayOrig, rayDir, out closestHit);

                    if (closestHit.Dist < refVal)
                    {
                        res = sceneObj;
                        refVal = closestHit.Dist;
                    }
                }
            }
            return res;
        }

        protected Script script = null;

        internal Script OurScript
        {
            get { return script; }
        }

        protected TimeLine timeline = null;

        public void SetScript(Script script)
        {
            this.script = script;
            this.script.SetParent(null);
            this.script.SetScene(this);
        }

        public Script GetScript()
        {
            if (script == null)
            {
                SetScript(new Script());
            }
            return script;
        }

        public void SetTimeLine(TimeLine timeLine)
        {
            this.timeline = timeLine;
            this.timeline.SetParent(null);
            this.timeline.SetScene(this);
        }

        public TimeLine GetTimeLine()
        {
            if (timeline == null)
            {
                SetTimeLine(new TimeLine());
            }
            return timeline;
        }

        public virtual void Evaluate(double appTime, float elapsedTime)
        {
            if (script != null)
            {
                script.Evaluate(appTime, elapsedTime);
            }
            if (timeline != null)
            {
                timeline.Evaluate(appTime, elapsedTime);
            }
        }

        public void Reset()
        {
            if (script != null)
            {
                script.Reset();
            }
            if (timeline != null)
            {
                timeline.Reset();
            }
        }


        private List<Event> events = null;

        public void AddEvent(Event evt)
        {
            events.Add(evt);
        }

        public void RemoveEvent(Event evt)
        {
            events.Remove(evt);
        }

        public virtual void Clicked(double appTime, float elapsedTime)
        {
            if (script != null)
            {
                script.Clicked(appTime, elapsedTime);
            }
        }

        public virtual void Collision(double appTime, float elapsedTime, SceneObject collidingObject)
        {
            if (script != null)
            {
                script.Collision(appTime, elapsedTime, collidingObject);
            }
        }

        public Event[] popEventsByName(string name)
        {
            List<Event> ret = new List<Event>();

            foreach (Event evt in events)
            {
                if (evt.name.Equals(name))
                {
                    ret.Add(evt);
                    events.Remove(evt);
                }
            }

            return ret.ToArray();
        }

        public Event[] popEventsByType(string type)
        {
            List<Event> ret = new List<Event>();

            foreach (Event evt in events)
            {
                if (evt.type.Equals(type))
                {
                    ret.Add(evt);
                    events.Remove(evt);
                }
            }

            return ret.ToArray();
        }

        public Event[] peekEventsByName(string name)
        {
            List<Event> ret = new List<Event>();

            foreach (Event evt in events)
            {
                if (evt.name.Equals(name))
                {
                    ret.Add(evt);
                }
            }

            return ret.ToArray();
        }

        public Event[] peekEventsByType(string type)
        {
            List<Event> ret = new List<Event>();

            foreach (Event evt in events)
            {
                if (evt.type.Equals(type))
                {
                    ret.Add(evt);
                }
            }

            return ret.ToArray();
        }

        public virtual Vector3 PickEnvironmentPosition(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos)
        {
            return new Vector3();
        }
    }
}

---