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

namespace DXGfxLib
{
    public class Terrain
    {
        public static string terrainEffectFile = "terrainTile.fx";

        private Bitmap terrainData;

        public Texture texture = null;

        public Material material;

        public string heightmapFile;

        public string baseTextureFile;

        public string secondTextureFile;

        public float maxTerrainHeigth;

        public float minTerrainHeigth;

        public float secondTexHeigth;

        public Texture secondTexture = null;

        public Texture alphaMap = null;

        public float desiredWidth;

        public float desiredHeigth;

        public int width;

        public int heigth;

        public float xSpacing;

        public float zSpacing;

        public float stretchFactor;

        private List<TerrainTile> tiles = null;

        public Terrain()
        {
            Initialize();
        }

        public Terrain(float desiredWidth, float desiredHeigth)
        {
            Initialize(desiredWidth, desiredHeigth);
        }

        public void Initialize()
        {
            Initialize(1024, 1024);
        }

        public void Initialize(float desiredWidth, float desiredHeigth)
        {
            // This means that we have 129*129 vertices. Our bitmap should also be
            // 129*129
            //bitmapWidth = 128;
            //bitmapHeigth = 128;
            //spacing = 10;
            this.desiredWidth = desiredWidth;
            this.desiredHeigth = desiredHeigth;

            stretchFactor = 70.0f;

            maxTerrainHeigth = -10000.0f;
            minTerrainHeigth = 10000.0f;

            // Default material
            material = new Material();
            material.Ambient = Color.Aqua;
            material.Diffuse = Color.Azure;
            material.Emissive = Color.Blue;
            material.Specular = Color.Brown;

            secondTexHeigth = 0.0f;

            tiles = new List<TerrainTile>();
        }

        public void DeviceChanged(Device d3ddevice, OutDoorScene scene)
        {
            Load(d3ddevice, scene, heightmapFile, baseTextureFile, secondTextureFile);
        }

        public void Load(Device d3ddevice, OutDoorScene scene, string ressourceName)
        {
            LoadFromFile(d3ddevice, scene, ressourceName);
        }

        public void LoadFromFile(Device d3ddevice, OutDoorScene scene, string fileName)
        {
            string path = StringUtil.GetPath(fileName);
            if (path == null)
            {
                Load(d3ddevice, scene, fileName, "newbase.jpg", "grass.bmp");
            }
            else
            {
                if (path.Length != 0)
                {
                    Load(d3ddevice, scene, fileName, path + "\\newbase.jpg", path + "\\grass.bmp");
                }
                else
                {
                    Load(d3ddevice, scene, fileName, "newbase.jpg", "grass.bmp");
                }
            }
        }
        public void Load(Device d3ddevice, OutDoorScene scene, string fileName, string baseTextureFile, string secondTextureFile)
        {
            this.heightmapFile = fileName;
            this.baseTextureFile = baseTextureFile;
            this.secondTextureFile = secondTextureFile;

            if (File.Exists(baseTextureFile))
            {
                texture = ResourceCache.GetGlobalInstance().CreateTextureFromFile(d3ddevice, baseTextureFile);
            }
            else
            {
                Trace.TraceError("File for base texture does not exist!");
                throw new ArgumentException("File :" + baseTextureFile + " for base texture does not exist!");
            }

            if (File.Exists(secondTextureFile))
            {
                secondTexture = ResourceCache.GetGlobalInstance().CreateTextureFromFile(d3ddevice, secondTextureFile);
            }
            else
            {
                Trace.TraceError("File for second texture file does not exist!");
                throw new ArgumentException("File :" + secondTextureFile + " for second texture does not exist!");
            }

            if (File.Exists(heightmapFile))
            {
                this.terrainData = new Bitmap(heightmapFile);
            }
            else
            {
                Trace.TraceError("File for heigthmap does not exist!");
                throw new ArgumentException("File :" + heightmapFile + " for heigthmap does not exist!");
            }

            width = terrainData.Width - 1;
            heigth = terrainData.Height - 1;

            xSpacing = this.desiredWidth / width;
            zSpacing = this.desiredHeigth / heigth;

            TerrainVertex[] vertices = BuildVerticesFromBitMap(width, heigth, xSpacing,
                zSpacing, stretchFactor, terrainData);

            BuildTilesFromVertices(d3ddevice, scene, vertices);

            terrainData.Dispose();
        }

