D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/Batch.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.Drawing;

namespace DXGfxLib
{
    public struct InstanceInfo
    {
        public Vector4 positionRot;
    }

    public class Batch : IDisposable, IDrawable
    {
        private int maxNumberFaces = 5000;

        private EffectGroup associatedEffetGroup = null;

        public EffectGroup AssociatedEffectGroup
        {
            get { return associatedEffetGroup; }
            set { associatedEffetGroup = value; }
        }

        protected bool hide = false;

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

        public Material[] meshMaterials; // Materials for our mesh

        public Texture[] meshTextures; // Textures for our mesh

        public Mesh[] meshes = null;

        private Mesh initialMesh = null;

        private Matrix[] worldMatrices = null;

        public Batch()
        {
            associatedEffetGroup = DXGfxManager.GetGlobalInstance().defaultEffectGroup;
        }

        public void Dispose()
        {
            if (meshes != null)
            {
                foreach (Mesh mesh in meshes)
                {
                    mesh.Dispose();
                }
            }
            if (meshTextures != null)
            {
                foreach(Texture tex in meshTextures)
                {
                    tex.Dispose();
                }
            }
        }

        public void SetEffectsValues(Device d3ddevice, Effect eff, int pass)
        {
            d3ddevice.SetTransform(TransformType.World, Matrix.Identity);
        }


        public void Draw(Device d3ddevice)
        {
            // Meshes are divided into subsets, one for each material. Render them in
            // a loop
            for (int i = 0; i < meshMaterials.Length; i++)
            {
                // Set the material and texture for this subset
                d3ddevice.Material = meshMaterials[i];
                d3ddevice.SetTexture(0, meshTextures[i]);

                // Draw the mesh subset
                foreach (Mesh mesh in meshes)
                {
                    mesh.DrawSubset(i);
                }
            }
        }

        public void Populate(Mesh initialMesh, Material[] materials, Texture[] textures, Matrix[] matrices)
        {
            this.initialMesh = initialMesh.Clone(initialMesh.Options.Value, CustomVertex.PositionNormalTextured.Format, initialMesh.Device);
            this.worldMatrices = matrices;

            meshMaterials = materials;
            meshTextures = textures;

            int max = Math.Max(initialMesh.NumberFaces, initialMesh.NumberVertices);
            // Cannot create meshes with more than 65534 faces or vertices (check doc).
            int maxInstanceInOneMesh = (int)Math.Floor((double)(maxNumberFaces / max));

            if (matrices.Length > maxInstanceInOneMesh)
            {
                int nbIter = (int)Math.Ceiling((double)(matrices.Length / maxInstanceInOneMesh));

                meshes = new Mesh[nbIter];

                for (int i = 0; i < nbIter; i++)
                {
                    int start = Math.Min(i * maxInstanceInOneMesh, matrices.Length);
                    int end = Math.Min((i + 1) * maxInstanceInOneMesh, matrices.Length);

                    meshes[i] = BuildOneBigMeshForStaticInstanciating(worldMatrices, start, end);
                }
            }
            else
            {
                meshes = new Mesh[1];
                meshes[0] = BuildOneBigMeshForStaticInstanciating(worldMatrices, 0, matrices.Length);
            }
        }

        public Mesh BuildOneBigMeshForStaticInstanciating(Matrix[] worldMatrices, int startIndex, int endIndex)
        {
            if (initialMesh == null)
            {
                throw new Exception("We need a valid initial mesh, please define one before calling this method!");
            }

            int nbInstance = endIndex - startIndex;
            Mesh mesh = new Mesh(nbInstance * initialMesh.NumberFaces, nbInstance * initialMesh.NumberVertices, initialMesh.Options.Value,
                CustomVertex.PositionNormalTextured.Format, initialMesh.Device);

            CustomVertex.PositionNormalTextured[] initialVertices = (CustomVertex.PositionNormalTextured[])initialMesh.LockVertexBuffer(typeof(CustomVertex.PositionNormalTextured),
                LockFlags.ReadOnly, initialMesh.NumberVertices);

            GraphicsStream stm = mesh.LockVertexBuffer(LockFlags.NoSystemLock);

            Int16[] initialIndices = (Int16[])initialMesh.LockIndexBuffer(typeof(Int16), LockFlags.ReadOnly, 3 * initialMesh.NumberFaces);

            GraphicsStream stmi = mesh.LockIndexBuffer(LockFlags.None);

            int count = 0;
            for (int i = startIndex; i < endIndex; i++)
            {
                Matrix mat = worldMatrices[i];
                CustomVertex.PositionNormalTextured[] instanceVertices = Transform(initialVertices, mat);

                stm.Write(instanceVertices);


                Int16[] instanceIndices = AddOffset(initialIndices, (Int16)(count * initialVertices.Length));

                stmi.Write(instanceIndices);

                count++;
            }

            initialMesh.UnlockVertexBuffer();
            mesh.UnlockVertexBuffer();

            initialMesh.UnlockIndexBuffer();
            mesh.UnlockIndexBuffer();

            //int[] adjacency = new int[3*initialMesh.NumberFaces];
            //initialMesh.GenerateAdjacency(0.05f, adjacency);
            //mesh.Optimize(MeshFlags.Managed, adjacency);

            mesh.SetAttributeTable(initialMesh.GetAttributeTable());
            int[] initialAttributes = initialMesh.LockAttributeBufferArray(LockFlags.ReadOnly);

            int[] destAttributes = mesh.LockAttributeBufferArray(LockFlags.NoSystemLock);

            count = 0;
            for (int i = startIndex; i < endIndex; i++)
            {
                initialAttributes.CopyTo(destAttributes, count * initialAttributes.Length);
                count++;
            }

            initialMesh.UnlockAttributeBuffer();
            mesh.UnlockAttributeBuffer();

            return mesh;
        }

        public CustomVertex.PositionNormalTextured[] Transform(CustomVertex.PositionNormalTextured[] vertices, Matrix mat)
        {
            CustomVertex.PositionNormalTextured[] outVertices = new CustomVertex.PositionNormalTextured[vertices.Length];
            int compteur = 0;

            foreach (CustomVertex.PositionNormalTextured vertex in vertices)
            {
                Vector3 inVec = new Vector3(vertex.X, vertex.Y, vertex.Z);
                Vector3 inNorm = new Vector3(vertex.Nx, vertex.Ny, vertex.Nz);

                inVec.TransformCoordinate(mat);
                inNorm.TransformCoordinate(mat);

                outVertices[compteur].X = inVec.X;
                outVertices[compteur].Y = inVec.Y;
                outVertices[compteur].Z = inVec.Z;

                outVertices[compteur].Nx = inNorm.X;
                outVertices[compteur].Ny = inNorm.Y;
                outVertices[compteur].Nz = inNorm.Z;

                outVertices[compteur].Tu = vertex.Tu;
                outVertices[compteur].Tv = vertex.Tv;
                compteur++;
            }

            return outVertices;
        }

        public Int16[] AddOffset(Int16[] inIndices, int offset)
        {
            Int16[] outIndices = new Int16[inIndices.Length];
            int compteur = 0;

            foreach (Int16 index in inIndices)
            {
                outIndices[compteur] = (Int16)(index + offset);
                compteur++;
            }

            return outIndices;
        }

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

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

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

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

---