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

namespace DXGfxLib
{
    public class OutDoorScene : Scene, IPositionConstraint
    {
        #region MovedFromDXGfxManager
        public Avatar CurrentAvatar
        {
            get
            {
                return currentInputHandler.CurrentAvatar;
            }
            set
            {
                CurrentInputHandler.CurrentAvatar = value;
                CurrentCamera.Person = currentInputHandler.CurrentAvatar.associatedSceneObject;
                avatarName = currentInputHandler.CurrentAvatar.associatedSceneObject.name;

                CurrentCamera.camera.positionConstraint = this;
                CurrentCamera.Person.positionConstraint = this;
            }
        }

        public string avatarName = "";

        private ThirdPersonCamera currentCamera = null;

        public ThirdPersonCamera CurrentCamera
        {
            get 
            {
                if (currentCamera == null)
                    currentCamera = new ThirdPersonCamera();

                return currentCamera; 
            }
            set
            {
                currentCamera = value;
            }
        }

        public Frustrum frustrum = null;

        public Matrix matView;
        public Matrix matProj;

        private IInputHandler currentInputHandler = null;

        public IInputHandler CurrentInputHandler
        {
            get
            {
                if (currentInputHandler == null)
                {
                    currentInputHandler = new PointAndClickHandler();
                }
                return currentInputHandler;
            }
            set
            {
                currentInputHandler = value;
            }
        }
        #endregion

        // For  refraction reflection
        private Texture backBufferTex = null;
        private Texture reflectionMap = null;
        private RenderToSurface rts = null;
        private Plane reflectPlane;
        private Rectangle rect;

        public float cameraHeightOffset = 3.0f;

        internal QuadTreeNode[][] nodes = null;

        private int[] levelNumCells;

        private float[] sizeOfCells;

        public int depth = -1;

        public const int maxDepth = 8;

        private List<SceneNode> nodesToPositionInTree = null;


        private Vector3 scale;
        private Vector3 extents;

        public Vector3 Extents
        {
            get { return extents; }
        }

        private AABBox worldAABBox;

        private const int numDimCells = 256;

        private const int numHeigthCells = 32;

        private Terrain sceneTerrain;

        public Terrain SceneTerrain
        {
            get { return sceneTerrain; }
            set { sceneTerrain = value; }
        }


        private Water2 sceneWater;

        public Water2 SceneWater
        {
            set { sceneWater = value; }
            get { return sceneWater; }
        }

        private SkyDome sceneSky;

        public SkyDome SceneSky
        {
            set { sceneSky = value; }
            get { return sceneSky; }
        }

        public Texture env = null;

        private Effect refractionMaskEffect = null;

                public OutDoorScene(AABBox worldBBox, int depth) : base()
                {
            Initialize(worldBBox, depth);
        }

