opensim/trunk/OpenSim/Region/Physics/BulletXPlugin/TriangleIndexVertexArray.cs

/*
  Bullet for XNA Copyright (c) 2003-2007 Vsevolod Klementjev http://www.codeplex.com/xnadevru
  Bullet original C++ version Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/

/*
 
 This file contains a class TriangleIndexVertexArray. I tried using the class with the same name 
 from the BulletX implementation and found it unusable for the purpose of using triangle meshes 
 within BulletX as the implementation was painfully incomplete.
 The attempt to derive from the original class failed as viable members were hidden.
 Fiddling around with BulletX itself was not my intention.
 So I copied the class to the BulletX-plugin and modified it.
 If you want to fiddle around with it it's up to you to move all this to BulletX.
 If someone someday implements the missing functionality in BulletX, feel free to remove this class.
 It's just an ugly hack.
 
 */
using System;
using System.Collections.Generic;
using MonoXnaCompactMaths;
using XnaDevRu.BulletX;

namespace OpenSim.Region.Physics.BulletXPlugin
{
    /// <summary>
    /// IndexedMesh indexes into existing vertex and index arrays, in a similar way OpenGL glDrawElements
    /// instead of the number of indices, we pass the number of triangles
    /// </summary>
    public struct IndexedMesh
    {
        private int _numTriangles;
        private int[] _triangleIndexBase;
        private int _triangleIndexStride;
        private int _numVertices;
        private Vector3[] _vertexBase;
        private int _vertexStride;

        public IndexedMesh(int numTriangleIndices, int[] triangleIndexBase, int triangleIndexStride, int numVertices,
                           Vector3[] vertexBase, int vertexStride)
        {
            _numTriangles = numTriangleIndices;
            _triangleIndexBase = triangleIndexBase;
            _triangleIndexStride = triangleIndexStride;
            _vertexBase = vertexBase;
            _numVertices = numVertices;
            _vertexStride = vertexStride;
        }

        public IndexedMesh(int[] triangleIndexBase, Vector3[] vertexBase)
        {
            _numTriangles = triangleIndexBase.Length;
            _triangleIndexBase = triangleIndexBase;
            _triangleIndexStride = 32;
            _vertexBase = vertexBase;
            _numVertices = vertexBase.Length;
            _vertexStride = 24;
        }

        public int TriangleCount
        {
            get { return _numTriangles; }
            set { _numTriangles = value; }
        }

        public int[] TriangleIndexBase
        {
            get { return _triangleIndexBase; }
            set { _triangleIndexBase = value; }
        }

        public int TriangleIndexStride
        {
            get { return _triangleIndexStride; }
            set { _triangleIndexStride = value; }
        }

        public int VertexCount
        {
            get { return _numVertices; }
            set { _numVertices = value; }
        }

        public Vector3[] VertexBase
        {
            get { return _vertexBase; }
            set { _vertexBase = value; }
        }

        public int VertexStride
        {
            get { return _vertexStride; }
            set { _vertexStride = value; }
        }
    }

    /// <summary>
    /// TriangleIndexVertexArray allows to use multiple meshes, by indexing into existing triangle/index arrays.
    /// Additional meshes can be added using addIndexedMesh
    /// </summary>
    public class TriangleIndexVertexArray : StridingMeshInterface
    {
        private List<IndexedMesh> _indexedMeshes = new List<IndexedMesh>();

        public TriangleIndexVertexArray()
        {
        }

        public TriangleIndexVertexArray(int numTriangleIndices, int[] triangleIndexBase, int triangleIndexStride,
                                        int numVertices, Vector3[] vertexBase, int vertexStride)
        {
            IndexedMesh mesh = new IndexedMesh();
            mesh.TriangleCount = numTriangleIndices;
            mesh.TriangleIndexBase = triangleIndexBase;
            mesh.TriangleIndexStride = triangleIndexStride;
            mesh.VertexBase = vertexBase;
            mesh.VertexCount = numVertices;
            mesh.VertexStride = vertexStride;

            AddIndexedMesh(mesh);
        }

        public TriangleIndexVertexArray(int[] triangleIndexBase, Vector3[] vertexBase)
            : this(triangleIndexBase.Length, triangleIndexBase, 32, vertexBase.Length, vertexBase, 24)
        {
        }

        public void AddIndexedMesh(IndexedMesh indexedMesh)
        {
            _indexedMeshes.Add(indexedMesh);
        }

        public override void GetLockedVertexIndexBase(out List<Vector3> verts, out List<int> indicies, out int numfaces,
                                                      int subpart)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public override void GetLockedReadOnlyVertexIndexBase(out List<Vector3> verts, out List<int> indicies,
                                                              out int numfaces, int subpart)
        {
            IndexedMesh m = _indexedMeshes[0];
            Vector3[] vertexBase = m.VertexBase;
            verts = new List<Vector3>();
            foreach (Vector3 v in vertexBase)
            {
                verts.Add(v);
            }
            int[] indexBase = m.TriangleIndexBase;
            indicies = new List<int>();
            foreach (int i in indexBase)
            {
                indicies.Add(i);
            }
            numfaces = vertexBase.GetLength(0);
        }

        public override void UnLockVertexBase(int subpart)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public override void UnLockReadOnlyVertexBase(int subpart)
        {
        }

        public override int SubPartsCount()
        {
            return _indexedMeshes.Count;
        }

        public override void PreallocateVertices(int numverts)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public override void PreallocateIndices(int numindices)
        {
            throw new Exception("The method or operation is not implemented.");
        }
    }
}