294 lines
8.5 KiB
Dart
294 lines
8.5 KiB
Dart
import 'dart:math' as math;
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:wolf_dart/classes/coordinate_2d.dart';
|
|
import 'package:wolf_dart/classes/matrix.dart';
|
|
import 'package:wolf_dart/features/entities/entity.dart';
|
|
import 'package:wolf_dart/features/player/player.dart';
|
|
import 'package:wolf_dart/features/renderer/color_palette.dart';
|
|
|
|
class RaycasterPainter extends CustomPainter {
|
|
final Matrix<int> map;
|
|
final List<Matrix<int>> textures;
|
|
final Player player;
|
|
final double fov;
|
|
final Map<String, double> doorOffsets;
|
|
final List<Matrix<int>> sprites;
|
|
final List<Entity> entities;
|
|
|
|
RaycasterPainter({
|
|
required this.map,
|
|
required this.textures,
|
|
required this.player,
|
|
required this.fov,
|
|
required this.doorOffsets,
|
|
required this.sprites,
|
|
required this.entities,
|
|
});
|
|
|
|
@override
|
|
void paint(Canvas canvas, Size size) {
|
|
final Paint bgPaint = Paint()..isAntiAlias = false;
|
|
|
|
// 1. Draw Ceiling & Floor
|
|
canvas.drawRect(
|
|
Rect.fromLTWH(0, 0, size.width, size.height / 2),
|
|
bgPaint..color = Colors.blueGrey[900]!,
|
|
);
|
|
canvas.drawRect(
|
|
Rect.fromLTWH(0, size.height / 2, size.width, size.height / 2),
|
|
bgPaint..color = Colors.brown[900]!,
|
|
);
|
|
|
|
const int renderWidth = 320;
|
|
double columnWidth = size.width / renderWidth;
|
|
|
|
final Paint columnPaint = Paint()
|
|
..isAntiAlias = false
|
|
..strokeWidth = columnWidth + 0.5;
|
|
|
|
List<double> zBuffer = List.filled(renderWidth, 0.0);
|
|
|
|
// --- Coordinate2D Camera Vectors ---
|
|
Coordinate2D dir = Coordinate2D(
|
|
math.cos(player.angle),
|
|
math.sin(player.angle),
|
|
);
|
|
|
|
// The camera plane is perpendicular to the direction vector, scaled by FOV
|
|
Coordinate2D plane = Coordinate2D(-dir.y, dir.x) * math.tan(fov / 2);
|
|
|
|
// --- 1. CAST WALLS ---
|
|
for (int x = 0; x < renderWidth; x++) {
|
|
double cameraX = 2 * x / renderWidth - 1.0;
|
|
Coordinate2D rayDir = dir + (plane * cameraX);
|
|
|
|
int mapX = player.x.toInt();
|
|
int mapY = player.y.toInt();
|
|
|
|
double sideDistX;
|
|
double sideDistY;
|
|
double deltaDistX = (rayDir.x == 0) ? 1e30 : (1.0 / rayDir.x).abs();
|
|
double deltaDistY = (rayDir.y == 0) ? 1e30 : (1.0 / rayDir.y).abs();
|
|
double perpWallDist;
|
|
|
|
int stepX;
|
|
int stepY;
|
|
bool hit = false;
|
|
bool hitOutOfBounds = false;
|
|
int side = 0;
|
|
int hitWallId = 0;
|
|
double doorOffset = 0.0;
|
|
Set<String> ignoredDoors = {};
|
|
|
|
if (rayDir.x < 0) {
|
|
stepX = -1;
|
|
sideDistX = (player.x - mapX) * deltaDistX;
|
|
} else {
|
|
stepX = 1;
|
|
sideDistX = (mapX + 1.0 - player.x) * deltaDistX;
|
|
}
|
|
if (rayDir.y < 0) {
|
|
stepY = -1;
|
|
sideDistY = (player.y - mapY) * deltaDistY;
|
|
} else {
|
|
stepY = 1;
|
|
sideDistY = (mapY + 1.0 - player.y) * deltaDistY;
|
|
}
|
|
|
|
// DDA Loop
|
|
while (!hit) {
|
|
if (sideDistX < sideDistY) {
|
|
sideDistX += deltaDistX;
|
|
mapX += stepX;
|
|
side = 0;
|
|
} else {
|
|
sideDistY += deltaDistY;
|
|
mapY += stepY;
|
|
side = 1;
|
|
}
|
|
|
|
if (mapY < 0 ||
|
|
mapY >= map.length ||
|
|
mapX < 0 ||
|
|
mapX >= map[0].length) {
|
|
hit = true;
|
|
hitOutOfBounds = true;
|
|
} else if (map[mapY][mapX] > 0) {
|
|
String doorKey = '$mapX,$mapY';
|
|
if (map[mapY][mapX] >= 90 && !ignoredDoors.contains(doorKey)) {
|
|
double currentOffset = doorOffsets[doorKey] ?? 0.0;
|
|
if (currentOffset > 0.0) {
|
|
double perpWallDistTemp = (side == 0)
|
|
? (sideDistX - deltaDistX)
|
|
: (sideDistY - deltaDistY);
|
|
double wallXTemp = (side == 0)
|
|
? player.y + perpWallDistTemp * rayDir.y
|
|
: player.x + perpWallDistTemp * rayDir.x;
|
|
wallXTemp -= wallXTemp.floor();
|
|
if (wallXTemp < currentOffset) {
|
|
ignoredDoors.add(doorKey);
|
|
continue;
|
|
}
|
|
}
|
|
doorOffset = currentOffset;
|
|
}
|
|
hit = true;
|
|
hitWallId = map[mapY][mapX];
|
|
}
|
|
}
|
|
|
|
if (hitOutOfBounds) continue;
|
|
|
|
if (side == 0) {
|
|
perpWallDist = (sideDistX - deltaDistX);
|
|
} else {
|
|
perpWallDist = (sideDistY - deltaDistY);
|
|
}
|
|
|
|
zBuffer[x] = perpWallDist;
|
|
|
|
double wallX = (side == 0)
|
|
? player.y + perpWallDist * rayDir.y
|
|
: player.x + perpWallDist * rayDir.x;
|
|
wallX -= wallX.floor();
|
|
|
|
double drawX = x * columnWidth;
|
|
|
|
_drawTexturedColumn(
|
|
canvas,
|
|
drawX,
|
|
perpWallDist,
|
|
wallX,
|
|
side,
|
|
size,
|
|
hitWallId,
|
|
textures,
|
|
doorOffset,
|
|
columnPaint,
|
|
);
|
|
}
|
|
|
|
// --- 2. DRAW SPRITES ---
|
|
List<Entity> activeSprites = List.from(entities);
|
|
|
|
// Sort sprites from furthest to closest using Coordinate2D
|
|
activeSprites.sort((a, b) {
|
|
double distA = player.position.distanceTo(a.position);
|
|
double distB = player.position.distanceTo(b.position);
|
|
return distB.compareTo(distA);
|
|
});
|
|
|
|
for (Entity entity in activeSprites) {
|
|
// Relative position to player
|
|
Coordinate2D spritePos = entity.position - player.position;
|
|
|
|
// Transform sprite with the inverse camera matrix
|
|
double invDet = 1.0 / (plane.x * dir.y - dir.x * plane.y);
|
|
double transformX = invDet * (dir.y * spritePos.x - dir.x * spritePos.y);
|
|
double transformY =
|
|
invDet * (-plane.y * spritePos.x + plane.x * spritePos.y);
|
|
|
|
if (transformY > 0) {
|
|
int spriteScreenX = ((renderWidth / 2) * (1 + transformX / transformY))
|
|
.toInt();
|
|
int spriteHeight = (size.height / transformY).abs().toInt();
|
|
int spriteColumnWidth = (spriteHeight / columnWidth).toInt();
|
|
|
|
int drawStartX = -spriteColumnWidth ~/ 2 + spriteScreenX;
|
|
int drawEndX = spriteColumnWidth ~/ 2 + spriteScreenX;
|
|
|
|
int clipStartX = math.max(0, drawStartX);
|
|
int clipEndX = math.min(renderWidth - 1, drawEndX);
|
|
|
|
for (int stripe = clipStartX; stripe < clipEndX; stripe++) {
|
|
if (transformY < zBuffer[stripe]) {
|
|
double texXDouble = (stripe - drawStartX) * 64 / spriteColumnWidth;
|
|
int texX = texXDouble.toInt().clamp(0, 63);
|
|
|
|
double startY = (size.height / 2) - (spriteHeight / 2);
|
|
double stepY = spriteHeight / 64.0;
|
|
double drawX = stripe * columnWidth;
|
|
|
|
int safeIndex = entity.spriteIndex.clamp(0, sprites.length - 1);
|
|
Matrix<int> spritePixels = sprites[safeIndex];
|
|
|
|
for (int ty = 0; ty < 64; ty++) {
|
|
int colorByte = spritePixels[texX][ty];
|
|
|
|
if (colorByte != 255) {
|
|
double endY = startY + stepY + 0.5;
|
|
|
|
if (endY > 0 && startY < size.height) {
|
|
columnPaint.color = ColorPalette.vga[colorByte];
|
|
canvas.drawLine(
|
|
Offset(drawX, startY),
|
|
Offset(drawX, endY),
|
|
columnPaint,
|
|
);
|
|
}
|
|
}
|
|
startY += stepY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void _drawTexturedColumn(
|
|
Canvas canvas,
|
|
double drawX,
|
|
double distance,
|
|
double wallX,
|
|
int side,
|
|
Size size,
|
|
int hitWallId,
|
|
List<Matrix<int>> textures,
|
|
double doorOffset,
|
|
Paint paint,
|
|
) {
|
|
if (distance <= 0.01) distance = 0.01;
|
|
|
|
double wallHeight = size.height / distance;
|
|
int drawStart = ((size.height / 2) - (wallHeight / 2)).toInt();
|
|
|
|
int texNum = ((hitWallId - 1) * 2).clamp(0, textures.length - 2);
|
|
int texX = (wallX * 64).toInt().clamp(0, 63);
|
|
|
|
if (hitWallId >= 90) {
|
|
texNum = 98.clamp(0, textures.length - 1);
|
|
texX = ((wallX - doorOffset) * 64).toInt().clamp(0, 63);
|
|
} else {
|
|
texNum = ((hitWallId - 1) * 2).clamp(0, textures.length - 2);
|
|
if (side == 1) texNum += 1;
|
|
}
|
|
|
|
if (side == 0 && math.cos(player.angle) > 0) texX = 63 - texX;
|
|
if (side == 1 && math.sin(player.angle) < 0) texX = 63 - texX;
|
|
|
|
double startY = drawStart.toDouble();
|
|
double stepY = wallHeight / 64.0;
|
|
|
|
for (int ty = 0; ty < 64; ty++) {
|
|
int colorByte = textures[texNum][texX][ty];
|
|
|
|
paint.color = ColorPalette.vga[colorByte];
|
|
|
|
double endY = startY + stepY + 0.5;
|
|
|
|
if (endY > 0 && startY < size.height) {
|
|
canvas.drawLine(
|
|
Offset(drawX, startY),
|
|
Offset(drawX, endY),
|
|
paint,
|
|
);
|
|
}
|
|
startY += stepY;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool shouldRepaint(RaycasterPainter oldDelegate) => true;
|
|
}
|