cleaned up collision in shader, abstracted out raycast, and added gpu timing
This commit is contained in:
@@ -1,9 +1,9 @@
|
||||
@group(0) @binding(0)
|
||||
var<uniform> view: View;
|
||||
@group(0) @binding(1)
|
||||
var<storage, read> voxels: array<u32>;
|
||||
var<storage, read> chunks: array<Chunk>;
|
||||
@group(0) @binding(2)
|
||||
var<storage, read> voxel_groups: array<VoxelGroup>;
|
||||
var<storage, read> voxel_data: array<u32>;
|
||||
@group(0) @binding(3)
|
||||
var<storage, read> global_lights: array<GlobalLight>;
|
||||
@group(0) @binding(4)
|
||||
@@ -16,12 +16,11 @@ struct GlobalLight {
|
||||
struct View {
|
||||
transform: mat4x4<f32>,
|
||||
zoom: f32,
|
||||
chunk_scale: u32,
|
||||
chunk_dist: u32,
|
||||
};
|
||||
|
||||
struct VoxelGroup {
|
||||
transform: mat4x4<f32>,
|
||||
transform_inv: mat4x4<f32>,
|
||||
scale: u32,
|
||||
struct Chunk {
|
||||
offset: u32,
|
||||
};
|
||||
|
||||
@@ -38,7 +37,8 @@ fn main(@builtin(global_invocation_id) cell: vec3<u32>) {
|
||||
let pixel_pos = vec2<f32>(
|
||||
(vec2<f32>(cell.xy) / view_dim_f - vec2<f32>(0.5)) * vec2<f32>(2.0, -2.0 * aspect)
|
||||
);
|
||||
let pos = view.transform * vec4<f32>(pixel_pos, 1.0, 1.0);
|
||||
let offset = vec3<f32>(f32(1u << (view.chunk_scale - 1)));
|
||||
let pos = view.transform * vec4<f32>(pixel_pos, 1.0, 1.0) + vec4<f32>(offset, 0.0);
|
||||
let dir = view.transform * vec4<f32>(normalize(vec3<f32>(pixel_pos, view.zoom)), 0.0);
|
||||
|
||||
var color = trace_full(pos, dir);
|
||||
@@ -53,6 +53,7 @@ fn main(@builtin(global_invocation_id) cell: vec3<u32>) {
|
||||
|
||||
const LEAF_BIT = 1u << 31u;
|
||||
const LEAF_MASK = ~LEAF_BIT;
|
||||
const MAX_HITS = 10;
|
||||
|
||||
const ZERO3F = vec3<f32>(0.0);
|
||||
const ZERO2F = vec2<f32>(0.0);
|
||||
@@ -62,126 +63,122 @@ const MAX_ITERS = 10000;
|
||||
// NOTE: CANNOT GO HIGHER THAN 23 due to how floating point
|
||||
// numbers are stored and the bit manipulation used
|
||||
const MAX_SCALE: u32 = 13;
|
||||
const AMBIENT: f32 = 0.2;
|
||||
const SPECULAR: f32 = 0.5;
|
||||
|
||||
fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
|
||||
let gi = 0;
|
||||
let group = voxel_groups[gi];
|
||||
if group.scale == 0 {
|
||||
if arrayLength(&voxel_data) == 1 {
|
||||
return vec4<f32>(0.0);
|
||||
}
|
||||
let dimensions = vec3<u32>(1u << group.scale);
|
||||
let gi = 0;
|
||||
let chunk = chunks[gi];
|
||||
let side_len = 1u << view.chunk_scale;
|
||||
let dimensions = vec3<u32>(side_len);
|
||||
let dim_f = vec3<f32>(dimensions);
|
||||
let dim_i = vec3<i32>(dimensions);
|
||||
|
||||
// transform so that group is at 0,0
|
||||
let pos_start = (group.transform_inv * pos_view).xyz;
|
||||
var dir = (group.transform_inv * dir_view).xyz;
|
||||
if dir.x == 0 {dir.x = EPSILON;}
|
||||
if dir.y == 0 {dir.y = EPSILON;}
|
||||
if dir.z == 0 {dir.z = EPSILON;}
|
||||
let pos_start = pos_view.xyz;
|
||||
var dir = dir_view.xyz;
|
||||
if dir.x == 0 { dir.x = EPSILON; }
|
||||
if dir.y == 0 { dir.y = EPSILON; }
|
||||
if dir.z == 0 { dir.z = EPSILON; }
|
||||
|
||||
let dir_if = sign(dir);
|
||||
let dir_uf = max(dir_if, vec3<f32>(0.0));
|
||||
|
||||
// find where ray intersects with group
|
||||
// closest (min) and furthest (max) corners of cube relative to direction
|
||||
let pos_min = (vec3<f32>(1.0) - dir_uf) * dim_f;
|
||||
let pos_max = dir_uf * dim_f;
|
||||
// time of intersection; x = td + p, solve for t
|
||||
let t_min = (pos_min - pos_start) / dir;
|
||||
let t_max = (pos_max - pos_start) / dir;
|
||||
// time of entrance and exit of the cube
|
||||
let t_start = max(max(t_min.x, t_min.y), t_min.z);
|
||||
let t_end = min(min(t_max.x, t_max.y), t_max.z);
|
||||
if t_end < t_start { return vec4<f32>(0.0); }
|
||||
// axis of intersection
|
||||
let axis = select(select(2u, 1u, t_start == t_min.y), 0u, t_start == t_min.x);
|
||||
// time to move entire side length in each direction
|
||||
let inc_t = abs(1.0 / dir) * f32(side_len);
|
||||
let t = max(0.0, t_start);
|
||||
|
||||
let inv_dir_bits = 7 - vec_to_dir(vec3<u32>(dir_uf));
|
||||
let corner_adj = t_min - inc_t;
|
||||
|
||||
// calculate normals
|
||||
var normals = mat3x3<f32>(
|
||||
(group.transform * vec4<f32>(dir_if.x, 0.0, 0.0, 0.0)).xyz,
|
||||
(group.transform * vec4<f32>(0.0, dir_if.y, 0.0, 0.0)).xyz,
|
||||
(group.transform * vec4<f32>(0.0, 0.0, dir_if.z, 0.0)).xyz,
|
||||
vec3<f32>(dir_if.x, 0.0, 0.0),
|
||||
vec3<f32>(0.0, dir_if.y, 0.0),
|
||||
vec3<f32>(0.0, 0.0, dir_if.z),
|
||||
);
|
||||
var axis = 0u;
|
||||
|
||||
// find where ray intersects with group
|
||||
let pos_min = (vec3<f32>(1.0) - dir_uf) * dim_f;
|
||||
// time of intersection; x = td + p, solve for t
|
||||
var t_min = (pos_min - pos_start) / dir;
|
||||
if outside3f(pos_start, ZERO3F, dim_f) {
|
||||
// points of intersection
|
||||
let px = pos_start + t_min.x * dir;
|
||||
let py = pos_start + t_min.y * dir;
|
||||
let pz = pos_start + t_min.z * dir;
|
||||
let result = cast_ray(chunk.offset, t, axis, inv_dir_bits, inc_t, corner_adj);
|
||||
return shade_ray(result, pos_start, dir_view.xyz, t_end, normals);
|
||||
}
|
||||
|
||||
// check if point is in bounds
|
||||
let hit = vec3<bool>(
|
||||
inside2f(px.yz, ZERO2F, dim_f.yz),
|
||||
inside2f(py.xz, ZERO2F, dim_f.xz),
|
||||
inside2f(pz.xy, ZERO2F, dim_f.xy),
|
||||
) && (t_min > ZERO3F);
|
||||
if !any(hit) {
|
||||
return vec4<f32>(0.0);
|
||||
}
|
||||
axis = select(select(2u, 1u, hit.y), 0u, hit.x);
|
||||
}
|
||||
let t_mult = f32(1u << (MAX_SCALE - group.scale));
|
||||
t_min *= t_mult;
|
||||
// time to move 1 unit in each direction
|
||||
let full = f32(1u << MAX_SCALE);
|
||||
let inc_t = abs(1.0 / dir) * full;
|
||||
let t_offset = max(max(t_min.x, t_min.y), t_min.z);
|
||||
var t = max(0.0, t_offset);
|
||||
fn shade_ray(result: RayResult, pos_start: vec3<f32>, dir: vec3<f32>, t_end: f32, normals: mat3x3<f32>) -> vec4<f32> {
|
||||
var hits = result.hits;
|
||||
|
||||
let dir_i = vec3<i32>(dir_if);
|
||||
let dir_u = vec3<u32>(dir_uf);
|
||||
let dir_bits = vec_to_dir(dir_u);
|
||||
let inv_dir_bits = 7 - dir_bits;
|
||||
|
||||
var node_start = 1u;
|
||||
var scale = MAX_SCALE - 1;
|
||||
var scale_exp2 = 0.5;
|
||||
var color = vec4<f32>(0.0);
|
||||
var parents = array<u32, MAX_SCALE>();
|
||||
var prev = LEAF_BIT;
|
||||
var old_t = t / t_mult;
|
||||
for (var i = 0u; i < result.len; i += 1u) {
|
||||
let hit = hits[i];
|
||||
let id = hit.id;
|
||||
let t = hit.t;
|
||||
let axis = hit.axis;
|
||||
|
||||
var child = 0u;
|
||||
let next_t = select(hits[i + 1].t, t_end, i == result.len - 1);
|
||||
|
||||
var pos = pos_start + dir * t;
|
||||
pos[axis] = round(pos[axis]) - f32(dir[axis] < 0.0);
|
||||
let normal = select(select(normals[0], normals[1], axis == 1), normals[2], axis == 2);
|
||||
let vcolor = shade(id, pos, normal, dir, next_t - t);
|
||||
color += vcolor * (1.0 - color.a);
|
||||
if color.a > FULL_ALPHA { break; }
|
||||
}
|
||||
return color;
|
||||
}
|
||||
|
||||
struct RayHit {
|
||||
t: f32,
|
||||
id: u32,
|
||||
axis: u32,
|
||||
}
|
||||
|
||||
struct RayResult {
|
||||
hits: array<RayHit, MAX_HITS>,
|
||||
len: u32,
|
||||
}
|
||||
|
||||
fn cast_ray(
|
||||
data_offset: u32, t_start: f32, axis_start: u32,
|
||||
inv_dir_bits: u32, inc_t: vec3<f32>, corner_adj: vec3<f32>
|
||||
) -> RayResult {
|
||||
var hits = array<RayHit, MAX_HITS>();
|
||||
var depth = 0u;
|
||||
var min_alpha = 0.0;
|
||||
|
||||
var t = t_start;
|
||||
var axis = axis_start;
|
||||
var node_start = 0u;
|
||||
var scale = MAX_SCALE;
|
||||
var scale_exp2 = 1.0;
|
||||
var parents = array<u32, MAX_SCALE>();
|
||||
var child = inv_dir_bits;
|
||||
var vox_pos = vec3<f32>(1.0);
|
||||
let t_center = t_min + scale_exp2 * inc_t;
|
||||
if t > t_center.x { vox_pos.x = 1.5; child |= 4u; }
|
||||
if t > t_center.y { vox_pos.y = 1.5; child |= 2u; }
|
||||
if t > t_center.z { vox_pos.z = 1.5; child |= 1u; }
|
||||
let min_adj = t_min - inc_t;
|
||||
var prev = 0u;
|
||||
|
||||
var iters = 0;
|
||||
loop {
|
||||
if iters == MAX_ITERS {
|
||||
return vec4<f32>(1.0, 0.0, 1.0, 1.0);
|
||||
}
|
||||
if iters == MAX_ITERS { break; }
|
||||
iters += 1;
|
||||
let t_corner = vox_pos * inc_t + min_adj;
|
||||
let node = voxels[group.offset + node_start + (child ^ inv_dir_bits)];
|
||||
let t_corner = vox_pos * inc_t + corner_adj;
|
||||
let node = voxel_data[data_offset + node_start + (child ^ inv_dir_bits)];
|
||||
if node >= LEAF_BIT {
|
||||
// ignore consecutive identical leaves
|
||||
if node != prev {
|
||||
if node != LEAF_BIT {
|
||||
let real_t = t / t_mult;
|
||||
let dist = real_t - old_t;
|
||||
old_t = real_t;
|
||||
let filt = min(dist / 64.0, 1.0);
|
||||
if prev == LEAF_BIT + 3 {
|
||||
color.a += filt * (1.0 - color.a);
|
||||
if color.a > FULL_ALPHA { break; }
|
||||
}
|
||||
var pos = (pos_view + dir_view * real_t).xyz;
|
||||
pos[axis] = round(pos[axis]) - (1.0 - dir_uf[axis]);
|
||||
let vcolor = get_color(node & LEAF_MASK, pos);
|
||||
var normal = normals[axis];
|
||||
let light_color = vec3<f32>(1.0);
|
||||
let light_dir = global_lights[0].dir;
|
||||
|
||||
let diffuse = max(dot(light_dir, normal), 0.0) * light_color;
|
||||
let ambient = AMBIENT * light_color;
|
||||
let spec_val = pow(max(dot(dir_view.xyz, reflect(-light_dir, normal)), 0.0), 32.0) * SPECULAR;
|
||||
let specular = spec_val * light_color;
|
||||
let new_color = (ambient + diffuse + specular) * vcolor.xyz;
|
||||
let new_a = min(vcolor.a + spec_val, 1.0);
|
||||
|
||||
color += vec4<f32>(new_color.xyz * new_a, new_a) * (1.0 - color.a);
|
||||
if color.a > FULL_ALPHA { break; }
|
||||
}
|
||||
let id = node & LEAF_MASK;
|
||||
hits[depth] = RayHit(t, id, axis);
|
||||
min_alpha += min_alpha(id) * (1.0 - min_alpha);
|
||||
depth += 1u;
|
||||
prev = node;
|
||||
if depth == 10 || min_alpha >= FULL_ALPHA { break; }
|
||||
}
|
||||
|
||||
// move to next time point and determine which axis to move along
|
||||
@@ -226,10 +223,15 @@ fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
|
||||
node_start = node;
|
||||
}
|
||||
}
|
||||
// let fog = min(t / t_mult / 1000.0, 1.0);
|
||||
// return vec4<f32>(color.xyz * (1.0 - fog) + vec3<f32>(fog), color.a * (1.0 - fog) + fog);
|
||||
// return vec4<f32>(f32(iters) / f32(MAX_ITERS), 0.0, 0.0, 1.0);
|
||||
return color;
|
||||
return RayResult(hits, depth);
|
||||
}
|
||||
|
||||
fn trace_chunk(
|
||||
offset: u32,
|
||||
inv_dir_bits: u32,
|
||||
t: f32, t_mult: f32, inc_t: vec3<f32>,
|
||||
min_adj: vec3<f32>
|
||||
) {
|
||||
}
|
||||
|
||||
fn dir_to_vec(bits: u32) -> vec3<u32> {
|
||||
@@ -240,29 +242,53 @@ fn vec_to_dir(vec: vec3<u32>) -> u32 {
|
||||
return vec.x * 4 + vec.y * 2 + vec.z * 1;
|
||||
}
|
||||
|
||||
fn get_color(id: u32, pos: vec3<f32>) -> vec4<f32> {
|
||||
fn min_alpha(id: u32) -> f32 {
|
||||
switch id {
|
||||
case 0u: {return 0.0;}
|
||||
case 3u: {return 0.5;}
|
||||
default: {return 1.0;}
|
||||
}
|
||||
}
|
||||
|
||||
const AMBIENT: f32 = 0.2;
|
||||
const SPECULAR: f32 = 0.5;
|
||||
|
||||
// returns premultiplied
|
||||
fn shade(id: u32, pos: vec3<f32>, normal: vec3<f32>, dir_view: vec3<f32>, dist: f32) -> vec4<f32> {
|
||||
var color = vec4<f32>(0.0);
|
||||
if id == 0 {
|
||||
return color;
|
||||
}
|
||||
let random = random(floor(pos));
|
||||
let random2 = random(floor(pos) + vec3<f32>(0.0001));
|
||||
switch id {
|
||||
case 0u: {
|
||||
return vec4<f32>(0.0);
|
||||
color = vec4<f32>(0.0);
|
||||
}
|
||||
case 1u: {
|
||||
let color = vec3<f32>(0.5, 0.5, 0.5 + random * 0.2) * (random2 * 0.4 + 0.8);
|
||||
return vec4<f32>(color, 1.0);
|
||||
color = vec4<f32>(vec3<f32>(0.5, 0.5, 0.5 + random * 0.2) * (random2 * 0.4 + 0.8), 1.0);
|
||||
}
|
||||
case 2u: {
|
||||
let color = vec3<f32>(0.4 + random * 0.2, 0.9, 0.4 + random * 0.2) * (random2 * 0.2 + 0.9);
|
||||
return vec4<f32>(color, 1.0);
|
||||
color = vec4<f32>(vec3<f32>(0.4 + random * 0.2, 0.9, 0.4 + random * 0.2) * (random2 * 0.2 + 0.9), 1.0);
|
||||
}
|
||||
case 3u: {
|
||||
let color = vec3<f32>(0.5, 0.5, 1.0) * (random2 * 0.2 + 0.8);
|
||||
return vec4<f32>(color, 0.5);
|
||||
}
|
||||
default: {
|
||||
return vec4<f32>(1.0, 0.0, 0.0, 1.0);
|
||||
let fog = min(dist / 64.0, 1.0);
|
||||
let a = 0.5;
|
||||
let rgb = vec3<f32>(0.5, 0.5, 1.0) * (random2 * 0.2 + 0.8);
|
||||
color = vec4<f32>(rgb * (1.0 - fog * a), a + fog * (1.0 - a));
|
||||
}
|
||||
default: {}
|
||||
}
|
||||
let light_color = vec3<f32>(1.0);
|
||||
let light_dir = global_lights[0].dir;
|
||||
|
||||
let diffuse = max(dot(light_dir, normal), 0.0) * light_color;
|
||||
let ambient = AMBIENT * light_color;
|
||||
let spec_val = pow(max(dot(dir_view.xyz, reflect(-light_dir, normal)), 0.0), 32.0) * SPECULAR;
|
||||
let specular = spec_val * light_color;
|
||||
let new_color = (ambient + diffuse + specular) * color.xyz;
|
||||
let new_a = min(color.a + spec_val, 1.0);
|
||||
return vec4<f32>(new_color * new_a, new_a);
|
||||
}
|
||||
|
||||
fn random(pos: vec3<f32>) -> f32 {
|
||||
|
||||
Reference in New Issue
Block a user