bool ISimulationDataPhysicsConvexStorageInterface.TryGetValue(ObjectPart.PrimitiveShape primShape, out PhysicsConvexShape shape)
        {
            using (var conn = new NpgsqlConnection(m_ConnectionString))
            {
                conn.Open();
                using (var cmd = new NpgsqlCommand("SELECT \"ConvexData\" FROM primphysics WHERE \"ShapeKey\"=@id LIMIT 1", conn))
                {
                    cmd.Parameters.AddParameter("@id", primShape.Serialization);
                    using (NpgsqlDataReader dbReader = cmd.ExecuteReader())
                    {
                        if (dbReader.Read())
                        {
                            shape = new PhysicsConvexShape
                            {
                                SerializedData = dbReader.GetBytes("ConvexData")
                            };
                            return(true);
                        }
                    }
                }
            }

            shape = null;
            return(false);
        }
        public bool Run()
        {
            PhysicsShapeReference physicsShapeRef;

            DumpParams(m_Shape);
            ObjectPart.PrimitiveShape ps = new ObjectPart.PrimitiveShape
            {
                DecodedParams = m_Shape
            };
            m_Log.Info("---- Transformed to physics shape manager accepted format ----");
            m_Log.InfoFormat("PhysicsShapeType: {0}", m_PhysicsShapeType);
            DumpParams(ps.DecodedParams);
            if (!m_PhysicsShapeManager.TryGetConvexShape(m_PhysicsShapeType, ps, out physicsShapeRef))
            {
                m_Log.Error("Could not generate physics hull shape");
                return(false);
            }

            PhysicsConvexShape convexShape = physicsShapeRef;

            int hullidx = 0;

            foreach (PhysicsConvexShape.ConvexHull hull in convexShape.Hulls)
            {
                m_Log.InfoFormat("Hull {0}: Generated vertices: {1}", hullidx, hull.Vertices.Count);
                m_Log.InfoFormat("Hull {0}: Generated triangles: {1}", hullidx, hull.Triangles.Count / 3);
                ++hullidx;
            }
            m_Log.InfoFormat("Generated hulls: {0}", hullidx);

            /* write a blender .raw */
            ((PhysicsConvexShape)physicsShapeRef).DumpToBlenderRaw(m_OutputFileName);
            return(true);
        }
        bool ISimulationDataPhysicsConvexStorageInterface.TryGetValue(UUID meshid, PrimitivePhysicsShapeType physicsShape, out PhysicsConvexShape shape)
        {
            using (var conn = new NpgsqlConnection(m_ConnectionString))
            {
                conn.Open();
                using (var cmd = new NpgsqlCommand("SELECT \"ConvexData\" FROM meshphysics WHERE \"MeshID\"=@id AND \"PhysicsShape\"=@stype LIMIT 1", conn))
                {
                    cmd.Parameters.AddParameter("@id", meshid);
                    cmd.Parameters.AddParameter("@stype", physicsShape);
                    using (NpgsqlDataReader dbReader = cmd.ExecuteReader())
                    {
                        if (dbReader.Read())
                        {
                            shape = new PhysicsConvexShape
                            {
                                SerializedData = dbReader.GetBytes("ConvexData")
                            };
                            return(true);
                        }
                    }
                }
            }

            shape = null;
            return(false);
        }