        public void Initialize(AABBox worldBBox, int depth)
        {
            base.Initialize();

                        nodesToPositionInTree = new List<SceneNode>();

                        if(depth>maxDepth)
                                depth=maxDepth;

                        this.depth = depth;
                        this.extents = worldBBox.Size();

                        this.worldAABBox = worldBBox;

                        scale.X = numDimCells/extents.X;
                        scale.Z = numDimCells/extents.Z;
                        scale.Y = numHeigthCells/extents.Y;

                        nodes = new QuadTreeNode[depth+1][];
                        levelNumCells = new int[depth+1];
                        sizeOfCells = new float[depth+1];

                        for(int i=0; i<depth+1; i++)
                        {
                                levelNumCells[i] = (int)(System.Math.Pow(2, i));
                                sizeOfCells[i] = extents.X / levelNumCells[i];
                                nodes[i] = new QuadTreeNode[levelNumCells[i]*levelNumCells[i]];
                        }

                        nodes[0][0] = new QuadTreeNode();
                        rootNode = nodes[0][0];
            rootNode.scene = this;
            rootNode.Moved +=new NodeMovedEventHandler(RegisterForPositionUpdate);
                        rootNode.worldAABBox.vMin.X = worldBBox.vMin.X;
                        rootNode.worldAABBox.vMin.Y = worldBBox.vMin.Y;
                        rootNode.worldAABBox.vMin.Z = worldBBox.vMin.Z;

                        rootNode.worldAABBox.vMax.X = worldBBox.vMax.X;
                        rootNode.worldAABBox.vMax.Y = worldBBox.vMax.Y;
                        rootNode.worldAABBox.vMax.Z = worldBBox.vMax.Z;

                        for(int i=1; i<depth+1; i++)
                        {
                                for(int z=0; z<levelNumCells[i]; z++)
                                {
                                        for(int x=0; x<levelNumCells[i]; x++)
                                        {
                                                QuadTreeNode tmpNode = new QuadTreeNode();
                        tmpNode.Moved +=new NodeMovedEventHandler(RegisterForPositionUpdate);
                                                AABBox tmpBBox = new AABBox();
                                                tmpBBox.vMin.Y = this.worldAABBox.vMin.Y;
                                                tmpBBox.vMax.Y = this.worldAABBox.vMax.Y;

                                                tmpBBox.vMin.X = this.worldAABBox.vMin.X + (this.extents.X / (levelNumCells[i])) * x;
                                                tmpBBox.vMax.X = this.worldAABBox.vMin.X + (this.extents.X / (levelNumCells[i])) * (x+1);

                                                tmpBBox.vMin.Z = this.worldAABBox.vMin.Z + (this.extents.Z / (levelNumCells[i])) * (z);
                                                tmpBBox.vMax.Z = this.worldAABBox.vMin.Z + (this.extents.Z / (levelNumCells[i])) * (z+1);
                                                
                                                tmpNode.worldAABBox = tmpBBox;
                        tmpNode.ForceWorldMatValueWithoutUpdate(Matrix.Translation(tmpBBox.MinPoint()));

                                                nodes[i][x+z*levelNumCells[i]] = tmpNode;

                                                int xParent = (int)System.Math.Floor((double)x/2);
                                                int zParent = (int)System.Math.Floor((double)z/2);
                                                (nodes[i-1][xParent+zParent*levelNumCells[i-1]]).AddChild(tmpNode);
                                        }
                                }
                        }
                }

        private void InitRefractionReflection()
        {
            Device dev = DXGfxManager.GetGlobalInstance().d3dDevice;
            SurfaceDescription backBufferDescription = DXGfxManager.GetGlobalInstance().backBufferDescription;

            reflectPlane = Microsoft.DirectX.Plane.FromPointNormal(new Vector3(0, 0.0f, 0), new Vector3(0, 1, 0));

            reflectionMap = new Texture(dev, backBufferDescription.Width, backBufferDescription.Height, 1, Usage.RenderTarget, backBufferDescription.Format, Pool.Default);
            backBufferTex = new Texture(dev, backBufferDescription.Width, backBufferDescription.Height, 1, Usage.RenderTarget, backBufferDescription.Format, Pool.Default);
            rts = new RenderToSurface(dev, backBufferDescription.Width, backBufferDescription.Height, backBufferDescription.Format, true, DepthFormat.D16);
            rect = new Rectangle(0, 0, backBufferDescription.Width, backBufferDescription.Height);
        }

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

            while (sceneObjects.MoveNext())
            {
                SceneObject currObj = sceneObjects.Value as SceneObject;
                if ((currObj != null)&&(currObj.GetType()!=typeof(Water))&&(currObj.GetType()!=typeof(SkyBox))&&
                    (currObj.GetType() != typeof(Water2)) && (currObj.GetType() != typeof(SkyDome)))
                {
                    currObj.GetPrepared();
                    Attach(currObj);
                }
            }

            if (sceneSky != null)
            {
                sceneSky.GetPrepared();
            }
            if (sceneWater != null)
            {
                sceneWater.GetPrepared();
            }

            if (avatarName != "")
            {
                CurrentAvatar = new Avatar(sceneContent[avatarName] as SceneObject);
            }
        }

