protected void ExtendPolution(List <Cell> tCells) { List <Cell> newArray = new List <Cell>(); int nbCell = tCells.Count; for (int i = 0; i < nbCell; i++) { int nbICell = tCells[i].Neighbors.Count; for (int j = 0; j < nbICell; j++) { Cell neighbor = tCells[i].Neighbors[j]; if (!neighbor.Poluted && !newArray.Contains(neighbor) && !CELLS_USED.Contains(neighbor) && polutionStates.Contains(neighbor.State)) { newArray.Add(neighbor); _CELLS_USED.Add(neighbor); } } } if (newArray.Count > 0) { iteration++; cellIterator = 0; newArray = ObjectArray <Cell> .CheckIt(newArray); iterationCells.Add(newArray); Action(); } else { ForceExtend(); } }
// public static void BottomUp(Dbvt pdbvt, ObjectArray <DbvtNode> leaves) { while (leaves.Count > 1) { float minsize = float.MaxValue; int[] minidx = { -1, -1 }; for (int i = 0; i < leaves.Count; ++i) { for (int j = i + 1; j < leaves.Count; ++j) { DbvtAabbMm mergeResults = DbvtAabbMm.Merge(ref leaves[i].volume, ref leaves[j].volume); float sz = Size(ref mergeResults); if (sz < minsize) { minsize = sz; minidx[0] = i; minidx[1] = j; } } } DbvtNode[] n = { leaves[minidx[0]], leaves[minidx[1]] }; DbvtNode p = CreateNode(pdbvt, null, ref n[0].volume, ref n[1].volume, null); p._children[0] = n[0]; p._children[1] = n[1]; n[0].parent = p; n[1].parent = p; leaves[minidx[0]] = p; leaves.Swap(minidx[1], leaves.Count - 1); leaves.PopBack(); } }
CollisionShape BuildLargeMesh() { //int vertStride = sizeof(IndexedVector3); //int indexStride = 3*sizeof(int); int vertStride = 1; int indexStride = 3; ObjectArray <IndexedVector3> vertexArray = new ObjectArray <IndexedVector3>(); for (int i = 0; i < vertices.Length; ++i) { vertexArray.Add(vertices[i]); } ObjectArray <int> intArray = new ObjectArray <int>(); for (int i = 0; i < indices.Length; ++i) { intArray.Add(indices[i]); } //TriangleIndexVertexArray indexVertexArray = new TriangleIndexVertexArray(DemoMeshes.BUNNY_NUM_TRIANGLES, DemoMeshes.gBunnyIndices, 3, DemoMeshes.BUNNY_NUM_VERTICES, DemoMeshes.gBunnyVertices, 3); TriangleIndexVertexArray indexVertexArray = new TriangleIndexVertexArray(numTriangles, intArray, indexStride, vertexArray.Count, vertexArray, vertStride); TriangleMeshShape triangleMesh = new TriangleMeshShape(indexVertexArray); //TriangleMeshShape triangleMesh = new BvhTriangleMeshShape(indexVertexArray,true,true); return(triangleMesh); }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { Vector3 t1 = triangle[0]; Vector3 t2 = triangle[1]; Vector3 t3 = triangle[2]; OptimizedBvhNode node = new OptimizedBvhNode(); Vector3 aabbMin = MathUtil.MAX_VECTOR; Vector3 aabbMax = MathUtil.MIN_VECTOR; MathUtil.VectorMax(ref t1,ref aabbMax); MathUtil.VectorMin(ref t1,ref aabbMin); MathUtil.VectorMax(ref t2,ref aabbMax); MathUtil.VectorMin(ref t2,ref aabbMin); MathUtil.VectorMax(ref t3,ref aabbMax); MathUtil.VectorMin(ref t3,ref aabbMin); //with quantization? node.m_aabbMinOrg = aabbMin; node.m_aabbMaxOrg = aabbMax; node.m_escapeIndex = -1; //for child nodes node.m_subPart = partId; node.m_triangleIndex = triangleIndex; m_triangleNodes.Add(node); }
///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those public DiscreteDynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface pairCache, IConstraintSolver constraintSolver, ICollisionConfiguration collisionConfiguration) : base(dispatcher, pairCache, collisionConfiguration) { m_ownsIslandManager = true; m_constraints = new ObjectArray<TypedConstraint>(); m_actions = new List<IActionInterface>(); m_nonStaticRigidBodies = new ObjectArray<RigidBody>(); m_islandManager = new SimulationIslandManager(); m_constraintSolver = constraintSolver; Gravity = new Vector3(0, -10, 0); m_localTime = 1f / 60f; m_profileTimings = 0; m_synchronizeAllMotionStates = false; if (m_constraintSolver == null) { m_constraintSolver = new SequentialImpulseConstraintSolver(); m_ownsConstraintSolver = true; } else { m_ownsConstraintSolver = false; } }
public void CreateDynamicObjectArray() { var arrayObject = Default; arrayObject.Fields.Add(new ObjectField(Field, "key", new Argument(E, "value"))); var array = new ObjectArray(new ArraySyntax(), state, new Argument[] { new Argument(Field, "a"), new Argument(Field, arrayObject) }); var creator = Default; creator.Fields.Add(new ObjectField(Field, "array", new Argument(E, array))); dynamic top = creator.Create(typeof(object), null); Assert.NotNull(top); var arr = top.array; Assert.NotNull(arr); var value = arr[0]; Assert.IsType <string>(value); Assert.Equal("a", value); var arrayEntry = arr[1]; var entryValue = arrayEntry.key; Assert.IsType <string>(entryValue); Assert.Equal("value", entryValue); }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { Matrix i = new Matrix(); Vector3 a = triangle[0] - m_center; Vector3 b = triangle[1] - m_center; Vector3 c = triangle[2] - m_center; float volNeg = -System.Math.Abs(MathUtil.Vector3Triple(ref a,ref b,ref c) * (1f / 6f)); for (int j = 0; j < 3; j++) { for (int k = 0; k <= j; k++) { float aj = MathUtil.VectorComponent(ref a,j); float ak = MathUtil.VectorComponent(ref a,k); float bj = MathUtil.VectorComponent(ref b,j); float bk = MathUtil.VectorComponent(ref b,k); float cj = MathUtil.VectorComponent(ref c,j); float ck = MathUtil.VectorComponent(ref c,k); float temp = volNeg * (.1f * (aj * ak + bj * bk + cj * ck) + .05f * (aj * bk + ak * bj + aj * ck + ak * cj + bj * ck + bk * cj)); MathUtil.MatrixComponent(ref i,j,k,temp); MathUtil.MatrixComponent(ref i,k,j,temp); } } float i00 = -i.M11; float i11 = -i.M22; float i22 = -i.M33; i.M11 = i11 + i22; i.M22 = i22 + i00; i.M33 = i00 + i11; m_sum.Right += i.Right; m_sum.Up += i.Up; m_sum.Backward += i.Backward; }
public SimulationIslandManager() { m_splitIslands = true; m_unionFind = new UnionFind(); m_islandmanifold = new ObjectArray<PersistentManifold>(); m_islandBodies = new ObjectArray<CollisionObject>(); }
//! classify points that are closer public void MergePoints(ref Vector4 plane, float margin, ObjectArray<IndexedVector3> points, int point_count) { m_point_count = 0; m_penetration_depth = -1000.0f; int[] point_indices = new int[MAX_TRI_CLIPPING]; int _k; for (_k = 0; _k < point_count; _k++) { float _dist = -ClipPolygon.DistancePointPlane(ref plane, ref points.GetRawArray()[_k]) + margin; if (_dist >= 0.0f) { if (_dist > m_penetration_depth) { m_penetration_depth = _dist; point_indices[0] = _k; m_point_count = 1; } else if ((_dist + MathUtil.SIMD_EPSILON) >= m_penetration_depth) { point_indices[m_point_count] = _k; m_point_count++; } } } for (_k = 0; _k < m_point_count; _k++) { m_points[_k] = points[point_indices[_k]]; } }
static void Main(string[] args) { ObjectArray arr = new ObjectArray(); arr.Run(); Console.ReadLine(); }
//! classify points that are closer public void MergePoints(ref Vector4 plane, float margin, ObjectArray <IndexedVector3> points, int point_count) { m_point_count = 0; m_penetration_depth = -1000.0f; int[] point_indices = new int[MAX_TRI_CLIPPING]; int _k; for (_k = 0; _k < point_count; _k++) { float _dist = -ClipPolygon.DistancePointPlane(ref plane, ref points.GetRawArray()[_k]) + margin; if (_dist >= 0.0f) { if (_dist > m_penetration_depth) { m_penetration_depth = _dist; point_indices[0] = _k; m_point_count = 1; } else if ((_dist + MathUtil.SIMD_EPSILON) >= m_penetration_depth) { point_indices[m_point_count] = _k; m_point_count++; } } } for (_k = 0; _k < m_point_count; _k++) { m_points[_k] = points[point_indices[_k]]; } }
public void QueryNode(QuadTreeNode node, ObjectArray <QuadTreeNode> results, IndexedVector3 source, IndexedVector3 direction) { //if(node.children == null && node.Intersects(raySource,rayTarget)) // add the lowest level. if (node.children == null) { results.Add(node); #if DEBUG_ACCELERATOR if (BulletGlobals.gDebugDraw != null) { IndexedVector3 drawMin = new IndexedVector3(node.boundingBox.Min); IndexedVector3 drawMax = new IndexedVector3(node.boundingBox.Max); IndexedVector3 worldMin = LocalToWorld2(drawMin); IndexedVector3 worldMax = LocalToWorld2(drawMax); BulletGlobals.gDebugDraw.DrawAabb(worldMin, worldMax, new IndexedVector3(1, 1, 1)); } #endif } else { // simple rescursive for now. for (int i = 0; i < 4; ++i) { if (node.children[i].Intersects(source, direction)) { QueryNode(node.children[i], results, source, direction); } } } }
public object getAsset(string path, System.Type systemTypeInstance, bool array = false) { object obj = null; if (mDictAsset.ContainsKey(path)) { if (array) { obj = mDictAsset[path]; } else { obj = GameObject.Instantiate(mDictAsset[path] as Object); } addGameObjectList(path, obj as Object); return(obj); } if (array) { Object[] objs = Resources.LoadAll(path, systemTypeInstance); ObjectArray objArray = new ObjectArray(); objArray.objectArray = objs; obj = objArray; mDictAsset[path] = obj; } else { obj = Resources.Load(path, systemTypeInstance); mDictAsset[path] = obj; obj = GameObject.Instantiate(mDictAsset[path] as Object); } addGameObjectList(path, obj); return(obj); }
///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those public DiscreteDynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface pairCache, IConstraintSolver constraintSolver, ICollisionConfiguration collisionConfiguration) : base(dispatcher, pairCache, collisionConfiguration) { m_ownsIslandManager = true; m_constraints = new ObjectArray <TypedConstraint>(); m_sortedConstraints = new ObjectArray <TypedConstraint>(); m_islandSortPredicate = new SortConstraintOnIslandPredicate(); m_islandQuickSortPredicate = new QuickSortConstraintOnIslandPredicate(); m_actions = new List <IActionInterface>(); m_nonStaticRigidBodies = new ObjectArray <RigidBody>(); m_islandManager = new SimulationIslandManager(); m_constraintSolver = constraintSolver; IndexedVector3 gravity = new IndexedVector3(0, -10, 0); SetGravity(ref gravity); m_localTime = 0f; m_profileTimings = 0; m_synchronizeAllMotionStates = false; if (m_constraintSolver == null) { m_constraintSolver = new SequentialImpulseConstraintSolver(); m_ownsConstraintSolver = true; } else { m_ownsConstraintSolver = false; } }
//just to be backwards compatible public TriangleIndexVertexArray(int numTriangles,ObjectArray<int> triangleIndexBase,int triangleIndexStride,int numVertices,Object vertexBase,int vertexStride) { // ignore the provided stride values as we infer them from the version of the ctor called... IndexedMesh indexedMesh = new IndexedMesh(); indexedMesh.m_numTriangles = numTriangles; indexedMesh.m_triangleIndexBase = triangleIndexBase; indexedMesh.m_triangleIndexStride = 3; indexedMesh.m_numVertices = numVertices; indexedMesh.m_vertexBase = vertexBase; if (vertexBase is ObjectArray<IndexedVector3>) { indexedMesh.m_vertexStride = 1; } #if XNA else if (vertexBase is ObjectArray<Microsoft.Xna.Framework.Vector3>) { indexedMesh.m_vertexStride = 1; } #endif else if (vertexBase is ObjectArray<float>) { indexedMesh.m_vertexStride = 3; } else { Debug.Assert(false,"Unsupported vertex object base."); } AddIndexedMesh(indexedMesh,PHY_ScalarType.PHY_INTEGER); }
public override void ProcessAllTriangles(ITriangleCallback callback, ref Vector3 aabbMin, ref Vector3 aabbMax) { Vector3 halfExtents = (aabbMax - aabbMin) * .5f; float radius = halfExtents.Length(); Vector3 center = (aabbMax + aabbMin) * 0.5f; //this is where the triangles are generated, given AABB and plane equation (normal/constant) Vector3 tangentDir0 = Vector3.Zero; Vector3 tangentDir1 = Vector3.Zero; //tangentDir0/tangentDir1 can be precalculated TransformUtil.PlaneSpace1(ref m_planeNormal,ref tangentDir0,ref tangentDir1); Vector3 supVertex0 = Vector3.Zero; Vector3 supVertex1 = Vector3.Zero; Vector3 projectedCenter = center - (Vector3.Dot(m_planeNormal,center) - m_planeConstant)*m_planeNormal; ObjectArray<Vector3> triangle = new ObjectArray<Vector3>(3); triangle.Add(projectedCenter + tangentDir0*radius + tangentDir1*radius); triangle.Add(projectedCenter + tangentDir0 * radius - tangentDir1 * radius); triangle.Add(projectedCenter - tangentDir0 * radius - tangentDir1 * radius); callback.ProcessTriangle(triangle,0,0); triangle[0] = projectedCenter - tangentDir0*radius - tangentDir1*radius; triangle[1] = projectedCenter - tangentDir0*radius + tangentDir1*radius; triangle[2] = projectedCenter + tangentDir0*radius + tangentDir1*radius; callback.ProcessTriangle(triangle,0,1); }
public SimulationIslandManager() { m_splitIslands = true; m_unionFind = new UnionFind(); m_islandmanifold = new PersistentManifoldArray(); m_islandBodies = new ObjectArray <CollisionObject>(); }
public void LengthTest() { const int length = 3; var stringArray = new ObjectArray<String>(length); Assert.AreEqual(length, stringArray.Length); }
public override void ProcessAllTriangles(ITriangleCallback callback, ref IndexedVector3 aabbMin, ref IndexedVector3 aabbMax) { LockChildShapes(); AABB box = new AABB(); box.m_min = aabbMin; box.m_max = aabbMax; ObjectArray <int> collided = new ObjectArray <int>(); m_box_set.BoxQuery(ref box, collided); if (collided.Count == 0) { UnlockChildShapes(); return; } int part = GetPart(); PrimitiveTriangle triangle = new PrimitiveTriangle(); int i = collided.Count; while (i-- != 0) { GetPrimitiveTriangle(collided[i], triangle); callback.ProcessTriangle(triangle.m_vertices, part, collided[i]); } UnlockChildShapes(); }
//just to be backwards compatible public TriangleIndexVertexArray(int numTriangles, ObjectArray <int> triangleIndexBase, int triangleIndexStride, int numVertices, Object vertexBase, int vertexStride) { // ignore the provided stride values as we infer them from the version of the ctor called... IndexedMesh indexedMesh = new IndexedMesh(); indexedMesh.m_numTriangles = numTriangles; indexedMesh.m_triangleIndexBase = triangleIndexBase; indexedMesh.m_triangleIndexStride = 3; indexedMesh.m_numVertices = numVertices; indexedMesh.m_vertexBase = vertexBase; if (vertexBase is ObjectArray <IndexedVector3> ) { indexedMesh.m_vertexStride = 1; } #if XNA else if (vertexBase is ObjectArray <Microsoft.Xna.Framework.Vector3> ) { indexedMesh.m_vertexStride = 1; } #endif else if (vertexBase is ObjectArray <float> ) { indexedMesh.m_vertexStride = 3; } else { Debug.Assert(false, "Unsupported vertex object base."); } AddIndexedMesh(indexedMesh, PHY_ScalarType.PHY_INTEGER); }
internal static object CreateMeshShapeF(object pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats) { ObjectArray <int> indicesarr = new ObjectArray <int>(indices); ObjectArray <float> vertices = new ObjectArray <float>(verticesAsFloats); var world = pWorld as DiscreteDynamicsWorld; IndexedMesh mesh = new IndexedMesh(); mesh.m_indexType = PHY_ScalarType.PHY_INTEGER; mesh.m_numTriangles = pIndicesCount / 3; mesh.m_numVertices = pVerticesCount; mesh.m_triangleIndexBase = indicesarr; mesh.m_vertexBase = vertices; mesh.m_vertexStride = 3; mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT; mesh.m_triangleIndexStride = 3; TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray(); tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER); BvhTriangleMeshShape meshShape = new BvhTriangleMeshShape(tribuilder, false, true); //TriangleMeshShape meshShape = new TriangleMeshShape(tribuilder); //meshShape.SetMargin(world.WorldSettings.Params.collisionMargin); float margin = 0.02f; meshShape.SetMargin(margin); return(meshShape); }
public SortedOverlappingPairCache() { m_blockedForChanges = false; m_hasDeferredRemoval = true; m_overlapFilterCallback = null; m_ghostPairCallback = null; m_overlappingPairArray = new ObjectArray <BroadphasePair>(2); }
public SortedOverlappingPairCache() { m_blockedForChanges = false; m_hasDeferredRemoval = true; m_overlapFilterCallback = null; m_ghostPairCallback = null; m_overlappingPairArray = new ObjectArray<BroadphasePair>(2); }
//this constructor doesn't own the dispatcher and paircache/broadphase public CollisionWorld(IDispatcher dispatcher, IBroadphaseInterface broadphasePairCache, ICollisionConfiguration collisionConfiguration) { m_dispatcher1 = dispatcher; m_broadphasePairCache = broadphasePairCache; m_collisionObjects = new ObjectArray<CollisionObject>(); m_dispatchInfo = new DispatcherInfo(); m_forceUpdateAllAabbs = true; }
//! returns the indices of the primitives in the m_primitive_manager public bool BoxQueryTrans(ref AABB box, ref IndexedMatrix transform, ObjectArray <int> collided_results) { AABB transbox = box; transbox.ApplyTransform(ref transform); return(BoxQuery(ref transbox, collided_results)); }
public override void ClientMoveAndDisplay(GameTime gameTime) { // OPTIONAL: We simply move our ghost objects around (without rotating them.....)============== if (m_ghostObject != null || m_pairCachingGhostObject != null) { rad += 0.005f; // Bad (depends on PC speed) float sinRad = (float)Math.Sin(rad); float cosRad = (float)Math.Cos(rad); if (m_ghostObject != null) { IndexedMatrix im = IndexedMatrix.CreateFromQuaternion(quatDeg45Y); im._origin = new IndexedVector3(15 * cosRad, 5, -15 * sinRad); m_ghostObject.SetWorldTransform(ref im); } if (m_pairCachingGhostObject != null) { IndexedMatrix im = IndexedMatrix.CreateFromQuaternion(quatDeg45Y); im._origin = new IndexedVector3(-15 * cosRad, 7, 15 * sinRad); m_pairCachingGhostObject.SetWorldTransform(ref im); } } base.ClientMoveAndDisplay(gameTime); // NEW => Retrives the content from all ghost objects in the world and call ProcessObectsInsideGhostObjects(...) for each ==== if (m_dynamicsWorld != null) { ObjectArray <CollisionObject> objsInsidePairCachingGhostObject = new ObjectArray <CollisionObject>(); // We might want this to be a member variable... ObjectArray <CollisionObject> pObjsInsideGhostObject = null; // We will store a reference of the current array in this pointer ObjectArray <CollisionObject> objs = m_dynamicsWorld.GetCollisionObjectArray(); for (int i = 0, sz = objs.Count; i < sz; i++) { CollisionObject o = objs[i]; GhostObject go = GhostObject.Upcast(o); if (go != null) { objsInsidePairCachingGhostObject.Resize(0); PairCachingGhostObject pgo = go as PairCachingGhostObject; // No upcast functionality... if (pgo != null) { GetCollidingObjectsInsidePairCachingGhostObject((DiscreteDynamicsWorld)m_dynamicsWorld, pgo, objsInsidePairCachingGhostObject); pObjsInsideGhostObject = objsInsidePairCachingGhostObject; } else { pObjsInsideGhostObject = go.GetOverlappingPairs(); // It's better not to try and copy the whole array, but to keep a reference to it! // Side Note: btAlignedObjectArray < btCollisionObject* > objs = go.getOverlappingPairs(); (at the moment) makes my program crash on my system... // Nevermind, that was the wrong way of doing it: btAlignedObjectArray < btCollisionObject* >& objs = go.getOverlappingPairs(); is much better. } // Here pObjsInsideGhostObject should be valid. ProcessObectsInsideGhostObjects(pObjsInsideGhostObject, pgo != null); } } } }
public HashedOverlappingPairCache() { m_overlapFilterCallback = null; m_blockedForChanges = false; m_ghostPairCallback = null; int initialAllocatedSize = 2; m_overlappingPairArray = new ObjectArray<BroadphasePair>(initialAllocatedSize); GrowTables(); }
public bool BoxQuery(ref AABB box, ObjectArray <int> collided_results, bool graphics) { int curIndex = 0; int numNodes = GetNodeCount(); if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactBVH && !graphics) { BulletGlobals.g_streamWriter.WriteLine("QIQBVH BoxQuery [{0}]", numNodes); } //quantize box UShortVector3 quantizedMin; UShortVector3 quantizedMax; m_box_tree.QuantizePoint(out quantizedMin, ref box.m_min); m_box_tree.QuantizePoint(out quantizedMax, ref box.m_max); while (curIndex < numNodes) { //catch bugs in tree data bool aabbOverlap = m_box_tree.TestQuantizedBoxOverlap(curIndex, ref quantizedMin, ref quantizedMax); bool isLeafNode = IsLeafNode(curIndex); if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactBVH && !graphics) { BulletGlobals.g_streamWriter.WriteLine("QIQBVH BoxQuery [{0}] o[{1}] l[{2}]", curIndex, aabbOverlap ? 1 : 0, isLeafNode ? 1 : 0); } if (isLeafNode && aabbOverlap) { foreach (var i in GetNodeData(curIndex)) { collided_results.Add(i); } } if (aabbOverlap || isLeafNode) { //next subnode curIndex++; } else { //skip node curIndex += GetEscapeNodeIndex(curIndex); } } if (collided_results.Count > 0) { return(true); } return(false); }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle,int partId,int triangleIndex) { if (AabbUtil2.TestTriangleAgainstAabb2(triangle,ref m_aabbMin,ref m_aabbMax)) { //check aabb in triangle-space, before doing this m_callback.ProcessTriangle(triangle,partId,triangleIndex); } }
public void NoChange() { var source = new ObjectArray(); var patched = new ObjectArray(); var diff = DiffBuilder.Build(source, patched); Assert.Null(diff); }
//! Clips a polygon by a plane /*! *\param clipped must be an array of 16 points. *\return The count of the clipped counts */ public static int PlaneClipTriangle( ref Vector4 plane, ref IndexedVector3 point0, ref IndexedVector3 point1, ref IndexedVector3 point2, ObjectArray <IndexedVector3> clipped // an allocated array of 16 points at least ) { int clipped_count = 0; //clip first point0 float firstdist = DistancePointPlane(ref plane, ref point0); if (!(firstdist > MathUtil.SIMD_EPSILON)) { clipped[clipped_count] = point0; clipped_count++; } // point 1 float olddist = firstdist; float dist = DistancePointPlane(ref plane, ref point1); PlaneClipPolygonCollect( ref point0, ref point1, olddist, dist, clipped, ref clipped_count); olddist = dist; // point 2 dist = DistancePointPlane(ref plane, ref point2); PlaneClipPolygonCollect( ref point1, ref point2, olddist, dist, clipped, ref clipped_count); olddist = dist; //RETURN TO FIRST point0 PlaneClipPolygonCollect( ref point2, ref point0, olddist, firstdist, clipped, ref clipped_count); return(clipped_count); }
// public static DbvtAabbMm Bounds(ObjectArray <DbvtNode> leafs) { DbvtAabbMm volume = leafs[0].volume; for (int i = 1, ni = leafs.Count; i < ni; ++i) { DbvtAabbMm.Merge(ref volume, ref leafs[i].volume, ref volume); } return(volume); }
public HashedOverlappingPairCache() { m_overlapFilterCallback = null; m_blockedForChanges = false; m_ghostPairCallback = null; int initialAllocatedSize = 2; m_overlappingPairArray = new ObjectArray <BroadphasePair>(initialAllocatedSize); GrowTables(); }
public void AddValue() { var sut = new ObjectArray(); sut.Add(0); sut.Add(2.657); sut.Add("string"); Assert.Equal("string", sut[2]); Assert.Equal(3, sut.Count); }
public void OptimizeTopDown(int bu_threshold) { // threshhold defaults to 128 if (Root != null) { ObjectArray <DbvtNode> leafs = new ObjectArray <DbvtNode>(m_leaves); FetchLeafs(this, Root, leafs); Root = TopDown(this, leafs, bu_threshold); } }
public void Method_asList() { var stringArray = new ObjectArray<String>(3); stringArray[0] = "string 1"; stringArray[1] = "string 2"; stringArray[2] = "string 3"; List<String> list = jvm4csharp.java.util.Arrays.asList(stringArray); AssertEx.IsValidJavaObject(list); }
public void OptimizeBottomUp() { if (Root != null) { ObjectArray <DbvtNode> leafs = new ObjectArray <DbvtNode>(m_leaves); FetchLeafs(this, Root, leafs); BottomUp(this, leafs); Root = leafs[0]; } }
public virtual void ProcessTriangle(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { //aabb filter is already applied! CollisionAlgorithmConstructionInfo ci = new CollisionAlgorithmConstructionInfo(); ci.SetDispatcher(m_dispatcher); CollisionObject ob = (CollisionObject)m_triBody; ///debug drawing of the overlapping triangles /// if (m_dispatchInfoPtr != null && m_dispatchInfoPtr.getDebugDraw() != null&& ((m_dispatchInfoPtr.getDebugDraw().GetDebugMode() & DebugDrawModes.DBG_DrawWireframe) > 0)) { Vector3 color = new Vector3(1,1,0); Matrix tr = ob.GetWorldTransform(); Vector3[] transformedTriangles = new Vector3[3]; for(int i=0;i<transformedTriangles.Length;++i) { transformedTriangles[i] = Vector3.Transform(triangle[i],tr); } m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[0], ref transformedTriangles[1], ref color); m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[1], ref transformedTriangles[2], ref color); m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[2], ref transformedTriangles[0], ref color); } if (m_convexBody.GetCollisionShape().IsConvex()) { TriangleShape tm = new TriangleShape(triangle[0],triangle[1],triangle[2]); tm.Margin = m_collisionMarginTriangle; CollisionShape tmpShape = ob.GetCollisionShape(); ob.InternalSetTemporaryCollisionShape(tm); CollisionAlgorithm colAlgo = ci.GetDispatcher().FindAlgorithm(m_convexBody,m_triBody,m_manifoldPtr); ///this should use the btDispatcher, so the actual registered algorithm is used // btConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexBody,m_triBody); if (m_resultOut.GetBody0Internal() == m_triBody) { m_resultOut.SetShapeIdentifiersA(partId, triangleIndex); } else { m_resultOut.SetShapeIdentifiersB(partId, triangleIndex); } colAlgo.ProcessCollision(m_convexBody,m_triBody,m_dispatchInfoPtr, m_resultOut); colAlgo.Cleanup(); ci.GetDispatcher().FreeCollisionAlgorithm(colAlgo); colAlgo = null; ob.InternalSetTemporaryCollisionShape( tmpShape); } }
//InplaceSolverIslandCallback operator=(InplaceSolverIslandCallback& other) //{ // Debug.Assert(false); // //(void)other; // return *this; //} public void Setup(ContactSolverInfo solverInfo, ObjectArray <TypedConstraint> sortedConstraints, int numConstraints, IDebugDraw debugDrawer) { Debug.Assert(solverInfo != null); m_solverInfo = solverInfo; m_sortedConstraints = sortedConstraints; m_numConstraints = numConstraints; m_debugDrawer = debugDrawer; m_bodies.Resize(0); m_manifolds.Resize(0); m_constraints.Resize(0); }
public PolutionArea(int cID, List <CellState> polutionTypes) { ObjectArray <Cell> newArray = new ObjectArray <Cell>(); initialCell = EarthManager.Instance.Cells.Find(c => c.ID == cID); polutionStates = polutionTypes; iterationCells.Add(new List <Cell>() { initialCell }); }
public SequentialImpulseConstraintSolver() { //FIXME RHS SEEMS TO BE OUT m_tmpSolverContactConstraintPool = new ObjectArray<SolverConstraint>(); m_tmpSolverNonContactConstraintPool = new ObjectArray<SolverConstraint>(); m_tmpSolverContactFrictionConstraintPool = new ObjectArray<SolverConstraint>(); m_tmpConstraintSizesPool = new ObjectArray<ConstraintInfo1>(); m_orderTmpConstraintPool = new ObjectArray<int>(); m_orderFrictionConstraintPool = new ObjectArray<int>(); }
//just to be backwards compatible public TriangleIndexVertexArray(int numTriangles,ObjectArray<int> triangleIndexBase,int triangleIndexStride,int numVertices,ObjectArray<Vector3> vertexBase,int vertexStride) { IndexedMesh indexedMesh = new IndexedMesh(); indexedMesh.m_numTriangles = numTriangles; indexedMesh.m_triangleIndexBase = triangleIndexBase; indexedMesh.m_triangleIndexStride = triangleIndexStride; indexedMesh.m_numVertices = numVertices; indexedMesh.m_vertexBase = vertexBase; indexedMesh.m_vertexStride = vertexStride; AddIndexedMesh(indexedMesh,PHY_ScalarType.PHY_INTEGER); }
// This static method is useful for the demo only. It's called by "void GhostObjectsDemo::clientMoveAndDisplay()". // Basically we must find a way to "display" the objects inside ghost objects to the user. // We choose to apply a vertical impulse to them (just because it's easier). // (The strength of the impulse is different depending on the type of ghost object) static void ProcessObectsInsideGhostObjects(ObjectArray <CollisionObject> objs, bool isPairCachingGhostObject) { foreach (CollisionObject co in objs) { RigidBody b = RigidBody.Upcast(co); if (b != null) { b.Activate(); IndexedVector3 impulse = isPairCachingGhostObject ? new IndexedVector3(0, 0.5f, 0) : new IndexedVector3(0, 0.25f, 0); b.ApplyCentralImpulse(ref impulse); } } }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { Vector3 t1 = triangle[0]; Vector3 t2 = triangle[1]; Vector3 t3 = triangle[2]; MathUtil.VectorMin(ref t1,ref m_aabbMin); MathUtil.VectorMax(ref t1,ref m_aabbMax); MathUtil.VectorMin(ref t2,ref m_aabbMin); MathUtil.VectorMax(ref t2,ref m_aabbMax); MathUtil.VectorMin(ref t3,ref m_aabbMin); MathUtil.VectorMax(ref t3,ref m_aabbMax); }
public static void FetchLeafs(Dbvt pdbvt, DbvtNode root, ObjectArray <DbvtNode> leafs, int depth) { if (root.IsInternal() && depth != 0) { FetchLeafs(pdbvt, root._children[0], leafs, depth - 1); FetchLeafs(pdbvt, root._children[1], leafs, depth - 1); DeleteNode(pdbvt, root); } else { leafs.Add(root); } }
public void ValueChanged() { var source = new ObjectArray(); var patched = new ObjectArray(); patched.Objects[1].Integer = 3; var diff = DiffBuilder.Build(source, patched); Assert.True(JObject.DeepEquals( JObject.Parse($"{{Objects:{JsonConvert.SerializeObject(patched.Objects)}}}"), diff)); }
public void CheckLengthAferInsertion() { var sut = new ObjectArray(); var intArr = new int[] { 2, 3, 4 }; sut.Add(0); sut.Add(true); sut.Add(3.4647); sut.Add("string"); sut.Add(intArr); sut.Insert(1, 4); Assert.Equal(6, sut.Count); }
public virtual void ProcessTriangle(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { //(void)partId; //(void)triangleIndex; Vector3 wv0, wv1, wv2; wv0 = Vector3.Transform(triangle[0], m_worldTrans); wv1 = Vector3.Transform(triangle[1], m_worldTrans); wv2 = Vector3.Transform(triangle[2], m_worldTrans); m_debugDrawer.DrawLine(ref wv0, ref wv1, ref m_color); m_debugDrawer.DrawLine(ref wv1, ref wv2, ref m_color); m_debugDrawer.DrawLine(ref wv2, ref wv0, ref m_color); }
public virtual void ProcessTriangle(ObjectArray<Vector3> triangle,int partId, int triangleIndex) { Vector3[] rawData = triangle.GetRawArray(); for (int i=0;i<3;i++) { float dot; Vector3.Dot(ref m_supportVecLocal,ref rawData[i],out dot); if (dot > m_maxDot) { m_maxDot = dot; m_supportVertexLocal = triangle[i]; } } }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { // The partId and triangle index must fit in the same (positive) integer Debug.Assert(partId < (1<<MAX_NUM_PARTS_IN_BITS)); Debug.Assert(triangleIndex < (1 << (31 - MAX_NUM_PARTS_IN_BITS))); //negative indices are reserved for escapeIndex Debug.Assert(triangleIndex >= 0); QuantizedBvhNode node = new QuantizedBvhNode(); Vector3 aabbMin,aabbMax; aabbMin = MathUtil.MAX_VECTOR; aabbMax = MathUtil.MIN_VECTOR; Vector3 t1 = triangle[0]; Vector3 t2 = triangle[1]; Vector3 t3 = triangle[2]; MathUtil.VectorMin(ref t1, ref aabbMin); MathUtil.VectorMax(ref t1, ref aabbMax); MathUtil.VectorMin(ref t2, ref aabbMin); MathUtil.VectorMax(ref t2, ref aabbMax); MathUtil.VectorMin(ref t3, ref aabbMin); MathUtil.VectorMax(ref t3, ref aabbMax); //PCK: add these checks for zero dimensions of aabb float MIN_AABB_DIMENSION = 0.002f; float MIN_AABB_HALF_DIMENSION = 0.001f; if (aabbMax.X - aabbMin.X < MIN_AABB_DIMENSION) { aabbMax.X = (aabbMax.X + MIN_AABB_HALF_DIMENSION); aabbMin.X = (aabbMin.X - MIN_AABB_HALF_DIMENSION); } if (aabbMax.Y - aabbMin.Y < MIN_AABB_DIMENSION) { aabbMax.Y = (aabbMax.Y + MIN_AABB_HALF_DIMENSION); aabbMin.Y = (aabbMin.Y - MIN_AABB_HALF_DIMENSION); } if (aabbMax.Z - aabbMin.Z < MIN_AABB_DIMENSION) { aabbMax.Z = (aabbMax.Z + MIN_AABB_HALF_DIMENSION); aabbMin.Z = (aabbMin.Z - MIN_AABB_HALF_DIMENSION); } m_optimizedTree.Quantize(ref node.m_quantizedAabbMin,ref aabbMin,false); m_optimizedTree.Quantize(ref node.m_quantizedAabbMax,ref aabbMax,true); node.m_escapeIndexOrTriangleIndex = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | triangleIndex; m_triangleNodes.Add(node); }
public void IndexedPropertyTest() { const string expectedString1 = "string 1"; const string expectedString2 = "2 string"; var stringArray = new ObjectArray<String>(2); stringArray[0] = expectedString1; stringArray[1] = expectedString2; var actualString1 = (string)stringArray[0]; var actualString2 = (string)stringArray[1]; Assert.AreEqual(expectedString1, actualString1); Assert.AreEqual(expectedString2, actualString2); }
public CompoundShape(bool enableDynamicAabbTree) { m_children = new ObjectArray<CompoundShapeChild>(); m_localAabbMax = new IndexedVector3(float.MinValue); m_localAabbMin = new IndexedVector3(float.MaxValue); m_collisionMargin = 0f; m_localScaling = new IndexedVector3(1f); m_dynamicAabbTree = null; m_updateRevision = 1; m_shapeType = BroadphaseNativeTypes.COMPOUND_SHAPE_PROXYTYPE; if (enableDynamicAabbTree) { m_dynamicAabbTree = new Dbvt(); } }
public virtual void InternalProcessTriangleIndex(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { if (first) { reference = triangle[0]; first = false; } else { Vector3 a = triangle[0] - reference; Vector3 b = triangle[1] - reference; Vector3 c = triangle[2] - reference; float vol = System.Math.Abs(MathUtil.Vector3Triple(ref a,ref b,ref c)); sum += (.25f * vol) * ((triangle[0] + triangle[1] + triangle[2] + reference)); volume += vol; } }
//! Clips a polygon by a plane /*! *\return The count of the clipped counts */ public static int PlaneClipPolygon( ref Vector4 plane, ObjectArray<IndexedVector3> polygon_points, int polygon_point_count, ObjectArray<IndexedVector3> clipped) { int clipped_count = 0; IndexedVector3[] rawPoints = polygon_points.GetRawArray(); //clip first point float firstdist = DistancePointPlane(ref plane, ref rawPoints[0]); ; if (!(firstdist > MathUtil.SIMD_EPSILON)) { clipped[clipped_count] = polygon_points[0]; clipped_count++; } float olddist = firstdist; for (int i = 1; i < polygon_point_count; i++) { float dist = DistancePointPlane(ref plane, ref rawPoints[i]); PlaneClipPolygonCollect( ref rawPoints[i - 1], ref rawPoints[i], olddist, dist, clipped, ref clipped_count); olddist = dist; } //RETURN TO FIRST point PlaneClipPolygonCollect( ref rawPoints[polygon_point_count - 1], ref rawPoints[0], olddist, firstdist, clipped, ref clipped_count); return clipped_count; }
public InplaceSolverIslandCallback( ContactSolverInfo solverInfo, IConstraintSolver solver, ObjectArray<TypedConstraint> sortedConstraints, int numConstraints, IDebugDraw debugDrawer, IDispatcher dispatcher) { m_solverInfo = solverInfo; m_solver = solver; m_sortedConstraints = sortedConstraints; m_numConstraints = numConstraints; m_debugDrawer = debugDrawer; m_dispatcher = dispatcher; m_bodies = new ObjectArray<CollisionObject>(); m_manifolds = new ObjectArray<PersistentManifold>(); m_constraints = new ObjectArray<TypedConstraint>(); }
public virtual void ProcessTriangle(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { //(voidpartId; //(void)triangleIndex; Vector3 wv0 = Vector3.Transform(triangle[0],m_worldTrans); Vector3 wv1 = Vector3.Transform(triangle[1],m_worldTrans); Vector3 wv2 = Vector3.Transform(triangle[2],m_worldTrans); Vector3 center = (wv0+wv1+wv2)*(1f/3f); Vector3 normal = Vector3.Cross((wv1-wv0),(wv2-wv0)); normal.Normalize(); Vector3 normalColor = new Vector3(1,1,0); m_debugDrawer.DrawLine(center,center+normal,normalColor); m_debugDrawer.DrawLine(ref wv0,ref wv1,ref m_color); m_debugDrawer.DrawLine(ref wv1,ref wv2,ref m_color); m_debugDrawer.DrawLine(ref wv2,ref wv0,ref m_color); }
public static int Allocate(ObjectArray<int> ifree, ObjectArray<sStkNPS> stock, sStkNPS value) { //int i; //if(ifree.Count>0) //{ // i = ifree[ifree.Count - 1]; // ifree.pop_back(); // stock[i] = value; //} //else //{ // i=stock.Count; // stock.push_back(value); //} //return(i); return 0; }
public void EnumerableTest() { const string expectedStringBase = "s7r"; const int length = 5; var stringArray = new ObjectArray<String>(length); for (int i = 0; i < length; i++) stringArray[i] = expectedStringBase + i; var currentIndex = 0; foreach (var actualString in stringArray) { var actualClrString = (string) actualString; Assert.AreEqual(expectedStringBase + currentIndex, actualClrString); currentIndex++; } Assert.AreEqual(length, currentIndex); }
public virtual void ProcessTriangle(ObjectArray<Vector3> triangle, int partId, int triangleIndex) { TriangleShape triangleShape = new TriangleShape(triangle[0], triangle[1], triangle[2]); triangleShape.Margin = m_triangleCollisionMargin; VoronoiSimplexSolver simplexSolver = new VoronoiSimplexSolver(); GjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver = new GjkEpaPenetrationDepthSolver(); //#define USE_SUBSIMPLEX_CONVEX_CAST 1 //if you reenable USE_SUBSIMPLEX_CONVEX_CAST see commented ref code below #if USE_SUBSIMPLEX_CONVEX_CAST SubsimplexConvexCast convexCaster = new SubsimplexConvexCast(m_convexShape, triangleShape, simplexSolver); #else //btGjkConvexCast convexCaster(m_convexShape,&triangleShape,&simplexSolver); ContinuousConvexCollision convexCaster = new ContinuousConvexCollision(m_convexShape,triangleShape,simplexSolver,gjkEpaPenetrationSolver); #endif //#USE_SUBSIMPLEX_CONVEX_CAST CastResult castResult = new CastResult(); castResult.m_fraction = 1f; if (convexCaster.CalcTimeOfImpact(ref m_convexShapeFrom,ref m_convexShapeTo,ref m_triangleToWorld, ref m_triangleToWorld, castResult)) { //add hit if (castResult.m_normal.LengthSquared() > 0.0001f) { if (castResult.m_fraction < m_hitFraction) { /* btContinuousConvexCast's normal is already in world space */ /* #ifdef USE_SUBSIMPLEX_CONVEX_CAST //rotate normal into worldspace castResult.m_normal = m_convexShapeFrom.getBasis() * castResult.m_normal; #endif //USE_SUBSIMPLEX_CONVEX_CAST */ castResult.m_normal.Normalize(); ReportHit (ref castResult.m_normal,ref castResult.m_hitPoint,castResult.m_fraction,partId,triangleIndex); } } } }
public TriangleMesh(bool use32bitIndices, bool use4componentVertices) { m_use32bitIndices = use32bitIndices; m_use4componentVertices = use4componentVertices; IndexedMesh meshIndex = new IndexedMesh(); m_indexedMeshes.Add(meshIndex); if (m_use32bitIndices) { m_32bitIndices = new ObjectArray<int>(); m_indexedMeshes[0].m_numTriangles = m_32bitIndices.Count / 3; m_indexedMeshes[0].m_indexType = PHY_ScalarType.PHY_INTEGER; m_indexedMeshes[0].m_triangleIndexStride = 3; } else { m_16bitIndices = new ObjectArray<short>(); m_indexedMeshes[0].m_numTriangles = m_16bitIndices.Count / 3; m_indexedMeshes[0].m_triangleIndexBase = null; m_indexedMeshes[0].m_indexType = PHY_ScalarType.PHY_SHORT; m_indexedMeshes[0].m_triangleIndexStride = 3; } if (m_use4componentVertices) { m_4componentVertices = new ObjectArray<IndexedVector3>(); m_indexedMeshes[0].m_numVertices = m_4componentVertices.Count; m_indexedMeshes[0].m_vertexStride = 1; m_indexedMeshes[0].m_vertexBase = m_4componentVertices; } else { m_3componentVertices = new ObjectArray<float>(); m_indexedMeshes[0].m_numVertices = m_3componentVertices.Count / 3; m_indexedMeshes[0].m_vertexStride = 3; m_indexedMeshes[0].m_vertexBase = m_3componentVertices; } }