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

typed gpu resource ids

Browse Source
This commit is contained in:
jacob 2025-09-24 17:50:33 -05:00
parent 7a7c6c2350
commit c61e30d3a4
10 changed files with 168 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/base/base.h
View File

@ -369,20 +369,6 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t);
#define ColorOrange Rgb32(0xFF, 0xA5, 0x00) #define ColorOrange Rgb32(0xFF, 0xA5, 0x00)
#define ColorPurple Rgb32(0xFF, 0x00, 0XFF) #define ColorPurple Rgb32(0xFF, 0x00, 0XFF)
////////////////////////////////
//~ Gpu helpers
#if LanguageIsGpu
//- Resource heap index
# define GpuResourceFromUrid(urid) ResourceDescriptorHeap[(urid)]
# define GpuResourceFromNurid(nurid) ResourceDescriptorHeap[NonUniformResourceIndex((nurid))]
# define GpuSamplerFromUrid(urid) SamplerDescriptorHeap[(urid)]
# define GpuSamplerFromNurid(nurid) SamplerDescriptorHeap[NonUniformResourceIndex((nurid))]
//- Semantic declaration
# define Semantic(t, n) t n : n
#endif
//////////////////////////////// ////////////////////////////////
//~ Intrinsic headers //~ Intrinsic headers
@ -695,6 +681,7 @@ Struct(Resource)
#if LanguageIsC #if LanguageIsC
Struct(VertexShader) { Resource resource; }; Struct(VertexShader) { Resource resource; };
Struct(PixelShader) { Resource resource; }; Struct(PixelShader) { Resource resource; };
Struct(ComputeShader) { Resource resource; }; Struct(ComputeShader) { Resource resource; };
@ -703,8 +690,31 @@ Struct(ComputeShader) { Resource resource; };
# define PSDecl(name) extern PixelShader name; # define PSDecl(name) extern PixelShader name;
# define CSDecl(name) extern ComputeShader name; # define CSDecl(name) extern ComputeShader name;
//- Resource descriptor index types
Struct(StructuredBufferRid) { u32 v; };
Struct(RWStructuredBufferRid) { u32 v; };
Struct(Texture1DRid) { u32 v; };
Struct(Texture2DRid) { u32 v; };
Struct(Texture3DRid) { u32 v; };
Struct(RWTexture1DRid) { u32 v; };
Struct(RWTexture2DRid) { u32 v; };
Struct(RWTexture3DRid) { u32 v; };
Struct(SamplerStateRid) { u32 v; };
#elif LanguageIsGpu #elif LanguageIsGpu
//- Resource descriptor index types
typedef uint StructuredBufferRid;
typedef uint RWStructuredBufferRid;
typedef uint Texture1DRid;
typedef uint Texture2DRid;
typedef uint Texture3DRid;
typedef uint RWTexture1DRid;
typedef uint RWTexture2DRid;
typedef uint RWTexture3DRid;
typedef uint SamplerStateRid;
//- Shader declaration
# define VSDecl(name) # define VSDecl(name)
# define PSDecl(name) # define PSDecl(name)
# define CSDecl(name) # define CSDecl(name)
@ -713,6 +723,15 @@ Struct(ComputeShader) { Resource resource; };
# define PSDef(name, ...) name(__VA_ARGS__) # define PSDef(name, ...) name(__VA_ARGS__)
# define CSDef(name, ...) name(__VA_ARGS__) # define CSDef(name, ...) name(__VA_ARGS__)
//- Semantic declaration
# define Semantic(t, n) t n : n
//- Descriptor heap index
# define UniformResourceFromRid(rid) ResourceDescriptorHeap[rid]
# define UniformSamplerFromRid(rid) SamplerDescriptorHeap[rid]
# define NonUniformResourceFromRid(rid) ResourceDescriptorHeap[NonUniformResourceIndex(rid)]
# define NonUniformSamplerFromRid(rid) SamplerDescriptorHeap[NonUniformResourceIndex(rid)]
#endif #endif
//////////////////////////////// ////////////////////////////////

4
src/config.h
View File

