Initial project import

tools/v/examples/gg/raycaster.v

@@ -0,0 +1,278 @@
+// Demonstrates how raycasting works. The left side shows
+// the 2D layout of the walls and player. The green lines
+// represent the field of view of the player.
+//
+// The right side is a simple 3D projection of the field
+// of view.
+//
+// There is no collision detection so yes, you can walk
+// through walls.
+//
+// Watch https://www.youtube.com/watch?v=gYRrGTC7GtA to
+// learn more on how this code works. There are some silly
+// digressons in the video but the tech content is spot on.
+import gg
+import math
+
+const player_size = 8
+const map_x_size = 8
+const map_y_size = 8
+const map_square = 64
+
+struct App {
+mut:
+	ctx          &gg.Context = unsafe { nil }
+	player_x     f32
+	player_y     f32
+	player_dx    f32
+	player_dy    f32
+	player_angle f32
+	map          []int
+}
+
+fn main() {
+	mut app := App{
+		player_x: 230
+		player_y: 320
+		// each number represents an 8x8 square
+		// 1 is a wall cube, 0 is empty space
+		map: [
+			// vfmt off
+			1, 1, 1, 1, 1, 1, 1, 1,
+			1, 0, 0, 0, 0, 0, 0, 1,
+			1, 0, 1, 1, 0, 0, 0, 1,
+			1, 0, 1, 0, 0, 0, 0, 1,
+			1, 0, 0, 0, 0, 0, 0, 1,
+			1, 0, 0, 0, 0, 1, 0, 1,
+			1, 0, 0, 0, 0, 0, 0, 1,
+			1, 1, 1, 1, 1, 1, 1, 1,
+			// vfmt on
+		]
+	}
+
+	calc_deltas(mut app)
+
+	app.ctx = gg.new_context(
+		user_data:    &app
+		window_title: 'Raycaster Demo'
+		width:        1024
+		height:       512
+		bg_color:     gg.gray
+		frame_fn:     draw
+		event_fn:     handle_events
+	)
+
+	app.ctx.run()
+}
+
+fn draw(mut app App) {
+	app.ctx.begin()
+	draw_map_2d(app)
+	draw_player(app)
+	draw_rays_and_walls(app)
+	draw_instructions(app)
+	app.ctx.end()
+}
+
+fn draw_map_2d(app App) {
+	for y := 0; y < map_y_size; y++ {
+		for x := 0; x < map_x_size; x++ {
+			color := if app.map[y * map_x_size + x] == 1 { gg.white } else { gg.black }
+			app.ctx.draw_rect_filled(x * map_square, y * map_square, map_square - 1,
+				map_square - 1, color)
+		}
+	}
+}
+
+fn draw_player(app App) {
+	app.ctx.draw_rect_filled(app.player_x, app.player_y, player_size, player_size, gg.yellow)
+	cx := app.player_x + player_size / 2
+	cy := app.player_y + player_size / 2
+	app.ctx.draw_line(cx, cy, cx + app.player_dx * 5, cy + app.player_dy * 5, gg.yellow)
+}
+
+fn draw_rays_and_walls(app App) {
+	pi2 := math.pi / 2
+	pi3 := 3 * math.pi / 2
+	degree_radian := f32(0.0174533)
+	max_depth_of_field := 8
+	field_of_view := 60 // 60 degrees
+
+	mut distance := f32(0)
+	mut depth_of_field := 0
+	mut ray_x := f32(0)
+	mut ray_y := f32(0)
+	mut offset_x := f32(0)
+	mut offset_y := f32(0)
+	mut map_x := 0
+	mut map_y := 0
+	mut map_pos := 0
+	mut color := gg.red
+	mut ray_angle := clamp_ray_angle(app.player_angle - degree_radian * field_of_view / 2)
+
+	// each step = 1/2 degree
+	steps := field_of_view * 2
+
+	for step := 0; step < steps; step++ {
+		// check horizontal lines
+		mut hd := f32(max_int)
+		mut hx := app.player_x
+		mut hy := app.player_y
+		depth_of_field = 0
+		arc_tan := -1.0 / math.tanf(ray_angle)
+		if ray_angle > math.pi { // looking up
+			ray_y = f32(int(app.player_y) / map_square * map_square) - .0001
+			ray_x = (app.player_y - ray_y) * arc_tan + app.player_x
+			offset_y = -map_square
+			offset_x = -offset_y * arc_tan
+		} else if ray_angle < math.pi { // looking down
+			ray_y = f32(int(app.player_y) / map_square * map_square + map_square)
+			ray_x = (app.player_y - ray_y) * arc_tan + app.player_x
+			offset_y = map_square
+			offset_x = -offset_y * arc_tan
+		} else if ray_angle == 0 || ray_angle == 2 * math.pi { // looking straight left/right
+			ray_x = app.player_x
+			ray_y = app.player_y
+			depth_of_field = max_depth_of_field
+		}
+		for depth_of_field < max_depth_of_field {
+			map_x = int(ray_x) / map_square
+			map_y = int(ray_y) / map_square
+			map_pos = map_y * map_x_size + map_x
+			if app.map[map_pos] or { 0 } == 1 {
+				// hit a wall
+				hx = ray_x
+				hy = ray_y
+				hd = hypotenuse(app.player_x, app.player_y, hx, hy)
+				depth_of_field = max_depth_of_field
+			} else { // go to next line
+				ray_x += offset_x
+				ray_y += offset_y
+				depth_of_field += 1
+			}
+		}
+		// check vertical lines
+		mut vd := f32(max_int)
+		mut vx := app.player_x
+		mut vy := app.player_y
+		depth_of_field = 0
+		neg_tan := -math.tanf(ray_angle)
+		if ray_angle > pi2 && ray_angle < pi3 { // looking left
+			ray_x = f32(int(app.player_x) / map_square * map_square) - .0001
+			ray_y = (app.player_x - ray_x) * neg_tan + app.player_y
+			offset_x = -map_square
+			offset_y = -offset_x * neg_tan
+		} else if ray_angle < pi2 || ray_angle > pi3 { // looking right
+			ray_x = f32(int(app.player_x) / map_square * map_square + map_square)
+			ray_y = (app.player_x - ray_x) * neg_tan + app.player_y
+			offset_x = map_square
+			offset_y = -offset_x * neg_tan
+		} else if ray_angle == 0 || ray_angle == 2 * math.pi { // looking straight up/down
+			ray_x = app.player_x
+			ray_y = app.player_y
+			depth_of_field = max_depth_of_field
+		}
+		for depth_of_field < max_depth_of_field {
+			map_x = int(ray_x) / map_square
+			map_y = int(ray_y) / map_square
+			map_pos = map_y * map_x_size + map_x
+			if app.map[map_pos] or { 0 } == 1 {
+				// hit a wall
+				vx = ray_x
+				vy = ray_y
+				vd = hypotenuse(app.player_x, app.player_y, vx, vy)
+				depth_of_field = max_depth_of_field
+			} else { // go to next line
+				ray_x += offset_x
+				ray_y += offset_y
+				depth_of_field += 1
+			}
+		}
+		// use the shorter of the horizontal and vertical distances to draw rays
+		// use different colors for the two sides of the walls for lighting effect
+		if vd < hd {
+			ray_x = vx
+			ray_y = vy
+			distance = vd
+			color = gg.rgb(0, 100, 0)
+		} else if hd < vd {
+			ray_x = hx
+			ray_y = hy
+			distance = hd
+			color = gg.rgb(0, 120, 0)
+		}
+		// draw ray
+		cx := app.player_x + player_size / 2
+		cy := app.player_y + player_size / 2
+		app.ctx.draw_line(cx, cy, ray_x, ray_y, gg.green)
+		// draw wall section
+		mut ca := clamp_ray_angle(app.player_angle - ray_angle)
+		distance *= math.cosf(ca) // remove fish eye
+		offset_3d_view := 530
+		line_thickeness := 4
+		max_wall_height := 320
+		wall_height := math.min((map_square * max_wall_height) / distance, max_wall_height)
+		wall_offset := max_wall_height / 2 - wall_height / 2
+		app.ctx.draw_line_with_config(step * line_thickeness + offset_3d_view, wall_offset,
+
+			step * line_thickeness + offset_3d_view, wall_offset + wall_height, gg.PenConfig{
+			color:     color
+			thickness: line_thickeness
+		})
+		// step to next ray angle
+		ray_angle = clamp_ray_angle(ray_angle + degree_radian / 2)
+	}
+}
+
+fn handle_events(event &gg.Event, mut app App) {
+	if event.typ == .key_down {
+		match event.key_code {
+			.up {
+				app.player_x += app.player_dx
+				app.player_y += app.player_dy
+			}
+			.down {
+				app.player_x -= app.player_dx
+				app.player_y -= app.player_dy
+			}
+			.left {
+				app.player_angle -= 0.1
+				if app.player_angle < 0 {
+					app.player_angle += 2 * math.pi
+				}
+				calc_deltas(mut app)
+			}
+			.right {
+				app.player_angle += 0.1
+				if app.player_angle > 2 * math.pi {
+					app.player_angle -= 2 * math.pi
+				}
+				calc_deltas(mut app)
+			}
+			else {}
+		}
+	}
+}
+
+fn calc_deltas(mut app App) {
+	app.player_dx = math.cosf(app.player_angle) * 5
+	app.player_dy = math.sinf(app.player_angle) * 5
+}
+
+fn hypotenuse(ax f32, ay f32, bx f32, by f32) f32 {
+	a2 := math.square(bx - ax)
+	b2 := math.square(by - ay)
+	return math.sqrtf(a2 + b2)
+}
+
+fn clamp_ray_angle(ra f32) f32 {
+	return match true {
+		ra < 0 { ra + 2 * math.pi }
+		ra > 2 * math.pi { ra - 2 * math.pi }
+		else { ra }
+	}
+}
+
+fn draw_instructions(app App) {
+	app.ctx.draw_text(700, app.ctx.height - 17, 'use arrow keys to move player')
+}