D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/MeshObject.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;
using System.IO;

namespace DXGfxLib
{
    public class MeshObject : SceneObject
    {
        public Vector3 barycenter = new Vector3();

        public float bSphereRadius;

        protected Mesh originalMesh = null;

        protected ExtendedMaterial[] extendedMaterials;

        protected Material[] meshMaterials;

        protected Texture[] meshTextures;

        protected EffectInstance[] effects;

        public float objectRadius = 0.0f;

        public Vector3 objectCenter;

        public MeshObject()
        {
            Initialize();
        }

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

        public MeshObject(string fileName)
        {
            if (DXGfxManager.GetGlobalInstance().d3dDevice == null)
            {
                throw new Exception("Manager does not have any reference to any valid d3ddevice, this constructor can not be executed");
            }
            LoadFromFile(DXGfxManager.GetGlobalInstance().d3dDevice, fileName);
        }

        public MeshObject(Device d3ddevice, string fileName)
        {
            LoadFromFile(d3ddevice, fileName);
        }

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

            Device dxDevice = DXGfxManager.GetGlobalInstance().d3dDevice;

            string currDir = Directory.GetCurrentDirectory();

            if (!File.Exists(fileName))
            {
                throw new Exception("The ressource file does not exist! There is a problem somewhere.... did you delete or moved any file?");
            }
            else
            {
                LoadFromFile(dxDevice, fileName);
            }

        }

        public override void LoadFromFile(Device d3ddevice, string fileName)
        {
            this.fileName = fileName;
            this.name = StringUtil.GetName(fileName);

            originalMesh = Mesh.FromFile(fileName, MeshFlags.Managed, d3ddevice, out extendedMaterials);

            // We need to extract the material properties and texture names 
            meshTextures = new Texture[extendedMaterials.Length];
            meshMaterials = new Material[extendedMaterials.Length];
            for (int i = 0; i < extendedMaterials.Length; i++)
            {
                if (File.Exists(extendedMaterials[i].TextureFilename))
                {
                    meshMaterials[i] = extendedMaterials[i].Material3D;
                    // Set the ambient color for the material (D3DX does not do this)
                    meshMaterials[i].Ambient = meshMaterials[i].Diffuse;

                    // Create the texture if there is one

                    meshTextures[i] = ResourceCache.GetGlobalInstance().CreateTextureFromFile(d3ddevice,
                                                                                      extendedMaterials[i].TextureFilename);

                }
            }

            localBoundingBox = CalculateLocalBBox(originalMesh);
            extents = localBoundingBox.Size();

            // Find the mesh's center, then generate a centering matrix
            using (VertexBuffer vb = originalMesh.VertexBuffer)
            {
                using (GraphicsStream stm = vb.Lock(0, 0, LockFlags.NoSystemLock))
                {
                    try
                    {
                        this.bSphereRadius = Geometry.ComputeBoundingSphere(stm,
                            originalMesh.NumberVertices, originalMesh.VertexFormat, out this.barycenter);
                    }
                    finally
                    {
                        vb.Unlock();
                    }
                }
            }
        }

        public MeshObject Clone()
        {
            MeshObject clone = new MeshObject();
            clone.name = name;
            clone.fileName = fileName;

            clone.originalMesh = originalMesh;
            clone.extendedMaterials = extendedMaterials;
            clone.meshMaterials = meshMaterials;
            clone.meshTextures = meshTextures;

            clone.associatedEffectGroup = associatedEffectGroup;
            clone.localBoundingBox = localBoundingBox;
            clone.barycenter = barycenter;
            clone.extents = extents;

            return clone;
        }

        public virtual void Attach(Mesh mesh)
        {
            originalMesh = mesh;
            localBoundingBox = CalculateLocalBBox(mesh);
            extents = localBoundingBox.Size();

            // Find the mesh's center, then generate a centering matrix
            using (VertexBuffer vb = mesh.VertexBuffer)
            {
                using (GraphicsStream stm = vb.Lock(0, 0, LockFlags.NoSystemLock))
                {
                    try
                    {
                        this.bSphereRadius = Geometry.ComputeBoundingSphere(stm,
                            mesh.NumberVertices, mesh.VertexFormat, out this.barycenter);
                    }
                    finally
                    {
                        vb.Unlock();
                    }
                }
            }
        }


        public override void Draw(Device device)
        {
            device.RenderState.CullMode = Cull.None;
            device.SetTransform(TransformType.World, worldMat);

            base.Draw(device);

            for (int i = 0; i < originalMesh.NumberAttributes; i++)
            {
                device.SetTexture(i, meshTextures[i]);
                originalMesh.DrawSubset(i);
            }
        }

        public virtual void DrawSubset(int index)
        {
            originalMesh.DrawSubset(index);
        }

        public override bool Intersect(Vector3 rayPos, Vector3 rayDir, out IntersectInformation closestHit)
        {
            // Let's transform rayPos and rayDir to local coordinates
            Matrix invWorldMat = Matrix.Invert(worldMat);
            Vector3 rayPosLocal = Vector3.TransformCoordinate(rayPos, invWorldMat);
            Vector3 rayDirLocal = Vector3.TransformNormal(rayDir, invWorldMat);
            rayDirLocal.Normalize();
            bool collision = false;
            if (originalMesh != null)
            {
                collision = originalMesh.Intersect(rayPosLocal, rayDirLocal, out closestHit);
            }
            else
            {
                closestHit = new IntersectInformation();
            }
            return collision;
        }

        public override bool Intersect(Vector3 rayOri, Vector3 rayDir, ref List<SceneObject> collidingSceneObjects)
        {
            // First let's quickly check if we have any chance to collide with anything.
            bool any = false;

            AABBox aabox = new AABBox(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;
                }

                Matrix invWorldMat = Matrix.Invert(worldMat);
                Vector3 rayPosLocal = Vector3.TransformCoordinate(rayOri, invWorldMat);
                Vector3 rayDirLocal = Vector3.TransformNormal(rayDir, invWorldMat);
                rayDirLocal.Normalize();

                if (originalMesh != null)
                {
                    if (originalMesh.Intersect(rayPosLocal, rayDirLocal))
                    {
                        collidingSceneObjects.Add(this);
                        any = true;
                    }
                }
                else
                {
                    collidingSceneObjects.Add(this);
                    any = true;
                }
            }

            return any;
        }

        public override 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))
                        any = true;
                }

                Matrix invWorldMat = Matrix.Invert(worldMat);
                Vector3 rayPosLocal = Vector3.TransformCoordinate(rayOri, invWorldMat);
                Vector3 rayDirLocal = Vector3.TransformNormal(rayDir, invWorldMat);
                rayDirLocal.Normalize();

                if (originalMesh != null)
                {
                    if ((originalMesh.Intersect(rayPosLocal, rayDirLocal)) && (desiredType.IsInstanceOfType(this)))
                    {
                        collidingSceneObjects.Add(this);
                        any = true;
                    }
                }
                else
                {
                    collidingSceneObjects.Add(this);
                    any = true;
                }
            }
            return any;
        }
    }
}

---