//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();
}
}