예제 #4
0
 internal void DecrementUseCount(ObjectPart.PrimitiveShape primshape, PhysicsConvexShape shape)
 {
     if (0 == Interlocked.Decrement(ref shape.UseCount))
     {
         m_Lock.AcquireWriterLock(() => m_ConvexShapesByPrimShape.RemoveIf(primshape, (PhysicsConvexShape s) => s.UseCount == 0));
     }
 }
        public override bool Run()
        {
            ISimulationDataPhysicsConvexStorageInterface m_PhysicsStorage = SimulationData.PhysicsConvexShapes;
            var shape = new PhysicsConvexShape();
            var hull  = new PhysicsConvexShape.ConvexHull();

            hull.Vertices.Add(Vector3.UnitX);
            hull.Vertices.Add(Vector3.UnitY);
            hull.Vertices.Add(Vector3.UnitZ);
            hull.Triangles.Add(0);
            hull.Triangles.Add(1);
            hull.Triangles.Add(2);
            shape.Hulls.Add(hull);
            var shapeKey = new ObjectPart.PrimitiveShape();
            PhysicsConvexShape test;

            m_Log.Info("Testing non-existence 1");
            if (m_PhysicsStorage.ContainsKey(shapeKey))
            {
                return(false);
            }
            m_Log.Info("Testing non-existence 2");
            if (m_PhysicsStorage.TryGetValue(shapeKey, out test))
            {
                return(false);
            }
            m_Log.Info("Testing non-existence 3");
            try
            {
                shape = m_PhysicsStorage[shapeKey];
                return(false);
            }
            catch (KeyNotFoundException)
            {
                /* we should see this one */
            }
            m_Log.Info("Testing non-existence 4");
            if (m_PhysicsStorage.Remove(shapeKey))
            {
                return(false);
            }

            m_Log.Info("Create physics convex shape");
            m_PhysicsStorage[shapeKey] = shape;

            m_Log.Info("Testing existence 1");
            if (!m_PhysicsStorage.ContainsKey(shapeKey))
            {
                return(false);
            }
            m_Log.Info("Testing existence 2");
            if (!m_PhysicsStorage.TryGetValue(shapeKey, out test))
            {
                return(false);
            }
            m_Log.Info("Testing equality");
            if (!test.SerializedData.SequenceEqual(shape.SerializedData))
            {
                return(false);
            }
            m_Log.Info("Testing existence 3");
            shape = m_PhysicsStorage[shapeKey];
            m_Log.Info("Testing equality");
            if (!test.SerializedData.SequenceEqual(shape.SerializedData))
            {
                return(false);
            }
            m_Log.Info("Testing existence 4");
            if (!m_PhysicsStorage.Remove(shapeKey))
            {
                return(false);
            }

            return(true);
        }
        public bool Run()
        {
            PhysicsShapeReference physicsShapeRef;
            bool success = true;

            foreach (PrimitiveShapeType shapeType in new PrimitiveShapeType[] { PrimitiveShapeType.Box, PrimitiveShapeType.Cylinder, PrimitiveShapeType.Prism, PrimitiveShapeType.Ring, PrimitiveShapeType.Sphere, PrimitiveShapeType.Torus, PrimitiveShapeType.Tube })
            {
                foreach (PrimitiveProfileShape profileShape in new PrimitiveProfileShape[] { PrimitiveProfileShape.Circle, PrimitiveProfileShape.EquilateralTriangle, PrimitiveProfileShape.HalfCircle, PrimitiveProfileShape.IsometricTriangle, PrimitiveProfileShape.RightTriangle, PrimitiveProfileShape.Square })
                {
                    foreach (PrimitiveProfileHollowShape hollowShape in new PrimitiveProfileHollowShape[] { PrimitiveProfileHollowShape.Circle, PrimitiveProfileHollowShape.Same, PrimitiveProfileHollowShape.Square, PrimitiveProfileHollowShape.Triangle })
                    {
                        foreach (PrimitivePhysicsShapeType physicsShapeType in new PrimitivePhysicsShapeType[] { PrimitivePhysicsShapeType.Convex, PrimitivePhysicsShapeType.Prim })
                        {
                            foreach (PrimitiveExtrusion pathCurve in new PrimitiveExtrusion[] { PrimitiveExtrusion.Curve1, PrimitiveExtrusion.Curve2, PrimitiveExtrusion.Default, PrimitiveExtrusion.Straight })
                            {
                                for (double pathbegin = 0; pathbegin < 1; pathbegin += 0.1)
                                {
                                    for (double pathend = 0; pathend < 1; pathend += 0.1)
                                    {
                                        for (double profilebegin = 0; profilebegin < 1; profilebegin += 0.1)
                                        {
                                            for (double profileend = 0; profileend < 1; profileend += 0.1)
                                            {
                                                for (double revolutions = 1; revolutions < 4; revolutions += 0.5)
                                                {
                                                    for (double twistbegin = -1; twistbegin < 1; twistbegin += 0.1)
                                                    {
                                                        for (double twistend = -1; twistend < 1; twistend += 0.1)
                                                        {
                                                            /*
                                                             * public double RadiusOffset;
                                                             */
                                                            for (double hollow = 0; hollow < 0.90; hollow += 0.1)
                                                            {
                                                                for (double skew = -0.9; skew < 0.9; skew += 0.1)
                                                                {
                                                                    for (double topshearx = -1; topshearx < 1; topshearx += 0.1)
                                                                    {
                                                                        for (double topsheary = -1; topsheary < 1; topsheary += 0.1)
                                                                        {
                                                                            for (double taperx = -1; taperx < 1; taperx += 0.1)
                                                                            {
                                                                                for (double tapery = -1; tapery < 1; tapery += 0.1)
                                                                                {
                                                                                    for (double pathscalex = 0; pathscalex < 1; pathscalex += 0.1)
                                                                                    {
                                                                                        for (double pathscaley = 0; pathscaley < 1; pathscaley += 0.1)
                                                                                        {
                                                                                            var shape = new ObjectPart.PrimitiveShape.Decoded();
                                                                                            shape.ProfileShape  = profileShape;
                                                                                            shape.ShapeType     = shapeType;
                                                                                            shape.HoleShape     = hollowShape;
                                                                                            shape.ProfileHollow = hollow;
                                                                                            shape.PathCurve     = pathCurve;
                                                                                            shape.Revolutions   = revolutions;
                                                                                            shape.PathBegin     = pathbegin;
                                                                                            shape.PathEnd       = pathend;
                                                                                            shape.TwistBegin    = twistbegin;
                                                                                            shape.TwistEnd      = twistend;
                                                                                            shape.ProfileBegin  = profilebegin;
                                                                                            shape.ProfileEnd    = profileend;
                                                                                            shape.TopShear.X    = topshearx;
                                                                                            shape.TopShear.Y    = topsheary;
                                                                                            shape.Taper.X       = taperx;
                                                                                            shape.Taper.Y       = tapery;
                                                                                            shape.PathScale.X   = pathscalex;
                                                                                            shape.PathScale.Y   = pathscaley;
                                                                                            shape.Skew          = skew;

                                                                                            var ps = new ObjectPart.PrimitiveShape
                                                                                            {
                                                                                                DecodedParams = shape
                                                                                            };

                                                                                            m_Log.Info("---- Transformed to physics shape manager accepted format ----");
                                                                                            m_Log.InfoFormat("PhysicsShapeType: {0}/{1}", physicsShapeType, shapeType);
                                                                                            m_Log.Info($"Serialized data {physicsShapeType.ToString()}/{ps.Serialization.ToHexString()}");
                                                                                            try
                                                                                            {
                                                                                                if (!m_PhysicsShapeManager.TryGetConvexShape(physicsShapeType, ps, out physicsShapeRef))
                                                                                                {
                                                                                                    DumpParams(shape);
                                                                                                    m_Log.Error("Could not generate physics hull shape");
                                                                                                    success = false;
                                                                                                    continue;
                                                                                                }
                                                                                            }
                                                                                            catch (Exception e)
                                                                                            {
                                                                                                DumpParams(shape);
                                                                                                m_Log.Error("Could not generate physics hull shape", e);
                                                                                                continue;
                                                                                            }

                                                                                            PhysicsConvexShape convexShape = physicsShapeRef;

                                                                                            int hullidx = 0;
                                                                                            foreach (PhysicsConvexShape.ConvexHull hull in convexShape.Hulls)
                                                                                            {
                                                                                                m_Log.InfoFormat("Hull {0}: Generated vertices: {1}", hullidx, hull.Vertices.Count);
                                                                                                m_Log.InfoFormat("Hull {0}: Generated triangles: {1}", hullidx, hull.Triangles.Count / 3);
                                                                                                ++hullidx;
                                                                                            }
                                                                                            m_Log.InfoFormat("Generated hulls: {0}", hullidx);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                /* write a blender .raw */
                                //                ((PhysicsConvexShape)physicsShapeRef).DumpToBlenderRaw(m_OutputFileName);
                            }
                        }
                    }
                }
            }

            return(success);
        }
예제 #7
0
 internal PhysicsShapePrimShapeReference(ObjectPart.PrimitiveShape primshape, PhysicsShapeManager manager, PhysicsConvexShape shape)
     : base(manager, shape)
 {
     m_Shape = new ObjectPart.PrimitiveShape(primshape);
 }
예제 #8
0
 internal PhysicsShapeDefaultAvatarReference(PhysicsShapeManager manager, PhysicsConvexShape shape)
     : base(manager, shape)
 {
 }
예제 #9
0
 internal PhysicsShapeMeshReference(UUID id, PrimitivePhysicsShapeType shapeType, PhysicsShapeManager manager, PhysicsConvexShape shape)
     : base(manager, shape)
 {
     m_ID        = id;
     m_ShapeType = shapeType;
 }
예제 #10
0
        private PhysicsConvexShape ConvertToMesh(PrimitivePhysicsShapeType physicsShape, ObjectPart.PrimitiveShape shape)
        {
            PhysicsConvexShape convexShape = null;
            bool hasHullList = false;

            if (shape.Type == PrimitiveShapeType.Sculpt && shape.SculptType == PrimitiveSculptType.Mesh)
            {
                var m = new LLMesh(m_AssetService[shape.SculptMap]);
                if (physicsShape == PrimitivePhysicsShapeType.Convex)
                {
#if DEBUG
                    m_Log.DebugFormat("Selected convex of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                    if (m.HasConvexPhysics())
                    {
                        try
                        {
#if DEBUG
                            m_Log.DebugFormat("Using convex of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                            convexShape = m.GetConvexPhysics(false);
                            hasHullList = convexShape.HasHullList;
                            return(convexShape);
                        }
                        catch (NoSuchMeshDataException)
                        {
                            /* no shape */
#if DEBUG
                            m_Log.DebugFormat("No convex in asset of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                        }
                        catch (Exception e)
                        {
                            m_Log.Warn($"Failed to get convex data of {shape.SculptType} {shape.SculptMap}", e);
                        }
                    }
#if DEBUG
                    else
                    {
                        m_Log.DebugFormat("No convex shape in {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
                    }
#endif
                    if (convexShape == null)
                    {
#if DEBUG
                        m_Log.DebugFormat("Using decompose to single convex for {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                        MeshLOD lod = m.GetLOD(LLMesh.LodLevel.LOD3);
                        lod.Optimize();
                        convexShape = DecomposeConvex(lod, true);
                    }
                }
                else
                {
#if DEBUG
                    m_Log.DebugFormat("Selected detailed physics of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                    if (m.HasLOD(LLMesh.LodLevel.Physics))
                    {
                        /* check for physics mesh before giving out the single hull */
#if DEBUG
                        m_Log.DebugFormat("Using detailed physics of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                        MeshLOD lod = m.GetLOD(LLMesh.LodLevel.Physics);
                        lod.Optimize();
                        convexShape = DecomposeConvex(lod);
                    }
                    else if (m.HasConvexPhysics())
                    {
#if DEBUG
                        m_Log.DebugFormat("Using convex of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                        try
                        {
                            convexShape = m.GetConvexPhysics(true);
                            hasHullList = convexShape.HasHullList;
                        }
                        catch (NoSuchMeshDataException)
                        {
                            /* no shape */
#if DEBUG
                            m_Log.DebugFormat("No suitable convex in asset of {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                        }
                        catch (Exception e)
                        {
                            m_Log.Warn($"Failed to get convex data of {shape.Type}/{shape.SculptType}/{shape.SculptMap}", e);
                        }
                        if (convexShape == null)
                        {
                            /* this way we keep convex hull type functional by having it only get active on PrimitivePhysicsShapeType.Prim */
#if DEBUG
                            m_Log.DebugFormat("Using decompose to convex for {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                            MeshLOD lod = m.GetLOD(LLMesh.LodLevel.LOD3);
                            lod.Optimize();
                            convexShape = DecomposeConvex(lod);
                        }
                    }
                }
            }
            else
            {
#if DEBUG
                m_Log.DebugFormat("Using decompose to convex for {0}/{1}/{2}", shape.Type, shape.SculptType, shape.SculptMap);
#endif
                MeshLOD m = shape.ToMesh(m_AssetService);
                m.Optimize();
                convexShape = DecomposeConvex(m, physicsShape == PrimitivePhysicsShapeType.Convex);
            }

            return(convexShape);
        }
예제 #11
0
 internal void DecrementUseCount(UUID id, PrimitivePhysicsShapeType physicsShape, PhysicsConvexShape shape)
 {
     if (0 == Interlocked.Decrement(ref shape.UseCount))
     {
         m_Lock.AcquireWriterLock(() => m_ConvexShapesBySculptMesh.RemoveIf(GetMeshKey(id, physicsShape), (PhysicsConvexShape s) => s.UseCount == 0));
     }
 }
예제 #12
0
        public PhysicsConvexShape Compute(MeshLOD m, bool useSingleConvex = false)
        {
            if (m_VHacd == IntPtr.Zero)
            {
                throw new ObjectDisposedException("VHACD");
            }
            var points   = new double[m.Vertices.Count * 3];
            var tris     = new int[m.Triangles.Count * 3];
            int idx      = 0;
            int vertices = m.Vertices.Count;

            foreach (Vector3 v in m.Vertices)
            {
                points[idx++] = v.X;
                points[idx++] = v.Y;
                points[idx++] = v.Z;
            }

            idx = 0;
            foreach (Triangle t in m.Triangles)
            {
                tris[idx++] = t.Vertex1;
                tris[idx++] = t.Vertex2;
                tris[idx++] = t.Vertex3;
                if (t.Vertex1 >= vertices || t.Vertex2 >= vertices || t.Vertex3 >= vertices)
                {
                    throw new InputDataException("Invalid triangle found");
                }
            }
            if (idx == 0)
            {
                throw new InputDataException("No triangles found");
            }

            Parameters p = Parameters.Defaults;

            if (useSingleConvex)
            {
                p.Depth = 0;
            }
            if (!VHacd_Compute(m_VHacd, points, 3, (uint)m.Vertices.Count, tris, 3, (uint)m.Triangles.Count, ref p))
            {
                throw new InputDataException("Decompose failed");
            }

            var shape    = new PhysicsConvexShape();
            int numhulls = VHacd_GetNConvexHulls(m_VHacd);

            for (uint hullidx = 0; hullidx < numhulls; ++hullidx)
            {
                var hull = new ConvexHull();
                VHacd_GetConvexHull(m_VHacd, hullidx, ref hull);
                var resPoints = new double[hull.NumPoints * 3];
                Marshal.Copy(hull.Points, resPoints, 0, hull.NumPoints * 3);
                var resTris = new int[hull.NumTriangles * 3];
                Marshal.Copy(hull.Triangles, resTris, 0, hull.NumTriangles * 3);

                var cHull = new PhysicsConvexShape.ConvexHull();
                for (int vertidx = 0; vertidx < hull.NumPoints * 3; vertidx += 3)
                {
                    cHull.Vertices.Add(new Vector3(
                                           resPoints[vertidx + 0],
                                           resPoints[vertidx + 1],
                                           resPoints[vertidx + 2]));
                }

                int vCount = cHull.Vertices.Count;
                for (int triidx = 0; triidx < hull.NumTriangles * 3; ++triidx)
                {
                    int tri = resTris[triidx];
                    if (tri >= vCount || tri < 0)
                    {
                        m_Log.ErrorFormat("Tri Index out of range");
                        throw new InputDataException("Tri index out of range");
                    }
                    cHull.Triangles.Add(resTris[triidx]);
                }
                shape.Hulls.Add(cHull);
            }

            return(shape);
        }
예제 #13
0
 protected PhysicsShapeReference(PhysicsShapeManager manager, PhysicsConvexShape shape)
 {
     m_PhysicsManager = manager;
     m_ConvexShape    = shape;
     Interlocked.Increment(ref m_ConvexShape.UseCount);
 }
예제 #14
0
 bool ISimulationDataPhysicsConvexStorageInterface.TryGetValue(ObjectPart.PrimitiveShape primShape, out PhysicsConvexShape shape) =>
 m_ConvexShapesByPrimShape.TryGetValue(primShape, out shape);
예제 #15
0
 bool ISimulationDataPhysicsConvexStorageInterface.TryGetValue(UUID meshid, PrimitivePhysicsShapeType physicsShape, out PhysicsConvexShape shape) =>
 m_ConvexShapesByMesh.TryGetValue(GetMeshKey(meshid, physicsShape), out shape);