jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

shading pass progress

Browse Source
This commit is contained in:
jacob 2026-01-22 11:03:03 -06:00
parent f9067bfa8b
commit 7a81397fd1
4 changed files with 329 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/base/base_math.h
View File

@ -229,28 +229,28 @@ f64 SaturateF64(f64 v);
//~ Float ops //~ Float ops
//- Round //- Round
#define RoundF32(v) roundf(v) #define RoundF32 roundf
#define RoundF64(v) round(v) #define RoundF64 round
//- Floor //- Floor
#define FloorF32(v) floorf(v) #define FloorF32 floorf
#define FloorF64(v) floor(v) #define FloorF64 floor
//- Ceil //- Ceil
#define CeilF32(v) ceilf(v) #define CeilF32 ceilf
#define CeilF64(v) ceil(v) #define CeilF64 ceil
//- Trunc //- Trunc
#define TruncF32(v) truncf(v) #define TruncF32 truncf
#define TruncF64(v) trunc(v) #define TruncF64 trunc
//- Mod //- Mod
#define ModF32(v, m) fmodf((v), (m)) #define ModF32 fmodf
#define ModF64(v, m) fmod((v), (m)) #define ModF64 fmod
//- Abs //- Abs
#define AbsF32(v) fabsf(v) #define AbsF32 fabsf
#define AbsF64(v) fabs(v) #define AbsF64 fabs
//- Sign //- Sign
i32 SignF32(f32 v); i32 SignF32(f32 v);
@ -261,15 +261,15 @@ i32 SignF64(f64 v);
u64 PowU64(u64 v, u8 exp); u64 PowU64(u64 v, u8 exp);
#define PowF32(v, exp) powf((v), (exp)) #define PowF32 powf
#define PowF64(v, exp) pow((v), (exp)) #define PowF64 pow
#define SqrtF32(v) sqrtf(v) #define SqrtF32 sqrtf
#define SqrtF64(v) sqrt(v) #define SqrtF64 sqrt
#define LnF32(v) log(v) #define LnF32 log
#define Log2F32(v) log2f(v) #define Log2F32 log2f
#define Log10F32(v) log10f(v) #define Log10F32 log10f
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Align //~ Align
@ -280,11 +280,11 @@ u64 NextPow2U64(u64 x);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Trig //~ Trig
#define SinF32(v) sinf(v) #define SinF32 sinf
#define CosF32(v) cosf(v) #define CosF32 cosf
#define TanF32(x) tanf(x) #define TanF32 tanf
#define ArcTanF32(x) atanf(x) #define ArcTanF32 atanf
#define ArcTan2F32(y, x) atan2f((y), (x)) #define ArcTan2F32 atan2f
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Angle unwind //~ Angle unwind

29
src/pp/pp_vis/pp_vis_core.c
View File

