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;
}
}
