public static void UpdateLightProxy(MyLight light) { if ((!light.LightOn || light.LightType == MyLight.LightTypeEnum.None) && light.ProxyId != MyDynamicAABBTree.NullNode) { m_tree.RemoveProxy(light.ProxyId); light.ProxyId = MyDynamicAABBTree.NullNode; } BoundingBox bbox = BoundingBoxHelper.InitialBox; if (light.IsTypePoint || light.IsTypeHemisphere) { bbox = BoundingBox.CreateFromSphere(light.PointBoundingSphere); } if (light.IsTypeSpot) { var box = light.SpotBoundingBox; BoundingBoxHelper.AddBBox(box, ref bbox); } if (light.ProxyId == MyDynamicAABBTree.NullNode) { light.ProxyId = m_tree.AddProxy(ref bbox, light, 0); } else { m_tree.MoveProxy(light.ProxyId, ref bbox, Vector3.Zero); } }
void UpdateMoneyStack() { //HashSet<GameObject> stacks = new HashSet<GameObject>(); int totalStacksToShow = TotalMoney / 1000; while (_shownMoneyStacks < totalStacksToShow) { GameObject newBundle = GameObject.Instantiate("cashStack", transform.position + 0.5f * Vector3.Up, MyRandom.YRotation()); //stacks.Add(newBundle); Vector3 size = BoundingBoxHelper.CalculateSize(newBundle.Model, newBundle.transform.scale); int stackId = _shownMoneyStacks / BundlesPerStack; int rowId = stackId % ColumnsPerRow; int colId = stackId / ColumnsPerRow; Vector3 up = (0.1f + (_shownMoneyStacks % BundlesPerStack) * size.Y) * Vector3.Up; Vector3 right = (rowId * Margin + size.X * rowId) * Vector3.Right; Vector3 back = (colId * Margin + size.Z * colId) * Vector3.Backward; newBundle.transform.position = transform.position + up + right + back; lock (lockList) { _moneyGameObjects.Add(newBundle); ++_shownMoneyStacks; } //await Time.WaitForSeconds(0.1f); } }
void AddToActive(CollisionSkin cs, SkinTester st) { int n = active_.Count; float xMin = cs.WorldBoundingBox.Min.X; bool active = (cs.Owner != null) && cs.Owner.IsActive; for (int i = 0; i != n;) { CollisionSkin asi = active_[i]; if (asi.WorldBoundingBox.Max.X < xMin) { // prune no longer interesting boxes from potential overlaps --n; active_.RemoveAt(i); } else { bool active2 = active || (active_[i].Owner != null && asi.Owner.IsActive); if (active2 && BoundingBoxHelper.OverlapTest(ref cs.WorldBoundingBox, ref asi.WorldBoundingBox)) { if (active) { st.TestSkin(cs, asi); } else { st.TestSkin(asi, cs); } } ++i; } } active_.Add(cs); }
public WorstCouple GetWorstCouple(IEnumerable <ShapeItem <T> > items) { var worstCouple = new WorstCouple(); var currentCoverArea = BoundingBoxHelper <T> .GetDiffCoveredArea( items.ElementAt(0).BoundingBox , items.ElementAt(1).BoundingBox); for (int i = 0; i < items.Count(); i++) { for (int l = 0; l < items.Count(); l++) { if (l != i) { var coverArea = BoundingBoxHelper <T> .GetDiffCoveredArea( items.ElementAt(i).BoundingBox , items.ElementAt(l).BoundingBox); if (coverArea.CompareTo(currentCoverArea) > 0) { currentCoverArea = coverArea; worstCouple.IndexA = i; worstCouple.IndexB = l; } } } } return(worstCouple); }
public virtual void Draw(GameTime gameTime) { foreach (MapTile tile in DrawnMap) { MapRender.Draw( MapSpriteSheet.Sprite(CharToTile[tile.ModelChar]), tile.Position, 0.1f, Color.White, 0, 1, SpriteEffects.None); } foreach (MapTile tile in DrawnMap) { if (tile.IsCollidable) { if (DebugConstants.ShowBoundingBoxes) { BoundingBoxHelper.DrawRectangle(tile.BoundingBox, GlobalAssets.BBoxOutline, Color.White, MapBatch, false, 1); } if ((tile.IsBeingCollided || tile.IsBeingStoodOn) && DebugConstants.ShowCollisionOverlays) { BoundingBoxHelper.DrawRectangle(tile.BoundingBox, GlobalAssets.CollisionOverlay, Color.White, MapBatch, true, 1); } } } }
public BoundingBox GetAABB() { BoundingBox box = BoundingBoxHelper.InitialBox; BoundingFrustum frustum = ConvertToFrustum(); BoundingBoxHelper.AddFrustum(ref frustum, ref box); return(box); }
/// <summary> /// CollDetectBoxStaticMeshOverlap /// </summary> /// <param name="oldBox"></param> /// <param name="newBox"></param> /// <param name="mesh"></param> /// <param name="info"></param> /// <param name="collTolerance"></param> /// <param name="collisionFunctor"></param> /// <returns>bool</returns> private static bool CollDetectBoxStaticMeshOverlap(Box oldBox, Box newBox, TriangleMesh mesh, ref CollDetectInfo info, float collTolerance, CollisionFunctor collisionFunctor) { float boxRadius = newBox.GetBoundingRadiusAroundCentre(); #region REFERENCE: Vector3 boxCentre = newBox.GetCentre(); Vector3 boxCentre; newBox.GetCentre(out boxCentre); // Deano need to trasnform the box center into mesh space Matrix invTransformMatrix = mesh.InverseTransformMatrix; Vector3.Transform(ref boxCentre, ref invTransformMatrix, out boxCentre); #endregion BoundingBox bb = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddBox(newBox, ref bb); bool collision = false; int[] potTriArray = IntStackAlloc(); // aabox is done in mesh space and handles the mesh transform correctly int numTriangles = mesh.GetTrianglesIntersectingtAABox(potTriArray, MaxLocalStackTris, ref bb); for (int iTriangle = 0; iTriangle < numTriangles; ++iTriangle) { IndexedTriangle meshTriangle = mesh.GetTriangle(potTriArray[iTriangle]); // quick early test is done in mesh space float dist = meshTriangle.Plane.DotCoordinate(boxCentre); // BEN-BUG-FIX: Fixed by chaning 0.0F to -boxRadius. if (dist > boxRadius || dist < -boxRadius) { continue; } if (DoOverlapBoxTriangleTest( oldBox, newBox, ref meshTriangle, mesh, ref info, collTolerance, collisionFunctor)) { collision = true; } } FreeStackAlloc(potTriArray); return(collision); }
public void ShouldGet3Diff() { var rectangle = BoundingBoxHelper <Int32> .GetBoundingBox(3, 3); var rectangle2 = BoundingBoxHelper <Int32> .GetBoundingBox(4, 3); var diff = BoundingBoxHelper <Int32> .GetDiffCoveredArea(rectangle, rectangle2); Assert.AreEqual(3, diff); }
// --------------------- CUSTOM METHODS ---------------- // queries // other private Vector3 CalculateShadowSize(GameObject shadow) { Vector3 modelSize = BoundingBoxHelper.CalculateSize(gameObject.Model, transform.scale); Vector3 shadowSize = BoundingBoxHelper.CalculateSize(shadow.Model, shadow.transform.scale); float xFactor = shadowSize.X / modelSize.X; float zFactor = shadowSize.Z / modelSize.Z; return(new Vector3(1.5f / xFactor, 1.0f, 1.5f / zFactor)); }
private static void CollDetectSweep(ref CollDetectInfo info, float collTolerance, CollisionFunctor collisionFunctor) { var mesh = info.Skin1.GetPrimitiveNewWorld(info.IndexPrim1) as TriangleMesh; var oldBox = info.Skin0.GetPrimitiveOldWorld(info.IndexPrim0) as Box; var newBox = info.Skin0.GetPrimitiveNewWorld(info.IndexPrim0) as Box; oldBox.GetCentre(out var oldCentre); newBox.GetCentre(out var newCentre); Vector3.Subtract(ref newCentre, ref oldCentre, out var delta); var boxMinLen = 0.5f * System.Math.Min(newBox.SideLengths.X, System.Math.Min(newBox.SideLengths.Y, newBox.SideLengths.Z)); var nPositions = 1 + (int)(delta.Length() / boxMinLen); if (nPositions > 50) { System.Diagnostics.Debug.WriteLine("Warning - clamping max positions in swept box test"); nPositions = 50; } if (nPositions == 1) { CollDetectBoxStaticMeshOverlap(oldBox, newBox, mesh, ref info, collTolerance, collisionFunctor); } else { var bb = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddBox(oldBox, ref bb); BoundingBoxHelper.AddBox(newBox, ref bb); unsafe { var potentialTriangles = stackalloc int[MaxLocalStackTris]; { var numTriangles = mesh.GetTrianglesIntersectingtAABox(potentialTriangles, MaxLocalStackTris, ref bb); if (numTriangles <= 0) { return; } for (var i = 0; i <= nPositions; ++i) { var frac = (float)i / nPositions; Vector3.Multiply(ref delta, frac, out var centre); Vector3.Add(ref centre, ref oldCentre, out centre); var orient = Matrix.Add(Matrix.Multiply(oldBox.Orientation, 1.0f - frac), Matrix.Multiply(newBox.Orientation, frac)); var box = new Box(centre - 0.5f * Vector3.TransformNormal(newBox.SideLengths, orient), orient, newBox.SideLengths); CollDetectBoxStaticMeshOverlap(oldBox, box, mesh, ref info, collTolerance, collisionFunctor); } } } } }
/// <summary> /// SegmentIntersect /// </summary> /// <param name="fracOut"></param> /// <param name="skinOut"></param> /// <param name="posOut"></param> /// <param name="normalOut"></param> /// <param name="seg"></param> /// <param name="collisionPredicate"></param> /// <returns>bool</returns> public override bool SegmentIntersect(out float fracOut, out CollisionSkin skinOut, out Microsoft.Xna.Framework.Vector3 posOut, out Microsoft.Xna.Framework.Vector3 normalOut, JigLibX.Geometry.Segment seg, CollisionSkinPredicate1 collisionPredicate) { fracOut = float.MaxValue; skinOut = null; posOut = normalOut = Vector3.Zero; float frac; Vector3 pos; Vector3 normal; Vector3 segmentBeginning = seg.Origin; Vector3 segmentEnd = seg.Origin + seg.Delta; Vector3 min = Vector3.Min(segmentBeginning, segmentEnd); Vector3 max = Vector3.Max(segmentBeginning, segmentEnd); active_.Clear(); BoundingBox box = new BoundingBox(min, max); Extract(min, max, active_); float distanceSquared = float.MaxValue; int nActive = active_.Count; for (int i = 0; i != nActive; ++i) { CollisionSkin skin = active_[i]; if (collisionPredicate == null || collisionPredicate.ConsiderSkin(skin)) { if (BoundingBoxHelper.OverlapTest(ref box, ref skin.WorldBoundingBox)) { if (skin.SegmentIntersect(out frac, out pos, out normal, seg)) { if (frac >= 0) { float newDistanceSquared = Vector3.DistanceSquared(segmentBeginning, pos); if (newDistanceSquared < distanceSquared) { distanceSquared = newDistanceSquared; fracOut = frac; skinOut = skin; posOut = pos; normalOut = normal; } } } } } } return(fracOut <= 1); }
public void ShouldGet4x4Bb() { var rectangle = BoundingBoxHelper <Int32> .GetBoundingBox(3, 4); var rectangle2 = BoundingBoxHelper <Int32> .GetBoundingBox(4, 3); var coverdArea = (BoundingBox2D <Int32>)rectangle.GetCoveredBoundingbox(rectangle2); Assert.AreEqual(4, coverdArea.Width); Assert.AreEqual(4, coverdArea.Height); }
static void UpdateBoundingFrustum() { // Update frustum BoundingFrustum.Matrix = ViewProjectionMatrix; // Update bounding box BoundingBox = new BoundingBox(new Vector3(float.PositiveInfinity), new Vector3(float.NegativeInfinity)); BoundingBoxHelper.AddFrustum(ref BoundingFrustum, ref BoundingBox); // Update bounding sphere BoundingSphere = MyUtils.GetBoundingSphereFromBoundingBox(ref BoundingBox); }
private static void FindObjectsInDetectingArea() { // find max detector's range float range = Math.Max(DefaultRadarRange, MyHudConstants.RADAR_JAMMER_RANGE); Debug.Assert(m_objectsInDetectingArea.Count == 0); BoundingSphere sphereToDetecting = new BoundingSphere(GetRadarPosition(), range); BoundingBox radarBoundingBox = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddSphere(ref sphereToDetecting, ref radarBoundingBox); MyEntities.GetElementsInBox(ref radarBoundingBox, m_objectsInDetectingArea); }
protected void CutOutFromVoxel(MyVoxelMap voxelMap, ref BoundingSphere bigSphereForTunnel) { if (!IsDummy) { if (MyMultiplayerGameplay.IsRunning) { MyMultiplayerGameplay.Static.CutOut(voxelMap, ref bigSphereForTunnel); } //remove decals MyDecals.HideTrianglesAfterExplosion(voxelMap, ref bigSphereForTunnel); //cut off MyVoxelGenerator.CutOutSphereFast(voxelMap, bigSphereForTunnel); if (MySession.Is25DSector) { // Create debris rocks thrown from the explosion MyExplosionDebrisVoxel.CreateExplosionDebris(ref bigSphereForTunnel, 1, CommonLIB.AppCode.Networking.MyMwcVoxelMaterialsEnum.Ice_01, MinerWars.AppCode.Game.Managers.Session.MySession.PlayerShip.GroupMask, voxelMap); BoundingBox boundingBox = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddSphere(ref bigSphereForTunnel, ref boundingBox); // we need local list because this method can be called from inside of the loop var elements = MyEntities.GetElementsInBox(ref boundingBox); foreach (var el in elements) { MyEntity entity = ((MinerWars.AppCode.Game.Physics.MyPhysicsBody)el.GetRigidBody().m_UserData).Entity; MyExplosionDebrisVoxel debris = entity as MyExplosionDebrisVoxel; if (debris == null) { continue; } Vector3 awayDirection = debris.GetPosition() - bigSphereForTunnel.Center; debris.Physics.AddForce( MinerWars.AppCode.Game.Physics.MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE, awayDirection * MyExplosionsConstants.EXPLOSION_FORCE_RADIUS_MULTIPLIER * 100000, bigSphereForTunnel.Center, MinerWars.CommonLIB.AppCode.Utils.MyMwcUtils.GetRandomVector3Normalized() * 10000); } elements.Clear(); } PlayVoxelCutCue(); } }
// IMPORTANT: This struct must be initialized using this constructor, or by filling all four fields. It's because // some code may need length or distance, and if they aren't calculated, we can have problems. public MyLine(Vector3 from, Vector3 to, bool calculateBoundingBox = true) { From = from; To = to; Direction = MyMwcUtils.Normalize(to - from); Vector3.Distance(ref to, ref from, out Length); // Calculate line's bounding box, but only if we know we will need it BoundingBox = BoundingBoxHelper.InitialBox; if (calculateBoundingBox == true) { BoundingBoxHelper.AddLine(ref this, ref BoundingBox); } }
public override bool SegmentIntersect(out float fracOut, out CollisionSkin skinOut, out Vector3 posOut, out Vector3 normalOut, Segment seg, CollisionSkinPredicate1 collisionPredicate) { fracOut = float.MaxValue; skinOut = null; posOut = normalOut = Vector3.Zero; var segmentBeginning = seg.Origin; var segmentEnd = seg.Origin + seg.Delta; var min = Vector3.Min(segmentBeginning, segmentEnd); var max = Vector3.Max(segmentBeginning, segmentEnd); active_.Clear(); var box = new BoundingBox(min, max); Extract(min, max, active_); var distanceSquared = float.MaxValue; var nActive = active_.Count; for (var i = 0; i != nActive; ++i) { var skin = active_[i]; if (collisionPredicate == null || collisionPredicate.ConsiderSkin(skin)) { if (BoundingBoxHelper.OverlapTest(ref box, ref skin.WorldBoundingBox)) { if (skin.SegmentIntersect(out var frac, out var pos, out var normal, seg)) { if (frac >= 0) { var newDistanceSquared = Vector3.DistanceSquared(segmentBeginning, pos); if (newDistanceSquared < distanceSquared) { distanceSquared = newDistanceSquared; fracOut = frac; skinOut = skin; posOut = pos; normalOut = normal; } } } } } } return(fracOut <= 1); }
public bool GetIntersectionWithSphere(MyEntity physObject, ref BoundingSphere sphere) { // Transform sphere from world space to object space Matrix worldInv = physObject.GetWorldMatrixInverted(); Vector3 positionInObjectSpace = MyUtils.GetTransform(sphere.Center, ref worldInv); BoundingSphere sphereInObjectSpace = new BoundingSphere(positionInObjectSpace, sphere.Radius); var aabb = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddSphere(ref sphereInObjectSpace, ref aabb); AABB gi_aabb = new AABB(ref aabb.Min, ref aabb.Max); m_overlappedTriangles.Clear(); if (m_bvh.BoxQuery(ref gi_aabb, m_overlappedTriangles)) { // temporary variable for storing tirngle boundingbox info BoundingBox triangleBoundingBox = new BoundingBox(); // Triangles that are directly in this node for (int i = 0; i < m_overlappedTriangles.Count; i++) { var triangleIndex = m_overlappedTriangles[i]; m_model.GetTriangleBoundingBox(triangleIndex, ref triangleBoundingBox); // First test intersection of triangleVertexes's bounding box with bounding sphere. And only if they overlap or intersect, do further intersection tests. if (MyUtils.IsBoxIntersectingSphere(triangleBoundingBox, ref sphereInObjectSpace) == true) { // See that we swaped vertex indices!! MyTriangle_Vertexes triangle; MyTriangleVertexIndices triangleIndices = m_model.Triangles[triangleIndex]; triangle.Vertex0 = m_model.GetVertex(triangleIndices.I0); triangle.Vertex1 = m_model.GetVertex(triangleIndices.I2); triangle.Vertex2 = m_model.GetVertex(triangleIndices.I1); MyPlane trianglePlane = new MyPlane(ref triangle); if (MyUtils.GetSphereTriangleIntersection(ref sphereInObjectSpace, ref trianglePlane, ref triangle) != null) { // If we found intersection we can stop and dont need to look further return(true); } } } } return(false); }
private void LoadWaypointEdges() { m_edges.Clear(); BoundingBox bb = BoundingBoxHelper.InitialBox; foreach (var part in m_parts) { if (part != null) { BoundingBoxHelper.AddBBox(part.WorldAABB, ref bb); } } m_edges.AddRange(MyWayPointGraph.GetAllEdgesInBox(ref bb)); }
} // void public override bool SegmentIntersect(out float fracOut, out CollisionSkin skinOut, out Vector3 posOut, out Vector3 normalOut, Segment seg, CollisionSkinPredicate1 collisionPredicate) { int numSkins = skins.Count; BoundingBox segBox = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddSegment(seg, ref segBox); //initialise the outputs fracOut = float.MaxValue; skinOut = null; posOut = normalOut = Vector3.Zero; // working vars float frac; Vector3 pos; Vector3 normal; for (int iskin = 0; iskin < numSkins; ++iskin) { CollisionSkin skin = skins[iskin]; if ((collisionPredicate == null) || collisionPredicate.ConsiderSkin(skin)) { // basic bbox test if (BoundingBoxHelper.OverlapTest(ref skin.WorldBoundingBox, ref segBox)) { if (skin.SegmentIntersect(out frac, out pos, out normal, seg)) { if (frac < fracOut) { posOut = pos; normalOut = normal; skinOut = skin; fracOut = frac; } } } } } if (fracOut > 1.0f) { return(false); } fracOut = MathHelper.Clamp(fracOut, 0.0f, 1.0f); return(true); }
public override void Draw(GameTime gameTime) { // Only draw if we're doing a BasicEffectPass pass if (GearsetResources.CurrentRenderPass != RenderPass.BasicEffectPass) { return; } if (_hoveringObject is IPickable <BoundingBox> ) { BoundingBoxHelper.DrawBoundingBox(((IPickable <BoundingBox>)_hoveringObject).PickableVolume, Color.Gray); } if (_selectedObject is IPickable <BoundingBox> ) { BoundingBoxHelper.DrawBoundingBox(((IPickable <BoundingBox>)_selectedObject).PickableVolume, Color.White); } }
public void Draw(GameTime deltaTime, Entity entity) { var currentFrame = _currentAnimation.GetCurrentFrame(); _spriteRender.Draw(currentFrame.SpriteFrame, new Vector2(entity.Position.X, entity.Position.Y), .5f, Color.White, rotation: 0, scale: entity.Scale, spriteEffects: currentFrame.SpriteEffect); if (DebugConstants.ShowBoundingBoxes) { BoundingBoxHelper.DrawRectangle(entity.BoundingBox, GlobalAssets.BBoxOutline, Color.White, _spriteBatch, false, 1); } }
public override bool SegmentIntersect(out float fracOut, out CollisionSkin skinOut, out Microsoft.Xna.Framework.Vector3 posOut, out Microsoft.Xna.Framework.Vector3 normalOut, JigLibX.Geometry.Segment seg, CollisionSkinPredicate1 collisionPredicate) { fracOut = float.MaxValue; skinOut = null; posOut = normalOut = Vector3.Zero; Vector3 min = seg.GetPoint(0); Vector3 tmp = seg.GetEnd(); Vector3 max; Vector3.Max(ref min, ref tmp, out max); Vector3.Min(ref min, ref tmp, out min); BoundingBox box = new BoundingBox(min, max); float frac; Vector3 pos; Vector3 normal; active_.Clear(); Extract(min, max, active_); int nActive = active_.Count; for (int i = 0; i != nActive; ++i) { CollisionSkin skin = active_[i]; if (collisionPredicate == null || collisionPredicate.ConsiderSkin(skin)) { if (BoundingBoxHelper.OverlapTest(ref box, ref skin.WorldBoundingBox)) { if (skin.SegmentIntersect(out frac, out pos, out normal, seg)) { if (frac >= 0 && frac < fracOut) { fracOut = frac; skinOut = skin; posOut = pos; normalOut = normal; } } } } } return(fracOut <= 1); }
public static RNode <T> GetLessEnlargementNode(IEnumerable <RNode <T> > nodes, IBoundingBox <T> item) { var nextNode = nodes.First(); var coverdArea = nextNode.BoundingBox.GetCoveredBoundingbox(item); var diff = BoundingBoxHelper <T> .Substract(coverdArea.GetArea(), nextNode.BoundingBox.GetArea()); //get node by trying to get the less enlargement for (int i = 1; i < nodes.Count(); i++) { var diff2 = BoundingBoxHelper <T> .GetDiffCoveredArea(item, nodes.ElementAt(i).BoundingBox); if (diff2.CompareTo(diff) < 0) { nextNode = nodes.ElementAt(i); } } return(nextNode); }
private static bool CollDetectBoxStaticMeshOverlap(Box oldBox, Box newBox, TriangleMesh mesh, ref CollDetectInfo info, float collTolerance, CollisionFunctor collisionFunctor) { var boxRadius = newBox.GetBoundingRadiusAroundCentre(); newBox.GetCentre(out var boxCentre); var invTransformMatrix = mesh.InverseTransformMatrix; Vector3.Transform(ref boxCentre, ref invTransformMatrix, out boxCentre); var bb = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddBox(newBox, ref bb); unsafe { var collision = false; var potentialTriangles = stackalloc int[MaxLocalStackTris]; { var numTriangles = mesh.GetTrianglesIntersectingtAABox(potentialTriangles, MaxLocalStackTris, ref bb); for (var iTriangle = 0; iTriangle < numTriangles; ++iTriangle) { var meshTriangle = mesh.GetTriangle(potentialTriangles[iTriangle]); var dist = meshTriangle.Plane.DotCoordinate(boxCentre); if (dist > boxRadius || dist < -boxRadius) { continue; } if (DoOverlapBoxTriangleTest(oldBox, newBox, ref meshTriangle, mesh, ref info, collTolerance, collisionFunctor)) { collision = true; } } } return(collision); } }
/// <summary> /// Updates bounding volume of this skin /// </summary> public void UpdateWorldBoundingBox() { BoundingBox temp = BoundingBoxHelper.InitialBox; for (int iold = primitivesOldWorld.Count; iold-- != 0;) { BoundingBoxHelper.AddPrimitive(primitivesOldWorld[iold], ref temp); } if (collSystem != null && collSystem.UseSweepTests) { for (int inew = primitivesNewWorld.Count; inew-- != 0;) { BoundingBoxHelper.AddPrimitive(primitivesNewWorld[inew], ref temp); } } WorldBoundingBox = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddBBox(temp, ref WorldBoundingBox); }
private static List <UtmSheet> GetIndexSheets(BoundingBox geographicIntersectRegion, double utmWidth, double utmHeight, UtmIndexType type, int utmZone) { var geoBound = BoundingBoxHelper.UtmMbbToGeodeticWgs84Mbb(_2kUtmBoudingBox, utmZone) .Intersect(geographicIntersectRegion); List <UtmSheet> result = new List <UtmSheet>(); if (geoBound.IsNaN()) { return(result); } var utmBound = BoundingBoxHelper.GeodeticWgs84MbbToUtmMbb(geoBound, utmZone) .Intersect(_2kUtmBoudingBox); if (utmBound.IsNaN()) { return(result); } int iStart = (int)Math.Floor((utmBound.XMin - _2kUtmXmin) / utmWidth); int iEnd = (int)Math.Ceiling((utmBound.XMax - _2kUtmXmin) / utmWidth); int jStart = (int)Math.Floor((utmBound.YMin - _2kUtmYmin) / utmHeight); int jEnd = (int)Math.Ceiling((utmBound.YMax - _2kUtmYmin) / utmHeight); for (int i = iStart; i < iEnd; i++) { for (int j = jStart; j < jEnd; j++) { var startX = _2kUtmXmin + i * utmWidth; var startY = _2kUtmYmin + j * utmHeight; result.Add(UtmSheet.Create(new BoundingBox(startX, startY, startX + utmWidth, startY + utmHeight), type, utmZone)); } } return(result); }
/// <summary> /// Calculate the tightest bounding-shape with the given <paramref name="type"/> /// </summary> /// <param name="type">Type of the bounding-shape</param> protected virtual void CalculateShape(ShapeType type) { Model model = gameObject.Model; BoundingBox bb = BoundingBoxHelper.Calculate(model); JVector bbSize = Conversion.ToJitterVector(bb.Max - bb.Min); bbSize = new JVector( bbSize.X * Size.X * gameObject.transform.scale.X, bbSize.Y * Size.Y * gameObject.transform.scale.Y, bbSize.Z * Size.Z * gameObject.transform.scale.Z ); JVector com = 0.5f * Conversion.ToJitterVector(bb.Max + bb.Min); CenterOfMass = new JVector(com.X * gameObject.transform.scale.X, com.Y * gameObject.transform.scale.Y, com.Z * gameObject.transform.scale.Z); float maxDimension = MathHelper.Max(bbSize.X, MathHelper.Max(bbSize.Y, bbSize.Z)); switch (type) { case ShapeType.Sphere: CollisionShape = new SphereShape(maxDimension); break; case ShapeType.BoxUniform: CollisionShape = new BoxShape(maxDimension, maxDimension, maxDimension); break; case ShapeType.Box: case ShapeType.BoxInvisible: CollisionShape = new BoxShape(bbSize); break; } }
private void CollDetectSweep(ref CollDetectInfo info, float collTolerance, CollisionFunctor collisionFunctor) { // todo - proper swept test // note - mesh is static and its triangles are in world space TriangleMesh mesh = info.Skin1.GetPrimitiveNewWorld(info.IndexPrim1) as TriangleMesh; Box oldBox = info.Skin0.GetPrimitiveOldWorld(info.IndexPrim0) as Box; Box newBox = info.Skin0.GetPrimitiveNewWorld(info.IndexPrim0) as Box; Vector3 oldCentre; oldBox.GetCentre(out oldCentre); Vector3 newCentre; newBox.GetCentre(out newCentre); Vector3 delta; Vector3.Subtract(ref newCentre, ref oldCentre, out delta); float boxMinLen = 0.5f * System.Math.Min(newBox.SideLengths.X, System.Math.Min(newBox.SideLengths.Y, newBox.SideLengths.Z)); int nPositions = 1 + (int)(delta.Length() / boxMinLen); // limit the max positions... if (nPositions > 50) { System.Diagnostics.Debug.WriteLine("Warning - clamping max positions in swept box test"); nPositions = 50; } if (nPositions == 1) { CollDetectBoxStaticMeshOverlap(oldBox, newBox, mesh, ref info, collTolerance, collisionFunctor); } else { BoundingBox bb = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddBox(oldBox, ref bb); BoundingBoxHelper.AddBox(newBox, ref bb); unsafe { #if USE_STACKALLOC int *potentialTriangles = stackalloc int[MaxLocalStackTris]; { #else int[] potTriArray = IntStackAlloc(); fixed(int *potentialTriangles = potTriArray) { #endif int numTriangles = mesh.GetTrianglesIntersectingtAABox(potentialTriangles, MaxLocalStackTris, ref bb); if (numTriangles > 0) { for (int i = 0; i <= nPositions; ++i) { float frac = ((float)i) / nPositions; Vector3 centre; Vector3.Multiply(ref delta, frac, out centre); Vector3.Add(ref centre, ref oldCentre, out centre); Matrix orient = Matrix.Add(Matrix.Multiply(oldBox.Orientation, 1.0f - frac), Matrix.Multiply(newBox.Orientation, frac)); Box box = new Box(centre - 0.5f * Vector3.Transform(newBox.SideLengths, orient), orient, newBox.SideLengths); // ideally we'd break if we get one collision... but that stops us getting multiple collisions // when we enter a corner (two walls meeting) - can let us pass through CollDetectBoxStaticMeshOverlap(oldBox, box, mesh, ref info, collTolerance, collisionFunctor); } } #if USE_STACKALLOC } #else } FreeStackAlloc(potTriArray); #endif } } }
public void OverlapAllLineSegment <T>(ref MyLine line, List <MyLineSegmentOverlapResult <T> > elementsList, uint requiredFlags) { MyPerformanceCounter.PerCameraDraw.StartTimer("DAABB"); MyPerformanceCounter.PerCameraDraw.Increment("DAABB Queries line"); elementsList.Clear(); if (_root == NullNode) { MyPerformanceCounter.PerCameraDraw.StopTimer("DAABB"); return; } using (m_rwLock.AcquireSharedUsing()) { Stack <int> stack = GetStack(); stack.Push(_root); BoundingBox bbox = BoundingBoxHelper.InitialBox; BoundingBoxHelper.AddLine(ref line, ref bbox); var ray = new Ray(line.From, line.Direction); while (stack.Count > 0) { int nodeId = stack.Pop(); if (nodeId == NullNode) { continue; } DynamicTreeNode node = _nodes[nodeId]; if (node.Aabb.Intersects(bbox)) { float?distance = node.Aabb.Intersects(ray); if (distance.HasValue && distance.Value <= line.Length && distance.Value >= 0) { if (node.IsLeaf()) { uint flags = GetUserFlag(nodeId); if ((flags & requiredFlags) == requiredFlags) { elementsList.Add(new MyLineSegmentOverlapResult <T> { Element = GetUserData <T>(nodeId), Distance = distance.Value }); } } else { stack.Push(node.Child1); stack.Push(node.Child2); } } } } PushStack(stack); } MyPerformanceCounter.PerCameraDraw.StopTimer("DAABB"); }