        public float GetHeigth(OutDoorScene scene, float x, float z)
        {
            TerrainTile tile = FindTile(scene, x, z);
            return tile.GetHeigth(x, z);
        }

        public float GetHeigth(OutDoorScene scene, float x, float y, float z)
        {
            TerrainTile tile = FindTile(scene, x, z);
            return tile.GetHeigth(x, y, z);
        }


        public float GetHeigth(OutDoorScene scene, Vector3 underPoint)
        {
            TerrainTile tile = FindTile(scene, underPoint.X, underPoint.Z);
            return tile.GetHeigth(underPoint);
        }

        internal TerrainTile FindTile(OutDoorScene scene, float x, float z)
        {
            int maxLevel;
            Vector3 extents;

            if (CheckForQuadTree(scene, out maxLevel, out extents))
            {
                if (x > extents.X * 0.5f)
                {
                    throw new ArgumentOutOfRangeException("x value is greater than terrain x limit");
                }
                if (z > extents.Z * 0.5f)
                {
                    throw new ArgumentOutOfRangeException("z value is greater than terrain z limit");
                }

                // Position 0,0 doesn't match with tile 0,0
                // we need to add half our extents value to x and z
                x += extents.X * 0.5f;
                z += extents.Z * 0.5f;

                int numTilesSQRT = (int)System.Math.Pow(2, maxLevel);


                float tileExtentX = extents.X / numTilesSQRT;
                float tileExtentZ = extents.Z / numTilesSQRT;

                int coll = (int)System.Math.Floor(x / tileExtentX);
                int row = (int)System.Math.Floor(z / tileExtentZ);

                return (TerrainTile)tiles[coll + row * numTilesSQRT];
            }
            return null;
        }

        private void BuildTilesFromVertices(Device d3ddevice, OutDoorScene scene, TerrainVertex[] vertices)
        {
            // Create an effect group that we are going to use for our terrain tiles.
            EffectGroup terrainEG = new EffectGroup();
            terrainEG.Set(d3ddevice, terrainEffectFile);

            int maxLevel;
            Vector3 extents;

            if (CheckForQuadTree(scene, out maxLevel, out extents))
            {
                int numTilesSQRT = (int)System.Math.Pow(2, maxLevel);


                for (int j = 0; j < numTilesSQRT; j++)
                {
                    for (int i = 0; i < numTilesSQRT; i++)
                    {

                        TerrainTile tile = new TerrainTile();
                        tile.AssociatedEffectGroup = terrainEG;
                        tile.Populate(d3ddevice, (width / numTilesSQRT), (heigth / numTilesSQRT),
                            i * (width / numTilesSQRT), j * (heigth / numTilesSQRT),
                            width, heigth,
                            vertices);

                        tile.texture = this.texture;
                        tile.material = this.material;
                        tile.secondTexture = this.secondTexture;

                        tiles.Add(tile);
                        scene.nodes[maxLevel][i + j * numTilesSQRT].AddChild(tile);
                    }
                }
            }
            else
            {
                TerrainTile tile = new TerrainTile();
                tile.AssociatedEffectGroup = terrainEG;
                tile.Populate(d3ddevice, width, heigth, 0, 0, width, heigth, vertices);
                tiles.Add(tile);
                scene.Add(tile);
            }
        }


        private bool CheckForQuadTree(OutDoorScene scene, out int maxLevel, out Vector3 extents)
        {

            maxLevel = scene.depth;
            extents = scene.Extents;

            return true;
        }