@ -69,7 +69,7 @@
#define FLOOD_DEBUG 0 #define FLOOD_DEBUG 0
#define GPU_DEBUG 1 #define GPU_DEBUG 0
/* If virtual fibers are enabled, each fiber will get its own OS thread, /* If virtual fibers are enabled, each fiber will get its own OS thread,
* and fiber suspend/resume will be emulated using OS thread primitives. * and fiber suspend/resume will be emulated using OS thread primitives.
@ -96,4 +96,4 @@
#define VSYNC !RtcIsEnabled #define VSYNC !RtcIsEnabled
#define AUDIO_ENABLED 0 #define AUDIO_ENABLED 0
#define FPS_LIMIT 300 #define FPS_LIMIT 0

16
src/gpu/gpu.h
View File

@ -380,13 +380,23 @@ GPU_Scissor GPU_ScissorFromRect(Rect rect);
GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc); GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc);
void GPU_ReleaseResource(GPU_Resource *resource, GPU_ReleaseFlag flags); void GPU_ReleaseResource(GPU_Resource *resource, GPU_ReleaseFlag flags);
u32 GPU_GetReadableId(GPU_Resource *resource);
u32 GPU_GetWritableId(GPU_Resource *resource);
u32 GPU_GetSamplerId(GPU_Resource *resource);
Vec2I32 GPU_GetTextureSize2D(GPU_Resource *resource); Vec2I32 GPU_GetTextureSize2D(GPU_Resource *resource);
Vec3I32 GPU_GetTextureSize3D(GPU_Resource *resource); Vec3I32 GPU_GetTextureSize3D(GPU_Resource *resource);
u64 GPU_GetFootprintSize(GPU_Resource *resource); u64 GPU_GetFootprintSize(GPU_Resource *resource);
////////////////////////////////
//~ @hookdecl Resource index operations
StructuredBufferRid GPU_StructuredBufferRidFromResource(GPU_Resource *resource);
RWStructuredBufferRid GPU_RWStructuredBufferRidFromResource(GPU_Resource *resource);
Texture1DRid GPU_Texture1DRidFromResource(GPU_Resource *resource);
Texture2DRid GPU_Texture2DRidFromResource(GPU_Resource *resource);
Texture3DRid GPU_Texture3DRidFromResource(GPU_Resource *resource);
RWTexture1DRid GPU_RWTexture1DRidFromResource(GPU_Resource *resource);
RWTexture2DRid GPU_RWTexture2DRidFromResource(GPU_Resource *resource);
RWTexture3DRid GPU_RWTexture3DRidFromResource(GPU_Resource *resource);
SamplerStateRid GPU_SamplerStateRidFromResource(GPU_Resource *resource);
//////////////////////////////// ////////////////////////////////
//~ @hookdecl Command list operations //~ @hookdecl Command list operations

78
src/gpu/gpu_dx12/gpu_dx12.c
View File

@ -147,7 +147,7 @@ void GPU_D12_InitDevice(void)
ID3D12Debug_EnableDebugLayer(debug_controller0); ID3D12Debug_EnableDebugLayer(debug_controller0);
/* FIXME: Enable this */ /* FIXME: Enable this */
// ID3D12Debug1_SetEnableGPUBasedValidation(debug_controller1, 1); ID3D12Debug1_SetEnableGPUBasedValidation(debug_controller1, 1);
ID3D12Debug_Release(debug_controller1); ID3D12Debug_Release(debug_controller1);
ID3D12Debug_Release(debug_controller0); ID3D12Debug_Release(debug_controller0);
@ -568,6 +568,7 @@ GPU_D12_Descriptor *GPU_D12_AcquireDescriptor(GPU_D12_DescriptorHeap *heap)
Unlock(&lock); Unlock(&lock);
} }
ZeroStruct(d); ZeroStruct(d);
d->valid = 1;
d->heap = heap; d->heap = heap;
d->handle = handle; d->handle = handle;
d->index = index; d->index = index;
@ -954,7 +955,7 @@ void GPU_Startup(void)
} }
//////////////////////////////// ////////////////////////////////
//~ @hookdecl Fence hooks //~ @hookdef Fence hooks
Fence *GPU_FenceFromQueue(GPU_QueueKind queue_kind) Fence *GPU_FenceFromQueue(GPU_QueueKind queue_kind)
{ {
@ -1150,12 +1151,17 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
} }
} }
r->srv_descriptor = &GPU_D12_NilDescriptor;
r->uav_descriptor = &GPU_D12_NilDescriptor;
r->rtv_descriptor = &GPU_D12_NilDescriptor;
r->sampler_descriptor = &GPU_D12_NilDescriptor;
/* Create texture srv descriptor */ /* Create texture srv descriptor */
if (desc.kind == GPU_ResourceKind_Texture1D if (desc.kind == GPU_ResourceKind_Texture1D
|| desc.kind == GPU_ResourceKind_Texture2D || desc.kind == GPU_ResourceKind_Texture2D
|| desc.kind == GPU_ResourceKind_Texture3D) || desc.kind == GPU_ResourceKind_Texture3D)
{ {
if (!r->srv_descriptor) if (!r->srv_descriptor->valid)
{ {
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap); r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
} }
@ -1167,7 +1173,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
&& desc.buffer.heap_kind != GPU_HeapKind_Download && desc.buffer.heap_kind != GPU_HeapKind_Download
&& desc.buffer.count > 0) && desc.buffer.count > 0)
{ {
if (!r->srv_descriptor) if (!r->srv_descriptor->valid)
{ {
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap); r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
} }
@ -1185,7 +1191,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create uav descriptor */ /* Create uav descriptor */
if (desc.flags & GPU_ResourceFlag_Writable) if (desc.flags & GPU_ResourceFlag_Writable)
{ {
if (!r->uav_descriptor) if (!r->uav_descriptor->valid)
{ {
r->uav_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap); r->uav_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
} }
@ -1195,7 +1201,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create rtv descriptor */ /* Create rtv descriptor */
if (desc.flags & GPU_ResourceFlag_Renderable) if (desc.flags & GPU_ResourceFlag_Renderable)
{ {
if (!r->rtv_descriptor) if (!r->rtv_descriptor->valid)
{ {
r->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap); r->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap);
} }
@ -1205,7 +1211,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create sampler descriptor */ /* Create sampler descriptor */
if (desc.kind == GPU_ResourceKind_Sampler) if (desc.kind == GPU_ResourceKind_Sampler)
{ {
if (!r->sampler_descriptor) if (!r->sampler_descriptor->valid)
{ {
r->sampler_descriptor = GPU_D12_AcquireDescriptor(g->sampler_heap); r->sampler_descriptor = GPU_D12_AcquireDescriptor(g->sampler_heap);
} }
@ -1246,25 +1252,21 @@ void GPU_ReleaseResource(GPU_Resource *gpu_resource, GPU_ReleaseFlag flags)
GPU_D12_SharedState *g = &GPU_D12_shared_state; GPU_D12_SharedState *g = &GPU_D12_shared_state;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource; GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r->srv_descriptor) if (r->srv_descriptor->valid)
{ {
GPU_D12_ReleaseDescriptor(r->srv_descriptor); GPU_D12_ReleaseDescriptor(r->srv_descriptor);
r->srv_descriptor = 0;
} }
if (r->uav_descriptor) if (r->uav_descriptor->valid)
{ {
GPU_D12_ReleaseDescriptor(r->uav_descriptor); GPU_D12_ReleaseDescriptor(r->uav_descriptor);
r->uav_descriptor = 0;
} }
if (r->rtv_descriptor) if (r->rtv_descriptor->valid)
{ {
GPU_D12_ReleaseDescriptor(r->rtv_descriptor); GPU_D12_ReleaseDescriptor(r->rtv_descriptor);
r->rtv_descriptor = 0;
} }
if (r->sampler_descriptor) if (r->sampler_descriptor->valid)
{ {
GPU_D12_ReleaseDescriptor(r->sampler_descriptor); GPU_D12_ReleaseDescriptor(r->sampler_descriptor);
r->sampler_descriptor = 0;
} }
if (flags & GPU_ReleaseFlag_Reuse) if (flags & GPU_ReleaseFlag_Reuse)
@ -1324,39 +1326,6 @@ void GPU_ReleaseResource(GPU_Resource *gpu_resource, GPU_ReleaseFlag flags)
} }
u32 GPU_GetReadableId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->srv_descriptor)
{
result = r->srv_descriptor->index;
}
return result;
}
u32 GPU_GetWritableId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->uav_descriptor)
{
result = r->uav_descriptor->index;
}
return result;
}
u32 GPU_GetSamplerId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->sampler_descriptor)
{
result = r->sampler_descriptor->index;
}
return result;
}
Vec2I32 GPU_GetTextureSize2D(GPU_Resource *gpu_resource) Vec2I32 GPU_GetTextureSize2D(GPU_Resource *gpu_resource)
{ {
GPU_D12_Resource *resource = (GPU_D12_Resource *)gpu_resource; GPU_D12_Resource *resource = (GPU_D12_Resource *)gpu_resource;
@ -1382,6 +1351,19 @@ u64 GPU_GetFootprintSize(GPU_Resource *gpu_resource)
return footprint_size; return footprint_size;
} }
////////////////////////////////
//~ @hookdef Resource index hooks
StructuredBufferRid GPU_StructuredBufferRidFromResource(GPU_Resource *resource) { return (StructuredBufferRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
RWStructuredBufferRid GPU_RWStructuredBufferRidFromResource(GPU_Resource *resource) { return (RWStructuredBufferRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
Texture1DRid GPU_Texture1DRidFromResource(GPU_Resource *resource) { return (Texture1DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
Texture2DRid GPU_Texture2DRidFromResource(GPU_Resource *resource) { return (Texture2DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
Texture3DRid GPU_Texture3DRidFromResource(GPU_Resource *resource) { return (Texture3DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
RWTexture1DRid GPU_RWTexture1DRidFromResource(GPU_Resource *resource) { return (RWTexture1DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
RWTexture2DRid GPU_RWTexture2DRidFromResource(GPU_Resource *resource) { return (RWTexture2DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
RWTexture3DRid GPU_RWTexture3DRidFromResource(GPU_Resource *resource) { return (RWTexture3DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
SamplerStateRid GPU_SamplerStateRidFromResource(GPU_Resource *resource) { return (SamplerStateRid) { ((GPU_D12_Resource *)resource)->sampler_descriptor->index }; }
//////////////////////////////// ////////////////////////////////
//~ @hookdef Command list hooks //~ @hookdef Command list hooks

3
src/gpu/gpu_dx12/gpu_dx12.h
View File

@ -61,8 +61,11 @@ Struct(GPU_D12_Descriptor)
GPU_D12_Descriptor *next_free; GPU_D12_Descriptor *next_free;
struct GPU_D12_DescriptorHeap *heap; struct GPU_D12_DescriptorHeap *heap;
b32 valid;
u32 index; u32 index;
D3D12_CPU_DESCRIPTOR_HANDLE handle; D3D12_CPU_DESCRIPTOR_HANDLE handle;
} extern Readonly GPU_D12_NilDescriptor = {
.index = U32Max
}; };
Struct(GPU_D12_DescriptorHeap) Struct(GPU_D12_DescriptorHeap)

4
src/meta/meta.c
View File

@ -952,8 +952,10 @@ JobDef(Build, _, __)
//- Dxc //- Dxc
{ {
PushStringToList(arena, &cp.flags_dxc, Lit("-O0")); #if GPU_DEBUG
PushStringToList(arena, &cp.flags_dxc, Lit("-Od"));
PushStringToList(arena, &cp.flags_dxc, Lit("-Zi -Qembed_debug")); PushStringToList(arena, &cp.flags_dxc, Lit("-Zi -Qembed_debug"));
#endif
// PushStringToList(arena, &cp.flags_dxc, Lit("-fno-caret-diagnostics")); // PushStringToList(arena, &cp.flags_dxc, Lit("-fno-caret-diagnostics"));
} }
} }

2
src/platform/platform_win32/platform_win32.c
View File

@ -1838,7 +1838,7 @@ String P_GetClipboardText(Arena *arena)
} }
//////////////////////////////// ////////////////////////////////
//~ @hookdecl Timer hooks //~ @hookdef Timer hooks
Fence *P_GetTimerFence() Fence *P_GetTimerFence()
{ {

44
src/pp/pp.c
View File

@ -1249,7 +1249,7 @@ void UpdateUser(P_Window *window)
MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance); MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance);
*mat = DefaultMaterialInstance; *mat = DefaultMaterialInstance;
mat->xf = sprite_xform; mat->xf = sprite_xform;
mat->tex_nurid = GPU_GetReadableId(texture->gpu_texture); mat->tex = GPU_Texture2DRidFromResource(texture->gpu_texture);
mat->tint_srgb = tint; mat->tint_srgb = tint;
mat->uv0 = frame.clip.p0; mat->uv0 = frame.clip.p0;
mat->uv1 = frame.clip.p1; mat->uv1 = frame.clip.p1;
@ -1284,7 +1284,7 @@ void UpdateUser(P_Window *window)
MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance); MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance);
*mat = DefaultMaterialInstance; *mat = DefaultMaterialInstance;
mat->xf = tile_xf; mat->xf = tile_xf;
mat->tex_nurid = GPU_GetReadableId(tile_texture->gpu_texture); mat->tex = GPU_Texture2DRidFromResource(tile_texture->gpu_texture);
mat->is_light = 1; mat->is_light = 1;
mat->light_emittance_srgb = VEC3(0, 0, 0); mat->light_emittance_srgb = VEC3(0, 0, 0);
} }
@ -2311,10 +2311,10 @@ void UpdateUser(P_Window *window)
GPU_Scissor scissor = GPU_ScissorFromRect(render_viewport); GPU_Scissor scissor = GPU_ScissorFromRect(render_viewport);
MaterialSig sig = ZI; MaterialSig sig = ZI;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler);
sig.projection = world_to_render_vp_matrix; sig.projection = world_to_render_vp_matrix;
sig.instances_urid = GPU_GetReadableId(material_instance_buffer); sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.grids_urid = GPU_GetReadableId(grids_buffer); sig.instances = GPU_StructuredBufferRidFromResource(material_instance_buffer);
sig.grids = GPU_StructuredBufferRidFromResource(grids_buffer);
GPU_Rasterize(cl, GPU_Rasterize(cl,
&sig, &sig,
MaterialVS, MaterialPS, MaterialVS, MaterialPS,
@ -2353,9 +2353,9 @@ void UpdateUser(P_Window *window)
FloodSig sig = ZI; FloodSig sig = ZI;
sig.step_len = step_length; sig.step_len = step_length;
sig.emittance_tex_urid = GPU_GetReadableId(g->emittance); sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.read_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_read); sig.read = GPU_RWTexture2DRidFromResource(g->emittance_flood_read);
sig.target_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_target); sig.target = GPU_RWTexture2DRidFromResource(g->emittance_flood_target);
sig.tex_width = g->render_size.x; sig.tex_width = g->render_size.x;
sig.tex_height = g->render_size.y; sig.tex_height = g->render_size.y;
GPU_Compute(cl, &sig, FloodCS, (g->render_size.x + 7) / 8, (g->render_size.y + 7) / 8, 1); GPU_Compute(cl, &sig, FloodCS, (g->render_size.x + 7) / 8, (g->render_size.y + 7) / 8, 1);
@ -2411,12 +2411,12 @@ void UpdateUser(P_Window *window)
(u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF)); (u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF));
sig.frame_index = g->frame_index; sig.frame_index = g->frame_index;
sig.camera_offset = g->world_to_render_xf.og; sig.camera_offset = g->world_to_render_xf.og;
sig.albedo_tex_urid = GPU_GetReadableId(g->albedo); sig.noise = GPU_Texture3DRidFromResource(g->gpu_noise);
sig.emittance_tex_urid = GPU_GetReadableId(g->emittance); sig.albedo = GPU_Texture2DRidFromResource(g->albedo);
sig.noise_tex_urid = GPU_GetReadableId(g->gpu_noise); sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.emittance_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_read); sig.emittance_flood = GPU_Texture2DRidFromResource(g->emittance_flood_read);
sig.read_tex_urid = GPU_GetWritableId(g->shade_read); sig.read = GPU_Texture2DRidFromResource(g->shade_read);
sig.target_tex_urid = GPU_GetWritableId(g->shade_target); sig.target = GPU_RWTexture2DRidFromResource(g->shade_target);
sig.noise_tex_width = noise_size.x; sig.noise_tex_width = noise_size.x;
sig.noise_tex_height = noise_size.y; sig.noise_tex_height = noise_size.y;
sig.noise_tex_depth = noise_size.z; sig.noise_tex_depth = noise_size.z;
@ -2446,12 +2446,12 @@ void UpdateUser(P_Window *window)
GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport); GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport);
UiBlitSig sig = ZI; UiBlitSig sig = ZI;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler); sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.src = GPU_Texture2DRidFromResource(g->shade_read);
sig.projection = blit_vp_matrix; sig.projection = blit_vp_matrix;
sig.flags = UiBlitFlag_ToneMap | UiBlitFlag_GammaCorrect; sig.flags = UiBlitFlag_ToneMap | UiBlitFlag_GammaCorrect;
sig.exposure = 2.0; sig.exposure = 2.0;
sig.gamma = (f32)2.2; sig.gamma = (f32)2.2;
sig.tex_urid = GPU_GetWritableId(g->shade_read);
GPU_Rasterize(cl, GPU_Rasterize(cl,
&sig, &sig,
UiBlitVS, UiBlitPS, UiBlitVS, UiBlitPS,
@ -2471,10 +2471,10 @@ void UpdateUser(P_Window *window)
GPU_Viewport viewport = GPU_ViewportFromRect(ui_viewport); GPU_Viewport viewport = GPU_ViewportFromRect(ui_viewport);
GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport); GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport);
UiRectSig sig = ZI; UiRectSig sig = ZI;
sig.projection = ui_vp_matrix; sig.projection = ui_vp_matrix;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler); sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.instances_urid = GPU_GetReadableId(ui_rect_instance_buffer); sig.instances = GPU_StructuredBufferRidFromResource(ui_rect_instance_buffer);
GPU_Rasterize(cl, GPU_Rasterize(cl,
&sig, &sig,
UiRectVS, UiRectPS, UiRectVS, UiRectPS,
@ -2496,7 +2496,7 @@ void UpdateUser(P_Window *window)
UiShapeSig sig = ZI; UiShapeSig sig = ZI;
sig.projection = ui_vp_matrix; sig.projection = ui_vp_matrix;
sig.verts_urid = GPU_GetReadableId(ui_shape_verts_buffer); sig.verts = GPU_StructuredBufferRidFromResource(ui_shape_verts_buffer);
GPU_Rasterize(cl, GPU_Rasterize(cl,
&sig, &sig,
UiShapeVS, UiShapePS, UiShapeVS, UiShapePS,
@ -2564,11 +2564,13 @@ JobDef(UpdateUserOrSleep, UNUSED sig, UNUSED id)
__profn("Swapchain wait"); __profn("Swapchain wait");
GPU_YieldOnSwapchain(g->swapchain); GPU_YieldOnSwapchain(g->swapchain);
} }
#if FPS_LIMIT > 0
{ {
__profn("Frame limiter wait"); __profn("Frame limiter wait");
P_SleepFrame(time_ns, 1000000000 / FPS_LIMIT); P_SleepFrame(time_ns, 1000000000 / FPS_LIMIT);
time_ns = TimeNs(); time_ns = TimeNs();
} }
#endif
} }
UpdateUser(window); UpdateUser(window);
} }

