//For Chunk Selector public void SetSelectedChunk(Vector3 Position, Vector3 RayDirection) { CollisionResults Collision = ChunkSelectorQuad.CollideWith(Position, RayDirection); if (Collision == null) { return; } if (MasteryFile != null && Collision.GetClosest() != null) { float ChunkSize = MasteryFile.Settings.ChunkSize; SelectedChunkX = (int)Math.Floor(Collision.GetClosest().CollisionPoint.X / ChunkSize); SelectedChunkY = (int)Math.Floor(Collision.GetClosest().CollisionPoint.Y / ChunkSize); SelectedChunkX = SelectedChunkX >= 0 ? SelectedChunkX : 0; SelectedChunkY = SelectedChunkY >= 0 ? SelectedChunkY : 0; Vector3 ChunkPosition = new Vector3(SelectedChunkX * ChunkSize, SelectedChunkY * ChunkSize, 0); WorldFileGrid.SetPosition(Render.Graphics, ChunkPosition); ChunkSelectorQuad.SetPosition(ChunkPosition); //change CurrentWordFile CurrentWorldFile = null; if (MasteryFile.HasWorldFile(SelectedChunkX, SelectedChunkY)) { CurrentWorldFile = MasteryFile.GetWorldFile(SelectedChunkX, SelectedChunkY, 0); } } }
public CollisionResults Move(Vector3 distance) { //want to return: //how far the object can move //Whether or not there were any collision //what side the collisions were on CollisionResults result = new CollisionResults(distance, aabb.bounds, skinWidth); DoRaycasts(ref result, false); //vertical DoRaycasts(ref result, true); //horizontal return(result); }
public CollisionResults CollideWith(Vector3 Origin, Vector3 Direction, float Range) { CollisionResults Results = new CollisionResults(); for (int i = 0; i < Batches.Count; i++) { CollisionResults BatchResults = Batches[i].CollideWith(Origin, Direction, Range); if (Batches[i].InstanceCount > 0) { Results.AddRange(Batches[i].CollideWith(Origin, Direction, Range)); } } return(Results); }
public CollisionResults CollideWith(Vector3 Position, Vector3 Direction) { CollisionResults Results = new CollisionResults(); List <Geometry3D> HitList = GetAllGeometries(); for (int i = 0; i < HitList.Count; i++) { Geometry3D Geom = HitList.ElementAt(i); CollisionResults NewResults = Geom.CollideWith(Position, Direction); if (NewResults.Count > 0) { Results.AddRange(NewResults); } } return(Results); }
private void DoRaycasts(ref CollisionResults results, bool doHorizontal) { float sign = Mathf.Sign(doHorizontal ? results.distance.x : results.distance.y); Vector3 dir = sign * (doHorizontal ? Vector3.right : Vector3.up); float rayLength = skinWidth + Mathf.Abs(doHorizontal ? results.distance.x : results.distance.y); Vector3[] origins = doHorizontal ? results.GetOriginsH() : results.GetOriginsV(); foreach (Vector3 origin in origins) { Debug.DrawRay(origin, dir * rayLength); RaycastHit2D hit = Physics2D.Raycast(origin, dir, rayLength, collidableWith); if (hit.collider && hit.distance < rayLength) { rayLength = hit.distance; results.Limit(rayLength - skinWidth, doHorizontal); } } }
public void AABBProjectionTestC() { float currentFrame = GetNextTestTime(); Vector2f velocity1 = new SFML.Window.Vector2f(300.0f, 300.0f); Vector2f velocity2 = new SFML.Window.Vector2f(400.0f, -300.0f); Vector2f startPosition1 = new SFML.Window.Vector2f(150.0f, 100.0f) + (velocity1 * currentFrame); Vector2f startPosition2 = new SFML.Window.Vector2f(175.0f, 350.0f) + (velocity2 * currentFrame); velocity1 = velocity1 - (velocity1 * currentFrame); velocity2 = velocity2 - (velocity2 * currentFrame); CollisionObject box1 = new CollisionObject(startPosition1, new Vector2f(50.0f, 50.0f), Color.Blue); CollisionObject box2 = new CollisionObject(startPosition2, new Vector2f(50.0f, 50.0f), Color.Magenta); box1.Velocity = velocity1; box2.Velocity = velocity2; CollisionResults results = CollisionManager.TestCollisions(box1, box2); window.Draw(results); }
public void UpdateBrushHighLight(Vector3 Origin, Vector3 Direction, Vector4 Color, int ToolGroup, int Shape, float BrushRadius, float Radius) { if (FileManager.CurrentWorldFile == null || FileManager.MasteryFile == null) { return; } CollisionResults Results = new CollisionResults(); switch (ToolGroup) { case 0: Results.AddRange(RayCastTerrain(Origin, Direction, Radius)); break; case 1: Results.AddRange(RayCastWater(Origin, Direction, Radius)); break; case 2: Results.AddRange(RayCastWater(Origin, Direction, Radius)); Results.AddRange(RayCastTerrain(Origin, Direction, Radius)); break; } if (Results.Count == 0) { return; } CollisionResult Result = Results.GetClosest(); int SelectedLOD = FileManager.CurrentWorldFile.LODID; //Editing Bounds Vector2 A1 = new Vector2(Result.CollisionPoint.X - Radius, Result.CollisionPoint.Y - BrushRadius); Vector2 A2 = new Vector2(Result.CollisionPoint.X + Radius, Result.CollisionPoint.Y + BrushRadius); for (int i = 0; i < TerrainGeometries.Count; i++) { if (TerrainGeometries[i].WorldFile.LODID != SelectedLOD) { continue; } Vector2 B1 = TerrainGeometries[i].WorldFile.GetA(); Vector2 B2 = TerrainGeometries[i].WorldFile.GetB(); if (A1.X < B2.X && A2.X > B1.X && A1.Y < B2.Y && A2.Y > B1.Y) { if (Result.GeometryName.Contains("Water")) { WaterGeometries[i].SetHighLight(Result.CollisionPoint, Color, Shape, BrushRadius); } else if (Result.GeometryName.Contains("Terrain")) { TerrainGeometries[i].SetHighLight(Result.CollisionPoint, Color, Shape, BrushRadius); } } else { TerrainGeometries[i].SetHighLight(Result.CollisionPoint, new Vector4(), Shape, 0); WaterGeometries[i].SetHighLight(Result.CollisionPoint, new Vector4(), Shape, 0); } } }
public CollisionResults RayCastWater(Vector3 Origin, Vector3 Direction, float Range, bool HasCurrentChunkLock) { if (FileManager.MasteryFile == null) { return(new CollisionResults()); } int LOD = FileManager.CurrentWorldFile.LODID; SettingsContainer Settings = FileManager.MasteryFile.Settings; List <WorldFile> ActiveWorldFiles = FileManager.MasteryFile.ActiveWorldFiles; CollisionResults Results = new CollisionResults(); List <Vector2> QuadCheck = new List <Vector2>(); if (HasCurrentChunkLock) { if (FileManager.CurrentWorldFile != null) { float TerrainScale = FileManager.CurrentWorldFile.TerrainScale; float HeightScale = FileManager.CurrentWorldFile.HeightScale; int[,] HeightMap = FileManager.CurrentWorldFile.HeightMap; int[,] WaterHeightMap = FileManager.CurrentWorldFile.WaterHeightMap; float Precision = TerrainScale * 0.5f; for (float j = 0; j < Range; j += Precision) { Vector3 CurrentPosition = Origin + (Direction * j); Vector3 CurrentVertexPosition = (CurrentPosition - FileManager.CurrentWorldFile.GetPosition()) / TerrainScale; int VX = (int)Math.Floor(CurrentVertexPosition.X); int VY = (int)Math.Floor(CurrentVertexPosition.Y); if (VX < 0 || VY < 0 || VX >= HeightMap.GetLength(0) - 1 || VY >= HeightMap.GetLength(1) - 1) { continue; } float MidPoint = (HeightMap[VX, VY] + HeightMap[VX + 1, VY] + HeightMap[VX, VY + 1] + HeightMap[VX + 1, VY + 1] + WaterHeightMap[VX, VY] + WaterHeightMap[VX + 1, VY] + WaterHeightMap[VX, VY + 1] + WaterHeightMap[VX + 1, VY + 1]) / 4; Vector3[] QuadVertices = { new Vector3(0, 0, (WaterHeightMap[VX, VY] + HeightMap[VX, VY]) * HeightScale), new Vector3(TerrainScale, 0, (WaterHeightMap[VX + 1, VY] + HeightMap[VX + 1, VY]) * HeightScale), new Vector3(0, TerrainScale, (WaterHeightMap[VX, VY + 1] + HeightMap[VX, VY + 1]) * HeightScale), new Vector3(TerrainScale, TerrainScale, (WaterHeightMap[VX + 1, VY + 1] + HeightMap[VX + 1, VY + 1]) * HeightScale) }; if (!QuadCheck.Contains(new Vector2(VX, VY))) { QuadCheck.Add(new Vector2(VX, VY)); Vector3 VertexWorldPosition = FileManager.CurrentWorldFile.GetPosition() + new Vector3(VX * TerrainScale, VY * TerrainScale, 0); for (int k = 0; k < Indices.Length; k += 3) { Vector3 V0 = VertexWorldPosition + QuadVertices[Indices[k]]; Vector3 V1 = VertexWorldPosition + QuadVertices[Indices[k + 1]]; Vector3 V2 = VertexWorldPosition + QuadVertices[Indices[k + 2]]; if (CollisionUtil.Intersect(V0, V1, V2, Origin, Direction)) { TerrainWaterContainer WaterGeom = WaterGeometries.Where(x => x.WorldFile.FileName == FileManager.CurrentWorldFile.FileName).First(); Vector3 CollisionPoint = CollisionUtil.GetCollisionPoint(V0, V1, V2, Origin, Direction); CollisionResult Result = new CollisionResult( V0, V1, V2, Origin, CollisionPoint, WaterGeom.Geom); Results.Add(Result); } } } } } } else { int PX = (int)Math.Floor(Origin.X / Settings.ChunkSize); int PY = (int)Math.Floor(Origin.Y / Settings.ChunkSize); for (int i = 0; i < ActiveWorldFiles.Count; i++) { int ValidLOD = LOD == -1 ? ActiveWorldFiles[i].LODID : LOD; if (Math.Abs(ActiveWorldFiles[i].IDX - PX) <= Settings.ChunkSelectionRadius && Math.Abs(ActiveWorldFiles[i].IDY - PY) < Settings.ChunkSelectionRadius && ActiveWorldFiles[i].LODID == ValidLOD) { float TerrainScale = ActiveWorldFiles[i].TerrainScale; float HeightScale = ActiveWorldFiles[i].HeightScale; int[,] HeightMap = ActiveWorldFiles[i].HeightMap; int[,] WaterHeightMap = FileManager.CurrentWorldFile.WaterHeightMap; float Precision = TerrainScale * 0.5f; for (float j = 0; j < Range; j += Precision) { Vector3 CurrentPosition = Origin + (Direction * j); Vector3 CurrentVertexPosition = (CurrentPosition - ActiveWorldFiles[i].GetPosition()) / TerrainScale; int VX = (int)Math.Floor(CurrentVertexPosition.X); int VY = (int)Math.Floor(CurrentVertexPosition.Y); if (VX < 0 || VY < 0 || VX >= HeightMap.GetLength(0) - 1 || VY >= HeightMap.GetLength(1) - 1) { continue; } float MidPoint = (HeightMap[VX, VY] + HeightMap[VX + 1, VY] + HeightMap[VX, VY + 1] + HeightMap[VX + 1, VY + 1] + WaterHeightMap[VX, VY] + WaterHeightMap[VX + 1, VY] + WaterHeightMap[VX, VY + 1] + WaterHeightMap[VX + 1, VY + 1]) / 4; Vector3[] QuadVertices = { new Vector3(0, 0, (WaterHeightMap[VX, VY] + HeightMap[VX, VY]) * HeightScale), new Vector3(TerrainScale, 0, (WaterHeightMap[VX + 1, VY] + HeightMap[VX + 1, VY]) * HeightScale), new Vector3(0, TerrainScale, (WaterHeightMap[VX, VY + 1] + HeightMap[VX, VY + 1]) * HeightScale), new Vector3(TerrainScale, TerrainScale, (WaterHeightMap[VX + 1, VY + 1] + HeightMap[VX + 1, VY + 1]) * HeightScale) }; if (!QuadCheck.Contains(new Vector2(VX, VY))) { QuadCheck.Add(new Vector2(VX, VY)); Vector3 VertexWorldPosition = ActiveWorldFiles[i].GetPosition() + new Vector3(VX * TerrainScale, VY * TerrainScale, 0); for (int k = 0; k < Indices.Length; k += 3) { Vector3 V0 = VertexWorldPosition + QuadVertices[Indices[k]]; Vector3 V1 = VertexWorldPosition + QuadVertices[Indices[k + 1]]; Vector3 V2 = VertexWorldPosition + QuadVertices[Indices[k + 2]]; if (CollisionUtil.Intersect(V0, V1, V2, Origin, Direction)) { Vector3 CollisionPoint = CollisionUtil.GetCollisionPoint(V0, V1, V2, Origin, Direction); TerrainWaterContainer WaterGeom = WaterGeometries.Where(x => x.WorldFile.FileName == FileManager.CurrentWorldFile.FileName).First(); CollisionResult Result = new CollisionResult( V0, V1, V2, Origin, CollisionPoint, WaterGeom.Geom); Results.Add(Result); } } } } } } } return(Results); }
public CollisionResults RayCastTerrain(Vector3 Origin, Vector3 Direction, float Range, WorldFile File) { if (FileManager.MasteryFile == null) { return(new CollisionResults()); } SettingsContainer Settings = FileManager.MasteryFile.Settings; List <WorldFile> ActiveWorldFiles = FileManager.MasteryFile.ActiveWorldFiles; List <Vector2> QuadCheck = new List <Vector2>(); CollisionResults Results = new CollisionResults(); float TerrainScale = File.TerrainScale; float HeighScale = File.HeightScale; int[,] HeightMap = File.HeightMap; float Precision = TerrainScale * 0.5f; for (float j = 0; j < Range; j += Precision) { Vector3 CurrentPosition = Origin + (Direction * j); Vector3 CurrentVertexPosition = (CurrentPosition - File.GetPosition()) / TerrainScale; int VX = (int)Math.Floor(CurrentVertexPosition.X); int VY = (int)Math.Floor(CurrentVertexPosition.Y); if (VX < 0 || VY < 0 || VX >= HeightMap.GetLength(0) - 1 || VY >= HeightMap.GetLength(1) - 1) { continue; } Vector3[] QuadVertices = { new Vector3(0, 0, HeightMap[VX, VY] * HeighScale), new Vector3(TerrainScale, 0, HeightMap[VX + 1, VY] * HeighScale), new Vector3(0, TerrainScale, HeightMap[VX, VY + 1] * HeighScale), new Vector3(TerrainScale, TerrainScale, HeightMap[VX + 1, VY + 1] * HeighScale) }; if (!QuadCheck.Contains(new Vector2(VX, VY))) { QuadCheck.Add(new Vector2(VX, VY)); Vector3 VertexWorldPosition = File.GetPosition() + new Vector3(VX * TerrainScale, VY * TerrainScale, 0); for (int k = 0; k < Indices.Length; k += 3) { Vector3 V0 = VertexWorldPosition + QuadVertices[Indices[k]]; Vector3 V1 = VertexWorldPosition + QuadVertices[Indices[k + 1]]; Vector3 V2 = VertexWorldPosition + QuadVertices[Indices[k + 2]]; if (CollisionUtil.Intersect(V0, V1, V2, Origin, Direction)) { TerrainGeometryContainer TerrainGeom = TerrainGeometries.Where(x => x.WorldFile.FileName == FileManager.CurrentWorldFile.FileName).First(); Vector3 CollisionPoint = CollisionUtil.GetCollisionPoint(V0, V1, V2, Origin, Direction); CollisionResult Result = new CollisionResult( V0, V1, V2, Origin, CollisionPoint, TerrainGeom.TerrainGeometry); Results.Add(Result); } } } } return(Results); }
public CollisionResults CollideWith(Vector3 RayPosition, Vector3 RayDirection) { if (CurrentRenderMode == RenderMode.Instanced) { CollisionResults Results = new CollisionResults(); for (int i = 0; i < InstanceCollisionBuffer.Count; i++) { Matrix InstanceMatrix = InstanceCollisionBuffer[i]; for (int j = 0; j < CollisionBuffer.Length; j += 3) { Vector3 V0 = Vector3.Transform(CollisionBuffer[j], InstanceMatrix); Vector3 V1 = Vector3.Transform(CollisionBuffer[j + 1], InstanceMatrix); Vector3 V2 = Vector3.Transform(CollisionBuffer[j + 2], InstanceMatrix); //if (CollisionUtil.Intersect(V0 + Position, V1 + Position, V2 + Position, RayPosition, RayDirection)) //{ if (CollisionUtil.Intersect(V0, V1, V2, RayPosition, RayDirection)) { Vector3 CollisionPoint = CollisionUtil.GetCollisionPoint(V0, V1, V2, RayPosition, RayDirection); CollisionResult Result = new CollisionResult( V0, V1, V2, i, Position, CollisionPoint, this); Results.Add(Result); } } } } else { CollisionResults Results = new CollisionResults(); for (int i = 0; i < CollisionBuffer.Length; i += 3) { Vector3 V0 = CollisionBuffer[i] + Position; Vector3 V1 = CollisionBuffer[i + 1] + Position; Vector3 V2 = CollisionBuffer[i + 2] + Position; //if (CollisionUtil.Intersect(V0 + Position, V1 + Position, V2 + Position, RayPosition, RayDirection)) //{ if (CollisionUtil.Intersect(V0, V1, V2, RayPosition, RayDirection)) { Vector3 CollisionPoint = CollisionUtil.GetCollisionPoint(V0, V1, V2, RayPosition, RayDirection); CollisionResult Result = new CollisionResult( V0, V1, V2, Position, CollisionPoint, this); Results.Add(Result); } } return(Results); } return(null); }
//TODO ADD Prop Scale public CollisionResults CollideWith(Vector3 RayPosition, Vector3 RayDirection, float Range) { CollisionResults Results = new CollisionResults(); if (CurrentRenderMode == RenderMode.Instanced) { for (int i = 0; i < InstanceCollisionBuffer.Count; i++) { Matrix InstanceMatrix = InstanceCollisionBuffer[i]; if (Vector3.Distance(RayPosition, Position) <= Range) { } for (int j = 0; j < CollisionBuffer.Length; j += 3) { Vector3 V0 = Vector3.Transform(CollisionBuffer[j], InstanceMatrix); Vector3 V1 = Vector3.Transform(CollisionBuffer[j + 1], InstanceMatrix); Vector3 V2 = Vector3.Transform(CollisionBuffer[j + 2], InstanceMatrix); Vector3 CollisionPoint = new Vector3(); if (CollisionUtil.Intersect(V0, V1, V2, RayPosition, RayDirection, CollisionPoint)) { CollisionResult Result = new CollisionResult( V0, V1, V2, i, Position, CollisionPoint, this); /* * Debug.WriteLine("----------"); * Debug.WriteLine(CollisionPoint); * Debug.WriteLine(V0); * Debug.WriteLine(V1); * Debug.WriteLine(V2); */ Results.Add(Result); } } } } else { for (int i = 0; i < CollisionBuffer.Length; i += 3) { Vector3 V0 = CollisionBuffer[i] + Position; Vector3 V1 = CollisionBuffer[i + 1] + Position; Vector3 V2 = CollisionBuffer[i + 2] + Position; //if (CollisionUtil.Intersect(V0 + Position, V1 + Position, V2 + Position, RayPosition, RayDirection)) //{ Vector3 CollisionPoint = new Vector3(); if (CollisionUtil.Intersect(V0, V1, V2, RayPosition, RayDirection, CollisionPoint)) { CollisionResult Result = new CollisionResult( V0, V1, V2, Position, CollisionPoint, this); Results.Add(Result); } } } return(Results); }
public void SimulateWorld() { /*simulationPlayer.Velocity = new Vector2f(0.5f, 1.0f); * if (simulationPlayer.BoundingBox.Position.X > 250.0f || simulationPlayer.BoundingBox.Position.Y > 250.0f) * { * simulationPlayer.BoundingBox.Position = new Vector2f(70.5f, 60.5f); * }*/ if (SFML.Window.Keyboard.IsKeyPressed(Keyboard.Key.W)) { simulationPlayer.Velocity = new Vector2f(simulationPlayer.Velocity.X, -0.5f); } else if (SFML.Window.Keyboard.IsKeyPressed(Keyboard.Key.S)) { simulationPlayer.Velocity = new Vector2f(simulationPlayer.Velocity.X, 0.5f); } else { simulationPlayer.Velocity = new Vector2f(simulationPlayer.Velocity.X, 0.0f); } if (Keyboard.IsKeyPressed(Keyboard.Key.D)) { simulationPlayer.Velocity = new Vector2f(0.5f, simulationPlayer.Velocity.Y); } else if (Keyboard.IsKeyPressed(Keyboard.Key.A)) { simulationPlayer.Velocity = new Vector2f(-0.5f, simulationPlayer.Velocity.Y); } else { simulationPlayer.Velocity = new Vector2f(0.0f, simulationPlayer.Velocity.Y); } //center the player if (Keyboard.IsKeyPressed(Keyboard.Key.I)) { simulationPlayer.Velocity = new Vector2f(79.5f - simulationPlayer.BoundingBox.Position.X, 59.5f - simulationPlayer.BoundingBox.Position.Y); simulationPlayer.Move(); simulationPlayer.Velocity = new Vector2f(); } Vector2f tempPosition = simulationPlayer.BoundingBox.Position + simulationPlayer.Velocity; Vector2f testVector = new Vector2f(80.0f, 99.5f); if (tempPosition.X == testVector.X && tempPosition.Y == testVector.Y) { int i = 0; } //Gravity //simulationPlayer.Velocity = new Vector2f(simulationPlayer.Velocity.X, simulationPlayer.Velocity.Y + 0.5f); foreach (CollisionObject collisionObject in simulatedObjects) { collisionObject.RevertToOriginalColor(); } //Reset the colors and figure out collisions /*for ( int i = 0; i < simulatedObjects.Count; i++ ) * { * CollisionObject collisionObject = simulatedObjects[i]; * for (int z = i + 1; z < simulatedObjects.Count; z++) * { * CollisionObject otherObject = simulatedObjects[z]; * * CollisionResults collisionResults = CollisionManager.TestCollisions(collisionObject, otherObject); * * if (collisionResults.Type != CollisionType.enNone) * { * collisionObject.OnCollision(collisionResults); * otherObject.OnCollision(collisionResults); * } * } * }*/ foreach (CollisionObject collisionObject in simulatedObjects) { if (collisionObject == simulationPlayer) { continue; } CollisionResults results = CollisionManager.TestCollisions(simulationPlayer, collisionObject); if (results.Type != CollisionType.enNone) { simulationPlayer.OnCollision(results); collisionObject.OnCollision(results); } } //Process collisions foreach (CollisionObject collisionObject in simulatedObjects) { collisionObject.ProcessCollisions(); } //Draw the objects. foreach (CollisionObject collisionObject in simulatedObjects) { collisionObject.Move(); window.Draw(collisionObject); } foreach (CollisionObject collisionObject in simulatedObjects) { if (collisionObject == simulationPlayer) { continue; } CollisionResults results = CollisionManager.TestCollisions(simulationPlayer, collisionObject); if (results.Type == CollisionType.enAbsolute) { int i = 0; } } foreach (CollisionObject collisionObject in simulatedObjects) { collisionObject.PostFrame(); } }