        public override void Dispose()
        {
            if (currentInputHandler != null)
            {
                currentInputHandler.Dispose();
                currentInputHandler = null;
            }
            if (rootNode != null)
            {
            }
        }

        public void ValidateOrMove(ref SceneNode node)
        {
            ValidateOrMove(ref node, 0);
        }

        public void ValidateOrMove(ref SceneNode node, float offset)
        {
            Vector3 pos = node.Position;
            float y = GetHeigth(pos.X, pos.Z)+offset;
            if ((y > pos.Y) && (y < 1000))
            {
                pos.Y = y;
                node.Position = pos;
            }
        }

        public Matrix ValidateOrMove(Vector3 pos, BBox localBBox)
        {
            Matrix res = Matrix.Identity;

            float y = GetHeigth(pos.X, pos.Z) + 0.5f * localBBox.Size().Y;
            if ((y > pos.Y) && (y < 1000))
            {
                res = Matrix.Translation(0.0f, y - pos.Y, 0.0f);
            }

            return res;
        }

        public void ValidateCameraOrMove(ref SceneNode camera, ref SceneNode subject)
        {
            // First let's validate or move our two nodes
            ValidateOrMove(ref subject);
            ValidateOrMove(ref camera, 3.0f);
        }

        public virtual void DeviceChanged(Device d3ddevice)
        {
            sceneTerrain.DeviceChanged(d3ddevice, this);
            defaultState = null;
        }

        public float GetHeigth(float x, float z)
        {
            float heigth = 0.0f;

            if (sceneTerrain != null)
            {
                heigth = sceneTerrain.GetHeigth(this, x, z);    
            }
            return heigth;
        }

        public override void Update(double appTime, float elapsedTime, Frustrum frustrum, List<IDrawable> objectsToBeRendered)
        {
            this.frustrum = frustrum;

            base.Update(appTime, elapsedTime, frustrum, objectsToBeRendered);

            if (sceneWater != null)
            {
                sceneWater.Update(frustrum, appTime, elapsedTime);
            }

            if (sceneSky != null)
            {
                sceneSky.Update(frustrum, appTime, elapsedTime);
            }

            UpdatePositionInTree();
        }

        public void Update(Device d3ddevice, double appTime, float elapsedTime)
        {
            matView = Matrix.Multiply(currentCamera.WorldMatrix, currentCamera.ViewMatrix);
            matProj = currentCamera.ProjectionMatrix;
            Update(d3ddevice, matView, currentCamera.ProjectionMatrix, appTime, elapsedTime);
        }

        public override void RenderScene(Device d3ddevice, Frustrum frustrum)
        {
            d3ddevice.SetTransform(TransformType.World, Matrix.Identity);
            RenderScene(d3ddevice, frustrum.matView, frustrum.matProj);
        }

        public override void RenderScene(Device d3ddevice, Matrix matView, Matrix matProj)
        {
            d3ddevice.SetTransform(TransformType.World, Matrix.Identity);

            if (SceneWater != null)
            {
                CheckRefractionReflectionReady();
                CreateReflectionMap(d3ddevice);
            }

            // Clear the render target and the zbuffer 
            d3ddevice.Clear(ClearFlags.ZBuffer | ClearFlags.Target, 0x002D32AA, 1.0f, 0);
            d3ddevice.Transform.World = Matrix.Identity;
            d3ddevice.Transform.View = matView;
            d3ddevice.Transform.Projection = matProj;

                d3ddevice.BeginScene();

            RenderObjectAndSky(d3ddevice);

            if (SceneWater != null)
            {
                CreateRefractionMap(d3ddevice);
                SceneWater.Render(d3ddevice, backBufferTex, reflectionMap);
            }

                d3ddevice.EndScene();
        }

        public void CheckRefractionReflectionReady()
        {
            if ((reflectionMap == null) || (backBufferTex == null))
            {
                InitRefractionReflection();
            }
        }

