diff --git a/src/base/base_core.h b/src/base/base_core.h index 8a9b618a..bfa7c8f3 100644 --- a/src/base/base_core.h +++ b/src/base/base_core.h @@ -112,7 +112,7 @@ extern "C" { //~ Debug //- Static assert -#if CompilerIsMsvc || (LanguageIsC && __STDC_VERSION__ < 202311L) +#if CompilerIsMsvc || (LanguageIsC && __STDC_VERSION__ < 202311L) || LanguageIsGpu # if CompilerIsMsvc # define StaticAssert2(cond, line) struct STATIC_ASSERT_____##line {int foo[(cond) ? 1 : -1];} # define StaticAssert1(cond, line) StaticAssert2(cond, line) @@ -138,6 +138,12 @@ extern "C" { # define Assert(cond) (void)(0) #endif +//- Root constant assert +#define AssertRootConst(s, n) StaticAssert((sizeof(s) % 16 == 0) && /* Root constant struct should pad to 16 byte alignment */ \ + ((sizeof(s) / 4) == n) && /* Root constant struct size should match the specified 32-bit-constant count */ \ + (sizeof(s) <= 256)) /* Root constant struct can only fit 64 DWORDS */ + + //- Debug alias /* TODO: Remove this */ #if CompilerIsMsvc @@ -354,6 +360,18 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t); #define ColorOrange Rgb32(0xFF, 0xA5, 0x00) #define ColorPurple Rgb32(0xFF, 0x00, 0XFF) +//////////////////////////////// +//~ Gpu helpers + +#if LanguageIsGpu +//- Resource heap index +# define GpuResourceFromUrid(urid) ResourceDescriptorHeap[urid] +# define GpuResourceFromNurid(nurid) ResourceDescriptorHeap[NonUniformResourceIndex(nurid)] + +//- Semantic declaration +# define Semantic(t, n) t n : n +#endif + //////////////////////////////// //~ Intrinsic headers @@ -377,8 +395,8 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t); //////////////////////////////// //~ Struct helper macros -#define Struct(name) typedef struct name name; struct name -#define AlignedStruct(name, n) typedef struct name name; struct alignas(n) name +#define Struct(name) typedef struct name name; struct name +#define AlignedStruct(name, n) typedef struct name name; struct alignas(n) name //////////////////////////////// //~ Scalar types diff --git a/src/base/base_math.h b/src/base/base_math.h index c0a59438..b2fcca7f 100644 --- a/src/base/base_math.h +++ b/src/base/base_math.h @@ -59,6 +59,15 @@ Struct(Vec3I32) { }; #define VEC3I32(x, y, z) CppCompatInitListType(Vec3I32) { (x), (y), (z) } +//////////////////////////////// +//~ Integer vector4 types + +Struct(Vec4I32) +{ + i32 x, y, z, w; +}; +#define VEC4I32(x, y, z, w) CppCompatInitListType(Vec4I32) { (x), (y), (z), (w) } + //////////////////////////////// //~ Xform types diff --git a/src/base/base_math_gpu.h b/src/base/base_math_gpu.h index 288d465b..d3bf3e2f 100644 --- a/src/base/base_math_gpu.h +++ b/src/base/base_math_gpu.h @@ -1,19 +1,50 @@ +//////////////////////////////// +//~ Gpu math constants + #define Pi ((f32)3.14159265358979323846) #define Tau ((f32)6.28318530717958647693) #define GoldenRatio ((f32)1.61803398874989484820) -#if LanguageIsC || LanguageIsCpp || !LanguageIsGpu -# error AAA -#endif +//////////////////////////////// +//~ Gpu math types typedef float2 Vec2; typedef float3 Vec3; typedef float4 Vec4; typedef int2 Vec2I32; typedef int3 Vec3I32; +typedef int4 Vec4I32; typedef float2x3 Xform; typedef float4 Rect; -typedef float2 ClipRect; -typedef float2 Aabb; +typedef float4 ClipRect; +typedef float4 Aabb; typedef float4 Quad; typedef float4x4 Mat4x4; + +//////////////////////////////// +//~ Integer -> float + +Vec4 Vec4NormFromU32(u32 v) +{ + Vec4 result; + result.r = ((v >> 0) & 0xFF) / 255.0; + result.g = ((v >> 8) & 0xFF) / 255.0; + result.b = ((v >> 16) & 0xFF) / 255.0; + result.a = ((v >> 24) & 0xFF) / 255.0; + return result; +} + +//////////////////////////////// +//~ Srgb -> linear + +/* Linear color from normalized sRGB */ +Vec4 LinearFromSrgbVec4(Vec4 srgb) +{ + return Vec4(pow(abs(srgb.rgb), 2.2), srgb.a); +} + +/* Linear color from R8G8B8A8 sRGB */ +Vec4 LinearFromSrgbU32(u32 srgb32) +{ + return LinearFromSrgbVec4(Vec4NormFromU32(srgb32)); +} diff --git a/src/gpu/gpu_core_dx12.c b/src/gpu/gpu_core_dx12.c index f018ef8a..062411d0 100644 --- a/src/gpu/gpu_core_dx12.c +++ b/src/gpu/gpu_core_dx12.c @@ -2658,14 +2658,14 @@ u32 gp_push_render_cmd(GPU_RenderSig *render_sig, GPU_RenderCmdDesc *cmd_desc) case GP_RENDER_CMD_KIND_DRAW_UI_SHAPE: { u32 color = cmd_desc->ui_shape.color; - struct k_shape_vert *verts = PushStructsNoZero(sig->ui_shape_verts_arena, struct k_shape_vert, cmd_desc->ui_shape.vertices.count); + K_ShapeVert *verts = PushStructsNoZero(sig->ui_shape_verts_arena, K_ShapeVert, cmd_desc->ui_shape.vertices.count); u32 *indices = PushStructsNoZero(sig->ui_shape_indices_arena, u32, cmd_desc->ui_shape.indices.count); for (u32 i = 0; i < cmd_desc->ui_shape.vertices.count; ++i) { - struct k_shape_vert *v = &verts[i]; - v->pos = K_Float2FromV2(cmd_desc->ui_shape.vertices.points[i]); - v->color_srgb = K_UintFromU32(color); + K_ShapeVert *v = &verts[i]; + v->pos = cmd_desc->ui_shape.vertices.points[i]; + v->color_srgb = color; } - u32 vert_offset = verts - (struct k_shape_vert *)ArenaBase(sig->ui_shape_verts_arena); + u32 vert_offset = verts - (K_ShapeVert *)ArenaBase(sig->ui_shape_verts_arena); for (u32 i = 0; i < cmd_desc->ui_shape.indices.count; ++i) { indices[i] = cmd_desc->ui_shape.indices.indices[i] + vert_offset; } @@ -2769,9 +2769,9 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param struct command_buffer *quad_index_buffer = command_list_push_buffer(cl, countof(quad_indices), quad_indices); /* Process sig data into uploadable data */ - struct k_material_instance *material_instances = PushStructsNoZero(scratch.arena, struct k_material_instance, rsig->num_material_instance_descs); - struct k_ui_instance *ui_rect_instances = PushStructsNoZero(scratch.arena, struct k_ui_instance, rsig->num_ui_rect_instance_descs); - struct k_material_grid *grids = PushStructsNoZero(scratch.arena, struct k_material_grid, rsig->num_material_grid_descs); + K_MaterialInstance *material_instances = PushStructsNoZero(scratch.arena, K_MaterialInstance, rsig->num_material_instance_descs); + K_UiInstance *ui_rect_instances = PushStructsNoZero(scratch.arena, K_UiInstance, rsig->num_ui_rect_instance_descs); + K_MaterialGrid *grids = PushStructsNoZero(scratch.arena, K_MaterialGrid, rsig->num_material_grid_descs); { __profn("Process sig data"); @@ -2780,15 +2780,15 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param __profn("Process material instances"); for (u32 i = 0; i < rsig->num_material_instance_descs; ++i) { struct material_instance_desc *desc = &((struct material_instance_desc *)ArenaBase(rsig->material_instance_descs_arena))[i]; - struct k_material_instance *instance = &material_instances[i]; - instance->tex_nurid = K_UintFromU32(desc->texture_id); - instance->grid_id = K_UintFromU32(desc->grid_id); - instance->xf = K_Float2x3FromXform(desc->xf); - instance->uv0 = K_Float2FromV2(desc->clip.p0); - instance->uv1 = K_Float2FromV2(desc->clip.p1); - instance->tint_srgb = K_UintFromU32(desc->tint); - instance->is_light = K_UintFromU32(desc->is_light); - instance->light_emittance_srgb = K_Float3FromV3(desc->light_emittance); + K_MaterialInstance *instance = &material_instances[i]; + instance->tex_nurid = desc->texture_id; + instance->grid_id = desc->grid_id; + instance->xf = desc->xf; + instance->uv0 = desc->clip.p0; + instance->uv1 = desc->clip.p1; + instance->tint_srgb = desc->tint; + instance->is_light = desc->is_light; + instance->light_emittance_srgb = desc->light_emittance; } } @@ -2797,12 +2797,12 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param __profn("Process ui rect instances"); for (u32 i = 0; i < rsig->num_ui_rect_instance_descs; ++i) { struct ui_rect_instance_desc *desc = &((struct ui_rect_instance_desc *)ArenaBase(rsig->ui_rect_instance_descs_arena))[i]; - struct k_ui_instance *instance = &ui_rect_instances[i]; - instance->tex_nurid = K_UintFromU32(desc->texture_id); - instance->xf = K_Float2x3FromXform(desc->xf); - instance->uv0 = K_Float2FromV2(desc->clip.p0); - instance->uv1 = K_Float2FromV2(desc->clip.p1); - instance->tint_srgb = K_UintFromU32(desc->tint); + K_UiInstance *instance = &ui_rect_instances[i]; + instance->tex_nurid = desc->texture_id; + instance->xf = desc->xf; + instance->uv0 = desc->clip.p0; + instance->uv1 = desc->clip.p1; + instance->tint_srgb = desc->tint; } } @@ -2811,25 +2811,25 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param __profn("Process grids"); for (u32 i = 0; i < rsig->num_material_grid_descs; ++i) { struct material_grid_desc *desc = &((struct material_grid_desc *)ArenaBase(rsig->material_grid_descs_arena))[i]; - struct k_material_grid *grid = &grids[i]; - grid->line_thickness = K_FloatFromF32(desc->line_thickness); - grid->line_spacing = K_FloatFromF32(desc->line_spacing); - grid->offset = K_Float2FromV2(desc->offset); - grid->bg0_srgb = K_UintFromU32(desc->bg0_color); - grid->bg1_srgb = K_UintFromU32(desc->bg1_color); - grid->line_srgb = K_UintFromU32(desc->line_color); - grid->x_srgb = K_UintFromU32(desc->x_color); - grid->y_srgb = K_UintFromU32(desc->y_color); + K_MaterialGrid *grid = &grids[i]; + grid->line_thickness = desc->line_thickness; + grid->line_spacing = desc->line_spacing; + grid->offset = desc->offset; + grid->bg0_srgb = desc->bg0_color; + grid->bg1_srgb = desc->bg1_color; + grid->line_srgb = desc->line_color; + grid->x_srgb = desc->x_color; + grid->y_srgb = desc->y_color; } } } /* Upload buffers */ - u64 num_ui_shape_verts = rsig->ui_shape_verts_arena->pos / sizeof(struct k_shape_vert); + u64 num_ui_shape_verts = rsig->ui_shape_verts_arena->pos / sizeof(K_ShapeVert); u64 num_ui_shape_indices = rsig->ui_shape_indices_arena->pos / sizeof(u32); struct command_buffer *material_instance_buffer = command_list_push_buffer(cl, rsig->num_material_instance_descs, material_instances); struct command_buffer *ui_rect_instance_buffer = command_list_push_buffer(cl, rsig->num_ui_rect_instance_descs, ui_rect_instances); - struct command_buffer *ui_shape_verts_buffer = command_list_push_buffer(cl, num_ui_shape_verts, (struct k_shape_vert *)ArenaBase(rsig->ui_shape_verts_arena)); + struct command_buffer *ui_shape_verts_buffer = command_list_push_buffer(cl, num_ui_shape_verts, (K_ShapeVert *)ArenaBase(rsig->ui_shape_verts_arena)); struct command_buffer *ui_shape_indices_buffer = command_list_push_buffer(cl, num_ui_shape_indices, (u32 *)ArenaBase(rsig->ui_shape_indices_arena)); struct command_buffer *grid_buffer = command_list_push_buffer(cl, rsig->num_material_grid_descs, grids); @@ -2878,14 +2878,14 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor); /* Set sig */ - struct k_material_sig sig = ZI; + K_MaterialSig sig = ZI; sig.projection = world_to_render_vp_matrix; sig.instances_urid = material_instance_buffer->resource->srv_descriptor->index; sig.grids_urid = grid_buffer->resource->srv_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Draw */ - u32 instance_count = material_instance_buffer->size / sizeof(struct k_material_instance); + u32 instance_count = material_instance_buffer->size / sizeof(K_MaterialInstance); D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0); D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT); ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); @@ -2936,13 +2936,13 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param } /* Set sig */ - struct k_flood_sig sig = ZI; - sig.step_len = K_IntFromI32(step_length); - sig.emittance_tex_urid = K_UintFromU32(rsig->emittance->srv_descriptor->index); - sig.read_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_read->uav_descriptor->index); - sig.target_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_target->uav_descriptor->index); - sig.tex_width = K_UintFromU32(render_size.x); - sig.tex_height = K_UintFromU32(render_size.y); + K_FloodSig sig = ZI; + sig.step_len = step_length; + sig.emittance_tex_urid = rsig->emittance->srv_descriptor->index; + sig.read_flood_tex_urid = rsig->emittance_flood_read->uav_descriptor->index; + sig.target_flood_tex_urid = rsig->emittance_flood_target->uav_descriptor->index; + sig.tex_width = render_size.x; + sig.tex_height = render_size.y; command_list_set_sig(cl, &sig, sizeof(sig)); /* Dispatch */ @@ -3004,21 +3004,21 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param } /* Set sig */ - struct k_shade_sig sig = ZI; - sig.flags = K_UintFromU32(shade_flags); - sig.tex_width = K_UintFromU32(render_size.x); - sig.tex_height = K_UintFromU32(render_size.y); - sig.frame_seed = K_Uint4FromU32((u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), - (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), - (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), - (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF)); - sig.frame_index = K_UintFromU32(rsig->frame_index); - sig.camera_offset = K_Float2FromV2(world_to_render_xf.og); - sig.albedo_tex_urid = K_UintFromU32(rsig->albedo->srv_descriptor->index); - sig.emittance_tex_urid = K_UintFromU32(rsig->emittance->srv_descriptor->index); - sig.emittance_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_read->srv_descriptor->index); - sig.read_tex_urid = K_UintFromU32(rsig->shade_read->uav_descriptor->index); - sig.target_tex_urid = K_UintFromU32(rsig->shade_target->uav_descriptor->index); + K_ShadeSig sig = ZI; + sig.flags = shade_flags; + sig.tex_width = render_size.x; + sig.tex_height = render_size.y; + sig.frame_seed = VEC4I32((u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), + (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), + (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF), + (u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF)); + sig.frame_index = rsig->frame_index; + sig.camera_offset = world_to_render_xf.og; + sig.albedo_tex_urid = rsig->albedo->srv_descriptor->index; + sig.emittance_tex_urid = rsig->emittance->srv_descriptor->index; + sig.emittance_flood_tex_urid = rsig->emittance_flood_read->srv_descriptor->index; + sig.read_tex_urid = rsig->shade_read->uav_descriptor->index; + sig.target_tex_urid = rsig->shade_target->uav_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Dispatch */ @@ -3066,12 +3066,12 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor); /* Set sig */ - struct k_blit_sig sig = ZI; - sig.projection = K_Float4x4FromMat4x4(blit_vp_matrix); - sig.flags = K_UintFromU32(K_BLIT_FLAG_TONE_MAP | K_BLIT_FLAG_GAMMA_CORRECT); - sig.exposure = K_FloatFromF32(2.0); - sig.gamma = K_FloatFromF32((f32)2.2); - sig.tex_urid = K_UintFromU32(rsig->shade_read->uav_descriptor->index); + K_BlitSig sig = ZI; + sig.projection = blit_vp_matrix; + sig.flags = K_BLIT_FLAG_TONE_MAP | K_BLIT_FLAG_GAMMA_CORRECT; + sig.exposure = 2.0; + sig.gamma = (f32)2.2; + sig.tex_urid = rsig->shade_read->uav_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Draw */ @@ -3098,13 +3098,13 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor); /* Set sig */ - struct k_ui_sig sig = ZI; - sig.projection = K_Float4x4FromMat4x4(ui_vp_matrix); - sig.instances_urid = K_UintFromU32(ui_rect_instance_buffer->resource->srv_descriptor->index); + K_UiSig sig = ZI; + sig.projection = ui_vp_matrix; + sig.instances_urid = ui_rect_instance_buffer->resource->srv_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Draw */ - u32 instance_count = ui_rect_instance_buffer->size / sizeof(struct k_ui_instance); + u32 instance_count = ui_rect_instance_buffer->size / sizeof(K_UiInstance); D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0); D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT); ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); @@ -3128,9 +3128,9 @@ GPU_Resource *gp_run_render(GPU_RenderSig *gp_render_sig, GPU_RenderParams param ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor); /* Set sig */ - struct k_shape_sig sig = ZI; - sig.projection = K_Float4x4FromMat4x4(ui_vp_matrix); - sig.verts_urid = K_UintFromU32(ui_shape_verts_buffer->resource->srv_descriptor->index); + K_ShapeSig sig = ZI; + sig.projection = ui_vp_matrix; + sig.verts_urid = ui_shape_verts_buffer->resource->srv_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Draw */ @@ -3405,10 +3405,10 @@ internal void present_blit(struct swapchain_buffer *dst, struct dx12_resource *s ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor); /* Set sig */ - struct k_blit_sig sig = ZI; - sig.projection = K_Float4x4FromMat4x4(vp_matrix); - sig.flags = K_UintFromU32(K_BLIT_FLAG_NONE); - sig.tex_urid = K_UintFromU32(src->srv_descriptor->index); + K_BlitSig sig = ZI; + sig.projection = vp_matrix; + sig.flags = K_BLIT_FLAG_NONE; + sig.tex_urid = src->srv_descriptor->index; command_list_set_sig(cl, &sig, sizeof(sig)); /* Draw */ diff --git a/src/kernel/kernel_blit.rst b/src/kernel/kernel_blit.rst index 03391aa7..7b69c688 100644 --- a/src/kernel/kernel_blit.rst +++ b/src/kernel/kernel_blit.rst @@ -1,33 +1,35 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); /* ========================== * * Vertex shader * ========================== */ -struct vs_input { - DECLS(uint, SV_VertexID); -}; - -struct vs_output { - DECLS(float4, SV_Position); - DECLS(float2, uv); -}; - -K_ENTRY struct vs_output vs(struct vs_input input) +Struct(VsInput) { - static const float2 unit_quad_verts[4] = { - float2(-0.5f, -0.5f), - float2(0.5f, -0.5f), - float2(0.5f, 0.5f), - float2(-0.5f, 0.5f) + Semantic(u32, SV_VertexID); +}; + +Struct(VSOutput) +{ + Semantic(Vec4, SV_Position); + Semantic(Vec2, uv); +}; + +K_ENTRY VSOutput vs(VsInput input) +{ + static const Vec2 unit_quad_verts[4] = { + Vec2(-0.5f, -0.5f), + Vec2(0.5f, -0.5f), + Vec2(0.5f, 0.5f), + Vec2(-0.5f, 0.5f) }; - float2 vert = unit_quad_verts[input.SV_VertexID]; + Vec2 vert = unit_quad_verts[input.SV_VertexID]; - struct vs_output output; - output.SV_Position = mul(sig.projection, float4(vert, 0, 1)); + VSOutput output; + output.SV_Position = mul(sig.projection, Vec4(vert, 0, 1)); output.uv = vert + 0.5; return output; } @@ -38,7 +40,7 @@ K_ENTRY struct vs_output vs(struct vs_input input) /* ACES approximation by Krzysztof Narkowicz * https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/ */ -float3 tone_map(float3 v) +Vec3 tone_map(Vec3 v) { return saturate((v * (2.51f * v + 0.03f)) / (v * (2.43f * v + 0.59f) + 0.14f)); } @@ -47,19 +49,21 @@ float3 tone_map(float3 v) * Pixel shader * ========================== */ -struct ps_input { - struct vs_output vs; -}; - -struct ps_output { - DECLS(float4, SV_Target); -}; - -K_ENTRY struct ps_output ps(struct ps_input input) +Struct(PsInput) { - struct ps_output output; - Texture2D tex = resource_from_urid(sig.tex_urid); - float4 color = tex.Sample(s_point_clamp, input.vs.uv); + VSOutput vs; +}; + +Struct(PSOutput) +{ + Semantic(Vec4, SV_Target); +}; + +K_ENTRY PSOutput ps(PsInput input) +{ + PSOutput output; + Texture2D tex = GpuResourceFromUrid(sig.tex_urid); + Vec4 color = tex.Sample(s_point_clamp, input.vs.uv); /* Apply tone map */ if (sig.flags & K_BLIT_FLAG_TONE_MAP) { diff --git a/src/kernel/kernel_core.h b/src/kernel/kernel_core.h index 2180d1e8..c7b21e71 100644 --- a/src/kernel/kernel_core.h +++ b/src/kernel/kernel_core.h @@ -5,121 +5,7 @@ # define K_IS_CPU 0 #endif -#if K_IS_CPU - -#define K_STRUCT(s) Packed(struct s) -#define K_DECL(t, n) struct Cat(K_, t) n -#define K_DECLS(t, n) K_DECL(t, n) -#define K_STATIC_ASSERT(c) StaticAssert(c) - -typedef struct K_uint K_uint; -struct K_uint { u32 v; }; -Inline struct K_uint K_UintFromU32(u32 v) -{ - return (struct K_uint) { .v = v }; -} - -typedef struct K_int K_int; -struct K_int { i32 v; }; -Inline struct K_int K_IntFromI32(i32 v) -{ - return (struct K_int) { .v = v }; -} - -typedef struct K_uint2 K_uint2; -struct K_uint2 { u32 v[2]; }; -Inline struct K_uint2 K_Uint2FromU32(u32 x, u32 y) -{ - return (struct K_uint2) { .v[0] = x, .v[1] = y }; -} - -typedef struct K_uint3 K_uint3; -struct K_uint3 { u32 v[3]; }; -Inline struct K_uint3 K_Uint3FromU32(u32 x, u32 y, u32 z) -{ - return (struct K_uint3) { .v[0] = x, .v[1] = y, .v[2] = z }; -} - -typedef struct K_uint4 K_uint4; -struct K_uint4 { u32 v[4]; }; -Inline struct K_uint4 K_Uint4FromU32(u32 x, u32 y, u32 z, u32 w) -{ - return (struct K_uint4) { .v[0] = x, .v[1] = y, .v[2] = z, .v[3] = w }; -} - -typedef struct K_float K_float; -struct K_float { f32 v; }; -Inline struct K_float K_FloatFromF32(f32 v) -{ - return (struct K_float) { .v = v }; -} - -typedef struct K_float2 K_float2; -struct K_float2 { f32 v[2]; }; -Inline struct K_float2 K_Float2FromV2(Vec2 v) -{ - return (struct K_float2) { .v[0] = v.x, .v[1] = v.y }; -} - -typedef struct K_float3 K_float3; -struct K_float3 { f32 v[3]; }; -Inline struct K_float3 K_Float3FromV3(Vec3 v) -{ - return (struct K_float3) { .v[0] = v.x, .v[1] = v.y, .v[2] = v.z }; -} - -typedef struct K_float4x4 K_float4x4; -struct K_float4x4 { f32 v[4][4]; }; -Inline struct K_float4x4 K_Float4x4FromMat4x4(Mat4x4 v) -{ - struct K_float4x4 result; - StaticAssert(sizeof(result) == sizeof(v)); - CopyBytes(&result, v.e, sizeof(result)); - return result; -} - -struct K_float2x3 { f32 v[2][3]; }; -Inline struct K_float2x3 K_Float2x3FromXform(Xform v) -{ - struct K_float2x3 result; - StaticAssert(sizeof(result) == sizeof(v)); - CopyBytes(&result, &v, sizeof(result)); - return result; -} - -#else - -#define K_STRUCT(s) struct s -#define K_DECL(t, n) t n -#define K_DECLS(t, n) t n : n -#define K_STATIC_ASSERT(c) _Static_assert(c, "") - -#define DECLS(t, n) t n : n - -#define resource_from_urid(urid) ResourceDescriptorHeap[urid] -#define resource_from_nurid(nurid) ResourceDescriptorHeap[NonUniformResourceIndex(nurid)] - -float4 float4_from_uint_norm(uint v) -{ - float4 result; - result.r = ((v >> 0) & 0xFF) / 255.0; - result.g = ((v >> 8) & 0xFF) / 255.0; - result.b = ((v >> 16) & 0xFF) / 255.0; - result.a = ((v >> 24) & 0xFF) / 255.0; - return result; -} - -/* Linear color from normalized sRGB */ -float4 linear_from_srgb(float4 srgb) -{ - return float4(pow(abs(srgb.rgb), 2.2), srgb.a); -} - -/* Linear color from R8G8B8A8 sRGB */ -float4 linear_from_srgb32(uint srgb32) -{ - return linear_from_srgb(float4_from_uint_norm(srgb32)); -} +#if !K_IS_CPU /* ========================== * * Root signature @@ -143,10 +29,6 @@ SamplerState s_point_clamp : register(s0); #endif -#define K_ASSERT_ROOT_CONST(s, n) K_STATIC_ASSERT((sizeof(s) % 16 == 0) && /* Root constant struct should pad to 16 byte alignment */ \ - ((sizeof(s) / 4) == n) && /* Root constant struct size should match the specified 32-bit-constant count */ \ - (sizeof(s) <= 256)) /* Root constant struct can only fit 64 DWORDS */ - /* ========================== * * Global textures * ========================== */ @@ -161,20 +43,7 @@ SamplerState s_point_clamp : register(s0); * Material shader structs * ========================== */ -#if 0 -K_STRUCT(k_material_sig { - /* ----------------------------------------------------- */ - K_DECL(float4x4, projection); /* 16 consts */ - /* ----------------------------------------------------- */ - K_DECL(uint, instances_urid); /* 01 consts */ - K_DECL(uint, grids_urid); /* 01 consts */ - K_DECL(uint, _pad0); /* 01 consts (padding) */ - K_DECL(uint, _pad1); /* 01 consts (padding) */ - /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_material_sig, 20); -#else -Struct(k_material_sig) +Struct(K_MaterialSig) { /* ----------------------------------------------------- */ Mat4x4 projection; /* 16 consts */ @@ -185,49 +54,51 @@ Struct(k_material_sig) u32 _pad1; /* 01 consts (padding) */ /* ----------------------------------------------------- */ }; -K_ASSERT_ROOT_CONST(struct k_material_sig, 20); -#endif +AssertRootConst(K_MaterialSig, 20); -K_STRUCT(k_material_instance { - K_DECL(uint, tex_nurid); - K_DECL(uint, grid_id); - K_DECL(float2x3, xf); - K_DECL(float2, uv0); - K_DECL(float2, uv1); - K_DECL(uint, tint_srgb); - K_DECL(uint, is_light); - K_DECL(float3, light_emittance_srgb); -}); +Struct(K_MaterialInstance) +{ + u32 tex_nurid; + u32 grid_id; + Xform xf; + Vec2 uv0; + Vec2 uv1; + u32 tint_srgb; + u32 is_light; + Vec3 light_emittance_srgb; +}; -K_STRUCT(k_material_grid { - K_DECL(float, line_thickness); - K_DECL(float, line_spacing); - K_DECL(float2, offset); - K_DECL(uint, bg0_srgb); - K_DECL(uint, bg1_srgb); - K_DECL(uint, line_srgb); - K_DECL(uint, x_srgb); - K_DECL(uint, y_srgb); -}); +Struct(K_MaterialGrid) +{ + f32 line_thickness; + f32 line_spacing; + Vec2 offset; + u32 bg0_srgb; + u32 bg1_srgb; + u32 line_srgb; + u32 x_srgb; + u32 y_srgb; +}; /* ========================== * * Flood shader structs * ========================== */ -K_STRUCT(k_flood_sig { +Struct(K_FloodSig) +{ /* ----------------------------------------------------- */ - K_DECL(int, step_len); /* 01 consts */ - K_DECL(uint, emittance_tex_urid); /* 01 consts */ - K_DECL(uint, read_flood_tex_urid); /* 01 consts */ - K_DECL(uint, target_flood_tex_urid); /* 01 consts */ + i32 step_len; /* 01 consts */ + u32 emittance_tex_urid; /* 01 consts */ + u32 read_flood_tex_urid; /* 01 consts */ + u32 target_flood_tex_urid; /* 01 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, tex_width); /* 01 consts */ - K_DECL(uint, tex_height); /* 01 consts */ - K_DECL(uint, _pad0); /* 01 consts (padding) */ - K_DECL(uint, _pad1); /* 01 consts (padding) */ + u32 tex_width; /* 01 consts */ + u32 tex_height; /* 01 consts */ + u32 _pad0; /* 01 consts (padding) */ + u32 _pad1; /* 01 consts (padding) */ /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_flood_sig, 8); +}; +AssertRootConst(K_FloodSig, 8); /* ========================== * * Shade shader structs @@ -236,89 +107,95 @@ K_ASSERT_ROOT_CONST(struct k_flood_sig, 8); #define K_SHADE_FLAG_NONE (0 << 0) #define K_SHADE_FLAG_DISABLE_EFFECTS (1 << 0) -K_STRUCT(k_shade_sig { +Struct(K_ShadeSig) +{ /* ----------------------------------------------------- */ - K_DECL(uint4, frame_seed); /* 04 consts */ + Vec4I32 frame_seed; /* 04 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, flags); /* 01 consts */ - K_DECL(uint, _pad0); /* 01 consts (padding) */ - K_DECL(uint, tex_width); /* 01 consts */ - K_DECL(uint, tex_height); /* 01 consts */ + u32 flags; /* 01 consts */ + u32 _pad0; /* 01 consts (padding) */ + u32 tex_width; /* 01 consts */ + u32 tex_height; /* 01 consts */ /* ----------------------------------------------------- */ - K_DECL(float2, camera_offset); /* 02 consts */ - K_DECL(uint, frame_index); /* 01 consts */ - K_DECL(uint, albedo_tex_urid); /* 01 consts */ + Vec2 camera_offset; /* 02 consts */ + u32 frame_index; /* 01 consts */ + u32 albedo_tex_urid; /* 01 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, emittance_tex_urid); /* 01 consts */ - K_DECL(uint, emittance_flood_tex_urid); /* 01 consts */ - K_DECL(uint, read_tex_urid); /* 01 consts */ - K_DECL(uint, target_tex_urid); /* 01 consts */ + u32 emittance_tex_urid; /* 01 consts */ + u32 emittance_flood_tex_urid; /* 01 consts */ + u32 read_tex_urid; /* 01 consts */ + u32 target_tex_urid; /* 01 consts */ /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_shade_sig, 16); +}; +AssertRootConst(K_ShadeSig, 16); /* ========================== * * Shape shader structs * ========================== */ -K_STRUCT(k_shape_sig { +Struct(K_ShapeSig) +{ /* ----------------------------------------------------- */ - K_DECL(float4x4, projection); /* 16 consts */ + Mat4x4 projection; /* 16 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, verts_urid); /* 01 consts */ - K_DECL(uint, _pad0); /* 01 consts (padding) */ - K_DECL(uint, _pad1); /* 01 consts (padding) */ - K_DECL(uint, _pad2); /* 01 consts (padding) */ + u32 verts_urid; /* 01 consts */ + u32 _pad0; /* 01 consts (padding) */ + u32 _pad1; /* 01 consts (padding) */ + u32 _pad2; /* 01 consts (padding) */ /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_shape_sig, 20); +}; +AssertRootConst(K_ShapeSig, 20); -K_STRUCT(k_shape_vert { - K_DECL(float2, pos); - K_DECL(uint, color_srgb); -}); +Struct(K_ShapeVert) +{ + Vec2 pos; + u32 color_srgb; +}; /* ========================== * * UI shader structs * ========================== */ -K_STRUCT(k_ui_sig { +Struct(K_UiSig) +{ /* ----------------------------------------------------- */ - K_DECL(float4x4, projection); /* 16 consts */ + Mat4x4 projection; /* 16 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, instances_urid); /* 01 consts */ - K_DECL(uint, _pad0); /* 01 consts (padding) */ - K_DECL(uint, _pad1); /* 01 consts (padding) */ - K_DECL(uint, _pad2); /* 01 consts (padding) */ + u32 instances_urid; /* 01 consts */ + u32 _pad0; /* 01 consts (padding) */ + u32 _pad1; /* 01 consts (padding) */ + u32 _pad2; /* 01 consts (padding) */ /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_ui_sig, 20); +}; +AssertRootConst(K_UiSig, 20); -K_STRUCT(k_ui_instance { - K_DECL(uint, tex_nurid); - K_DECL(uint, grid_id); - K_DECL(float2x3, xf); - K_DECL(float2, uv0); - K_DECL(float2, uv1); - K_DECL(uint, tint_srgb); -}); +Struct(K_UiInstance) +{ + u32 tex_nurid; + u32 grid_id; + Xform xf; + Vec2 uv0; + Vec2 uv1; + u32 tint_srgb; +}; /* ========================== * * Blit shader structs * ========================== */ - #define K_BLIT_FLAG_NONE (0 << 0) - #define K_BLIT_FLAG_TONE_MAP (1 << 0) - #define K_BLIT_FLAG_GAMMA_CORRECT (1 << 1) +#define K_BLIT_FLAG_NONE (0 << 0) +#define K_BLIT_FLAG_TONE_MAP (1 << 0) +#define K_BLIT_FLAG_GAMMA_CORRECT (1 << 1) -K_STRUCT(k_blit_sig { +Struct(K_BlitSig) +{ /* ----------------------------------------------------- */ - K_DECL(float4x4, projection); /* 16 consts */ + Mat4x4 projection; /* 16 consts */ /* ----------------------------------------------------- */ - K_DECL(uint, flags); /* 01 consts */ - K_DECL(uint, tex_urid); /* 01 consts */ - K_DECL(float, exposure); /* 01 consts */ - K_DECL(float, gamma); /* 01 consts */ + u32 flags; /* 01 consts */ + u32 tex_urid; /* 01 consts */ + f32 exposure; /* 01 consts */ + f32 gamma; /* 01 consts */ /* ----------------------------------------------------- */ -}); -K_ASSERT_ROOT_CONST(struct k_blit_sig, 20); +}; +AssertRootConst(K_BlitSig, 20); diff --git a/src/kernel/kernel_flood.knl b/src/kernel/kernel_flood.knl index 66845386..6708d64d 100644 --- a/src/kernel/kernel_flood.knl +++ b/src/kernel/kernel_flood.knl @@ -1,28 +1,29 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); /* ========================== * * Entry point * ========================== */ -struct cs_input { - DECLS(uint3, SV_DispatchThreadID); +Struct(CsInput) +{ + Semantic(uint3, SV_DispatchThreadID); }; [numthreads(8, 8, 1)] -K_ENTRY void cs(struct cs_input input) +K_ENTRY void cs(CsInput input) { uint2 id = input.SV_DispatchThreadID.xy; uint2 tex_size = uint2(sig.tex_width, sig.tex_height); if (id.x < tex_size.x && id.y < tex_size.y) { - Texture2D emittance_tex = resource_from_urid(sig.emittance_tex_urid); - RWTexture2D read_flood_tex = resource_from_urid(sig.read_flood_tex_urid); - RWTexture2D target_flood_tex = resource_from_urid(sig.target_flood_tex_urid); + Texture2D emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid); + RWTexture2D read_flood_tex = GpuResourceFromUrid(sig.read_flood_tex_urid); + RWTexture2D target_flood_tex = GpuResourceFromUrid(sig.target_flood_tex_urid); int step_len = sig.step_len; if (step_len == -1) { /* Seed */ - float4 emittance = emittance_tex[id]; + Vec4 emittance = emittance_tex[id]; uint2 seed = uint2(0xFFFF, 0xFFFF); if (emittance.a > 0) { seed = id; @@ -30,25 +31,25 @@ K_ENTRY void cs(struct cs_input input) target_flood_tex[id] = seed; } else { /* Flood */ - int2 read_coords[9] = { - (int2)id + int2(-step_len, -step_len), /* top left */ - (int2)id + int2(0 , -step_len), /* top center */ - (int2)id + int2(+step_len, -step_len), /* top right */ - (int2)id + int2(-step_len, 0 ), /* center left */ - (int2)id + int2(0 , 0 ), /* center center */ - (int2)id + int2(+step_len, 0 ), /* center right */ - (int2)id + int2(-step_len, +step_len), /* bottom left */ - (int2)id + int2(0 , +step_len), /* bottom center */ - (int2)id + int2(+step_len, +step_len) /* bottom right */ + Vec2I32 read_coords[9] = { + (Vec2I32)id + Vec2I32(-step_len, -step_len), /* top left */ + (Vec2I32)id + Vec2I32(0 , -step_len), /* top center */ + (Vec2I32)id + Vec2I32(+step_len, -step_len), /* top right */ + (Vec2I32)id + Vec2I32(-step_len, 0 ), /* center left */ + (Vec2I32)id + Vec2I32(0 , 0 ), /* center center */ + (Vec2I32)id + Vec2I32(+step_len, 0 ), /* center right */ + (Vec2I32)id + Vec2I32(-step_len, +step_len), /* bottom left */ + (Vec2I32)id + Vec2I32(0 , +step_len), /* bottom center */ + (Vec2I32)id + Vec2I32(+step_len, +step_len) /* bottom right */ }; uint2 closest_seed = uint2(0xFFFF, 0xFFFF); - uint closest_seed_len_sq = 0xFFFFFFFF; + u32 closest_seed_len_sq = 0xFFFFFFFF; for (int i = 0; i < 9; ++i) { - int2 coord = read_coords[i]; + Vec2I32 coord = read_coords[i]; if (coord.x >= 0 && coord.x < (int)tex_size.x && coord.y >= 0 && coord.y < (int)tex_size.y) { uint2 seed = read_flood_tex[coord]; - int2 dist_vec = (int2)id - (int2)seed; - uint dist_len_sq = dot(dist_vec, dist_vec); + Vec2I32 dist_vec = (Vec2I32)id - (Vec2I32)seed; + u32 dist_len_sq = dot(dist_vec, dist_vec); if (dist_len_sq < closest_seed_len_sq) { closest_seed = seed; closest_seed_len_sq = dist_len_sq; diff --git a/src/kernel/kernel_material.rst b/src/kernel/kernel_material.rst index e74bca29..9865ec35 100644 --- a/src/kernel/kernel_material.rst +++ b/src/kernel/kernel_material.rst @@ -1,44 +1,46 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); /* ========================== * * Vertex shader * ========================== */ -struct vs_input { - DECLS(uint, SV_InstanceID); - DECLS(uint, SV_VertexID); -}; - -struct vs_output { - nointerpolation DECLS(uint, tex_nurid); - nointerpolation DECLS(uint, grid_id); - DECLS(float2, uv); - DECLS(float4, tint_lin); - DECLS(float4, emittance_lin); - DECLS(float4, SV_Position); -}; - -K_ENTRY struct vs_output vs(struct vs_input input) +Struct(VsInput) { - static const float2 unit_quad_verts[4] = { - float2(-0.5f, -0.5f), - float2(0.5f, -0.5f), - float2(0.5f, 0.5f), - float2(-0.5f, 0.5f) + Semantic(u32, SV_InstanceID); + Semantic(u32, SV_VertexID); +}; + +Struct(VSOutput) +{ + nointerpolation Semantic(u32, tex_nurid); + nointerpolation Semantic(u32, grid_id); + Semantic(Vec2, uv); + Semantic(Vec4, tint_lin); + Semantic(Vec4, emittance_lin); + Semantic(Vec4, SV_Position); +}; + +K_ENTRY VSOutput vs(VsInput input) +{ + static const Vec2 unit_quad_verts[4] = { + Vec2(-0.5f, -0.5f), + Vec2(0.5f, -0.5f), + Vec2(0.5f, 0.5f), + Vec2(-0.5f, 0.5f) }; - StructuredBuffer instances = resource_from_urid(sig.instances_urid); - struct k_material_instance instance = instances[input.SV_InstanceID]; - float2 vert = unit_quad_verts[input.SV_VertexID]; - float2 world_pos = mul(instance.xf, float3(vert, 1)).xy; - struct vs_output output; - output.SV_Position = mul(sig.projection, float4(world_pos, 0, 1)); + StructuredBuffer instances = GpuResourceFromUrid(sig.instances_urid); + K_MaterialInstance instance = instances[input.SV_InstanceID]; + Vec2 vert = unit_quad_verts[input.SV_VertexID]; + Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy; + VSOutput output; + output.SV_Position = mul(sig.projection, Vec4(world_pos, 0, 1)); output.tex_nurid = instance.tex_nurid; output.grid_id = instance.grid_id; output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0)); - output.tint_lin = linear_from_srgb32(instance.tint_srgb); - output.emittance_lin = linear_from_srgb(float4(instance.light_emittance_srgb, instance.is_light)); + output.tint_lin = LinearFromSrgbU32(instance.tint_srgb); + output.emittance_lin = LinearFromSrgbVec4(Vec4(instance.light_emittance_srgb, instance.is_light)); return output; } @@ -46,35 +48,37 @@ K_ENTRY struct vs_output vs(struct vs_input input) * Pixel shader * ========================== */ -struct ps_input { - struct vs_output vs; -}; - -struct ps_output { - DECLS(float4, SV_Target0); /* Albedo */ - DECLS(float4, SV_Target1); /* Emittance */ -}; - -K_ENTRY struct ps_output ps(struct ps_input input) +Struct(PsInput) { - struct ps_output output; - float4 albedo = input.vs.tint_lin; + VSOutput vs; +}; + +Struct(PSOutput) +{ + Semantic(Vec4, SV_Target0); /* Albedo */ + Semantic(Vec4, SV_Target1); /* Emittance */ +}; + +K_ENTRY PSOutput ps(PsInput input) +{ + PSOutput output; + Vec4 albedo = input.vs.tint_lin; /* Texture */ if (input.vs.tex_nurid < 0xFFFFFFFF) { - Texture2D tex = resource_from_nurid(input.vs.tex_nurid); + Texture2D tex = GpuResourceFromNurid(input.vs.tex_nurid); albedo *= tex.Sample(s_point_clamp, input.vs.uv); } /* Grid */ if (input.vs.grid_id < 0xFFFFFFFF) { - StructuredBuffer grids = resource_from_urid(sig.grids_urid); - struct k_material_grid grid = grids[input.vs.grid_id]; - float2 grid_pos = input.vs.SV_Position.xy + grid.offset; + StructuredBuffer grids = GpuResourceFromUrid(sig.grids_urid); + K_MaterialGrid grid = grids[input.vs.grid_id]; + Vec2 grid_pos = input.vs.SV_Position.xy + grid.offset; float half_thickness = grid.line_thickness / 2; float spacing = grid.line_spacing; - uint color_srgb = grid.bg0_srgb; - float2 v = abs(round(grid_pos / spacing) * spacing - grid_pos); + u32 color_srgb = grid.bg0_srgb; + Vec2 v = abs(round(grid_pos / spacing) * spacing - grid_pos); float dist = min(v.x, v.y); if (grid_pos.y <= half_thickness && grid_pos.y >= -half_thickness) { color_srgb = grid.x_srgb; @@ -84,8 +88,8 @@ K_ENTRY struct ps_output ps(struct ps_input input) color_srgb = grid.line_srgb; } else { bool checker = 0; - uint cell_x = (uint)(abs(grid_pos.x) / spacing) + (grid_pos.x < 0); - uint cell_y = (uint)(abs(grid_pos.y) / spacing) + (grid_pos.y < 0); + u32 cell_x = (u32)(abs(grid_pos.x) / spacing) + (grid_pos.x < 0); + u32 cell_y = (u32)(abs(grid_pos.y) / spacing) + (grid_pos.y < 0); if (cell_x % 2 == 0) { checker = cell_y % 2 == 0; } else { @@ -95,10 +99,10 @@ K_ENTRY struct ps_output ps(struct ps_input input) color_srgb = grid.bg1_srgb; } } - albedo = linear_from_srgb32(color_srgb); + albedo = LinearFromSrgbU32(color_srgb); } - float4 emittance = input.vs.emittance_lin * albedo.a; + Vec4 emittance = input.vs.emittance_lin * albedo.a; output.SV_Target0 = albedo; output.SV_Target1 = emittance; diff --git a/src/kernel/kernel_shade.knl b/src/kernel/kernel_shade.knl index b9e6d164..75d52c0d 100644 --- a/src/kernel/kernel_shade.knl +++ b/src/kernel/kernel_shade.knl @@ -1,6 +1,6 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); /* ========================== * * Lighting @@ -10,29 +10,29 @@ ConstantBuffer sig : register(b0); #define MARCHES 16 #define EDGE_FALLOFF 100 -float rand_angle(uint2 pos, uint ray_index) { - Texture3D noise_tex = resource_from_urid(K_BLUE_NOISE_TEX_ID); +float rand_angle(uint2 pos, u32 ray_index) { + Texture3D noise_tex = GpuResourceFromUrid(K_BLUE_NOISE_TEX_ID); - int3 noise_coord = int3(1, 1, 1); - noise_coord += int3(pos.xy, ray_index); + Vec3I32 noise_coord = Vec3I32(1, 1, 1); + noise_coord += Vec3I32(pos.xy, ray_index); noise_coord.xyz += sig.frame_seed.xyz; // noise_coord.xy -= sig.camera_offset; - uint noise = noise_tex[noise_coord % uint3(K_BLUE_NOISE_TEX_WIDTH, K_BLUE_NOISE_TEX_HEIGHT, K_BLUE_NOISE_TEX_DEPTH)]; + u32 noise = noise_tex[noise_coord % uint3(K_BLUE_NOISE_TEX_WIDTH, K_BLUE_NOISE_TEX_HEIGHT, K_BLUE_NOISE_TEX_DEPTH)]; return ((float)noise / (float)0xFFFF) * Tau; } -float3 get_light_in_dir(uint2 ray_start, float2 ray_dir) +Vec3 get_light_in_dir(uint2 ray_start, Vec2 ray_dir) { - Texture2D flood_tex = resource_from_urid(sig.emittance_flood_tex_urid); - Texture2D emittance_tex = resource_from_urid(sig.emittance_tex_urid); + Texture2D flood_tex = GpuResourceFromUrid(sig.emittance_flood_tex_urid); + Texture2D emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid); - float3 result = float3(0, 0, 0); - float2 at_float = ray_start; + Vec3 result = Vec3(0, 0, 0); + Vec2 at_float = ray_start; uint2 at_uint = ray_start; - for (uint i = 0; i < MARCHES; ++i) { + for (u32 i = 0; i < MARCHES; ++i) { uint2 flood = flood_tex[at_uint]; - float2 dist_vec = at_float - (float2)flood; + Vec2 dist_vec = at_float - (Vec2)flood; float dist = length(dist_vec); if (dist < 1) { /* Scale light by distance from edge so that offscreen-lights fade in/out rather than popping in */ @@ -53,13 +53,13 @@ float3 get_light_in_dir(uint2 ray_start, float2 ray_dir) return result; } -float3 get_light_at_pos(uint2 pos) +Vec3 get_light_at_pos(uint2 pos) { - float3 result = 0; - for (uint i = 0; i < SAMPLES; ++i) { + Vec3 result = 0; + for (u32 i = 0; i < SAMPLES; ++i) { float angle = rand_angle(pos, i); - float2 dir = float2(cos(angle), sin(angle)); - float3 light_in_dir = get_light_in_dir(pos, dir); + Vec2 dir = Vec2(cos(angle), sin(angle)); + Vec3 light_in_dir = get_light_in_dir(pos, dir); result += light_in_dir; } result /= SAMPLES; @@ -70,19 +70,20 @@ float3 get_light_at_pos(uint2 pos) * Entry point * ========================== */ -struct cs_input { - DECLS(uint3, SV_DispatchThreadID); +Struct(CsInput) +{ + Semantic(uint3, SV_DispatchThreadID); }; [numthreads(8, 8, 1)] -K_ENTRY void cs(struct cs_input input) +K_ENTRY void cs(CsInput input) { uint2 id = input.SV_DispatchThreadID.xy; if (id.x < sig.tex_width && id.y < sig.tex_height) { - Texture2D albedo_tex = resource_from_urid(sig.albedo_tex_urid); - Texture2D read_tex = resource_from_urid(sig.read_tex_urid); - RWTexture2D target_tex = resource_from_urid(sig.target_tex_urid); - float4 color = float4(1, 1, 1, 1); + Texture2D albedo_tex = GpuResourceFromUrid(sig.albedo_tex_urid); + Texture2D read_tex = GpuResourceFromUrid(sig.read_tex_urid); + RWTexture2D target_tex = GpuResourceFromUrid(sig.target_tex_urid); + Vec4 color = Vec4(1, 1, 1, 1); /* Apply albedo */ color *= albedo_tex[id]; diff --git a/src/kernel/kernel_shape.rst b/src/kernel/kernel_shape.rst index 6935ebcf..dbb54489 100644 --- a/src/kernel/kernel_shape.rst +++ b/src/kernel/kernel_shape.rst @@ -1,27 +1,29 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); /* ========================== * * Vertex shader * ========================== */ -struct vs_input { - DECLS(uint, SV_VertexID); -}; - -struct vs_output { - DECLS(float4, SV_Position); - DECLS(float4, color_srgb); -}; - -K_ENTRY struct vs_output vs(struct vs_input input) +Struct(VsInput) { - StructuredBuffer verts = resource_from_urid(sig.verts_urid); - struct k_shape_vert vert = verts[input.SV_VertexID]; - struct vs_output output; - output.SV_Position = mul(sig.projection, float4(vert.pos.xy, 0, 1)); - output.color_srgb = float4_from_uint_norm(vert.color_srgb); + Semantic(u32, SV_VertexID); +}; + +Struct(VSOutput) +{ + Semantic(Vec4, SV_Position); + Semantic(Vec4, color_srgb); +}; + +K_ENTRY VSOutput vs(VsInput input) +{ + StructuredBuffer verts = GpuResourceFromUrid(sig.verts_urid); + K_ShapeVert vert = verts[input.SV_VertexID]; + VSOutput output; + output.SV_Position = mul(sig.projection, Vec4(vert.pos.xy, 0, 1)); + output.color_srgb = Vec4NormFromU32(vert.color_srgb); return output; } @@ -29,17 +31,19 @@ K_ENTRY struct vs_output vs(struct vs_input input) * Pixel shader * ========================== */ -struct ps_input { - struct vs_output vs; -}; - -struct ps_output { - DECLS(float4, SV_Target); -}; - -K_ENTRY struct ps_output ps(struct ps_input input) +Struct(PsInput) { - struct ps_output output; + VSOutput vs; +}; + +Struct(PSOutput) +{ + Semantic(Vec4, SV_Target); +}; + +K_ENTRY PSOutput ps(PsInput input) +{ + PSOutput output; output.SV_Target = input.vs.color_srgb; return output; } diff --git a/src/kernel/kernel_ui.rst b/src/kernel/kernel_ui.rst index bc2234b4..363420d1 100644 --- a/src/kernel/kernel_ui.rst +++ b/src/kernel/kernel_ui.rst @@ -1,65 +1,73 @@ #include "kernel.h" -ConstantBuffer sig : register(b0); +ConstantBuffer sig : register(b0); -/* ========================== * - * Vertex shader - * ========================== */ +//////////////////////////////// +//~ Shader types -struct vs_input { - DECLS(uint, SV_InstanceID); - DECLS(uint, SV_VertexID); -}; - -struct vs_output { - nointerpolation DECLS(uint, tex_nurid); - DECLS(float2, uv); - DECLS(float4, tint_srgb); - DECLS(float4, SV_Position); -}; - -K_ENTRY struct vs_output vs(struct vs_input input) +//- Vertex shader in/out +Struct(VsInput) { - static const float2 unit_quad_verts[4] = { - float2(-0.5f, -0.5f), - float2(0.5f, -0.5f), - float2(0.5f, 0.5f), - float2(-0.5f, 0.5f) + Semantic(u32, SV_InstanceID); + Semantic(u32, SV_VertexID); +}; + +Struct(VSOutput) +{ + nointerpolation Semantic(u32, tex_nurid); + Semantic(Vec2, uv); + Semantic(Vec4, tint_srgb); + Semantic(Vec4, SV_Position); +}; + +//- Pixel shader in/out +Struct(PsInput) +{ + VSOutput vs; +}; + +Struct(PSOutput) +{ + Semantic(Vec4, SV_Target0); +}; + +//////////////////////////////// +//~ Vertex shader + +K_ENTRY VSOutput vs(VsInput input) +{ + static const Vec2 unit_quad_verts[4] = { + Vec2(-0.5f, -0.5f), + Vec2(0.5f, -0.5f), + Vec2(0.5f, 0.5f), + Vec2(-0.5f, 0.5f) }; - StructuredBuffer instances = resource_from_urid(sig.instances_urid); - struct k_ui_instance instance = instances[input.SV_InstanceID]; - float2 vert = unit_quad_verts[input.SV_VertexID]; - float2 world_pos = mul(instance.xf, float3(vert, 1)).xy; + StructuredBuffer instances = GpuResourceFromUrid(sig.instances_urid); + K_UiInstance instance = instances[input.SV_InstanceID]; + Vec2 vert = unit_quad_verts[input.SV_VertexID]; + Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy; - struct vs_output output; - output.SV_Position = mul(sig.projection, float4(world_pos, 0, 1)); + VSOutput output; + output.SV_Position = mul(sig.projection, Vec4(world_pos, 0, 1)); output.tex_nurid = instance.tex_nurid; output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0)); - output.tint_srgb = float4_from_uint_norm(instance.tint_srgb); + output.tint_srgb = Vec4NormFromU32(instance.tint_srgb); return output; } -/* ========================== * - * Pixel shader - * ========================== */ +//////////////////////////////// +//~ Pixel shader -struct ps_input { - struct vs_output vs; -}; - -struct ps_output { - DECLS(float4, SV_Target0); -}; - -K_ENTRY struct ps_output ps(struct ps_input input) +K_ENTRY PSOutput ps(PsInput input) { - struct ps_output output; - float4 color = input.vs.tint_srgb; + PSOutput output; + Vec4 color = input.vs.tint_srgb; /* Texture */ - if (input.vs.tex_nurid < 0xFFFFFFFF) { - Texture2D tex = resource_from_nurid(input.vs.tex_nurid); + if (input.vs.tex_nurid < 0xFFFFFFFF) + { + Texture2D tex = GpuResourceFromNurid(input.vs.tex_nurid); color *= tex.Sample(s_point_clamp, input.vs.uv); }