Implment getting horizontal/vertical intesections of ray casting.

level.cpp

@@ -1,6 +1,8 @@
-#include "level.h"
+#include "level.h"	
 #include <stdio.h>
 
+#include "maths.h"
+
 #define WIDTH  5
 #define HEIGHT 5
 
@@ -8,6 +10,9 @@ static void drawGrid();
 static void drawGridLine(unsigned int step, bool isHorizontal);
 static sf::Vertex getGridLineVertex(unsigned int n, unsigned int maxDimension, bool isStart, bool isHorizontal);
 
+static void castRay(sf::Vector2f point, float direction);
+static void getGridIndex(sf::Vector2f point, int* x, int* y);
+
 static sf::RenderWindow* window = nullptr;
 
 static unsigned int level[WIDTH * HEIGHT] = {
@@ -40,14 +45,15 @@ void level_end()
 
 float level_rayCastDistance(sf::Vector2f point, float direction)
 {
-	return 100.f;
+	castRay(point, direction);
+	return 1000.f;
 }
 
 static void drawGrid()
 {
 	const sf::Vector2u windowSize = window->getSize();
-	unsigned int stepX = windowSize.x/WIDTH;
-	unsigned int stepY = windowSize.y/HEIGHT;
+	const unsigned int stepX = windowSize.x/WIDTH;
+	const unsigned int stepY = windowSize.y/HEIGHT;
 
 	for (unsigned int x = 0; x < WIDTH; x++) {
 		for (unsigned int y = 0; y < HEIGHT; y++) {
@@ -100,3 +106,83 @@ static sf::Vertex getGridLineVertex(unsigned int offset, unsigned int maxDimensi
 	end.color = sf::Color(100, 100, 100);
 	return isStart? start : end;
 }
+
+static void castRay(sf::Vector2f point, float direction)
+{
+	const sf::Vector2u windowSize = window->getSize();
+	const unsigned int tileWidth = windowSize.x/WIDTH;
+	const unsigned int tileHeight = windowSize.y/HEIGHT;
+
+	// dx and dy are the delta x and delta y of closest grid intersection
+	int indexX, indexY;
+	float dx, dy;
+
+	getGridIndex(point, &indexX, &indexY);
+
+	direction = maths_modulo(direction, 2.0f*PI);
+	bool goingDown = direction < PI;
+	int signDown = goingDown? 1 : -1;
+
+	dy = (float)((indexY + goingDown) * tileHeight) - point.y;
+	dx = dy/tan(direction);
+
+	float horizontalStepX = (float)(signDown * (tileWidth/tan(direction)));
+	float horizontalStepY = (float)(signDown * (int)tileHeight);
+	float horizontalProjectedX = point.x + dx;
+	float horizontalProjectedY = (indexY + goingDown) * tileHeight;
+
+	direction = maths_modulo(direction + 0.5f*PI, 2.0f*PI);
+	bool goingRight = direction < PI;
+	int signRight = goingRight? 1 : -1;
+
+	dx = (float)((indexX + goingRight) * tileWidth) - point.x;
+	dy = -dx/tan(direction);
+
+	float verticalStepY = -(float)(signRight * (tileHeight/tan(direction)));
+	float verticalStepX = (float)(signRight * (int)tileHeight);
+	float verticalProjectedY = point.y + dy;
+	float verticalProjectedX = (indexX + goingRight) * tileWidth;
+
+	bool inLevel; 
+	do {
+		const float circleRadius = 3.f;
+		sf::CircleShape circle(circleRadius);
+
+		circle.setFillColor(sf::Color::Red);
+
+		circle.setPosition(sf::Vector2f(horizontalProjectedX, horizontalProjectedY));
+		circle.setOrigin(circleRadius, circleRadius);
+		window->draw(circle);
+
+		circle.setPosition(sf::Vector2f(verticalProjectedX, verticalProjectedY));
+		circle.setOrigin(circleRadius, circleRadius);
+		window->draw(circle);
+
+		horizontalProjectedX += horizontalStepX;
+		horizontalProjectedY += horizontalStepY;
+
+		verticalProjectedX += verticalStepX;
+		verticalProjectedY += verticalStepY;
+
+		int indexX0, indexY0;
+		int indexX1, indexY1;
+		getGridIndex(sf::Vector2f(horizontalProjectedX, horizontalProjectedY), &indexX0, &indexY0);
+		getGridIndex(sf::Vector2f(verticalProjectedX,   verticalProjectedY),   &indexX1, &indexY1);
+
+		bool inLevel0 = ((indexX0 >= 0 && indexX0 < WIDTH) && (indexY0 >= 0 && indexY0 < HEIGHT));
+		bool inLevel1 = ((indexX1 >= 0 && indexX1 < WIDTH) && (indexY1 >= 0 && indexY1 < HEIGHT));
+
+		inLevel = inLevel0 || inLevel1;
+	} while (inLevel);
+}
+
+static void getGridIndex(sf::Vector2f point, int* x, int* y)
+{
+	const sf::Vector2u windowSize = window->getSize();
+
+	*x = point.x / (int)(windowSize.x / WIDTH);
+	*y = point.y / (int)(windowSize.y / HEIGHT);
+
+	if (*x < 0 || WIDTH <= *x) *x = -1;
+	if (*y < 0 || HEIGHT <= *y) *y = -1;
+}