        private void RenderObjectAndSky(Device d3ddevice)
        {

            RenderObjects(d3ddevice);

            if (sceneSky != null)
            {
                sceneSky.RenderSky(d3ddevice);
                //int skyPasses = sceneSky.AssociatedEffectGroup.Default.Begin(0);
                //for (int skyPass = 0; skyPass < skyPasses; skyPass++)
                //{
                //    sceneSky.AssociatedEffectGroup.Default.BeginPass(skyPass);
                //    sceneSky.Draw(d3ddevice);
                //    sceneSky.AssociatedEffectGroup.Default.EndPass();
                //}
                //sceneSky.AssociatedEffectGroup.Default.End();
            }
        }

        private void RenderObjects(Device d3ddevice)
        {
            EffectGroup nextEG = DXGfxManager.GetGlobalInstance().defaultEffectGroup;
            EffectGroup currentEG = null;
            int startAt = 0;

            while ((nextEG != null) && (objectsToBeRendered.Count > 0))
            {
                currentEG = nextEG;
                int passes = currentEG.Default.Begin(0);
                bool lastPassDone = false;

                for (int pass = 0; pass < passes; pass++)
                {
                    currentEG.Default.BeginPass(pass);

                    for (int i = startAt; i < objectsToBeRendered.Count; i++)
                    {
                        if (currentEG.CompareTo(objectsToBeRendered[i].AssociatedEffectGroup) == 0)
                        {
                            objectsToBeRendered[i].SetEffectsValues(d3ddevice, currentEG.Default, pass);

                            objectsToBeRendered[i].Draw(d3ddevice);

                        }
                        else
                        {
                            if (pass == passes - 1)
                            {
                                nextEG = objectsToBeRendered[i].AssociatedEffectGroup;
                                startAt = i;
                                lastPassDone = true;
                            }
                            break;
                        }

                        if (i == objectsToBeRendered.Count - 1)
                        {
                            // If we are here we have rendered everything so just set effectToUse==null
                            // to avoid rendering everything again.
                            nextEG = null;
                        }
                    }
                    currentEG.Default.EndPass();

                    // We have two different situation to deal with here.
                    // If this is the last pass then change nextEG and startAt.
                    // else just break to draw all the objects that have been rendered
                    // but with second pass of the defaul effect.
                    if (lastPassDone)
                    {
                        break;
                    }


                }
                currentEG.Default.End();
            }
            TerrainTile.settedPass = -1;
        }

        public void CreateRefractionMap(Device device)
        {
            device.RenderState.ZBufferFunction = Compare.LessEqual;
            device.RenderState.ColorWriteEnable = ColorWriteEnable.Alpha;

            if (refractionMaskEffect == null)
            {
                DXGfxManager.GetGlobalInstance().LoadEffect(device, "RefeactionMaskHLSL.fx", ref refractionMaskEffect);
            }

            refractionMaskEffect.SetValue("g_WorldViewProj", SceneWater.WorldMat * frustrum.matView * frustrum.matProj);
            refractionMaskEffect.Technique = "RenderRefractionMask14";

            device.VertexFormat = CustomVertex.PositionNormalTextured.Format;
            // Water
            device.Transform.World = SceneWater.WorldMat;
            device.SetStreamSource(0, SceneWater.waterVBuff, 0);
            device.Indices = SceneWater.waterIBuff;

            // Apply the technique contained in the effect 
            int passes = refractionMaskEffect.Begin(0);
            for (int pass = 0; pass < passes; pass++)
            {
                refractionMaskEffect.BeginPass(pass);

                // Draw the mesh subset
                device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, SceneWater.numberVertices, 0, SceneWater.numberTri);

                refractionMaskEffect.EndPass();
            }
            refractionMaskEffect.End();
            device.RenderState.ColorWriteEnable = ColorWriteEnable.RedGreenBlueAlpha;