@ -345,7 +345,7 @@ void V_TickForever(WaveLaneCtx *lane)
const f32 zoom_rate = 1.50; const f32 zoom_rate = 1.50;
const f32 min_zoom = 0.03; const f32 min_zoom = 0.03;
const f32 max_zoom = 15.0; const f32 max_zoom = 15.0;
const f32 meters_per_screen_width = 16; const f32 meters_per_camera_width = 16;
NET_PipeHandle net_pipe = NET_AcquirePipe(); NET_PipeHandle net_pipe = NET_AcquirePipe();
BB_Buff packer_bb = BB_AcquireDynamicBuff(Gibi(64)); BB_Buff packer_bb = BB_AcquireDynamicBuff(Gibi(64));
@ -678,13 +678,16 @@ void V_TickForever(WaveLaneCtx *lane)
frame->screen_dims.x = MaxF32(frame->screen_dims.x, 64); frame->screen_dims.x = MaxF32(frame->screen_dims.x, 64);
frame->screen_dims.y = MaxF32(frame->screen_dims.y, 64); frame->screen_dims.y = MaxF32(frame->screen_dims.y, 64);
// frame->shade_dims = frame->screen_dims; // Since a shaded cell is smaller than a screen pixel, we increase the
// dimensions of our shaded texture to prevent gaps at the edge of the screen
Vec2 shade_extra_dims = VEC2(1, 1);
f32 max_shade_aspect_ratio = 16.0 / 10.0; f32 max_shade_aspect_ratio = 16.0 / 10.0;
frame->shade_dims.x = V_CellsPerMeter * meters_per_screen_width; frame->shade_dims.x = V_CellsPerMeter * meters_per_camera_width;
frame->shade_dims.y = frame->shade_dims.x / (frame->screen_dims.x / frame->screen_dims.y); frame->shade_dims.y = frame->shade_dims.x / (frame->screen_dims.x / frame->screen_dims.y);
frame->shade_dims.y = MinF32(frame->shade_dims.y, frame->shade_dims.x / max_shade_aspect_ratio); frame->shade_dims.y = MinF32(frame->shade_dims.y, frame->shade_dims.x / max_shade_aspect_ratio);
frame->shade_dims = AddVec2(frame->shade_dims, shade_extra_dims);
frame->shade_dims = CeilVec2(frame->shade_dims);
////////////////////////////// //////////////////////////////
//- Pop sim -> vis data //- Pop sim -> vis data
@ -824,8 +827,8 @@ void V_TickForever(WaveLaneCtx *lane)
Xform prev_frame_edit_to_screen_xf = Zi; Xform prev_frame_edit_to_screen_xf = Zi;
Xform edit_to_screen_xf = Zi; Xform edit_to_screen_xf = Zi;
{ {
f32 prev_edit_camera_scale = (f32)prev_frame->screen_dims.x / (meters_per_screen_width * prev_frame->edit_camera_zoom); f32 prev_edit_camera_scale = (f32)prev_frame->screen_dims.x / (meters_per_camera_width * prev_frame->edit_camera_zoom);
f32 edit_camera_scale = (f32)frame->screen_dims.x / (meters_per_screen_width * frame->edit_camera_zoom); f32 edit_camera_scale = (f32)frame->screen_dims.x / (meters_per_camera_width * frame->edit_camera_zoom);
prev_frame_edit_to_screen_xf = XformFromScale(VEC2(prev_edit_camera_scale, prev_edit_camera_scale)); prev_frame_edit_to_screen_xf = XformFromScale(VEC2(prev_edit_camera_scale, prev_edit_camera_scale));
prev_frame_edit_to_screen_xf = TranslateXform(prev_frame_edit_to_screen_xf, NegVec2(prev_frame->edit_camera_pos)); prev_frame_edit_to_screen_xf = TranslateXform(prev_frame_edit_to_screen_xf, NegVec2(prev_frame->edit_camera_pos));
prev_frame_edit_to_screen_xf = WorldTranslateXform(prev_frame_edit_to_screen_xf, MulVec2(Vec2FromVec(frame->screen_dims), 0.5)); prev_frame_edit_to_screen_xf = WorldTranslateXform(prev_frame_edit_to_screen_xf, MulVec2(Vec2FromVec(frame->screen_dims), 0.5));
@ -860,8 +863,7 @@ void V_TickForever(WaveLaneCtx *lane)
target_camera_pos.x = ClampF32(target_camera_pos.x, -world_pitch / 2, world_pitch / 2); target_camera_pos.x = ClampF32(target_camera_pos.x, -world_pitch / 2, world_pitch / 2);
target_camera_pos.y = ClampF32(target_camera_pos.y, -world_pitch / 2, world_pitch / 2); target_camera_pos.y = ClampF32(target_camera_pos.y, -world_pitch / 2, world_pitch / 2);
target_camera_zoom = ClampF32(target_camera_zoom, min_zoom, max_zoom); target_camera_zoom = ClampF32(target_camera_zoom, min_zoom, max_zoom);
// Interpolate camera
// Create world <-> screen xforms
{ {
if (prev_frame->tick == 0) if (prev_frame->tick == 0)
{ {
@ -899,10 +901,10 @@ void V_TickForever(WaveLaneCtx *lane)
frame->xf.world_to_screen = XformIdentity; frame->xf.world_to_screen = XformIdentity;
frame->xf.screen_to_world = XformIdentity; frame->xf.screen_to_world = XformIdentity;
{ {
f32 camera_scale = (f32)frame->screen_dims.x / (meters_per_screen_width * frame->camera_zoom); f32 camera_scale = frame->screen_dims.x / (meters_per_camera_width * frame->camera_zoom);
frame->xf.world_to_screen = XformFromScale(VEC2(camera_scale, camera_scale)); frame->xf.world_to_screen = XformFromScale(VEC2(camera_scale, camera_scale));
frame->xf.world_to_screen = TranslateXform(frame->xf.world_to_screen, NegVec2(frame->camera_pos)); frame->xf.world_to_screen = TranslateXform(frame->xf.world_to_screen, NegVec2(frame->camera_pos));
frame->xf.world_to_screen = WorldTranslateXform(frame->xf.world_to_screen, MulVec2(Vec2FromVec(frame->screen_dims), 0.5)); frame->xf.world_to_screen = WorldTranslateXform(frame->xf.world_to_screen, MulVec2(frame->screen_dims, 0.5));
frame->xf.world_to_screen.og = RoundVec2(frame->xf.world_to_screen.og); frame->xf.world_to_screen.og = RoundVec2(frame->xf.world_to_screen.og);
frame->xf.screen_to_world = InvertXform(frame->xf.world_to_screen); frame->xf.screen_to_world = InvertXform(frame->xf.world_to_screen);
} }
@ -911,7 +913,11 @@ void V_TickForever(WaveLaneCtx *lane)
frame->xf.world_to_shade = XformIdentity; frame->xf.world_to_shade = XformIdentity;
frame->xf.shade_to_world = XformIdentity; frame->xf.shade_to_world = XformIdentity;
{ {
frame->xf.world_to_shade = MulXform(frame->xf.world_to_screen, frame->xf.screen_to_shade); f32 camera_scale = (frame->shade_dims.x - shade_extra_dims.x) / (meters_per_camera_width * frame->camera_zoom);
frame->xf.world_to_shade = XformFromScale(VEC2(camera_scale, camera_scale));
frame->xf.world_to_shade = TranslateXform(frame->xf.world_to_shade, NegVec2(frame->camera_pos));
frame->xf.world_to_shade = WorldTranslateXform(frame->xf.world_to_shade, MulVec2(frame->shade_dims, 0.5));
frame->xf.world_to_shade.og = RoundVec2(frame->xf.world_to_shade.og);
frame->xf.shade_to_world = InvertXform(frame->xf.world_to_shade); frame->xf.shade_to_world = InvertXform(frame->xf.world_to_shade);
} }
@ -919,6 +925,7 @@ void V_TickForever(WaveLaneCtx *lane)
frame->xf.shade_to_screen = XformIdentity; frame->xf.shade_to_screen = XformIdentity;
frame->xf.screen_to_shade = XformIdentity; frame->xf.screen_to_shade = XformIdentity;
{ {
frame->xf.shade_to_screen = MulXform(frame->xf.world_to_screen, frame->xf.shade_to_world);
frame->xf.screen_to_shade = InvertXform(frame->xf.shade_to_screen); frame->xf.screen_to_shade = InvertXform(frame->xf.shade_to_screen);
} }

174
src/pp/pp_vis/pp_vis_gpu.g
View File

@ -76,8 +76,7 @@ ComputeShader2D(V_BackdropCS, 8, 8)
const Vec4 background_color_b = LinearFromSrgb(Vec4(0.15, 0.15, 0.15, 1)); const Vec4 background_color_b = LinearFromSrgb(Vec4(0.15, 0.15, 0.15, 1));
Vec2 screen_pos = SV_DispatchThreadID + Vec2(0.5, 0.5); Vec2 screen_pos = SV_DispatchThreadID + Vec2(0.5, 0.5);
if (all(screen_pos < params.screen_dims))
{
Vec4 result = Vec4(0.025, 0.025, 0.025, 1); Vec4 result = Vec4(0.025, 0.025, 0.025, 1);
Vec2 world_pos = mul(params.xf.screen_to_world, Vec3(screen_pos, 1)); Vec2 world_pos = mul(params.xf.screen_to_world, Vec3(screen_pos, 1));
Vec2 cell_pos = floor(mul(params.xf.world_to_cell, Vec3(world_pos, 1))); Vec2 cell_pos = floor(mul(params.xf.world_to_cell, Vec3(world_pos, 1)));
@ -97,33 +96,33 @@ ComputeShader2D(V_BackdropCS, 8, 8)
if (is_in_world_bounds) if (is_in_world_bounds)
{ {
// Checkered grid // // Checkered grid
{ // {
i32 color_idx = 0; // i32 color_idx = 0;
Vec4 colors[2] = { // Vec4 colors[2] = {
background_color_a, // background_color_a,
background_color_b // background_color_b
}; // };
const f32 checker_size = 0.5; // const f32 checker_size = 0.5;
Vec2 world_pos_modded = fmod(abs(world_pos), Vec2(checker_size * 2, checker_size * 2)); // Vec2 world_pos_modded = fmod(abs(world_pos), Vec2(checker_size * 2, checker_size * 2));
if (world_pos_modded.x < checker_size) // if (world_pos_modded.x < checker_size)
{ // {
color_idx = !color_idx; // color_idx = !color_idx;
} // }
if (world_pos_modded.y < checker_size) // if (world_pos_modded.y < checker_size)
{ // {
color_idx = !color_idx; // color_idx = !color_idx;
} // }
if (world_pos.x < 0) // if (world_pos.x < 0)
{ // {
color_idx = !color_idx; // color_idx = !color_idx;
} // }
if (world_pos.y < 0) // if (world_pos.y < 0)
{ // {
color_idx = !color_idx; // color_idx = !color_idx;
} // }
result = colors[color_idx]; // result = colors[color_idx];
} // }
// Tile test // Tile test
// TODO: Remove this // TODO: Remove this
@ -159,7 +158,7 @@ ComputeShader2D(V_BackdropCS, 8, 8)
{ {
SPR_Slice slice = params.tile_slices[tile]; SPR_Slice slice = params.tile_slices[tile];
Texture2D<Vec4> tile_tex = G_Dereference<Vec4>(slice.tex); Texture2D<Vec4> tile_tex = G_Dereference<Vec4>(slice.tex);
Vec4 tile_col = tile_tex.Sample(wrap_sampler, world_pos); Vec4 tile_col = tile_tex.SampleLevel(wrap_sampler, world_pos, 0);
result = tile_col; result = tile_col;
} }
@ -267,7 +266,9 @@ ComputeShader2D(V_BackdropCS, 8, 8)
} }
screen[SV_DispatchThreadID] = result; if (all(screen_pos < countof(screen)))
{
screen[screen_pos] = result;
} }
} }
@ -469,14 +470,113 @@ ComputeShader2D(V_ShadeCS, 8, 8)
{ {
V_GpuParams params = G_Dereference<V_GpuParams>(V_ShaderConst_Params)[0]; V_GpuParams params = G_Dereference<V_GpuParams>(V_ShaderConst_Params)[0];
RWTexture2D<Vec4> shade_tex = G_Dereference<Vec4>(params.shade_rw); RWTexture2D<Vec4> shade_tex = G_Dereference<Vec4>(params.shade_rw);
Texture2D<P_TileKind> tiles = G_Dereference<P_TileKind>(params.tiles);
SamplerState wrap_sampler = G_Dereference(params.pt_wrap_sampler);
Vec2 shade_pos = SV_DispatchThreadID + Vec2(0.5, 0.5); Vec2 shade_pos = SV_DispatchThreadID + Vec2(0.5, 0.5);
Vec2 world_pos = mul(params.xf.shade_to_world, Vec3(shade_pos, 1));
Vec2 cell_pos = floor(mul(params.xf.world_to_cell, Vec3(world_pos, 1)));
Vec2 tile_pos = mul(params.xf.world_to_tile, Vec3(world_pos, 1));
P_TileKind tile = tiles.Load(Vec3(tile_pos, 0));
Vec2 half_world_dims = Vec2(P_WorldPitch, P_WorldPitch) * 0.5;
b32 is_in_world_bounds = all(world_pos > -half_world_dims) && all(world_pos < half_world_dims);
//- Tile color
// TODO: Remove this
b32 tile_is_wall = 0;
Vec4 tile_color = 0;
if (is_in_world_bounds)
{
P_TileKind tile_tl = tiles.Load(Vec3(tile_pos.x - 1, tile_pos.y - 1, 0));
P_TileKind tile_tr = tiles.Load(Vec3(tile_pos.x + 1, tile_pos.y - 1, 0));
P_TileKind tile_br = tiles.Load(Vec3(tile_pos.x + 1, tile_pos.y + 1, 0));
P_TileKind tile_bl = tiles.Load(Vec3(tile_pos.x - 1, tile_pos.y + 1, 0));
P_TileKind tile_t = tiles.Load(Vec3(tile_pos.x, tile_pos.y - 1, 0));
P_TileKind tile_r = tiles.Load(Vec3(tile_pos.x + 1, tile_pos.y, 0));
P_TileKind tile_b = tiles.Load(Vec3(tile_pos.x, tile_pos.y + 1, 0));
P_TileKind tile_l = tiles.Load(Vec3(tile_pos.x - 1, tile_pos.y, 0));
f32 tile_edge_dist = Inf;
P_TileKind edge_tile = tile;
if (tile_tl != tile) { edge_tile = tile_tl; tile_edge_dist = min(tile_edge_dist, length(tile_pos - Vec2(floor(tile_pos.x), floor(tile_pos.y)))); }
if (tile_tr != tile) { edge_tile = tile_tr; tile_edge_dist = min(tile_edge_dist, length(tile_pos - Vec2(ceil(tile_pos.x), floor(tile_pos.y)))); }
if (tile_br != tile) { edge_tile = tile_br; tile_edge_dist = min(tile_edge_dist, length(tile_pos - Vec2(ceil(tile_pos.x), ceil(tile_pos.y)))); }
if (tile_bl != tile) { edge_tile = tile_bl; tile_edge_dist = min(tile_edge_dist, length(tile_pos - Vec2(floor(tile_pos.x), ceil(tile_pos.y)))); }
if (tile_l != tile) { edge_tile = tile_l; tile_edge_dist = min(tile_edge_dist, frac(tile_pos.x)); }
if (tile_r != tile) { edge_tile = tile_r; tile_edge_dist = min(tile_edge_dist, 1.0 - frac(tile_pos.x)); }
if (tile_t != tile) { edge_tile = tile_t; tile_edge_dist = min(tile_edge_dist, frac(tile_pos.y)); }
if (tile_b != tile) { edge_tile = tile_b; tile_edge_dist = min(tile_edge_dist, 1.0 - frac(tile_pos.y)); }
if (tile == P_TileKind_Wall)
{
Vec4 outer = LinearFromSrgb(Vec4(0.05, 0.05, 0.05, 1));
Vec4 inner = LinearFromSrgb(Vec4(0.15, 0.15, 0.15, 1));
tile_color = lerp(outer, inner, smoothstep(0, 1, tile_edge_dist / 0.375));
// tile_color = lerp(outer, inner, smoothstep(0, 1, tile_edge_dist / 0.5));
tile_is_wall = 1;
}
else if (tile != P_TileKind_Empty)
{
SPR_Slice slice = params.tile_slices[tile];
Texture2D<Vec4> tile_tex = G_Dereference<Vec4>(slice.tex);
tile_color = tile_tex.SampleLevel(wrap_sampler, world_pos, 0);
}
// Checkered grid
else if (tile == P_TileKind_Empty)
{
i32 color_idx = 0;
Vec4 colors[2] = {
LinearFromSrgb(Vec4(0.30, 0.30, 0.30, 1)),
LinearFromSrgb(Vec4(0.15, 0.15, 0.15, 1))
};
const f32 checker_size = 0.5;
Vec2 world_pos_modded = fmod(abs(world_pos), Vec2(checker_size * 2, checker_size * 2));
if (world_pos_modded.x < checker_size)
{
color_idx = !color_idx;
}
if (world_pos_modded.y < checker_size)
{
color_idx = !color_idx;
}
if (world_pos.x < 0)
{
color_idx = !color_idx;
}
if (world_pos.y < 0)
{
color_idx = !color_idx;
}
tile_color = colors[color_idx];
}
// switch (tile)
// {
// default: break;
// case P_TileKind_Floor:
// {
// tile_color = Color_Blue;
// } break;
// case P_TileKind_Wall:
// {
// // tile_color = Color_Red;
// tile_color = Color_Black;
// } break;
// }
}
//- Composite
Vec4 result = 0;
result = BlendPremul(!tile_is_wall * tile_color, result); // Blend floor tile
result = BlendPremul(tile_is_wall * tile_color, result); // Blend wall tile
if (all(shade_pos < countof(shade_tex))) if (all(shade_pos < countof(shade_tex)))
{ {
Vec4 result = 0;
result.r = shade_pos.x / countof(shade_tex).x;
result.a = 1;
shade_tex[shade_pos] = result; shade_tex[shade_pos] = result;
} }
} }
@ -529,7 +629,7 @@ PixelShader(V_CompositePS, V_CompositePSOutput, V_CompositePSInput input)
if (all(shade_pos >= Vec2(0, 0)) && all(shade_pos < countof(shade_tex))) if (all(shade_pos >= Vec2(0, 0)) && all(shade_pos < countof(shade_tex)))
{ {
Vec2 shade_uv = shade_pos / countof(shade_tex); Vec2 shade_uv = shade_pos / countof(shade_tex);
shade_color = shade_tex.Sample(clamp_sampler, shade_uv); shade_color = shade_tex.SampleLevel(clamp_sampler, shade_uv, 0);
} }
//- Tile selection overlay //- Tile selection overlay
@ -637,9 +737,9 @@ PixelShader(V_CompositePS, V_CompositePSOutput, V_CompositePSInput input)
//- Composite //- Composite
Vec4 result = 0; Vec4 result = 0;
result = BlendPremul(shade_color, result);
result = BlendPremul(selection_color, result); result = BlendPremul(selection_color, result);
result = BlendPremul(overlay_color, result); result = BlendPremul(overlay_color, result);
result = BlendPremul(shade_color, result);
result = Unpremul(result); result = Unpremul(result);

2
src/ui/ui_gpu.g
View File

@ -78,7 +78,7 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
else else
{ {
Texture2D<Vec4> tex = G_Dereference<Vec4>(rect.tex); Texture2D<Vec4> tex = G_Dereference<Vec4>(rect.tex);
background_premul = tex.Sample(sampler, input.tex_uv); background_premul = tex.SampleLevel(sampler, input.tex_uv, 0);
background_premul.rgb *= background_premul.a; background_premul.rgb *= background_premul.a;
} }
} }