79
src/pp/pp_draw.gpu
View File

@ -11,7 +11,7 @@ ConstantBuffer<UiShapeSig> ui_shape_sig : register (b0);
Struct(MaterialPS_Input) Struct(MaterialPS_Input)
{ {
Semantic(Vec4, sv_position); Semantic(Vec4, sv_position);
Semantic(nointerpolation u32, tex_nurid); Semantic(nointerpolation Texture2DRid, tex);
Semantic(nointerpolation u32, grid_id); Semantic(nointerpolation u32, grid_id);
Semantic(Vec2, uv); Semantic(Vec2, uv);
Semantic(Vec4, tint_lin); Semantic(Vec4, tint_lin);
@ -26,7 +26,7 @@ Struct(MaterialPS_Output)
//- Vertex shader //- Vertex shader
MaterialPS_Input VSDef(MaterialVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_VertexID)) MaterialPS_Input VSDef(MaterialVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
{ {
ConstantBuffer<MaterialSig> sig = mat_sig; ConstantBuffer<MaterialSig> sig = mat_sig;
static const Vec2 unit_quad_verts[4] = { static const Vec2 unit_quad_verts[4] = {
@ -35,16 +35,16 @@ MaterialPS_Input VSDef(MaterialVS, Semantic(u32, SV_InstanceID), Semantic(u32, S
Vec2(0.5f, 0.5f), Vec2(0.5f, 0.5f),
Vec2(-0.5f, 0.5f) Vec2(-0.5f, 0.5f)
}; };
StructuredBuffer<MaterialInstance> instances = GpuResourceFromUrid(sig.instances_urid);
Vec2 vert = unit_quad_verts[SV_VertexID]; StructuredBuffer<MaterialInstance> instances = UniformResourceFromRid(sig.instances);
MaterialInstance instance = instances[SV_InstanceID]; Vec2 vert = unit_quad_verts[sv_vertexid];
MaterialInstance instance = instances[sv_instanceid];
Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy; Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy;
MaterialPS_Input output; MaterialPS_Input output;
output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1)); output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1));
output.tex_nurid = instance.tex_nurid; output.tex = instance.tex;
output.grid_id = instance.grid_id; output.grid_id = instance.grid_id;
output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0)); output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0));
output.tint_lin = LinearFromSrgbU32(instance.tint_srgb); output.tint_lin = LinearFromSrgbU32(instance.tint_srgb);
@ -62,17 +62,18 @@ MaterialPS_Output PSDef(MaterialPS, MaterialPS_Input input)
Vec4 albedo = input.tint_lin; Vec4 albedo = input.tint_lin;
/* Texture */ /* Texture */
if (input.tex_nurid < 0xFFFFFFFF) if (input.tex < 0xFFFFFFFF)
{ {
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid); SamplerState sampler = UniformSamplerFromRid(sig.sampler);
Texture2D<Vec4> tex = GpuResourceFromNurid(input.tex_nurid); Texture2D<Vec4> tex = NonUniformResourceFromRid(input.tex);
albedo *= tex.Sample(sampler, input.uv); albedo *= tex.Sample(sampler, input.uv);
} }
/* Grid */ /* Grid */
if (input.grid_id < 0xFFFFFFFF) if (input.grid_id < 0xFFFFFFFF)
{ {
StructuredBuffer<MaterialGrid> grids = GpuResourceFromUrid(sig.grids_urid); // StructuredBuffer<MaterialGrid> grids = UniformResourceFromRid(sig.grids);
StructuredBuffer<MaterialGrid> grids = ResourceDescriptorHeap[sig.grids];
MaterialGrid grid = grids[input.grid_id]; MaterialGrid grid = grids[input.grid_id];
Vec2 grid_pos = input.sv_position.xy + grid.offset; Vec2 grid_pos = input.sv_position.xy + grid.offset;
f32 half_thickness = grid.line_thickness / 2; f32 half_thickness = grid.line_thickness / 2;
@ -127,17 +128,17 @@ MaterialPS_Output PSDef(MaterialPS, MaterialPS_Input input)
//- Compute shader //- Compute shader
[numthreads(8, 8, 1)] [numthreads(8, 8, 1)]
void CSDef(FloodCS, Semantic(Vec3U32, SV_DispatchThreadID)) void CSDef(FloodCS, Semantic(Vec3U32, sv_dispatchthreadid))
{ {
ConstantBuffer<FloodSig> sig = flood_sig; ConstantBuffer<FloodSig> sig = flood_sig;
Vec2U32 id = SV_DispatchThreadID.xy; Vec2U32 id = sv_dispatchthreadid.xy;
Vec2U32 tex_size = Vec2U32(sig.tex_width, sig.tex_height); Vec2U32 tex_size = Vec2U32(sig.tex_width, sig.tex_height);
if (id.x < tex_size.x && id.y < tex_size.y) if (id.x < tex_size.x && id.y < tex_size.y)
{ {
Texture2D<Vec4> emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid); Texture2D<Vec4> emittance_tex = UniformResourceFromRid(sig.emittance);
RWTexture2D<Vec2U32> read_flood_tex = GpuResourceFromUrid(sig.read_flood_tex_urid); RWTexture2D<Vec2U32> read_flood_tex = UniformResourceFromRid(sig.read);
RWTexture2D<Vec2U32> target_flood_tex = GpuResourceFromUrid(sig.target_flood_tex_urid); RWTexture2D<Vec2U32> target_flood_tex = UniformResourceFromRid(sig.target);
i32 step_len = sig.step_len; i32 step_len = sig.step_len;
if (step_len == -1) if (step_len == -1)
{ {
@ -196,7 +197,7 @@ void CSDef(FloodCS, Semantic(Vec3U32, SV_DispatchThreadID))
f32 RandAngle(Vec2U32 pos, u32 ray_index) f32 RandAngle(Vec2U32 pos, u32 ray_index)
{ {
ConstantBuffer<ShadeSig> sig = shade_sig; ConstantBuffer<ShadeSig> sig = shade_sig;
Texture3D<u32> noise_tex = GpuResourceFromUrid(sig.noise_tex_urid); Texture3D<u32> noise_tex = UniformResourceFromRid(sig.noise);
Vec3I32 noise_coord = Vec3U32(1, 1, 1); Vec3I32 noise_coord = Vec3U32(1, 1, 1);
noise_coord += Vec3I32(pos.xy, ray_index); noise_coord += Vec3I32(pos.xy, ray_index);
@ -210,8 +211,8 @@ f32 RandAngle(Vec2U32 pos, u32 ray_index)
Vec3 ColorFromDir(Vec2U32 ray_start, Vec2 ray_dir) Vec3 ColorFromDir(Vec2U32 ray_start, Vec2 ray_dir)
{ {
ConstantBuffer<ShadeSig> sig = shade_sig; ConstantBuffer<ShadeSig> sig = shade_sig;
Texture2D<Vec2U32> flood_tex = GpuResourceFromUrid(sig.emittance_flood_tex_urid); Texture2D<Vec2U32> flood_tex = UniformResourceFromRid(sig.emittance_flood);
Texture2D<Vec4> emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid); Texture2D<Vec4> emittance_tex = UniformResourceFromRid(sig.emittance);
Vec3 result = Vec3(0, 0, 0); Vec3 result = Vec3(0, 0, 0);
Vec2 at_f32 = ray_start; Vec2 at_f32 = ray_start;
@ -261,16 +262,16 @@ Vec3 ColorFromPos(Vec2U32 pos)
//- Compute shader //- Compute shader
[numthreads(8, 8, 1)] [numthreads(8, 8, 1)]
void CSDef(ShadeCS, Semantic(Vec3U32, SV_DispatchThreadID)) void CSDef(ShadeCS, Semantic(Vec3U32, sv_dispatchthreadid))
{ {
ConstantBuffer<ShadeSig> sig = shade_sig; ConstantBuffer<ShadeSig> sig = shade_sig;
Vec2U32 id = SV_DispatchThreadID.xy; Vec2U32 id = sv_dispatchthreadid.xy;
if (id.x < sig.tex_width && id.y < sig.tex_height) if (id.x < sig.tex_width && id.y < sig.tex_height)
{ {
Texture2D<Vec4> albedo_tex = GpuResourceFromUrid(sig.albedo_tex_urid); Texture2D<Vec4> albedo_tex = UniformResourceFromRid(sig.albedo);
Texture2D<Vec4> read_tex = GpuResourceFromUrid(sig.read_tex_urid); Texture2D<Vec4> read_tex = UniformResourceFromRid(sig.read);
RWTexture2D<Vec4> target_tex = GpuResourceFromUrid(sig.target_tex_urid); RWTexture2D<Vec4> target_tex = UniformResourceFromRid(sig.target);
Vec4 color = Vec4(1, 1, 1, 1); Vec4 color = Vec4(1, 1, 1, 1);
/* Apply albedo */ /* Apply albedo */
@ -318,7 +319,7 @@ Vec3 ToneMap(Vec3 v)
//- Vertex shader //- Vertex shader
UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID)) UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, sv_vertexid))
{ {
ConstantBuffer<UiBlitSig> sig = ui_blit_sig; ConstantBuffer<UiBlitSig> sig = ui_blit_sig;
static const Vec2 unit_quad_verts[4] = { static const Vec2 unit_quad_verts[4] = {
@ -327,7 +328,7 @@ UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID))
Vec2(0.5f, 0.5f), Vec2(0.5f, 0.5f),
Vec2(-0.5f, 0.5f) Vec2(-0.5f, 0.5f)
}; };
Vec2 vert = unit_quad_verts[SV_VertexID]; Vec2 vert = unit_quad_verts[sv_vertexid];
UiBlitPS_Input output; UiBlitPS_Input output;
output.sv_position = mul(sig.projection, Vec4(vert, 0, 1)); output.sv_position = mul(sig.projection, Vec4(vert, 0, 1));
@ -340,10 +341,10 @@ UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID))
UiBlitPS_Output PSDef(UiBlitPS, UiBlitPS_Input input) UiBlitPS_Output PSDef(UiBlitPS, UiBlitPS_Input input)
{ {
ConstantBuffer<UiBlitSig> sig = ui_blit_sig; ConstantBuffer<UiBlitSig> sig = ui_blit_sig;
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid); SamplerState sampler = UniformSamplerFromRid(sig.sampler);
UiBlitPS_Output output; UiBlitPS_Output output;
Texture2D<Vec4> tex = GpuResourceFromUrid(sig.tex_urid); Texture2D<Vec4> tex = UniformResourceFromRid(sig.src);
Vec4 color = tex.Sample(sampler, input.uv); Vec4 color = tex.Sample(sampler, input.uv);
/* Apply tone map */ /* Apply tone map */
@ -370,7 +371,7 @@ UiBlitPS_Output PSDef(UiBlitPS, UiBlitPS_Input input)
Struct(UiRectPS_Input) Struct(UiRectPS_Input)
{ {
Semantic(Vec4, sv_position); Semantic(Vec4, sv_position);
Semantic(nointerpolation u32, tex_nurid); Semantic(nointerpolation Texture2DRid, tex);
Semantic(Vec2, uv); Semantic(Vec2, uv);
Semantic(Vec4, tint_srgb); Semantic(Vec4, tint_srgb);
}; };
@ -382,7 +383,7 @@ Struct(UiRectPS_Output)
//- Vertex shader //- Vertex shader
UiRectPS_Input VSDef(UiRectVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_VertexID)) UiRectPS_Input VSDef(UiRectVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
{ {
ConstantBuffer<UiRectSig> sig = ui_rect_sig; ConstantBuffer<UiRectSig> sig = ui_rect_sig;
static const Vec2 unit_quad_verts[4] = { static const Vec2 unit_quad_verts[4] = {
@ -392,14 +393,14 @@ UiRectPS_Input VSDef(UiRectVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_Ve
Vec2(-0.5f, 0.5f) Vec2(-0.5f, 0.5f)
}; };
StructuredBuffer<UiRectInstance> instances = GpuResourceFromUrid(sig.instances_urid); StructuredBuffer<UiRectInstance> instances = UniformResourceFromRid(sig.instances);
UiRectInstance instance = instances[SV_InstanceID]; UiRectInstance instance = instances[sv_instanceid];
Vec2 vert = unit_quad_verts[SV_VertexID]; Vec2 vert = unit_quad_verts[sv_vertexid];
Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy; Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy;
UiRectPS_Input output; UiRectPS_Input output;
output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1)); output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1));
output.tex_nurid = instance.tex_nurid; output.tex = instance.tex;
output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0)); output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0));
output.tint_srgb = Vec4NormFromU32(instance.tint_srgb); output.tint_srgb = Vec4NormFromU32(instance.tint_srgb);
return output; return output;
@ -414,10 +415,10 @@ UiRectPS_Output PSDef(UiRectPS, UiRectPS_Input input)
Vec4 color = input.tint_srgb; Vec4 color = input.tint_srgb;
/* Texture */ /* Texture */
if (input.tex_nurid < 0xFFFFFFFF) if (input.tex < 0xFFFFFFFF)
{ {
Texture2D<Vec4> tex = GpuResourceFromNurid(input.tex_nurid); Texture2D<Vec4> tex = NonUniformResourceFromRid(input.tex);
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid); SamplerState sampler = UniformSamplerFromRid(sig.sampler);
color *= tex.Sample(sampler, input.uv); color *= tex.Sample(sampler, input.uv);
} }
@ -441,11 +442,11 @@ Struct(UiShapePS_Output)
//- Vertex shader //- Vertex shader
UiShapePS_Input VSDef(UiShapeVS, Semantic(u32, SV_VertexID)) UiShapePS_Input VSDef(UiShapeVS, Semantic(u32, sv_vertexid))
{ {
ConstantBuffer<UiShapeSig> sig = ui_shape_sig; ConstantBuffer<UiShapeSig> sig = ui_shape_sig;
StructuredBuffer<UiShapeVert> verts = GpuResourceFromUrid(sig.verts_urid); StructuredBuffer<UiShapeVert> verts = UniformResourceFromRid(sig.verts);
UiShapeVert vert = verts[SV_VertexID]; UiShapeVert vert = verts[sv_vertexid];
UiShapePS_Input output; UiShapePS_Input output;
output.sv_position = mul(sig.projection, Vec4(vert.pos.xy, 0, 1)); output.sv_position = mul(sig.projection, Vec4(vert.pos.xy, 0, 1));
output.color_srgb = Vec4NormFromU32(vert.color_srgb); output.color_srgb = Vec4NormFromU32(vert.color_srgb);

40
src/pp/pp_draw.h
View File

@ -6,9 +6,9 @@ Struct(MaterialSig)
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */ Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 tex_sampler_urid; /* 01 consts */ SamplerStateRid sampler; /* 01 consts */
u32 instances_urid; /* 01 consts */ StructuredBufferRid instances; /* 01 consts */
u32 grids_urid; /* 01 consts */ StructuredBufferRid grids; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */ u32 _pad0; /* 01 consts (padding) */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
}; };
@ -16,7 +16,7 @@ AssertRootConst(MaterialSig, 20);
Struct(MaterialInstance) Struct(MaterialInstance)
{ {
u32 tex_nurid; Texture2DRid tex;
u32 grid_id; u32 grid_id;
Xform xf; Xform xf;
Vec2 uv0; Vec2 uv0;
@ -26,7 +26,7 @@ Struct(MaterialInstance)
Vec3 light_emittance_srgb; Vec3 light_emittance_srgb;
}; };
#define DefaultMaterialInstance (MaterialInstance) { \ #define DefaultMaterialInstance (MaterialInstance) { \
.tex_nurid = U32Max, \ .tex = { U32Max }, \
.grid_id = U32Max, \ .grid_id = U32Max, \
.xf = XformIdentity, \ .xf = XformIdentity, \
.uv1 = VEC2(1, 1), \ .uv1 = VEC2(1, 1), \
@ -58,9 +58,9 @@ Struct(FloodSig)
{ {
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
i32 step_len; /* 01 consts */ i32 step_len; /* 01 consts */
u32 emittance_tex_urid; /* 01 consts */ Texture2DRid emittance; /* 01 consts */
u32 read_flood_tex_urid; /* 01 consts */ RWTexture2DRid read; /* 01 consts */
u32 target_flood_tex_urid; /* 01 consts */ RWTexture2DRid target; /* 01 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 tex_width; /* 01 consts */ u32 tex_width; /* 01 consts */
u32 tex_height; /* 01 consts */ u32 tex_height; /* 01 consts */
@ -88,14 +88,14 @@ Struct(ShadeSig)
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
Vec2 camera_offset; /* 02 consts */ Vec2 camera_offset; /* 02 consts */
u32 frame_index; /* 01 consts */ u32 frame_index; /* 01 consts */
u32 albedo_tex_urid; /* 01 consts */ Texture2DRid albedo; /* 01 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 emittance_tex_urid; /* 01 consts */ Texture2DRid emittance; /* 01 consts */
u32 emittance_flood_tex_urid; /* 01 consts */ Texture2DRid emittance_flood; /* 01 consts */
u32 read_tex_urid; /* 01 consts */ Texture2DRid read; /* 01 consts */
u32 target_tex_urid; /* 01 consts */ RWTexture2DRid target; /* 01 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 noise_tex_urid; /* 01 consts */ Texture3DRid noise; /* 01 consts */
u32 noise_tex_width; /* 01 consts */ u32 noise_tex_width; /* 01 consts */
u32 noise_tex_height; /* 01 consts */ u32 noise_tex_height; /* 01 consts */
u32 noise_tex_depth; /* 01 consts */ u32 noise_tex_depth; /* 01 consts */
@ -116,11 +116,11 @@ Struct(UiBlitSig)
Mat4x4 projection; /* 16 consts */ Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 flags; /* 01 consts */ u32 flags; /* 01 consts */
u32 tex_urid; /* 01 consts */ Texture2DRid src; /* 01 consts */
f32 exposure; /* 01 consts */ f32 exposure; /* 01 consts */
f32 gamma; /* 01 consts */ f32 gamma; /* 01 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 tex_sampler_urid; /* 01 consts */ SamplerStateRid sampler; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */ u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */ u32 _pad1; /* 01 consts (padding) */
u32 _pad2; /* 01 consts (padding) */ u32 _pad2; /* 01 consts (padding) */
@ -137,8 +137,8 @@ Struct(UiRectSig)
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */ Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 instances_urid; /* 01 consts */ StructuredBufferRid instances; /* 01 consts */
u32 tex_sampler_urid; /* 01 consts */ SamplerStateRid sampler; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */ u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */ u32 _pad1; /* 01 consts (padding) */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
@ -147,7 +147,7 @@ AssertRootConst(UiRectSig, 20);
Struct(UiRectInstance) Struct(UiRectInstance)
{ {
u32 tex_nurid; Texture2DRid tex;
Xform xf; Xform xf;
Vec2 uv0; Vec2 uv0;
Vec2 uv1; Vec2 uv1;
@ -162,7 +162,7 @@ Struct(UiShapeSig)
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */ Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */ /* ----------------------------------------------------- */
u32 verts_urid; /* 01 consts */ StructuredBufferRid verts; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */ u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */ u32 _pad1; /* 01 consts (padding) */
u32 _pad2; /* 01 consts (padding) */ u32 _pad2; /* 01 consts (padding) */