            device.StretchRectangle(device.GetBackBuffer(0, 0, BackBufferType.Mono),
                rect, backBufferTex.GetSurfaceLevel(0), rect, TextureFilter.Linear);
        }

        public void CreateReflectionMap(Device device)
        {
            bool fogStatus = device.RenderState.FogEnable;
            device.RenderState.FogEnable = false;

            Surface surface = reflectionMap.GetSurfaceLevel(0);

            Viewport view = new Viewport();
            view.Width = DXGfxManager.GetGlobalInstance().backBufferDescription.Width;
            view.Height = DXGfxManager.GetGlobalInstance().backBufferDescription.Height;
            view.MaxZ = 1.0f;

            rts.BeginScene(surface, view);

            device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0x00efefff, 1.0f, 0);
            

            // Do magic reflection stuff                                
            Matrix reflectViewMatrix = Matrix.Identity;
            reflectViewMatrix.Reflect(reflectPlane);
            reflectViewMatrix = reflectViewMatrix * frustrum.matView;

            device.Transform.View = reflectViewMatrix;
            device.Transform.Projection = frustrum.matProj;

            device.ClipPlanes[0].Enabled = true;
            device.ClipPlanes[0].Plane = reflectPlane;
            device.RenderState.Clipping = true;

            // render scene                
            RenderObjectAndSky(device);

            // reset render states
            device.RenderState.Clipping = false;
            device.ClipPlanes[0].Enabled = false;

            // end RTS
            rts.EndScene(Filter.None);

            device.RenderState.FogEnable = fogStatus;
        }

        public QuadTreeNode GetNode(int level, int x, int z)
        {
            QuadTreeNode res = null;

            if ((level <= depth) && (x < levelNumCells[level]) && (z < levelNumCells[level]))
                res = nodes[level][x + z * levelNumCells[level]];

            if (res == null)
                res = rootNode as QuadTreeNode;

            return res;
        }

        public SceneNode GetParent(BBox boundingBox)
        {
            // Guess what, if we are not passed a valid boundingbox we just return the rootNode.
            if (boundingBox == null)
            {
                return rootNode;
            }

            int xMinEnclosedRow;
            int xMaxEnclosedRow;

            int zMinEnclosedRow;
            int zMaxEnclosedRow;

            AABBox aaBox = new AABBox(boundingBox);

            aaBox.vMin += new Vector3(0.01f, 0.01f, 0.01f);
            aaBox.vMax -= new Vector3(0.01f, 0.01f, 0.01f);

            xMinEnclosedRow = (int)System.Math.Floor(((aaBox.vMin.X - this.worldAABBox.vMin.X) / extents.X) * numDimCells);
            xMaxEnclosedRow = (int)System.Math.Floor(((aaBox.vMax.X - this.worldAABBox.vMin.X) / extents.X) * numDimCells);

            zMinEnclosedRow = (int)System.Math.Floor(((aaBox.vMin.Z - this.worldAABBox.vMin.Z) / extents.Z) * numDimCells);
            zMaxEnclosedRow = (int)System.Math.Floor(((aaBox.vMax.Z - this.worldAABBox.vMin.Z) / extents.Z) * numDimCells);

            xMinEnclosedRow = (int)MathUtil.Clamp(xMinEnclosedRow, 0, 255);
            xMaxEnclosedRow = (int)MathUtil.Clamp(xMaxEnclosedRow, xMinEnclosedRow + 1, 255);

            zMinEnclosedRow = (int)MathUtil.Clamp(zMinEnclosedRow, 0, 255);
            zMaxEnclosedRow = (int)MathUtil.Clamp(zMaxEnclosedRow, zMinEnclosedRow + 1, 255);

            int xPattern = (xMinEnclosedRow ^ xMaxEnclosedRow);
            int zPattern = (zMinEnclosedRow ^ zMaxEnclosedRow);

            int bitPattern = System.Math.Max(xPattern, zPattern);

            BitVector32 bitVec = new BitVector32(bitPattern);
            int myBit1 = BitVector32.CreateMask();
            int myBit2 = BitVector32.CreateMask(myBit1);
            int myBit3 = BitVector32.CreateMask(myBit2);
            int myBit4 = BitVector32.CreateMask(myBit3);
            int myBit5 = BitVector32.CreateMask(myBit4);
            int myBit6 = BitVector32.CreateMask(myBit5);
            int myBit7 = BitVector32.CreateMask(myBit6);
            int myBit8 = BitVector32.CreateMask(myBit7);

            int destLevel = 0;

            if (bitVec[myBit1])
                destLevel = maxDepth - 1;
            if (bitVec[myBit2])
                destLevel = maxDepth - 2;
            if (bitVec[myBit3])
                destLevel = maxDepth - 3;
            if (bitVec[myBit4])
                destLevel = maxDepth - 4;
            if (bitVec[myBit5])
                destLevel = maxDepth - 5;
            if (bitVec[myBit6])
                destLevel = maxDepth - 6;
            if (bitVec[myBit7])
                destLevel = maxDepth - 7;
            if (bitVec[myBit8])
                destLevel = maxDepth - 8;

            destLevel = (int)MathUtil.Clamp(destLevel, 0, depth);

            int x = (int)System.Math.Floor(((aaBox.vMin.X - this.worldAABBox.vMin.X) / extents.X) * levelNumCells[destLevel]);
            int z = (int)System.Math.Floor(((aaBox.vMin.Z - this.worldAABBox.vMin.Z) / extents.Z) * levelNumCells[destLevel]);

            SceneNode res = GetNode(destLevel, (int)MathUtil.Clamp(x, 0, levelNumCells[destLevel]),
                (int)MathUtil.Clamp(z, 0, levelNumCells[destLevel]));

            if (aaBox.IsInside(res.worldAABBox))
            {
                return res;
            }
            else
            {
                return rootNode;
            }
        }

        public SceneNode GetParent(SceneNode node)
        {
            return GetParent(node.worldAABBox);
        }

        public void RegisterForPositionUpdate(SceneNode node)
        {
            // Check a simple check! QuadTree nodes should not move in the tree.
            // SceneNode can move but QuedTree nodes are not expected to move!
            // Let's check it
            QuadTreeNode testNode = node as QuadTreeNode;
            if (testNode != null)
            {
                throw new ArgumentException("Any SceneNode can move but we don't expect to see quadtree nodes here!?");
            }

            nodesToPositionInTree.Add(node);
        }

        public void UpdatePositionInTree()
        {
            foreach (SceneNode tmpNode in this.nodesToPositionInTree)
            {
                SceneNode oldParent = tmpNode.parent;
                SceneNode newParent = GetParent(tmpNode);

                if (oldParent == null)
                {
                    throw new NullReferenceException("This should not ever happen!");
                }
                if (newParent == null)
                {
                    throw new NullReferenceException("This should not ever happen!");
                }
                if (oldParent != newParent)
                {
                    oldParent.RemoveChild(tmpNode);
                    newParent.AddChild(tmpNode);
                }
            }
            this.nodesToPositionInTree.Clear();
        }

        public override void Attach(SceneObject sceneObj)
        {
            SceneNode parent = GetParent(sceneObj);
            sceneObj.parent = parent;
            sceneObj.scene = this;
            parent.AddChild(sceneObj);
        }

        public virtual void AttachStatic(SceneObject sceneObj)
        {
            TerrainTile tile = sceneTerrain.FindTile(this, sceneObj.Position.X, sceneObj.Position.Z);
            tile.AddChild(sceneObj);
        }

        struct BatchInterm
        {
            public Mesh theMesh;
            public Material[] materials;
            public Texture[] textures;
            public List<Matrix> matrices;
        }

        public virtual void AttachBatch(Mesh mesh, Material[] materials, Texture[] textures, Matrix[] matrices)
        {
            Hashtable tmpBatches = new Hashtable();

            foreach (Matrix mat in matrices)
            {
                TerrainTile tile = sceneTerrain.FindTile(this, mat.M41, mat.M43);


                
                if (tmpBatches.ContainsKey(tile))
                {
                    BatchInterm interm = (BatchInterm)tmpBatches[tile];
                    interm.matrices.Add(mat);
                }
                else
                {
                    BatchInterm interm = new BatchInterm();
                    interm.theMesh = mesh;
                    interm.materials = materials;
                    interm.textures = textures;
                    interm.matrices = new List<Matrix>();
                    interm.matrices.Add(mat);
                    tmpBatches.Add(tile, interm);
                }
            }

            IDictionaryEnumerator enumerator = tmpBatches.GetEnumerator();

            while (enumerator.MoveNext())
            {
                TerrainTile tile = (TerrainTile)enumerator.Key;
                BatchInterm interm = (BatchInterm)enumerator.Value;

                Batch batch = new Batch();
                batch.Populate(interm.theMesh, interm.materials, interm.textures, interm.matrices.ToArray());

                tile.batches.Add(batch);
            }
        }

        public void Add(SceneNode node)
        {
            SceneNode parent = GetParent(node);
            

            if (parent == null) // Means we don't have container, in that case we just attach to the rootNode.
                parent = rootNode;
            parent.AddChild(node);
        }

        public override bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            SceneNode parentSceneNode = GetParent(sceneNode);

            return parentSceneNode.Collide(sceneNode, ref collidingSceneObjects);
        }

        public override bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects)
        {
            SceneNode parentSceneNode = GetParent(sceneNode);

            return parentSceneNode.CollideSolid(sceneNode, ref collidingSceneObjects);
        }

        public override bool Collide(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            SceneNode parentSceneNode = GetParent(sceneNode);

            return parentSceneNode.Collide(sceneNode, ref collidingSceneObjects, desiredType);
        }

        public override bool CollideSolid(SceneNode sceneNode, ref List<SceneObject> collidingSceneObjects, System.Type desiredType)
        {
            SceneNode parentSceneNode = GetParent(sceneNode);

            return parentSceneNode.CollideSolid(sceneNode, ref collidingSceneObjects, desiredType);
        }

        public Terrain LoadTerrain(string filename)
        {
            if (DXGfxManager.GetGlobalInstance().d3dDevice == null)
            {
                throw new Exception("DXGfxManager.d3dDevice is null, loading of terrain is impossible without a valid device!");
            }

            return LoadTerrain(DXGfxManager.GetGlobalInstance().d3dDevice, filename);
        }

        public Terrain LoadTerrain(Device d3ddevice, string filename)
        {
            sceneTerrain = new Terrain(1024, 1024);
            sceneTerrain.Load(d3ddevice, this, filename);

            return sceneTerrain;
        }

        public Terrain LoadTerrain(Device d3ddevice, string fileName, string baseTextureFile, string secondTextureFile, string alphaMapFile)
        {
            sceneTerrain = new Terrain(1024, 1024);
            sceneTerrain.Load(d3ddevice, this, fileName, baseTextureFile, secondTextureFile);

            return sceneTerrain;
        }

        public override SceneObject PickObject(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos)
        {
            return base.PickObject(viewport, proj, view, screenPos);
        }

        public override Vector3 PickEnvironmentPosition(Viewport viewport, Matrix proj, Matrix view, Vector2 screenPos)
        {
            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, typeof(TerrainTile));

            Vector3 position = new Vector3();
            if (any)
            {
                float refVal = 10000.0f;
                TerrainTile res = null;

                foreach (SceneObject sceneObj in collidingSceneObjects)
                {
                    TerrainTile tile = sceneObj as TerrainTile;

                    if (tile == null)
                        continue;

                    Microsoft.DirectX.Direct3D.IntersectInformation closestHit = new IntersectInformation();

                    bool intersect = tile.Intersect(rayOrig, rayDir, out closestHit);

                    if (!intersect)
                        continue;

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

                position = rayOrig + refVal * rayDir;
            }
            return position;
        }

        public void AddInstances(FrameworkMesh mesh, InstanceInfo[] instancesInfo)
        {
            if (sceneTerrain == null)
            {
                throw new Exception("terrain is null. It should be initialized before calling this method!");
            }

        }
    }
}

---