        private TerrainVertex[] BuildVerticesFromBitMap(int width, int heigth,
            float xSpacing, float zSpacing, float stretchFactor,
            Bitmap bitmapToUse)
        {

            TerrainVertex[] tmpVertices = new TerrainVertex[(width + 1) * (heigth + 1)];
            if (bitmapToUse != null)
            {
                float x = -(width * xSpacing) / 2;
                float z = -(heigth * zSpacing) / 2;

                float texv = 0.0f;

                for (int j = 0; j <= heigth; j++)
                {
                    float texu = 0.0f;

                    for (int i = 0; i <= width; i++)
                    {
                        tmpVertices[i + j * (width + 1)].X = x;
                        tmpVertices[i + j * (width + 1)].Z = z;

                        if ((i == 0) || (j == 0) || (i == width) || (j == heigth))
                            tmpVertices[i + j * (width + 1)].Y = -1000.0f;
                        else
                            tmpVertices[i + j * (width + 1)].Y = ((bitmapToUse.GetPixel(i, j)).ToArgb() / (100000)) + 100.0f;

                        if (tmpVertices[i + j * (width + 1)].Y < minTerrainHeigth)
                            minTerrainHeigth = tmpVertices[i + j * (width + 1)].Y;
                        if (tmpVertices[i + j * (width + 1)].Y > maxTerrainHeigth)
                            maxTerrainHeigth = tmpVertices[i + j * (width + 1)].Y;


                        // set the texture coordinates
                        tmpVertices[i + j * (width + 1)].Tu1 = (float)i / (float)width;
                        tmpVertices[i + j * (width + 1)].Tv1 = ((float)j / (float)heigth);
                        tmpVertices[i + j * (width + 1)].Tu2 = (((float)(texu) / (float)(width)));
                        tmpVertices[i + j * (width + 1)].Tv2 = (((float)texv / (float)heigth));


                        if (texu < width)
                            texu += stretchFactor;
                        else
                            texu = 0.0f;

                        // calc the normal from the last pixel and row
                        Vector3 rowVector = new Vector3(1.0f, 0.0f, 0.0f);
                        Vector3 collumnVector = new Vector3(0.0f, 1.0f, 0.0f);
                        Vector3 tempNorm = new Vector3(0.0f, 1.0f, 0.0f);
                        if (i > 0)
                        {
                            rowVector.X = tmpVertices[(i - 1) + j * (width + 1)].X - tmpVertices[i + j * (width + 1)].X;
                            rowVector.Y = tmpVertices[(i - 1) + j * (width + 1)].Y - tmpVertices[i + j * (width + 1)].Y;
                            rowVector.Z = tmpVertices[(i - 1) + j * (width + 1)].Z - tmpVertices[i + j * (width + 1)].Z;
                        }
                        if (j > 0)
                        {
                            collumnVector.X = tmpVertices[(i) + (j - 1) * (width + 1)].X - tmpVertices[i + j * (width + 1)].X;
                            collumnVector.Y = tmpVertices[(i) + (j - 1) * (width + 1)].Y - tmpVertices[i + j * (width + 1)].Y;
                            collumnVector.Z = tmpVertices[(i) + (j - 1) * (width + 1)].Z - tmpVertices[i + j * (width + 1)].Z;
                        }
                        tempNorm = Vector3.Cross(rowVector, collumnVector);
                        tempNorm = Vector3.Normalize(tempNorm);

                        tmpVertices[i + j * (width + 1)].Nx = tempNorm.X;
                        tmpVertices[i + j * (width + 1)].Ny = tempNorm.Y;
                        tmpVertices[i + j * (width + 1)].Nz = tempNorm.Z;

                        x += xSpacing;
                    }

                    if (texv < heigth)
                        texv += stretchFactor;
                    else
                        texv = 0.0f;

                    z += zSpacing;
                    x = -(width * xSpacing) / 2;
                }
            }

            return tmpVertices;
        }

        public void AddInstances(OutDoorScene scene, FrameworkMesh mesh, InstanceInfo[] instancesInfo)
        {
            Hashtable tileInstanceAssociations = new Hashtable();

            foreach (InstanceInfo info in instancesInfo)
            {
                TerrainTile tile = FindTile(scene, info.positionRot.X, info.positionRot.Z);

                if (tileInstanceAssociations.ContainsKey(tile))
                {
                    List<InstanceInfo> infos = (List<InstanceInfo>)tileInstanceAssociations[tile];
                    infos.Add(info);
                }
                else
                {
                    List<InstanceInfo> infos = new List<InstanceInfo>();
                    infos.Add(info);
                    tileInstanceAssociations.Add(tile, infos);
                }
            }

            IDictionaryEnumerator enumerator = tileInstanceAssociations.GetEnumerator();

            while (enumerator.MoveNext())
            {
                List<InstanceInfo> infos = (List<InstanceInfo>)enumerator.Value;
                InstanceInfo[] instInfos = new InstanceInfo[infos.Count];
                infos.CopyTo(instInfos);

                TerrainTile tile = (TerrainTile)enumerator.Key;
                tile.AddInstances(mesh, instInfos);
            }
        }
    }
}

---