opensim/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs

/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyrightD
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the OpenSimulator Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.Text;

using OpenSim.Framework;
using OpenSim.Region.PhysicsModules.SharedBase;
using OpenSim.Region.PhysicsModule.Meshing;
using OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet;

using OMV = OpenMetaverse;

namespace OpenSim.Region.PhysicsModule.BulletS
{
    // Information class that holds stats for the shape. Which values mean
    //     something depends on the type of shape.
    // This information is used for debugging and stats and is not used
    //     for operational things.
    public class ShapeInfoInfo
    {
        public int Vertices { get; set; }
        private int m_hullCount;
        private int[] m_verticesPerHull;
        public ShapeInfoInfo()
        {
            Vertices = 0;
            m_hullCount = 0;
            m_verticesPerHull = null;
        }
        public int HullCount
        {
            set
            {
                m_hullCount = value;
                m_verticesPerHull = new int[m_hullCount];
                Array.Clear(m_verticesPerHull, 0, m_hullCount);
            }
            get { return m_hullCount; }
        }
        public void SetVerticesPerHull(int hullNum, int vertices)
        {
            if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
            {
                m_verticesPerHull[hullNum] = vertices;
            }
        }
        public int GetVerticesPerHull(int hullNum)
        {
            if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
            {
                return m_verticesPerHull[hullNum];
            }
            return 0;
        }
        public override string ToString()
        {
            StringBuilder buff = new StringBuilder();
            // buff.Append("ShapeInfo=<");
            buff.Append("<");
            if (Vertices > 0)
            {
                buff.Append("verts=");
                buff.Append(Vertices.ToString());
            }

            if (Vertices > 0 && HullCount > 0) buff.Append(",");

            if (HullCount > 0)
            {
                buff.Append("nHulls=");
                buff.Append(HullCount.ToString());
                buff.Append(",");
                buff.Append("hullVerts=");
                for (int ii = 0; ii < HullCount; ii++)
                {
                    if (ii != 0) buff.Append(",");
                    buff.Append(GetVerticesPerHull(ii).ToString());
                }
            }
            buff.Append(">");
            return buff.ToString();
        }
    }

    public abstract class BSShape
    {
        private static string LogHeader = "[BULLETSIM SHAPE]";

        public int referenceCount { get; set; }
        public DateTime lastReferenced { get; set; }
        public BulletShape physShapeInfo { get; set; }
        public ShapeInfoInfo shapeInfo { get; private set; }

        public BSShape()
        {
            referenceCount = 1;
            lastReferenced = DateTime.Now;
            physShapeInfo = new BulletShape();
            shapeInfo = new ShapeInfoInfo();
        }
        public BSShape(BulletShape pShape)
        {
            referenceCount = 1;
            lastReferenced = DateTime.Now;
            physShapeInfo = pShape;
            shapeInfo = new ShapeInfoInfo();
        }

        // Get another reference to this shape.
        public abstract BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim);

        // Called when this shape is being used again.
        // Used internally. External callers should call instance.GetReference() to properly copy/reference
        //       the shape.
        protected virtual void IncrementReference()
        {
            referenceCount++;
            lastReferenced = DateTime.Now;
        }

        // Called when this shape is done being used.
        protected virtual void DecrementReference()
        {
            referenceCount--;
            lastReferenced = DateTime.Now;
        }

        // Release the use of a physical shape.
        public abstract void Dereference(BSScene physicsScene);

        // Return 'true' if there is an allocated physics physical shape under this class instance.
        public virtual bool HasPhysicalShape
        {
            get
            {
                if (physShapeInfo != null)
                    return physShapeInfo.HasPhysicalShape;
                return false;
            }
        }
        public virtual BSPhysicsShapeType ShapeType
        {
            get
            {
                BSPhysicsShapeType ret = BSPhysicsShapeType.SHAPE_UNKNOWN;
                if (physShapeInfo != null && physShapeInfo.HasPhysicalShape)
                    ret = physShapeInfo.shapeType;
                return ret;
            }
        }

        // Returns a string for debugging that uniquily identifies the memory used by this instance
        public virtual string AddrString
        {
            get
            {
                if (physShapeInfo != null)
                    return physShapeInfo.AddrString;
                return "unknown";
            }
        }

        public override string ToString()
        {
            StringBuilder buff = new StringBuilder();
            if (physShapeInfo == null)
            {
                buff.Append("<noPhys");
            }
            else
            {
                buff.Append("<phy=");
                buff.Append(physShapeInfo.ToString());
            }
            buff.Append(",c=");
            buff.Append(referenceCount.ToString());
            buff.Append(">");
            return buff.ToString();
        }

