mitchellhansen
/
voxel-raycaster
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Ahh! It works!! The camera is great now, it yaws and pitches perfectly, just need to limit it to 180 -> -180 on the pitch. There is still a problem when viewing in the negative angles, and as you move the camera closer to 0 things get weird and distorted. But the transfer over to a spherical camera point and a cartesian view plane worked fantastically

Browse Source
master
mitchellhansen 8 years ago
parent d609ed695a
commit 1de9c6dd35
2 changed files with 79 additions and 63 deletions
Show Stats Download Patch File Download Diff File

37
src/Ray.cpp
Unescape View File

@ -24,7 +24,7 @@ Ray::Ray(
sf::Color Ray::Cast() { sf::Color Ray::Cast() {
// Get the cartesian direction for computing // Get the cartesian direction for computing
sf::Vector3<float> cartesian = SphereToCart(direction); sf::Vector3<float> cartesian = direction;//SphereToCart(direction);
// Setup the voxel step based on what direction the ray is pointing // Setup the voxel step based on what direction the ray is pointing
sf::Vector3<int> voxel_step(1, 1, 1); sf::Vector3<int> voxel_step(1, 1, 1);
@ -47,27 +47,27 @@ sf::Color Ray::Cast() {
fabsf((float) (1.0 / cartesian.z)) fabsf((float) (1.0 / cartesian.z))
); );
//97, 25, 34 is an interesting example of the problems // So the way I need to do the camera is this.
// Ahhh, ya know what? This is a problem with how spherical coords // 1.) Setup the viewplane and then store the values
// work when approaching 0 on the chi axis as rotation about // - Camera origin
// the theta axis is completely useless. A viewing frustum will // - Resolution of the view plane X, Y
// be needed unfortunately // - Focal length to determine FOV
//
// 2.) For each draw. Get a copy of the view plane
// 3.) Rotate around the X axis first, left and right
// 4.) Then rotate alond the Y axis, up and down.
// 5.) Make sure to limit the camera Y Rotation to 180 and -180 degrees
// - Rays will still go pas 180 for the amount of FOV the camera has!
// Intersection T is the collection of the next intersection points // Intersection T is the collection of the next intersection points
// for all 3 axis XYZ. // for all 3 axis XYZ.
// I think this is where the hangup is currently. It's taking the delta_t which is signed
// and multiplying it by the voxel_step which is also signed. On top of this. Computing the
// camera position by voxel coord is debug only so I need to do the math to account for the
// origin being anywhere inside a voxel
intersection_t = sf::Vector3<float>( intersection_t = sf::Vector3<float>(
delta_t.x + origin.x, delta_t.x + origin.x,
delta_t.y + origin.y, delta_t.y + origin.y,
delta_t.z + origin.z delta_t.z + origin.z
); );
if (pixel.x == 0){ if (pixel.y == 200){
int i = 0; int i = 0;
i++; i++;
} }
@ -97,7 +97,7 @@ sf::Color Ray::Cast() {
} }
} }
// If the voxel went out of bounds // If the ray went out of bounds
if (voxel.z >= dimensions.z) { if (voxel.z >= dimensions.z) {
return sf::Color(0, 0, 255, 50); return sf::Color(0, 0, 255, 50);
} }
@ -117,9 +117,8 @@ sf::Color Ray::Cast() {
if (voxel.z < 0) { if (voxel.z < 0) {
return sf::Color(0, 255, 0, 50); return sf::Color(0, 255, 0, 50);
} }
// If we found a voxel
// Registers hit on non-zero
// If we hit a voxel
switch (map->list[voxel.x + dimensions.x * (voxel.y + dimensions.z * voxel.z)]) { switch (map->list[voxel.x + dimensions.x * (voxel.y + dimensions.z * voxel.z)]) {
case 1: case 1:
return sf::Color::Red; return sf::Color::Red;
@ -134,11 +133,7 @@ sf::Color Ray::Cast() {
case 6: case 6:
return sf::Color(150, 80, 220, 200); return sf::Color(150, 80, 220, 200);
} }
//else if (map->list[voxel.x + dimensions.x * (voxel.y + dimensions.z * voxel.z)] != 0){
//
// //TODO: Switch that assigns color on voxel data
// return sf::Color::Red;
//}
dist++; dist++;

103
src/RayCaster.cpp
Unescape View File

@ -33,62 +33,83 @@ RayCaster::~RayCaster() {
sf::Color* RayCaster::CastRays(sf::Vector3<float> camera_direction, sf::Vector3<float> camera_position) { sf::Color* RayCaster::CastRays(sf::Vector3<float> camera_direction, sf::Vector3<float> camera_position) {
// Setup the camera for this cast // Setup the camera for this cast
this->camera_direction = camera_direction; this->camera_direction = camera_direction;
camera_direction_cartesian = Normalize(SphereToCart(camera_direction)); camera_direction_cartesian = Normalize(SphereToCart(camera_direction));
this->camera_position = camera_position; this->camera_position = camera_position;
// The radian increment each ray is spaced from one another // The radian increment each ray is spaced from one another
double y_increment_radians = DegreesToRadians(60.0 / resolution.y); double y_increment_radians = DegreesToRadians(60.0 / resolution.y);
double x_increment_radians = DegreesToRadians(80.0 / resolution.x); double x_increment_radians = DegreesToRadians(80.0 / resolution.x);
// A reference to the positive X axis as our base viewport point // A reference to the positive X axis as our base viewport point
sf::Vector3f base_direction(1, 0, 0); sf::Vector3f base_direction(1, 0, 0);
//-resolution.y / 2 int view_plane_distance = 300;
// Start the loop at the top left, scan right and work down sf::Vector3f *view_plane_vectors = new sf::Vector3f[resolution.x * resolution.y];
for (int y = 0; y < resolution.y; y++) {
for (int x = 0; x < resolution.x; x++) {
// The direction the final ray will point. for (int y = -resolution.y / 2 ; y < resolution.y / 2; y++) {
// First take a reference to the base direction to setup the viewport for (int x = -resolution.x / 2; x < resolution.x / 2; x++) {
//Vector3<float> ray_direction = new Vector3<float> (base_direction);
// New method to cast rays using the original intended Spherical coords view_plane_vectors[(x + resolution.x / 2) + resolution.x * (y + resolution.y / 2)] = Normalize(sf::Vector3f(view_plane_distance, x, y));
// instead of that malarchy with converting them to cartesian from the formula }
}
//-resolution.y / 2
// Start the loop at the top left, scan right and work down
for (int y = 0; y < resolution.y; y++) {
for (int x = 0; x < resolution.x; x++) {
sf::Vector3f ray_direction(
camera_direction.x,
camera_direction.y + (float)(y_increment_radians * y),
camera_direction.z + (float)(x_increment_radians * x)
);
sf::Vector3f ray_cartesian = Normalize(SphereToCart(ray_direction)); sf::Vector3f ray = view_plane_vectors[x + resolution.x * y];
sf::Vector3f cam_cartesian = Normalize(SphereToCart(camera_direction));
if ((y == -99 || y == 0 || y == 99) && (/*x == 99 || x == 0 || */x == -99)) {
std::cout << "X : " << x << "\n";
std::cout << "Y : " << y << "\n";
std::cout << ray_direction.x << " : " << ray_direction.y << " : " << ray_direction.z << "\n";
}
// Setup the ray // Then rotate y axis, up down
Ray r(map, resolution, sf::Vector2i(x, y), camera_position, ray_direction); ray = sf::Vector3f(
ray.z * sin(camera_direction.y) + ray.x * cos(camera_direction.y),
ray.y,
ray.z * cos(camera_direction.y) - ray.x * sin(camera_direction.y)
);
// Cast it // // Rotate z axis, left to right.
sf::Color c = r.Cast(); ray = sf::Vector3f(
if (c.a == 0) ray.x * cos(camera_direction.z) - ray.y * sin(camera_direction.z),
std::cout << "BLACK"; ray.x * sin(camera_direction.z) + ray.y * cos(camera_direction.z),
image[x + resolution.x*y] = c; ray.z
} );
}
// sf::Vector3f ray_direction(
// camera_direction.x,
// camera_direction.y + (float)(y_increment_radians * y),
// camera_direction.z + (float)(x_increment_radians * x)
// );
return image; sf::Vector3f ray_cartesian = Normalize(SphereToCart(ray));
} sf::Vector3f cam_cartesian = Normalize(SphereToCart(camera_direction));
if ((y == -99 || y == 0 || y == 99) && (/*x == 99 || x == 0 || */x == -99)) {
std::cout << "X : " << x << "\n";
std::cout << "Y : " << y << "\n";
std::cout << ray.x << " : " << ray.y << " : " << ray.z << "\n";
}
// Setup the ray
Ray r(map, resolution, sf::Vector2i(x, y), camera_position, ray);
// Cast it
sf::Color c = r.Cast();
if (c.a == 0)
std::cout << "BLACK";
image[x + resolution.x*y] = c;
}
}
delete view_plane_vectors;
return image;
}
void RayCaster::moveCamera(sf::Vector2f v) { void RayCaster::moveCamera(sf::Vector2f v) {
camera_direction.y += v.x; camera_direction.y += v.x;

Write Preview
Loading…
Cancel
Save