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

namespace DXGfxLib
{
    public delegate void NodeMovedEventHandler(SceneNode node);

    public class SceneNode
    {
        public bool useFrustrumCulling;

        public static bool defaultForFrustrumCulling = true;

        public SceneNode parent = null;

        public Scene scene = null;

        public string name;

        public Vector3[] axes = new Vector3[3];

        public Vector3 extents = new Vector3();

        public event NodeMovedEventHandler Moved;

        public bool moved = true;

        internal Matrix worldMat = Matrix.Identity;

        public IPositionConstraint positionConstraint = null;

        [System.ComponentModel.BrowsableAttribute(false)]
        public Matrix WorldMat
        {
            get { return worldMat; }
            set
            {
                Matrix equivalentWorldTransform = Matrix.Multiply(Matrix.Invert(worldMat), value);
                ApplyWorldTransform(equivalentWorldTransform);
            }
        }

        [System.ComponentModel.BrowsableAttribute(false)]
        public Vector3 Position
        {
            get { return MathUtil.PositionFromMat(worldMat); }
            set
            {
                Matrix translation = Matrix.Translation(value.X - worldMat.M41,
                    value.Y - worldMat.M42,
                    value.Z - worldMat.M43);
                ApplyWorldTransform(translation);
            }
        }

        [System.ComponentModel.CategoryAttribute("Position"),
                System.ComponentModel.RefreshProperties( System.ComponentModel.RefreshProperties.Repaint )]
        public float X
        {
            get { return worldMat.M41; }
            set
            {
                Matrix translation = Matrix.Translation(value - worldMat.M41, 0.0f, 0.0f);
                ApplyWorldTransform(translation);
            }
        }

        [System.ComponentModel.CategoryAttribute("Position"),
        System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.Repaint)]
        public float Y
        {
            get { return worldMat.M42; }
            set
            {
                Matrix translation = Matrix.Translation(0.0f, value - worldMat.M42, 0.0f);
                ApplyWorldTransform(translation);
            }
        }