        #region Common shape routines
        // Create a hash of all the shape parameters to be used as a key for this particular shape.
        public static System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod)
        {
            // level of detail based on size and type of the object
            float lod = BSParam.MeshLOD;
            if (pbs.SculptEntry)
                lod = BSParam.SculptLOD;

            // Mega prims usually get more detail because one can interact with shape approximations at this size.
            float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z));
            if (maxAxis > BSParam.MeshMegaPrimThreshold)
                lod = BSParam.MeshMegaPrimLOD;

            retLod = lod;
            return pbs.GetMeshKey(size, lod);
        }

        // The creation of a mesh or hull can fail if an underlying asset is not available.
        // There are two cases: 1) the asset is not in the cache and it needs to be fetched;
        //     and 2) the asset cannot be converted (like failed decompression of JPEG2000s).
        //     The first case causes the asset to be fetched. The second case requires
        //     us to not loop forever.
        // Called after creating a physical mesh or hull. If the physical shape was created,
        //     just return.
        public static BulletShape VerifyMeshCreated(BSScene physicsScene, BulletShape newShape, BSPhysObject prim)
        {
            // If the shape was successfully created, nothing more to do
            if (newShape.HasPhysicalShape)
                return newShape;

            // VerifyMeshCreated is called after trying to create the mesh. If we think the asset had been
            //    fetched but we end up here again, the meshing of the asset must have failed.
            // Prevent trying to keep fetching the mesh by declaring failure.
            if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
            {
                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
                physicsScene.Logger.WarnFormat("{0} Fetched asset would not mesh. prim={1}, texture={2}",
                                                LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
                physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,setFailed,prim={1},tex={2}",
                                                prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
            }
            else
            {
                // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
                if (prim.BaseShape.SculptEntry
                    && !prim.AssetFailed()
                    && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Waiting
                    && prim.BaseShape.SculptTexture != OMV.UUID.Zero
                    )
                {
                    physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAsset,objNam={1},tex={2}",
                                                prim.LocalID, prim.PhysObjectName, prim.BaseShape.SculptTexture);
                    // Multiple requestors will know we're waiting for this asset
                    prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Waiting;

                    BSPhysObject xprim = prim;
                    RequestAssetDelegate assetProvider = physicsScene.RequestAssetMethod;
                    if (assetProvider != null)
                    {
                        BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
                        assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
                        {
                            // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,assetProviderCallback", xprim.LocalID);
                            bool assetFound = false;
                            string mismatchIDs = String.Empty;  // DEBUG DEBUG
                            if (asset != null && yprim.BaseShape.SculptEntry)
                            {
                                if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
                                {
                                    yprim.BaseShape.SculptData = asset.Data;
                                    // This will cause the prim to see that the filler shape is not the right
                                    //    one and try again to build the object.
                                    // No race condition with the normal shape setting since the rebuild is at taint time.
                                    yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
                                    yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
                                    assetFound = true;
                                }
                                else
                                {
                                    mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
                                }
                            }
                            if (!assetFound)
                            {
                                yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
                            }
                            physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
                                        yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
                        });
                    }
                    else
                    {
                        xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
                        physicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
                                                    LogHeader, physicsScene.PhysicsSceneName);
                    }
                }
                else
                {
                    if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
                    {
                        physicsScene.Logger.WarnFormat("{0} Mesh failed to fetch asset. prim={1}, texture={2}",
                                                    LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
                        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailed,prim={1},tex={2}",
                                                    prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
                    }
                    if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing)
                    {
                        physicsScene.Logger.WarnFormat("{0} Mesh asset would not mesh. prim={1}, texture={2}",
                                                    LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
                        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailedMeshing,prim={1},tex={2}",
                                                    prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
                    }
                }
             }

            // While we wait for the mesh defining asset to be loaded, stick in a simple box for the object.
            BSShape fillShape = BSShapeNative.GetReference(physicsScene, prim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
            physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,boxTempShape", prim.LocalID);

            return fillShape.physShapeInfo;
         }

        public static String UsefulPrimInfo(BSScene pScene, BSPhysObject prim)
        {
            StringBuilder buff = new StringBuilder(prim.PhysObjectName);
            buff.Append("/pos=");
            buff.Append(prim.RawPosition.ToString());
            if (pScene != null)
            {
                buff.Append("/rgn=");
                buff.Append(pScene.PhysicsSceneName);
            }
            return buff.ToString();
        }

        #endregion // Common shape routines
    }

    // ============================================================================================================
    public class BSShapeNull : BSShape
    {
        public BSShapeNull() : base()
        {
        }
        public static BSShape GetReference() { return new BSShapeNull();  }
        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim) { return new BSShapeNull();  }
        public override void Dereference(BSScene physicsScene) { /* The magic of garbage collection will make this go away */ }
    }

    // ============================================================================================================
    // BSShapeNative is a wrapper for a Bullet 'native' shape -- cube and sphere.
    // They are odd in that they don't allocate meshes but are computated/procedural.
    // This means allocation and freeing is different than meshes.
    public class BSShapeNative : BSShape
    {
        private static string LogHeader = "[BULLETSIM SHAPE NATIVE]";
        public BSShapeNative(BulletShape pShape) : base(pShape)
        {
        }

        public static BSShape GetReference(BSScene physicsScene, BSPhysObject prim,
                                                BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
        {
            // Native shapes are not shared and are always built anew.
            return new BSShapeNative(CreatePhysicalNativeShape(physicsScene, prim, shapeType, shapeKey));
        }

        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
        {
            // Native shapes are not shared so we return a new shape.
            BSShape ret = null;
            lock (physShapeInfo)
            {
                ret = new BSShapeNative(CreatePhysicalNativeShape(pPhysicsScene, pPrim,
                                            physShapeInfo.shapeType, (FixedShapeKey)physShapeInfo.shapeKey));
            }
            return ret;
        }

        // Make this reference to the physical shape go away since native shapes are not shared.
        public override void Dereference(BSScene physicsScene)
        {
            // Native shapes are not tracked and are released immediately
            lock (physShapeInfo)
            {
                if (physShapeInfo.HasPhysicalShape)
                {
                    physicsScene.DetailLog("{0},BSShapeNative.Dereference,deleteNativeShape,shape={1}", BSScene.DetailLogZero, this);
                    physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
                }
                physShapeInfo.Clear();
                // Garbage collection will free up this instance.
            }
        }

        private static BulletShape CreatePhysicalNativeShape(BSScene physicsScene, BSPhysObject prim,
                                                BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
        {
            BulletShape newShape;

            ShapeData nativeShapeData = new ShapeData();
            nativeShapeData.Type = shapeType;
            nativeShapeData.ID = prim.LocalID;
            nativeShapeData.Scale = prim.Scale;
            nativeShapeData.Size = prim.Scale;
            nativeShapeData.MeshKey = (ulong)shapeKey;
            nativeShapeData.HullKey = (ulong)shapeKey;

            if (shapeType == BSPhysicsShapeType.SHAPE_CAPSULE)
            {
                newShape = physicsScene.PE.BuildCapsuleShape(physicsScene.World, 1f, 1f, prim.Scale);
                physicsScene.DetailLog("{0},BSShapeNative,capsule,scale={1}", prim.LocalID, prim.Scale);
            }
            else
            {
                newShape = physicsScene.PE.BuildNativeShape(physicsScene.World, nativeShapeData);
            }
            if (!newShape.HasPhysicalShape)
            {
                physicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}",
                                        LogHeader, prim.LocalID, shapeType);
            }
            newShape.shapeType = shapeType;
            newShape.isNativeShape = true;
            newShape.shapeKey = (UInt64)shapeKey;
            return newShape;
        }

    }

    // ============================================================================================================
    // BSShapeMesh is a simple mesh.
    public class BSShapeMesh : BSShape
    {
        private static string LogHeader = "[BULLETSIM SHAPE MESH]";
        public static Dictionary<System.UInt64, BSShapeMesh> Meshes = new Dictionary<System.UInt64, BSShapeMesh>();

        public BSShapeMesh(BulletShape pShape) : base(pShape)
        {
        }
        public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
        {
            float lod;
            System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);

            BSShapeMesh retMesh = null;
            lock (Meshes)
            {
                if (Meshes.TryGetValue(newMeshKey, out retMesh))
                {
                    // The mesh has already been created. Return a new reference to same.
                    retMesh.IncrementReference();
                }
                else
                {
                    retMesh = new BSShapeMesh(new BulletShape());
                    // An instance of this mesh has not been created. Build and remember same.
                    BulletShape newShape = retMesh.CreatePhysicalMesh(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);

                    // Check to see if mesh was created (might require an asset).
                    newShape = VerifyMeshCreated(physicsScene, newShape, prim);
                    if (!newShape.isNativeShape || prim.AssetFailed() )
                    {
                        // If a mesh was what was created, remember the built shape for later sharing.
                        // Also note that if meshing failed we put it in the mesh list as there is nothing else to do about the mesh.
                        Meshes.Add(newMeshKey, retMesh);
                    }

                    retMesh.physShapeInfo = newShape;
                }
            }
            physicsScene.DetailLog("{0},BSShapeMesh,getReference,mesh={1},size={2},lod={3}", prim.LocalID, retMesh, prim.Size, lod);
            return retMesh;
        }
        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
        {
            BSShape ret = null;
            // If the underlying shape is native, the actual shape has not been build (waiting for asset)
            //     and we must create a copy of the native shape since they are never shared.
            if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
            {
                // TODO: decide when the native shapes should be freed. Check in Dereference?
                ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
            }
            else
            {
                // Another reference to this shape is just counted.
                IncrementReference();
                ret = this;
            }
            return ret;
        }
        public override void Dereference(BSScene physicsScene)
        {
            lock (Meshes)
            {
                this.DecrementReference();
                physicsScene.DetailLog("{0},BSShapeMesh.Dereference,shape={1}", BSScene.DetailLogZero, this);
                // TODO: schedule aging and destruction of unused meshes.
            }
        }
        // Loop through all the known meshes and return the description based on the physical address.
        public static bool TryGetMeshByPtr(BulletShape pShape, out BSShapeMesh outMesh)
        {
            bool ret = false;
            BSShapeMesh foundDesc = null;
            lock (Meshes)
            {
                foreach (BSShapeMesh sm in Meshes.Values)
                {
                    if (sm.physShapeInfo.ReferenceSame(pShape))
                    {
                        foundDesc = sm;
                        ret = true;
                        break;
                    }

                }
            }
            outMesh = foundDesc;
            return ret;
        }

        public delegate BulletShape CreateShapeCall(BulletWorld world, int indicesCount, int[] indices, int verticesCount, float[] vertices );
        private BulletShape CreatePhysicalMesh(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
                                                PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
        {
            return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
                                (w, iC, i, vC, v) =>
                                {
                                    shapeInfo.Vertices = vC;
                                    return physicsScene.PE.CreateMeshShape(w, iC, i, vC, v);
                                });
        }

        // Code that uses the mesher to create the index/vertices info for a trimesh shape.
        // This is used by the passed 'makeShape' call to create the Bullet mesh shape.
        // The actual build call is passed so this logic can be used by several of the shapes that use a
        //     simple mesh as their base shape.
        public static BulletShape CreatePhysicalMeshShape(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
                                                PrimitiveBaseShape pbs, OMV.Vector3 size, float lod, CreateShapeCall makeShape)
        {
            BulletShape newShape = new BulletShape();

            IMesh meshData = null;
            lock (physicsScene.mesher)
            {
                meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod,
                                                false,  // say it is not physical so a bounding box is not built
                                                false,   // do not cache the mesh and do not use previously built versions
                                                false,
                                                false
                                                );
            }

            if (meshData != null)
            {
                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
                {
                    // Release the fetched asset data once it has been used.
                    pbs.SculptData = Array.Empty<byte>();
                    prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
                }

                int[] indices = meshData.getIndexListAsInt();
                int realIndicesIndex = indices.Length;
                float[] verticesAsFloats = meshData.getVertexListAsFloat();

                if (BSParam.ShouldRemoveZeroWidthTriangles)
                {
                    // Remove degenerate triangles. These are triangles with two of the vertices
                    //    are the same. This is complicated by the problem that vertices are not
                    //    made unique in sculpties so we have to compare the values in the vertex.
                    realIndicesIndex = 0;
                    for (int tri = 0; tri < indices.Length; tri += 3)
                    {
                        // Compute displacements into vertex array for each vertex of the triangle
                        int v1 = indices[tri + 0] * 3;
                        int v2 = indices[tri + 1] * 3;
                        int v3 = indices[tri + 2] * 3;
                    // Check to see if any two of the vertices are the same
                        if (!( (  verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0]
                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1]
                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2])
                            || (  verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0]
                               && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1]
                               && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2])
                            || (  verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0]
                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1]
                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2]) )
                        )
                        {
                            // None of the vertices of the triangles are the same. This is a good triangle;
                            indices[realIndicesIndex + 0] = indices[tri + 0];
                            indices[realIndicesIndex + 1] = indices[tri + 1];
                            indices[realIndicesIndex + 2] = indices[tri + 2];
                            realIndicesIndex += 3;
                        }
                    }
                }
                physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,key={1},origTri={2},realTri={3},numVerts={4}",
                            BSScene.DetailLogZero, newMeshKey.ToString("X"), indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3);

                if (realIndicesIndex != 0)
                {
                    newShape = makeShape(physicsScene.World, realIndicesIndex, indices, verticesAsFloats.Length / 3, verticesAsFloats);
                }
                else
                {
                    // Force the asset condition to 'failed' so we won't try to keep fetching and processing this mesh.
                    prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
                    physicsScene.Logger.DebugFormat("{0} All mesh triangles degenerate. Prim={1}", LogHeader, UsefulPrimInfo(physicsScene, prim) );
                    physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,allDegenerate,key={1}", prim.LocalID, newMeshKey);
                }
            }
            newShape.shapeKey = newMeshKey;

            return newShape;
        }
    }

    // ============================================================================================================
    // BSShapeHull is a physical shape representation htat is made up of many convex hulls.
    // The convex hulls are either supplied with the asset or are approximated by one of the
    //     convex hull creation routines (in OpenSim or in Bullet).
    public class BSShapeHull : BSShape
    {
    #pragma warning disable 414
        private static string LogHeader = "[BULLETSIM SHAPE HULL]";
    #pragma warning restore 414

        public static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>();


        public BSShapeHull(BulletShape pShape) : base(pShape)
        {
        }
        public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
        {
            float lod;
            System.UInt64 newHullKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);

            BSShapeHull retHull = null;
            lock (Hulls)
            {
                if (Hulls.TryGetValue(newHullKey, out retHull))
                {
                    // The mesh has already been created. Return a new reference to same.
                    retHull.IncrementReference();
                }
                else
                {
                    retHull = new BSShapeHull(new BulletShape());
                    // An instance of this mesh has not been created. Build and remember same.
                    BulletShape newShape = retHull.CreatePhysicalHull(physicsScene, prim, newHullKey, prim.BaseShape, prim.Size, lod);

                    // Check to see if hull was created (might require an asset).
                    newShape = VerifyMeshCreated(physicsScene, newShape, prim);
                    if (!newShape.isNativeShape || prim.AssetFailed())
                    {
                        // If a mesh was what was created, remember the built shape for later sharing.
                        Hulls.Add(newHullKey, retHull);
                    }
                    retHull.physShapeInfo = newShape;
                }
            }
            physicsScene.DetailLog("{0},BSShapeHull,getReference,hull={1},size={2},lod={3}", prim.LocalID, retHull, prim.Size, lod);
            return retHull;
        }
        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
        {
            BSShape ret = null;
            // If the underlying shape is native, the actual shape has not been build (waiting for asset)
            //     and we must create a copy of the native shape since they are never shared.
            if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
            {
                // TODO: decide when the native shapes should be freed. Check in Dereference?
                ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
            }
            else
            {
                // Another reference to this shape is just counted.
                IncrementReference();
                ret = this;
            }
            return ret;
        }
        public override void Dereference(BSScene physicsScene)
        {
            lock (Hulls)
            {
                this.DecrementReference();
                physicsScene.DetailLog("{0},BSShapeHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
                // TODO: schedule aging and destruction of unused meshes.
            }
        }

        List<ConvexResult> m_hulls;
        private BulletShape CreatePhysicalHull(BSScene physicsScene, BSPhysObject prim, System.UInt64 newHullKey,
                                                PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
        {
            BulletShape newShape = new BulletShape();

            IMesh meshData = null;
            List<List<OMV.Vector3>> allHulls = null;
            lock (physicsScene.mesher)
            {
                // Pass true for physicalness as this prevents the creation of bounding box which is not needed
                meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod, true /* isPhysical */, false /* shouldCache */, false, false);

                // If we should use the asset's hull info, fetch it out of the locked mesher
                if (meshData != null && BSParam.ShouldUseAssetHulls)
                {
                    Meshmerizer realMesher = physicsScene.mesher as Meshmerizer;
                    if (realMesher != null)
                    {
                        allHulls = realMesher.GetConvexHulls(size);
                    }
                    if (allHulls == null)
                    {
                        physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,noAssetHull", prim.LocalID);
                    }
                }
            }

            // If there is hull data in the mesh asset, build the hull from that
            if (allHulls != null && BSParam.ShouldUseAssetHulls)
            {
                int hullCount = allHulls.Count;
                shapeInfo.HullCount = hullCount;
                int totalVertices = 1;      // include one for the count of the hulls
                // Using the structure described for HACD hulls, create the memory sturcture
                //     to pass the hull data to the creater.
                foreach (List<OMV.Vector3> hullVerts in allHulls)
                {
                    totalVertices += 4;                     // add four for the vertex count and centroid
                    totalVertices += hullVerts.Count * 3;   // one vertex is three dimensions
                }
                float[] convHulls = new float[totalVertices];

                convHulls[0] = (float)hullCount;
                int jj = 1;
                int hullIndex = 0;
                foreach (List<OMV.Vector3> hullVerts in allHulls)
                {
                    convHulls[jj + 0] = hullVerts.Count;
                    convHulls[jj + 1] = 0f;   // centroid x,y,z
                    convHulls[jj + 2] = 0f;
                    convHulls[jj + 3] = 0f;
                    jj += 4;
                    foreach (OMV.Vector3 oneVert in hullVerts)
                    {
                        convHulls[jj + 0] = oneVert.X;
                        convHulls[jj + 1] = oneVert.Y;
                        convHulls[jj + 2] = oneVert.Z;
                        jj += 3;
                    }
                    shapeInfo.SetVerticesPerHull(hullIndex, hullVerts.Count);
                    hullIndex++;
                }

                // create the hull data structure in Bullet
                newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);

                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,hulls={1},totVert={2},shape={3}",
                                            prim.LocalID, hullCount, totalVertices, newShape);
            }

            // If no hull specified in the asset and we should use Bullet's HACD approximation...
            if (!newShape.HasPhysicalShape && BSParam.ShouldUseBulletHACD)
            {
                // Build the hull shape from an existing mesh shape.
                // The mesh should have already been created in Bullet.
                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,entry", prim.LocalID);
                BSShape meshShape = BSShapeMesh.GetReference(physicsScene, true, prim);

                if (meshShape.physShapeInfo.HasPhysicalShape)
                {
                    HACDParams parms = new HACDParams();
                    parms.maxVerticesPerHull = BSParam.BHullMaxVerticesPerHull;
                    parms.minClusters = BSParam.BHullMinClusters;
                    parms.compacityWeight = BSParam.BHullCompacityWeight;
                    parms.volumeWeight = BSParam.BHullVolumeWeight;
                    parms.concavity = BSParam.BHullConcavity;
                    parms.addExtraDistPoints = BSParam.NumericBool(BSParam.BHullAddExtraDistPoints);
                    parms.addNeighboursDistPoints = BSParam.NumericBool(BSParam.BHullAddNeighboursDistPoints);
                    parms.addFacesPoints = BSParam.NumericBool(BSParam.BHullAddFacesPoints);
                    parms.shouldAdjustCollisionMargin = BSParam.NumericBool(BSParam.BHullShouldAdjustCollisionMargin);
                    parms.whichHACD = 0;    // Use the HACD routine that comes with Bullet

                    physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,beforeCall", prim.LocalID, newShape.HasPhysicalShape);
                    newShape = physicsScene.PE.BuildHullShapeFromMesh(physicsScene.World, meshShape.physShapeInfo, parms);
                    physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,shape={1}", prim.LocalID, newShape);

                    // Now done with the mesh shape.
                    shapeInfo.HullCount = 1;
                    BSShapeMesh maybeMesh = meshShape as BSShapeMesh;
                    if (maybeMesh != null)
                        shapeInfo.SetVerticesPerHull(0, maybeMesh.shapeInfo.Vertices);
                    meshShape.Dereference(physicsScene);
                }
                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,exit,hasBody={1}", prim.LocalID, newShape.HasPhysicalShape);
            }

            // If no other hull specifications, use our HACD hull approximation.
            if (!newShape.HasPhysicalShape && meshData != null)
            {
                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
                {
                    // Release the fetched asset data once it has been used.
                    pbs.SculptData = Array.Empty<byte>();
                    prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
                }

                int[] indices = meshData.getIndexListAsInt();
                List<OMV.Vector3> vertices = meshData.getVertexList();

                //format conversion from IMesh format to DecompDesc format
                List<int> convIndices = new List<int>();
                List<float3> convVertices = new List<float3>();
                for (int ii = 0; ii < indices.GetLength(0); ii++)
                {
                    convIndices.Add(indices[ii]);
                }
                foreach (OMV.Vector3 vv in vertices)
                {
                    convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
                }

                uint maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplit;
                if (BSParam.CSHullMaxDepthSplit != BSParam.CSHullMaxDepthSplitForSimpleShapes)
                {
                    // Simple primitive shapes we know are convex so they are better implemented with
                    //    fewer hulls.
                    // Check for simple shape (prim without cuts) and reduce split parameter if so.
                    if (BSShapeCollection.PrimHasNoCuts(pbs))
                    {
                        maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplitForSimpleShapes;
                    }
                }

                // setup and do convex hull conversion
                m_hulls = new List<ConvexResult>();
                DecompDesc dcomp = new DecompDesc();
                dcomp.mIndices = convIndices;
                dcomp.mVertices = convVertices;
                dcomp.mDepth = maxDepthSplit;
                dcomp.mCpercent = BSParam.CSHullConcavityThresholdPercent;
                dcomp.mPpercent = BSParam.CSHullVolumeConservationThresholdPercent;
                dcomp.mMaxVertices = (uint)BSParam.CSHullMaxVertices;
                dcomp.mSkinWidth = BSParam.CSHullMaxSkinWidth;
                ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
                // create the hull into the _hulls variable
                convexBuilder.process(dcomp);

                physicsScene.DetailLog("{0},BSShapeCollection.CreatePhysicalHull,key={1},inVert={2},inInd={3},split={4},hulls={5}",
                                    BSScene.DetailLogZero, newHullKey, indices.GetLength(0), vertices.Count, maxDepthSplit, m_hulls.Count);

                // Convert the vertices and indices for passing to unmanaged.
                // The hull information is passed as a large floating point array.
                // The format is:
                //  convHulls[0] = number of hulls
                //  convHulls[1] = number of vertices in first hull
                //  convHulls[2] = hull centroid X coordinate
                //  convHulls[3] = hull centroid Y coordinate
                //  convHulls[4] = hull centroid Z coordinate
                //  convHulls[5] = first hull vertex X
                //  convHulls[6] = first hull vertex Y
                //  convHulls[7] = first hull vertex Z
                //  convHulls[8] = second hull vertex X
                //  ...
                //  convHulls[n] = number of vertices in second hull
                //  convHulls[n+1] = second hull centroid X coordinate
                //  ...
                //
                // TODO: is is very inefficient. Someday change the convex hull generator to return
                //   data structures that do not need to be converted in order to pass to Bullet.
                //   And maybe put the values directly into pinned memory rather than marshaling.
                int hullCount = m_hulls.Count;
                int totalVertices = 1;          // include one for the count of the hulls
                foreach (ConvexResult cr in m_hulls)
                {
                    totalVertices += 4;                         // add four for the vertex count and centroid
                    totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
                }
                float[] convHulls = new float[totalVertices];

                convHulls[0] = (float)hullCount;
                int jj = 1;
                foreach (ConvexResult cr in m_hulls)
                {
                    // copy vertices for index access
                    float3[] verts = new float3[cr.HullVertices.Count];
                    int kk = 0;
                    foreach (float3 ff in cr.HullVertices)
                    {
                        verts[kk++] = ff;
                    }

                    // add to the array one hull's worth of data
                    convHulls[jj++] = cr.HullIndices.Count;
                    convHulls[jj++] = 0f;   // centroid x,y,z
                    convHulls[jj++] = 0f;
                    convHulls[jj++] = 0f;
                    foreach (int ind in cr.HullIndices)
                    {
                        convHulls[jj++] = verts[ind].x;
                        convHulls[jj++] = verts[ind].y;
                        convHulls[jj++] = verts[ind].z;
                    }
                }
                // create the hull data structure in Bullet
                newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);
            }
            newShape.shapeKey = newHullKey;
            return newShape;
        }
        // Callback from convex hull creater with a newly created hull.
        // Just add it to our collection of hulls for this shape.
        private void HullReturn(ConvexResult result)
        {
            m_hulls.Add(result);
            return;
        }
        // Loop through all the known hulls and return the description based on the physical address.
        public static bool TryGetHullByPtr(BulletShape pShape, out BSShapeHull outHull)
        {
            bool ret = false;
            BSShapeHull foundDesc = null;
            lock (Hulls)
            {
                foreach (BSShapeHull sh in Hulls.Values)
                {
                    if (sh.physShapeInfo.ReferenceSame(pShape))
                    {
                        foundDesc = sh;
                        ret = true;
                        break;
                    }

                }
            }
            outHull = foundDesc;
            return ret;
        }
    }

    // ============================================================================================================
    // BSShapeCompound is a wrapper for the Bullet compound shape which is built from multiple, separate
    //    meshes. Used by BulletSim for complex shapes like linksets.
    public class BSShapeCompound : BSShape
    {
        private static string LogHeader = "[BULLETSIM SHAPE COMPOUND]";
        public static Dictionary<string, BSShapeCompound> CompoundShapes = new Dictionary<string, BSShapeCompound>();

        public BSShapeCompound(BulletShape pShape) : base(pShape)
        {
        }
        public static BSShape GetReference(BSScene physicsScene)
        {
            // Base compound shapes are not shared so this returns a raw shape.
            // A built compound shape can be reused in linksets.
            BSShapeCompound ret = new BSShapeCompound(CreatePhysicalCompoundShape(physicsScene));
            CompoundShapes.Add(ret.AddrString, ret);
            return ret;
        }
        public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
        {
            // Calling this reference means we want another handle to an existing compound shape
            //     (usually linksets) so return this copy.
            IncrementReference();
            return this;
        }
        // Dereferencing a compound shape releases the hold on all the child shapes.
        public override void Dereference(BSScene physicsScene)
        {
            lock (physShapeInfo)
            {
                this.DecrementReference();
                physicsScene.DetailLog("{0},BSShapeCompound.Dereference,shape={1}", BSScene.DetailLogZero, this);
                if (referenceCount <= 0)
                {
                    if (!physicsScene.PE.IsCompound(physShapeInfo))
                    {
                        // Failed the sanity check!!
                        physicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}",
                                                    LogHeader, physShapeInfo.shapeType, physShapeInfo.AddrString);
                        physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}",
                                                    BSScene.DetailLogZero, physShapeInfo.shapeType, physShapeInfo.AddrString);
                        return;
                    }

                    int numChildren = physicsScene.PE.GetNumberOfCompoundChildren(physShapeInfo);
                    physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}",
                                            BSScene.DetailLogZero, physShapeInfo, numChildren);

                    // Loop through all the children dereferencing each.
                    for (int ii = numChildren - 1; ii >= 0; ii--)
                    {
                        BulletShape childShape = physicsScene.PE.RemoveChildShapeFromCompoundShapeIndex(physShapeInfo, ii);
                        DereferenceAnonCollisionShape(physicsScene, childShape);
                    }

                    lock (CompoundShapes)
                        CompoundShapes.Remove(physShapeInfo.AddrString);
                    physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
                }
            }
        }
        public static bool TryGetCompoundByPtr(BulletShape pShape, out BSShapeCompound outCompound)
        {
            lock (CompoundShapes)
            {
                string addr = pShape.AddrString;
                return CompoundShapes.TryGetValue(addr, out outCompound);
            }
        }
        private static BulletShape CreatePhysicalCompoundShape(BSScene physicsScene)
        {
            BulletShape cShape = physicsScene.PE.CreateCompoundShape(physicsScene.World, false);
            return cShape;
        }
        // Sometimes we have a pointer to a collision shape but don't know what type it is.
        // Figure out type and call the correct dereference routine.
        // Called at taint-time.
        private void DereferenceAnonCollisionShape(BSScene physicsScene, BulletShape pShape)
        {
            // TODO: figure a better way to go through all the shape types and find a possible instance.
            physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,shape={1}",
                                                BSScene.DetailLogZero, pShape);
            BSShapeMesh meshDesc;
            if (BSShapeMesh.TryGetMeshByPtr(pShape, out meshDesc))
            {
                meshDesc.Dereference(physicsScene);
                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundMesh,shape={1}", BSScene.DetailLogZero, pShape);
            }
            else
            {
                BSShapeHull hullDesc;
                if (BSShapeHull.TryGetHullByPtr(pShape, out hullDesc))
                {
                    hullDesc.Dereference(physicsScene);
                    // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundHull,shape={1}", BSScene.DetailLogZero, pShape);
                }
                else
                {
                    BSShapeConvexHull chullDesc;
                    if (BSShapeConvexHull.TryGetConvexHullByPtr(pShape, out chullDesc))
                    {
                        chullDesc.Dereference(physicsScene);
                        // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundConvexHull,shape={1}", BSScene.DetailLogZero, pShape);
                    }
                    else
                    {
                        BSShapeGImpact gImpactDesc;
                        if (BSShapeGImpact.TryGetGImpactByPtr(pShape, out gImpactDesc))
                        {
                            gImpactDesc.Dereference(physicsScene);
                            // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundgImpact,shape={1}", BSScene.DetailLogZero, pShape);
                        }
                        else
                        {
                            // Didn't find it in the lists of specific types. It could be compound.
                            BSShapeCompound compoundDesc;
                            if (BSShapeCompound.TryGetCompoundByPtr(pShape, out compoundDesc))
                            {
                                compoundDesc.Dereference(physicsScene);
                                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,recursiveCompoundShape,shape={1}", BSScene.DetailLogZero, pShape);
                            }
                            else
                            {
                                // If none of the above, maybe it is a simple native shape.
                                if (physicsScene.PE.IsNativeShape(pShape))
                                {
                                    // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,assumingNative,shape={1}", BSScene.DetailLogZero, pShape);
                                    BSShapeNative nativeShape = new BSShapeNative(pShape);
                                    nativeShape.Dereference(physicsScene);
                                }
                                else
                                {
                                    physicsScene.Logger.WarnFormat("{0} DereferenceAnonCollisionShape. Did not find shape. {1}",
                                        LogHeader, pShape);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    // ============================================================================================================
    // BSShapeConvexHull is a wrapper for a Bullet single convex hull. A BSShapeHull contains multiple convex
    //     hull shapes. This is used for simple prims that are convex and thus can be made into a simple
    //     collision shape (a single hull). More complex physical shapes will be BSShapeHull's.
    public class BSShapeConvexHull : BSShape
    {
    #pragma warning disable 414
        private static string LogHeader = "[BULLETSIM SHAPE CONVEX HULL]";
    #pragma warning restore 414

        public static Dictionary<System.UInt64, BSShapeConvexHull> ConvexHulls = new Dictionary<System.UInt64, BSShapeConvexHull>();

        public BSShapeConvexHull(BulletShape pShape) : base(pShape)
        {
        }
        public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
        {
            float lod;
            System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);

            physicsScene.DetailLog("{0},BSShapeConvexHull,getReference,newKey={1},size={2},lod={3}",
                                    prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);

            BSShapeConvexHull retConvexHull = null;
            lock (ConvexHulls)
            {
                if (ConvexHulls.TryGetValue(newMeshKey, out retConvexHull))
                {
                    // The mesh has already been created. Return a new reference to same.
                    retConvexHull.IncrementReference();
                }
                else
                {
                    retConvexHull = new BSShapeConvexHull(new BulletShape());
                    BulletShape convexShape = null;

                    // Get a handle to a mesh to build the hull from
                    BSShape baseMesh = BSShapeMesh.GetReference(physicsScene, false /* forceRebuild */, prim);
                    if (baseMesh.physShapeInfo.isNativeShape)
                    {
                        // We get here if the mesh was not creatable. Could be waiting for an asset from the disk.
                        // In the short term, we return the native shape and a later ForceBodyShapeRebuild should
                        //     get back to this code with a buildable mesh.
                        // TODO: not sure the temp native shape is freed when the mesh is rebuilt. When does this get freed?
                        convexShape = baseMesh.physShapeInfo;
                    }
                    else
                    {
                        convexShape = physicsScene.PE.BuildConvexHullShapeFromMesh(physicsScene.World, baseMesh.physShapeInfo);
                        convexShape.shapeKey = newMeshKey;
                        ConvexHulls.Add(convexShape.shapeKey, retConvexHull);
                        physicsScene.DetailLog("{0},BSShapeConvexHull.GetReference,addingNewlyCreatedShape,shape={1}",
                                            BSScene.DetailLogZero, convexShape);
                    }

                    // Done with the base mesh
                    baseMesh.Dereference(physicsScene);

                    retConvexHull.physShapeInfo = convexShape;
                }
            }
            return retConvexHull;
        }
        public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
        {
            // Calling this reference means we want another handle to an existing shape
            //     (usually linksets) so return this copy.
            IncrementReference();
            return this;
        }
        // Dereferencing a compound shape releases the hold on all the child shapes.
        public override void Dereference(BSScene physicsScene)
        {
            lock (ConvexHulls)
            {
                this.DecrementReference();
                physicsScene.DetailLog("{0},BSShapeConvexHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
                // TODO: schedule aging and destruction of unused meshes.
            }
        }
        // Loop through all the known hulls and return the description based on the physical address.
        public static bool TryGetConvexHullByPtr(BulletShape pShape, out BSShapeConvexHull outHull)
        {
            bool ret = false;
            BSShapeConvexHull foundDesc = null;
            lock (ConvexHulls)
            {
                foreach (BSShapeConvexHull sh in ConvexHulls.Values)
                {
                    if (sh.physShapeInfo.ReferenceSame(pShape))
                    {
                        foundDesc = sh;
                        ret = true;
                        break;
                    }

                }
            }
            outHull = foundDesc;
            return ret;
        }
    }
    // ============================================================================================================
    // BSShapeGImpact is a wrapper for the Bullet GImpact shape which is a collision mesh shape that
    //     can handle concave as well as convex shapes. Much slower computationally but creates smoother
    //     shapes than multiple convex hull approximations.
    public class BSShapeGImpact : BSShape
    {
    #pragma warning disable 414
        private static string LogHeader = "[BULLETSIM SHAPE GIMPACT]";
    #pragma warning restore 414

        public static Dictionary<System.UInt64, BSShapeGImpact> GImpacts = new Dictionary<System.UInt64, BSShapeGImpact>();

        public BSShapeGImpact(BulletShape pShape) : base(pShape)
        {
        }
        public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
        {
            float lod;
            System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);

            physicsScene.DetailLog("{0},BSShapeGImpact,getReference,newKey={1},size={2},lod={3}",
                                    prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);

            BSShapeGImpact retGImpact = null;
            lock (GImpacts)
            {
                if (GImpacts.TryGetValue(newMeshKey, out retGImpact))
                {
                    // The mesh has already been created. Return a new reference to same.
                    retGImpact.IncrementReference();
                }
                else
                {
                    retGImpact = new BSShapeGImpact(new BulletShape());
                    BulletShape newShape = retGImpact.CreatePhysicalGImpact(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);

                    // Check to see if mesh was created (might require an asset).
                    newShape = VerifyMeshCreated(physicsScene, newShape, prim);
                    newShape.shapeKey = newMeshKey;
                    if (!newShape.isNativeShape || prim.AssetFailed())
                    {
                        // If a mesh was what was created, remember the built shape for later sharing.
                        // Also note that if meshing failed we put it in the mesh list as there is nothing
                        //         else to do about the mesh.
                        GImpacts.Add(newMeshKey, retGImpact);
                    }

                    retGImpact.physShapeInfo = newShape;
                }
            }
            return retGImpact;
        }

        private BulletShape CreatePhysicalGImpact(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
                                                PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
        {
            return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
                                (w, iC, i, vC, v) =>
                                {
                                    shapeInfo.Vertices = vC;
                                    return physicsScene.PE.CreateGImpactShape(w, iC, i, vC, v);
                                });
        }

        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
        {
            BSShape ret = null;
            // If the underlying shape is native, the actual shape has not been build (waiting for asset)
            //     and we must create a copy of the native shape since they are never shared.
            if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
            {
                // TODO: decide when the native shapes should be freed. Check in Dereference?
                ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
            }
            else
            {
                // Another reference to this shape is just counted.
                IncrementReference();
                ret = this;
            }
            return ret;
        }
        // Dereferencing a compound shape releases the hold on all the child shapes.
        public override void Dereference(BSScene physicsScene)
        {
            lock (GImpacts)
            {
                this.DecrementReference();
                physicsScene.DetailLog("{0},BSShapeGImpact.Dereference,shape={1}", BSScene.DetailLogZero, this);
                // TODO: schedule aging and destruction of unused meshes.
            }
        }
        // Loop through all the known hulls and return the description based on the physical address.
        public static bool TryGetGImpactByPtr(BulletShape pShape, out BSShapeGImpact outHull)
        {
            bool ret = false;
            BSShapeGImpact foundDesc = null;
            lock (GImpacts)
            {
                foreach (BSShapeGImpact sh in GImpacts.Values)
                {
                    if (sh.physShapeInfo.ReferenceSame(pShape))
                    {
                        foundDesc = sh;
                        ret = true;
                        break;
                    }

                }
            }
            outHull = foundDesc;
            return ret;
        }
    }

    // ============================================================================================================
    // BSShapeAvatar is a specialized mesh shape for avatars.
    public class BSShapeAvatar : BSShape
    {
    #pragma warning disable 414
        private static string LogHeader = "[BULLETSIM SHAPE AVATAR]";
    #pragma warning restore 414

        public BSShapeAvatar()
            : base()
        {
        }
        public static BSShape GetReference(BSPhysObject prim)
        {
            return new BSShapeNull();
        }
        public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
        {
            return new BSShapeNull();
        }
        public override void Dereference(BSScene physicsScene) { }

        // From the front:
        //     A---A
        //    /     \
        //   B-------B
        //  /         \        +Z
        // C-----------C        |
        // \           /   -Y --+-- +Y
        //  \         /         |
        //   \       /         -Z
        //    D-----D
        //     \   /
        //      E-E

        // From the top A and E are just lines.
        //              B, C and D are hexagons:
        //
        //     C1--C2            +X
        //    /      \            |
        //  C0        C3     -Y --+-- +Y
        //    \      /            |
        //     C5--C4            -X

        // Zero goes directly through the middle so the offsets are from that middle axis
        //     and up and down from a middle horizon (A and E are the same distance from the zero).
        // The height, width and depth is one. All scaling is done by the simulator.

        // Z component -- how far the level is from the middle zero
        private const float Aup = 0.5f;
        private const float Bup = 0.4f;
        private const float Cup = 0.3f;
        private const float Dup = -0.4f;
        private const float Eup = -0.5f;

        // Y component -- distance from center to x0 and x3
        private const float Awid = 0.25f;
        private const float Bwid = 0.3f;
        private const float Cwid = 0.5f;
        private const float Dwid = 0.3f;
        private const float Ewid = 0.2f;

        // Y component -- distance from center to x1, x2, x4 and x5
        private const float Afwid = 0.0f;
        private const float Bfwid = 0.2f;
        private const float Cfwid = 0.4f;
        private const float Dfwid = 0.2f;
        private const float Efwid = 0.0f;

        // X component -- distance from zero to the front or back of a level
        private const float Adep = 0f;
        private const float Bdep = 0.3f;
        private const float Cdep = 0.5f;
        private const float Ddep = 0.2f;
        private const float Edep = 0f;

        private OMV.Vector3[] avatarVertices = {
               new OMV.Vector3( 0.0f, -Awid,  Aup),   // A0
               new OMV.Vector3( 0.0f, +Awid,  Aup),   // A3

               new OMV.Vector3( 0.0f, -Bwid,  Bup),   // B0
               new OMV.Vector3(+Bdep, -Bfwid, Bup),   // B1
               new OMV.Vector3(+Bdep, +Bfwid, Bup),   // B2
               new OMV.Vector3( 0.0f, +Bwid,  Bup),   // B3
               new OMV.Vector3(-Bdep, +Bfwid, Bup),   // B4
               new OMV.Vector3(-Bdep, -Bfwid, Bup),   // B5

               new OMV.Vector3( 0.0f, -Cwid,  Cup),   // C0
               new OMV.Vector3(+Cdep, -Cfwid, Cup),   // C1
               new OMV.Vector3(+Cdep, +Cfwid, Cup),   // C2
               new OMV.Vector3( 0.0f, +Cwid,  Cup),   // C3
               new OMV.Vector3(-Cdep, +Cfwid, Cup),   // C4
               new OMV.Vector3(-Cdep, -Cfwid, Cup),   // C5

               new OMV.Vector3( 0.0f, -Dwid,  Dup),   // D0
               new OMV.Vector3(+Ddep, -Dfwid, Dup),   // D1
               new OMV.Vector3(+Ddep, +Dfwid, Dup),   // D2
               new OMV.Vector3( 0.0f, +Dwid,  Dup),   // D3
               new OMV.Vector3(-Ddep, +Dfwid, Dup),   // D4
               new OMV.Vector3(-Ddep, -Dfwid, Dup),   // D5

               new OMV.Vector3( 0.0f, -Ewid,  Eup),   // E0
               new OMV.Vector3( 0.0f, +Ewid,  Eup),   // E3
        };

        // Offsets of the vertices in the vertices array
        private enum Ind : int
        {
            A0, A3,
            B0, B1, B2, B3, B4, B5,
            C0, C1, C2, C3, C4, C5,
            D0, D1, D2, D3, D4, D5,
            E0, E3
        }

        // Comments specify trianges and quads in clockwise direction
        private Ind[] avatarIndices = {
            Ind.A0, Ind.B0, Ind.B1,                         // A0,B0,B1
            Ind.A0, Ind.B1, Ind.B2, Ind.B2, Ind.A3, Ind.A0, // A0,B1,B2,A3
            Ind.A3, Ind.B2, Ind.B3,                         // A3,B2,B3
            Ind.A3, Ind.B3, Ind.B4,                         // A3,B3,B4
            Ind.A3, Ind.B4, Ind.B5, Ind.B5, Ind.A0, Ind.A3, // A3,B4,B5,A0
            Ind.A0, Ind.B5, Ind.B0,                         // A0,B5,B0

            Ind.B0, Ind.C0, Ind.C1, Ind.C1, Ind.B1, Ind.B0, // B0,C0,C1,B1
            Ind.B1, Ind.C1, Ind.C2, Ind.C2, Ind.B2, Ind.B1, // B1,C1,C2,B2
            Ind.B2, Ind.C2, Ind.C3, Ind.C3, Ind.B3, Ind.B2, // B2,C2,C3,B3
            Ind.B3, Ind.C3, Ind.C4, Ind.C4, Ind.B4, Ind.B3, // B3,C3,C4,B4
            Ind.B4, Ind.C4, Ind.C5, Ind.C5, Ind.B5, Ind.B4, // B4,C4,C5,B5
            Ind.B5, Ind.C5, Ind.C0, Ind.C0, Ind.B0, Ind.B5, // B5,C5,C0,B0

            Ind.C0, Ind.D0, Ind.D1, Ind.D1, Ind.C1, Ind.C0, // C0,D0,D1,C1
            Ind.C1, Ind.D1, Ind.D2, Ind.D2, Ind.C2, Ind.C1, // C1,D1,D2,C2
            Ind.C2, Ind.D2, Ind.D3, Ind.D3, Ind.C3, Ind.C2, // C2,D2,D3,C3
            Ind.C3, Ind.D3, Ind.D4, Ind.D4, Ind.C4, Ind.C3, // C3,D3,D4,C4
            Ind.C4, Ind.D4, Ind.D5, Ind.D5, Ind.C5, Ind.C4, // C4,D4,D5,C5
            Ind.C5, Ind.D5, Ind.D0, Ind.D0, Ind.C0, Ind.C5, // C5,D5,D0,C0

            Ind.E0, Ind.D0, Ind.D1,                         // E0,D0,D1
            Ind.E0, Ind.D1, Ind.D2, Ind.D2, Ind.E3, Ind.E0, // E0,D1,D2,E3
            Ind.E3, Ind.D2, Ind.D3,                         // E3,D2,D3
            Ind.E3, Ind.D3, Ind.D4,                         // E3,D3,D4
            Ind.E3, Ind.D4, Ind.D5, Ind.D5, Ind.E0, Ind.E3, // E3,D4,D5,E0
            Ind.E0, Ind.D5, Ind.D0,                         // E0,D5,D0

        };
    }
}