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

namespace DXGfxLib
{
    public class SceneObject : SceneNode, IDisposable, IComparable, IDrawable, IAmScriptable
    {
        private bool hasBeenClicked = false;

        public bool HasBeenClicked
        {
            get { return hasBeenClicked; }
            set { hasBeenClicked = value; }
        }

        private bool colliding = false;

        private SceneObject collidingObject = null;

        protected DrawableBBox drawBox;

        protected bool drawBoundingBox = false;

        public bool DrawBoundingBox
        {
            get { return drawBoundingBox; }
            set { drawBoundingBox = value; }
        }

        protected bool canBeClicked = false;

        public bool CanBeClicked
        {
            get { return canBeClicked; }
            set { canBeClicked = value; }
        }

        protected bool checkForCollision = false;

        public bool CheckForCollision
        {
            get { return checkForCollision; }
            set { checkForCollision = value; }
        }

        protected bool solid = false;

        public bool Solid
        {
            get { return solid; }
            set { solid = value; }
        }

        public string fileName;

        //[Editor(typeof(FileNameEditor), typeof(UITypeEditor))]
        public string Name
        {
            get { return fileName; }
        }

        protected EffectGroup associatedEffectGroup = null;

        [System.ComponentModel.BrowsableAttribute(false)]
        public EffectGroup AssociatedEffectGroup
        {
            get { return associatedEffectGroup; }
            set { associatedEffectGroup = value; }
        }

        protected bool hide = false;

        public bool Hide
        {
            get { return hide; }
            set { hide = value; }
        }


        public BBox localBoundingBox = null;

        public SceneObject()
        {
            Initialize();
        }

        public override void Initialize()
        {
            base.Initialize();

            localBoundingBox = new BBox();

            associatedEffectGroup = DXGfxManager.GetGlobalInstance().defaultEffectGroup;

            events = new List<Event>();
        }

        public override void Dispose()
        {
        }

        public virtual void LoadFromFile(Device d3ddevice, string fileName)
        {
        }

        public override void Update(Frustrum frustrum, double appTime, float elapsedTime)
        {
            if (moved)
            {
                worldAABBox = new AABBox(BBox.Transform(localBoundingBox, WorldMat));
                moved = false;
            }

            foreach (SceneNode child in children)
            {
                child.Update(frustrum, appTime, elapsedTime);
                worldAABBox.BoxFromBoxes(child.worldAABBox);
            }
        }

        public override void AttachForRendering(Frustrum frustrum, List<IDrawable> objectsToBeRendered)
        {
            // If we are in the frustrum we attach for rendering an let's our children decide for
            // themselves.
            if (useFrustrumCulling)
            {
                if (!frustrum.IsInFrustrum(worldAABBox))
                    return;
            }

            objectsToBeRendered.Add(this);

            foreach (SceneNode child in children)
            {
                child.AttachForRendering(frustrum, objectsToBeRendered);
            }
        }

        public BBox CalculateLocalBBox(Mesh meshToUse)
        {
            return AABBox.CalculateLocalBBox(meshToUse);
        }

        public override void DetachAll()
        {
            base.DetachAll();
        }

        public virtual void SetEffectsValues(Device d3ddevice, Effect eff, int pass)
        {
        }

        public virtual void Draw(Device device)
        {
            device.SetTransform(TransformType.World, worldMat);

            if (drawBoundingBox)
            {
                if (drawBox == null)
                {
                    drawBox = new DrawableBBox(device, localBoundingBox);
                }

                drawBox.Draw(device);
            }
        }

        public virtual bool Intersect(Vector3 rayPos, Vector3 rayDir, out IntersectInformation closestHit)
        {
            closestHit = new IntersectInformation() ;
            return false;
        }

        public override bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects)
        {
            return false;
        }

        public override bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            return false;
        }

        public virtual int CompareTo(Object obj)
        {
            int ret = 1;
            IDrawable drawable = obj as IDrawable;

            if (drawable != null)
            {
                ret = AssociatedEffectGroup.CompareTo(drawable.AssociatedEffectGroup);
            }
            return ret;
        }

        public virtual int CompareTo(SceneObject sceneObj)
        {
            return AssociatedEffectGroup.CompareTo(sceneObj.AssociatedEffectGroup);
        }

        public virtual int CompareTo(IDrawable sceneObj)
        {
            return AssociatedEffectGroup.CompareTo(sceneObj.AssociatedEffectGroup);
        }

        protected Matrix lastValidWorldMat = Matrix.Identity;

        public override void OnMove()
        {
            base.OnMove();

            if (checkForCollision)
            {
                List<SceneObject> collidingObjects = new List<SceneObject>();

                if (scene.CollideSolid(this, ref collidingObjects))
                {
                    double appTime = FrameworkTimer.GetTime();
                    float elapsedTime = (float)FrameworkTimer.GetElapsedTime();

                    foreach (SceneObject sceneObj in collidingObjects)
                    {
                        Collision(appTime, elapsedTime, sceneObj);
                        sceneObj.Collision(appTime, elapsedTime, this);
                    }

                    if (solid)
                    {
                        MathUtil.CopyMatrixValues(worldMat, lastValidWorldMat);
                    }
                    else
                    {
                        MathUtil.CopyMatrixValues(lastValidWorldMat, worldMat);
                    }
                }
                else
                {
                    MathUtil.CopyMatrixValues(lastValidWorldMat, worldMat);
                }
            }
            else
            {
                MathUtil.CopyMatrixValues(lastValidWorldMat, worldMat);
            }
        }

        internal Script script = null;

        internal Script OurScript
        {
            get { return script; }
        }

        protected TimeLine timeline = null;

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

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

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

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

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

            if (script == null)
            {
                return;
            }


            // Also here we should check a flag to know whether we have been clicked or not and if we have
            // we should also trigger the appropriate scripts !
            if(hasBeenClicked)
            {
                script.Clicked(appTime, elapsedTime);
            }
            // Ok Now check for collision and execute appropriate script if there are any collision.
            //if (colliding)
            //{
            //    if (collidingObject != null)
            //    {
            //        script.Collision(appTime, elapsedTime, collidingObject);
            //    }
            //}

            script.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 string[] ListFileRessources()
        {
            // By default return fileName and the effect files associated with the effectGroup
            string[] list = new string[2];

            list[0] = fileName;
            list[1] = associatedEffectGroup.DefaultFile;

            return list;
        }

        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();
        }
    }
}

---