        [System.ComponentModel.CategoryAttribute("Position"),
        System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.Repaint)]
        public float Z
        {
            get { return worldMat.M43; }
            set
            {
                Matrix translation = Matrix.Translation(0.0f, 0.0f, value - worldMat.M43);
                ApplyWorldTransform(translation);
            }
        }

        [System.ComponentModel.BrowsableAttribute(false)]
        public Vector3 PositionToParent
        {
            get { return MathUtil.PositionFromMat(LocalMat); }
            set
            {
                Matrix localMat = LocalMat;
                Matrix translation = Matrix.Translation(value.X - localMat.M41,
                    value.Y - localMat.M42,
                    value.Z - localMat.M43);
                ApplyLocalTransform(translation);
            }
        }

        private double threshold = 0.001;

        [System.ComponentModel.BrowsableAttribute(false)]
        public Vector3 Orientation
        {
            get
            {
                Vector3 ypr = MathUtil.YawPitchRollFromMat(worldMat);

                ypr.X = MathUtil.ResetToNullIfTooSmall(ypr.X, threshold);
                ypr.Y = MathUtil.ResetToNullIfTooSmall(ypr.Y, threshold);
                ypr.Z = MathUtil.ResetToNullIfTooSmall(ypr.Z, threshold);

                return ypr;
            }
            set
            {
                Vector3 currentOrientation = Orientation;

                float yaw = value.X - currentOrientation.X;
                float pitch = value.Y - currentOrientation.Y;
                float roll = value.Z - currentOrientation.Z;

                yaw = MathUtil.ResetToNullIfTooSmall(yaw, threshold);
                pitch = MathUtil.ResetToNullIfTooSmall(pitch, threshold);
                roll = MathUtil.ResetToNullIfTooSmall(roll, threshold);

                Matrix rotation = Matrix.RotationYawPitchRoll(yaw,
                    pitch,
                    roll);
                ApplyWorldTransform(rotation);
            }
        }

        [System.ComponentModel.CategoryAttribute("Orientation"),
        System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.Repaint)]
        public float Yaw
        {
            get
            {
                return MathUtil.YawPitchRollFromMatInDegree(worldMat).X;
            }
            set
            {
                Vector3 current = Orientation;
                Orientation = new Vector3(Geometry.DegreeToRadian(value),
                    current.Y,
                    current.Z);
            }
        }

        [System.ComponentModel.CategoryAttribute("Orientation"),
        System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.Repaint)]
        public float Pitch
        {
            get
            {
                return MathUtil.YawPitchRollFromMatInDegree(worldMat).Y;
            }
            set
            {
                Vector3 current = Orientation;
                Orientation = new Vector3(current.X,
                    Geometry.DegreeToRadian(value),
                    current.Z);
            }
        }

        [System.ComponentModel.CategoryAttribute("Orientation"),
        System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.Repaint)]
        public float Roll
        {
            get
            {
                return MathUtil.YawPitchRollFromMatInDegree(worldMat).Z;
            }
            set
            {
                Vector3 current = Orientation;
                Orientation = new Vector3(current.X,
                    current.Y,
                    Geometry.DegreeToRadian(value));
            }
        }

        [System.ComponentModel.BrowsableAttribute(false)]
        public Vector3 OrientationToParent
        {
            get
            {
                return MathUtil.YawPitchRollFromMat(LocalMat);
            }
            set
            {
                Vector3 currentOrientation = Orientation;
                Matrix rotation = Matrix.RotationYawPitchRoll(value.X - currentOrientation.X,
                    value.Y - currentOrientation.Y,
                    value.Z - currentOrientation.Z);
                ApplyLocalTransform(rotation);
            }
        }

        public void ForcePositionWithoutUpdate(Vector3 position)
        {
            Matrix translation = Matrix.Translation(position.X - worldMat.M41,
                position.Y - worldMat.M42,
                position.Z - worldMat.M43);
            Vector3 orientation = Orientation;
            worldMat = Matrix.Multiply(Matrix.RotationYawPitchRoll(orientation.X, orientation.Y, orientation.Z),
                translation);
            OnMove();
        }

        public void ForceOrientationWithoutUpdate(Vector3 orientation)
        {
            worldMat = Matrix.Multiply(Matrix.RotationYawPitchRoll(orientation.X, orientation.Y, orientation.Z),
                Matrix.Translation(Position));
            OnMove();
        }

        public void ForceWorldMatValueWithoutUpdate(Matrix desiredWorldMat)
        {
            worldMat = desiredWorldMat;
        }

        [System.ComponentModel.BrowsableAttribute(false)]
        public Matrix LocalMat
        {
            get 
            {
                Matrix parentMat;

                if(parent==null)
                {
                    parentMat = Matrix.Identity;
                }
                else
                {
                    parentMat = parent.WorldMat;
                }
                return Matrix.Multiply(worldMat, Matrix.Invert(parentMat)); 
            }
            set
            {
                Matrix newWorldMat;

                if (parent == null)
                {
                    newWorldMat = value;
                }
                else
                {
                    newWorldMat = Matrix.Multiply(value, parent.worldMat);
                }

                Matrix equivalentWorldTransform = Matrix.Multiply(Matrix.Invert(worldMat), newWorldMat);
                ApplyWorldTransform(equivalentWorldTransform);
            }
        }

        public virtual void OnMove()
        {
            moved = true;

            if (Moved != null)
            {
                Moved(this);
            }
            UpdateAxes();
            UpdateExtents();
        }

        protected List<SceneNode> children = null;

        public AABBox worldAABBox = null;

        public SceneNode()
        {
            Initialize();
        }

        public virtual void Initialize()
        {
            if (children == null)
            {
                children = new List<SceneNode>();
            }
            if (worldAABBox == null)
            {
                worldAABBox = new AABBox();
            }
            useFrustrumCulling = defaultForFrustrumCulling;
        }

        public SceneNode(SceneNode sceneNode)
        {
            children = new List<SceneNode>(sceneNode.children);
            worldAABBox = sceneNode.worldAABBox;
            useFrustrumCulling = sceneNode.useFrustrumCulling;

            worldMat = sceneNode.worldMat;

            parent = sceneNode.parent;
            scene = sceneNode.scene;
        }

        public virtual void Dispose()
        {
            foreach (SceneNode node in children)
            {
                node.Dispose();
            }
            children.Clear();
            children = null;
        }

        public virtual void AddChild(SceneNode node)
        {
            if (children != null)
            {
                children.Add(node);
                node.parent = this;
                node.scene = scene;
            }
        }

        public virtual void RemoveChild(SceneNode node)
        {
            if (children != null)
            {
                children.Remove(node);
                node.parent = null;
                node.scene = null;
            }
        }

        public virtual void ApplyWorldTransform(Matrix transform)
        {
            worldMat = Matrix.Multiply(worldMat, transform);

            // Let's update our children if we have any.
            // We apply the same world transform on the children.
            // !!!!!!!!!!! This need to be done after the update of the worldMat, as in any
            // children we will use parent.worldMat to compute localMat !!!!!!!!!!!!!!!
            foreach (SceneNode node in children)
            {
                node.ApplyWorldTransform(transform);
            }

            OnMove();
        }

        public void ApplyLocalTransform(Matrix transform)
        {
            Matrix newWorldMat = Matrix.Multiply(transform, worldMat);

            Matrix equivalentWorldTransform = Matrix.Multiply(Matrix.Invert(worldMat), newWorldMat);
            ApplyWorldTransform(equivalentWorldTransform);
        }

        public virtual void GetPrepared()
        {
            Initialize();
            if (children == null)
            {
                children = new List<SceneNode>();
            }

            foreach (SceneNode child in children)
            {
                child.GetPrepared();
            }
        }

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

        public virtual void Update(Frustrum frustrum, double appTime, float elapsedTime)
        {

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

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

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

        public virtual void DetachAll()
        {
            //foreach (SceneNode child in children)
            //{
            //    child.DetachAll();
            //}
        }

        public virtual void Detach(SceneNode sceneNodeToDetach)
        {
            bool directChild = false;

            foreach (SceneNode child in children)
            {
                if (child == sceneNodeToDetach)
                {
                    directChild = true;
                }
            }

            if (directChild)
            {
                sceneNodeToDetach.DetachAll();
                children.Remove(sceneNodeToDetach);
            }
            else
            {
                foreach (SceneNode child in children)
                {
                    child.Detach(sceneNodeToDetach);
                }
            }
        }

        public virtual bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            bool res = false;

            if (CollideWithAABox(sceneNode))
            {
                SceneObject obj = this as SceneObject;
                if (obj != null)
                {
                    res = true;
                    collidingSceneObjects.Add(obj);
                }

                foreach (SceneNode childNode in children)
                {
                    SceneObject obj2 = childNode as SceneObject;
                    if (obj2 != null)
                    {
                        if (obj2.Collide(sceneNode, ref collidingSceneObjects))
                            res = true;
                    }
                }
            }

            return res;
        }

        public virtual bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            bool res = false;

            if (CollideWithAABox(sceneNode))
            {
                SceneObject obj = this as SceneObject;
                if ((obj != null)&&(obj.Solid))
                {
                    res = true;
                    collidingSceneObjects.Add(obj);
                }

                foreach (SceneNode childNode in children)
                {
                    SceneObject obj2 = childNode as SceneObject;
                    if (obj2 != null)
                    {
                        if (obj2.Collide(sceneNode, ref collidingSceneObjects))
                            res = true;
                    }
                }
            }

            return res;
        }

        public virtual bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            bool res = false;

            if (CollideWithAABox(sceneNode))
            {
                SceneObject obj = this as SceneObject;

                if (obj != null)
                {
                    if (this == sceneNode)
                        return res;
                    if (!desiredType.IsInstanceOfType(this))
                        return res;

                    res = true;
                    collidingSceneObjects.Add(obj);

                }

                foreach (SceneNode childNode in children)
                {
                    if (childNode.Collide(sceneNode, ref collidingSceneObjects, desiredType))
                        res = true;
                }
            }

            return res;
        }

        public virtual bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            bool res = false;

            if (CollideWithAABox(sceneNode))
            {
                SceneObject obj = this as SceneObject;

                if ((obj != null)&&(obj.Solid))
                {
                    if (this == sceneNode)
                        return res;
                    if (!desiredType.IsInstanceOfType(this))
                        return res;

                    res = true;
                    collidingSceneObjects.Add(obj);

                }

                foreach (SceneNode childNode in children)
                {
                    if (childNode.Collide(sceneNode, ref collidingSceneObjects, desiredType))
                        res = true;
                }
            }

            return res;
        }

        public bool CollideWithAABox(SceneNode sceneNode)
        {
            return this.worldAABBox.Collide(sceneNode.worldAABBox);
        }

        public void UpdateAxes()
        {
            if(axes==null)
                axes = new Vector3[3];

            axes[0].X = worldMat.M11;
            axes[0].Y = worldMat.M12;
            axes[0].Z = worldMat.M13;

            axes[1].X = worldMat.M21;
            axes[1].Y = worldMat.M22;
            axes[1].Z = worldMat.M23;

            axes[2].X = worldMat.M31;
            axes[2].Y = worldMat.M32;
            axes[2].Z = worldMat.M33;
        }

        public Vector3[] Axes()
        {
            return axes;
        }

        public void UpdateExtents()
        {
            Vector3 diag = worldAABBox.vMax - worldAABBox.vMin;

            extents.X = System.Math.Abs(Vector3.Dot(diag, axes[0]));
            extents.Y = System.Math.Abs(Vector3.Dot(diag, axes[1]));
            extents.Z = System.Math.Abs(Vector3.Dot(diag, axes[2]));
        }

        public Vector3 Extents()
        {
            return extents;
        }

        public virtual bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects)
        {
            bool any = false;

            AABBox aabox = worldAABBox;
            bool collision = true;
            if (((rayOri.X < aabox.vMin.X) && (rayDir.X <= 0))
                || ((rayOri.X > aabox.vMax.X) && (rayDir.X >= 0)))
                collision = false;
            if (((rayOri.Y < aabox.vMin.Y) && (rayDir.Y <= 0))
                || ((rayOri.Y > aabox.vMax.Y) && (rayDir.Y >= 0)))
                collision = false;
            if (((rayOri.Z < aabox.vMin.Z) && (rayDir.Z <= 0))
                || ((rayOri.Z > aabox.vMax.Z) && (rayDir.Z >= 0)))
                collision = false;

            if (collision)
            {
                foreach (SceneNode child in children)
                {
                    if (child.Intersect(rayOri, rayDir, ref collidingSceneObjects))
                        any = true;
                }
            }

            return any;
        }

        public virtual bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            bool any = false;

            AABBox aabox = worldAABBox;
            bool collision = true;
            if (((rayOri.X < aabox.vMin.X) && (rayDir.X <= 0))
                || ((rayOri.X > aabox.vMax.X) && (rayDir.X >= 0)))
                collision = false;
            if (((rayOri.Y < aabox.vMin.Y) && (rayDir.Y <= 0))
                || ((rayOri.Y > aabox.vMax.Y) && (rayDir.Y >= 0)))
                collision = false;
            if (((rayOri.Z < aabox.vMin.Z) && (rayDir.Z <= 0))
                || ((rayOri.Z > aabox.vMax.Z) && (rayDir.Z >= 0)))
                collision = false;

            if (collision)
            {
                foreach (SceneNode child in children)
                {
                    if (child.Intersect(rayOri, rayDir, ref collidingSceneObjects, desiredType))
                        any = true;
                }
            }

            return any;
        }
    }
}

---