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

re-enable ui & vis rendering

Browse Source
This commit is contained in:
jacob 2025-12-11 15:41:31 -06:00
parent eeec7e7191
commit ad359c8495
11 changed files with 228 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/config.h
View File

@ -73,7 +73,7 @@
#define GPU_DEBUG_VALIDATION 0 #define GPU_DEBUG_VALIDATION 0
#define GPU_SHADER_PRINT 1 #define GPU_SHADER_PRINT 1
#define GPU_SHADER_PRINT_BUFFER_SIZE Kibi(1); #define GPU_SHADER_PRINT_BUFFER_SIZE Kibi(64);
#define GPU_SHADER_PRINT_LOG 1 #define GPU_SHADER_PRINT_LOG 1
/* If enabled, bitbuffs will insert/verify magic numbers & length for each read & write */ /* If enabled, bitbuffs will insert/verify magic numbers & length for each read & write */

341
src/gpu/gpu_dx12/gpu_dx12_core.c
View File

@ -307,6 +307,12 @@ void G_Bootstrap(void)
queue->print_buffer_size, queue->print_buffer_size,
.flags = G_ResourceFlag_AllowShaderReadWrite .flags = G_ResourceFlag_AllowShaderReadWrite
); );
queue->print_readback_buffer = G_PushBuffer(
gpu_perm,
u8,
queue->print_buffer_size,
.flags = G_ResourceFlag_HostMemory
);
queue->print_buffer_ref = G_PushRWByteAddressBufferRef(gpu_perm, queue->print_buffer); queue->print_buffer_ref = G_PushRWByteAddressBufferRef(gpu_perm, queue->print_buffer);
} }
} }
@ -2837,197 +2843,196 @@ void G_CommitBackbuffer(G_ResourceHandle backbuffer_handle, i32 vsync)
void G_D12_CollectionWorkerEntry(WaveLaneCtx *lane) void G_D12_CollectionWorkerEntry(WaveLaneCtx *lane)
{ {
G_QueueKind queue_kind = G_QueueKind_Direct;
G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind);
// if (queue->print_buffer_size > 0)
G_ArenaHandle gpu_perm = G_PermArena();
G_ResourceHandle readback_buff = G_PushBuffer(
gpu_perm,
u8,
queue->print_buffer_size,
.flags = G_ResourceFlag_HostMemory
);
for (;;) for (;;)
{ {
/* FIXME: Remove this */ P_SleepSeconds(0.100);
Sleep(100); /* Copy print-buffers to readback */
for (G_QueueKind queue_kind = 0; queue_kind < G_NumQueues; ++queue_kind)
G_CommandListHandle cl = G_PrepareCommandList(queue_kind);
{ {
/* Copy print buffer to readback buffer */ G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind);
G_CopyBufferToBuffer(cl, readback_buff, 0, queue->print_buffer, RNGU64(0, queue->print_buffer_size)); if (!G_IsResourceNil(queue->print_buffer))
/* Reset counters to 0 */
G_MemorySync(cl, queue->print_buffer,
G_Stage_Copy, G_Access_CopyRead,
G_Stage_Copy, G_Access_CopyWrite
);
u8 zero[12] = ZI;
G_CopyCpuToBuffer(cl, queue->print_buffer, 0, zero, RNGU64(0, sizeof(zero)));
}
G_CommitCommandList(cl);
G_SyncCpu(G_MaskFromQueue(queue_kind));
u32 attempted_print_bytes_count = *(G_StructFromResource(readback_buff, u32) + 0); /* The number of bytes shaders attempted to write */
u32 prints_count = *(G_StructFromResource(readback_buff, u32) + 1); /* The number of shader prints that are in the buffer */
u32 overflows_count = *(G_StructFromResource(readback_buff, u32) + 2); /* The number of shader prints that could not fit in the buffer */
u8 *start = G_StructFromResource(readback_buff, u8) + 12;
/* Deserialize */
if (GPU_SHADER_PRINT_LOG)
{
if (prints_count > 0)
{ {
LogDebugF( G_CommandListHandle cl = G_PrepareCommandList(queue_kind);
"Forwarding logs collected from GPU - Resident prints: %F, Total attempted prints: %F, Total attempted bytes: %F",
FmtUint(prints_count),
FmtUint(prints_count + overflows_count),
FmtUint(attempted_print_bytes_count)
);
}
/* FIXME: Remove this */
TempArena scratch = BeginScratchNoConflict();
u8 *at = start;
{
for (u32 print_num = 1; print_num <= prints_count; ++print_num)
{ {
u32 chars_count = 0; /* Copy print buffer to readback buffer */
u32 args_count = 0; G_CopyBufferToBuffer(cl, queue->print_readback_buffer, 0, queue->print_buffer, RNGU64(0, queue->print_buffer_size));
b32 internal_overflow = 0; /* Reset counters to 0 */
G_MemorySync(cl, queue->print_buffer,
G_Stage_Copy, G_Access_CopyRead,
G_Stage_Copy, G_Access_CopyWrite
);
u8 zero[12] = ZI;
G_CopyCpuToBuffer(cl, queue->print_buffer, 0, zero, RNGU64(0, sizeof(zero)));
}
G_CommitCommandList(cl);
}
}
/* TODO: Collect asynchronously */
G_SyncCpu(G_QueueMask_Direct | G_QueueMask_AsyncCompute);
for (G_QueueKind queue_kind = 0; queue_kind < G_NumQueues; ++queue_kind)
{
G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind);
if (!G_IsResourceNil(queue->print_buffer))
{
u32 attempted_print_bytes_count = *(G_StructFromResource(queue->print_readback_buffer, u32) + 0); /* The number of bytes shaders attempted to write */
u32 prints_count = *(G_StructFromResource(queue->print_readback_buffer, u32) + 1); /* The number of shader prints that are in the buffer */
u32 overflows_count = *(G_StructFromResource(queue->print_readback_buffer, u32) + 2); /* The number of shader prints that could not fit in the buffer */
u8 *start = G_StructFromResource(queue->print_readback_buffer, u8) + 12;
/* Deserialize */
if (GPU_SHADER_PRINT_LOG)
{
if (prints_count > 0)
{ {
u32 header = *(u32 *)at; LogDebugF(
chars_count = (header & 0x0000FFFF) >> 0; "Forwarding logs collected from GPU - Resident prints: %F, Total attempted prints: %F, Total attempted bytes: %F",
args_count = (header & 0x7FFF0000) >> 16; FmtUint(prints_count),
internal_overflow = (header & 0xF0000000) >> 31; FmtUint(prints_count + overflows_count),
at += 4; FmtUint(attempted_print_bytes_count)
);
} }
String fmt = ZI; /* FIXME: Remove this */
TempArena scratch = BeginScratchNoConflict();
u8 *at = start;
{ {
fmt.len = chars_count; for (u32 print_num = 1; print_num <= prints_count; ++print_num)
fmt.text = at;
at += chars_count;
}
FmtArgArray args = ZI;
args.count = args_count;
{
if (args_count > 0)
{ {
args.args = PushStructs(scratch.arena, FmtArg, args_count); u32 chars_count = 0;
for (u32 arg_idx = 0; arg_idx < args_count; ++arg_idx) u32 args_count = 0;
b32 internal_overflow = 0;
{ {
G_FmtArgKind gpu_kind = (G_FmtArgKind)(*at); u32 header = *(u32 *)at;
at += 1; chars_count = (header & 0x0000FFFF) >> 0;
args_count = (header & 0x7FFF0000) >> 16;
internal_overflow = (header & 0xF0000000) >> 31;
at += 4;
}
FmtArg *dst = &args.args[arg_idx]; String fmt = ZI;
switch (gpu_kind) {
fmt.len = chars_count;
fmt.text = at;
at += chars_count;
}
FmtArgArray args = ZI;
args.count = args_count;
{
if (args_count > 0)
{ {
args.args = PushStructs(scratch.arena, FmtArg, args_count);
for (u32 arg_idx = 0; arg_idx < args_count; ++arg_idx)
{
G_FmtArgKind gpu_kind = (G_FmtArgKind)(*at);
at += 1;
/* Translate unsigned args */ FmtArg *dst = &args.args[arg_idx];
case G_FmtArgKind_Uint: switch (gpu_kind)
{ {
u32 gpu_value = *(u32 *)at;
*dst = FmtUint(gpu_value);
at += 4;
} break;
case G_FmtArgKind_Uint2:
{
Vec2U32 gpu_value = *(Vec2U32 *)at;
*dst = FmtUint2(gpu_value);
at += 8;
} break;
case G_FmtArgKind_Uint3:
{
Vec3U32 gpu_value = *(Vec3U32 *)at;
*dst = FmtUint3(gpu_value);
at += 12;
} break;
case G_FmtArgKind_Uint4:
{
Vec4U32 gpu_value = *(Vec4U32 *)at;
*dst = FmtUint4(gpu_value);
at += 16;
} break;
/* Translate signed args */ /* Translate unsigned args */
case G_FmtArgKind_Sint: case G_FmtArgKind_Uint:
{ {
i32 gpu_value = *(i32 *)at; u32 gpu_value = *(u32 *)at;
*dst = FmtSint(gpu_value); *dst = FmtUint(gpu_value);
at += 4; at += 4;
} break; } break;
case G_FmtArgKind_Sint2: case G_FmtArgKind_Uint2:
{ {
Vec2I32 gpu_value = *(Vec2I32 *)at; Vec2U32 gpu_value = *(Vec2U32 *)at;
*dst = FmtSint2(gpu_value); *dst = FmtUint2(gpu_value);
at += 8; at += 8;
} break; } break;
case G_FmtArgKind_Sint3: case G_FmtArgKind_Uint3:
{ {
Vec3I32 gpu_value = *(Vec3I32 *)at; Vec3U32 gpu_value = *(Vec3U32 *)at;
*dst = FmtSint3(gpu_value); *dst = FmtUint3(gpu_value);
at += 12; at += 12;
} break; } break;
case G_FmtArgKind_Sint4: case G_FmtArgKind_Uint4:
{ {
Vec4I32 gpu_value = *(Vec4I32 *)at; Vec4U32 gpu_value = *(Vec4U32 *)at;
*dst = FmtSint4(gpu_value); *dst = FmtUint4(gpu_value);
at += 16; at += 16;
} break; } break;
/* Translate float args */ /* Translate signed args */
case G_FmtArgKind_Float: case G_FmtArgKind_Sint:
{ {
f32 gpu_value = *(f32 *)at; i32 gpu_value = *(i32 *)at;
*dst = FmtFloat(gpu_value); *dst = FmtSint(gpu_value);
at += 4; at += 4;
} break; } break;
case G_FmtArgKind_Float2: case G_FmtArgKind_Sint2:
{ {
Vec2 gpu_value = *(Vec2 *)at; Vec2I32 gpu_value = *(Vec2I32 *)at;
*dst = FmtFloat2(gpu_value); *dst = FmtSint2(gpu_value);
at += 8; at += 8;
} break; } break;
case G_FmtArgKind_Float3: case G_FmtArgKind_Sint3:
{ {
Vec3 gpu_value = *(Vec3 *)at; Vec3I32 gpu_value = *(Vec3I32 *)at;
*dst = FmtFloat3(gpu_value); *dst = FmtSint3(gpu_value);
at += 12; at += 12;
} break; } break;
case G_FmtArgKind_Float4: case G_FmtArgKind_Sint4:
{ {
Vec4 gpu_value = *(Vec4 *)at; Vec4I32 gpu_value = *(Vec4I32 *)at;
*dst = FmtFloat4(gpu_value); *dst = FmtSint4(gpu_value);
at += 16; at += 16;
} break; } break;
/* Translate float args */
case G_FmtArgKind_Float:
{
f32 gpu_value = *(f32 *)at;
*dst = FmtFloat(gpu_value);
at += 4;
} break;
case G_FmtArgKind_Float2:
{
Vec2 gpu_value = *(Vec2 *)at;
*dst = FmtFloat2(gpu_value);
at += 8;
} break;
case G_FmtArgKind_Float3:
{
Vec3 gpu_value = *(Vec3 *)at;
*dst = FmtFloat3(gpu_value);
at += 12;
} break;
case G_FmtArgKind_Float4:
{
Vec4 gpu_value = *(Vec4 *)at;
*dst = FmtFloat4(gpu_value);
at += 16;
} break;
}
}
} }
} }
String final_str = ZI;
if (internal_overflow)
{
final_str = Lit("[Shader PrintF is too large]");
}
else
{
final_str = FormatString(scratch.arena, fmt, args);
}
LogDebug(final_str);
at = (u8 *)AlignU64((u64)at, 4);
} }
} }
EndScratch(scratch);
String final_str = ZI;
if (internal_overflow)
{
final_str = Lit("[Shader PrintF is too large]");
}
else
{
final_str = FormatString(scratch.arena, fmt, args);
}
LogDebug(final_str);
at = (u8 *)AlignU64((u64)at, 4);
} }
} }
EndScratch(scratch);
} }
DEBUGBREAKABLE;
} }
} }

1
src/gpu/gpu_dx12/gpu_dx12_core.h
View File

@ -222,6 +222,7 @@ Struct(G_D12_Queue)
/* Global resources */ /* Global resources */
u64 print_buffer_size; u64 print_buffer_size;
G_ResourceHandle print_buffer; G_ResourceHandle print_buffer;
G_ResourceHandle print_readback_buffer;
G_RWByteAddressBufferRef print_buffer_ref; G_RWByteAddressBufferRef print_buffer_ref;
/* Raw command lists */ /* Raw command lists */

1
src/platform/platform.h
View File

@ -137,5 +137,6 @@ i64 P_GetCurrentTimerPeriodNs(void);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookdecl Sleep //~ @hookdecl Sleep
void P_SleepSeconds(f64 seconds);
void P_SleepPrecise(i64 sleep_time_ns); void P_SleepPrecise(i64 sleep_time_ns);
void P_SleepFrame(i64 last_frame_time_ns, i64 target_dt_ns); void P_SleepFrame(i64 last_frame_time_ns, i64 target_dt_ns);

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

@ -978,6 +978,11 @@ i64 P_GetCurrentTimerPeriodNs(void)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookimpl Sleep //~ @hookimpl Sleep
void P_SleepSeconds(f64 seconds)
{
Sleep(seconds / 1000.0);
}
void P_SleepPrecise(i64 sleep_time_ns) void P_SleepPrecise(i64 sleep_time_ns)
{ {
i64 now_ns = TimeNs(); i64 now_ns = TimeNs();

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

@ -580,11 +580,12 @@ void V_TickForever(WaveLaneCtx *lane)
/* Params */ /* Params */
V_DParams params = ZI; V_DParams params = ZI;
{ {
params.target_size = draw_size; params.target_size = draw_size;
params.target_ro = draw_target_ro; params.target_ro = draw_target_ro;
params.target_rw = draw_target_rw; params.target_rw = draw_target_rw;
params.shape_verts = dverts_ro; params.shape_verts = dverts_ro;
params.world_to_draw_xf = world_to_draw_xf; params.world_to_draw_xf = world_to_draw_xf;
params.target_cursor_pos = draw_cursor;
} }
G_ResourceHandle params_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromStruct(&params)); G_ResourceHandle params_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromStruct(&params));
G_StructuredBufferRef params_ro = G_PushStructuredBufferRef(frame->gpu_arena, params_buff, V_DParams); G_StructuredBufferRef params_ro = G_PushStructuredBufferRef(frame->gpu_arena, params_buff, V_DParams);
@ -598,7 +599,6 @@ void V_TickForever(WaveLaneCtx *lane)
////////////////////////////// //////////////////////////////
//- Backdrop pass //- Backdrop pass
/* Backdrop pass */ /* Backdrop pass */
{ {
G_Compute(frame->cl, V_BackdropCS, V_BackdropCSThreadSizeFromTexSize(draw_size)); G_Compute(frame->cl, V_BackdropCS, V_BackdropCSThreadSizeFromTexSize(draw_size));
@ -623,7 +623,11 @@ void V_TickForever(WaveLaneCtx *lane)
//- Finalize draw target //- Finalize draw target
G_DumbMemoryLayoutSync(frame->cl, draw_target, G_Layout_DirectQueue_ShaderRead); G_DumbMemoryLayoutSync(frame->cl, draw_target, G_Layout_DirectQueue_ShaderRead);
UI_SetRawTexture(vis_box, draw_target_ro, VEC2(0, 0), VEC2(1, 1)); {
Vec2 uv0 = DivVec2Vec2(Vec2FromVec(viewport.p0), Vec2FromVec(window_frame.monitor_size));
Vec2 uv1 = DivVec2Vec2(Vec2FromVec(viewport.p1), Vec2FromVec(window_frame.monitor_size));
UI_SetRawTexture(vis_box, draw_target_ro, uv0, uv1);
}
} }
////////////////////////////// //////////////////////////////

15
src/pp/pp_vis/pp_vis_shaders.cgh
View File

@ -5,12 +5,15 @@ G_DeclConstant(G_StructuredBufferRef, V_ShaderConst_Params, 0);
Struct(V_DParams) Struct(V_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
G_Texture2DRef target_ro; G_Texture2DRef target_ro;
G_RWTexture2DRef target_rw; G_RWTexture2DRef target_rw;
G_StructuredBufferRef quads;
G_StructuredBufferRef shape_verts; G_StructuredBufferRef quads;
Xform world_to_draw_xf; G_StructuredBufferRef shape_verts;
Vec2 target_cursor_pos;
Xform world_to_draw_xf;
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

3
src/pp/pp_vis/pp_vis_shaders.g
View File

@ -10,7 +10,8 @@ ComputeShader2D(V_BackdropCS, 8, 8)
Vec2I32 target_size = params.target_size; Vec2I32 target_size = params.target_size;
if (target_pos.x < target_size.x && target_pos.y < target_size.y) if (target_pos.x < target_size.x && target_pos.y < target_size.y)
{ {
Vec4 result = Color_Blue; Vec4 result = Vec4(0.05, 0.05, 0.05, 1);
target[target_pos] = result; target[target_pos] = result;
} }
} }

40
src/ui/ui_core.c
View File

@ -483,7 +483,7 @@ UI_Frame *UI_BeginFrame(UI_FrameFlag frame_flags, Vec4 swapchain_color)
{ {
Arena *old_arena = frame->arena; Arena *old_arena = frame->arena;
Arena *old_rects_arena = frame->arena; Arena *old_rects_arena = frame->rects_arena;
G_ArenaHandle old_gpu_arena = frame->gpu_arena; G_ArenaHandle old_gpu_arena = frame->gpu_arena;
ZeroStruct(frame); ZeroStruct(frame);
frame->arena = old_arena; frame->arena = old_arena;
@ -691,6 +691,8 @@ void UI_EndFrame(UI_Frame *frame)
UI_State *g = &UI_state; UI_State *g = &UI_state;
Vec2I32 monitor_size = frame->window_frame.monitor_size; Vec2I32 monitor_size = frame->window_frame.monitor_size;
Rng3 monitor_viewport = RNG3(VEC3(0, 0, 0), VEC3(monitor_size.x, monitor_size.y, 1));
Rng2 monitor_scissor = RNG2(VEC2(0, 0), VEC2(monitor_size.x, monitor_size.y));
Vec2I32 draw_size = frame->window_frame.draw_size; Vec2I32 draw_size = frame->window_frame.draw_size;
Rng3 draw_viewport = RNG3(VEC3(0, 0, 0), VEC3(draw_size.x, draw_size.y, 1)); Rng3 draw_viewport = RNG3(VEC3(0, 0, 0), VEC3(draw_size.x, draw_size.y, 1));
@ -1386,6 +1388,7 @@ void UI_EndFrame(UI_Frame *frame)
G_Texture2DRef draw_target_ro = G_PushTexture2DRef(frame->gpu_arena, draw_target); G_Texture2DRef draw_target_ro = G_PushTexture2DRef(frame->gpu_arena, draw_target);
/* Rects */ /* Rects */
u64 rects_count = ArenaCount(frame->rects_arena, UI_DRect);
G_ResourceHandle rects_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena)); G_ResourceHandle rects_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena));
G_StructuredBufferRef rects_ro = G_PushStructuredBufferRef(frame->gpu_arena, rects_buff, UI_DRect); G_StructuredBufferRef rects_ro = G_PushStructuredBufferRef(frame->gpu_arena, rects_buff, UI_DRect);
@ -1396,6 +1399,7 @@ void UI_EndFrame(UI_Frame *frame)
params.target_ro = draw_target_ro; params.target_ro = draw_target_ro;
params.rects = rects_ro; params.rects = rects_ro;
params.sampler = G_BasicSampler(); params.sampler = G_BasicSampler();
params.cursor_pos = frame->cursor_pos;
} }
G_ResourceHandle params_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromStruct(&params)); G_ResourceHandle params_buff = G_PushBufferFromString(frame->gpu_arena, frame->cl, StringFromStruct(&params));
G_StructuredBufferRef params_ro = G_PushStructuredBufferRef(frame->gpu_arena, params_buff, UI_DParams); G_StructuredBufferRef params_ro = G_PushStructuredBufferRef(frame->gpu_arena, params_buff, UI_DParams);
@ -1410,33 +1414,33 @@ void UI_EndFrame(UI_Frame *frame)
//- Clear pass //- Clear pass
{ {
G_ClearRenderTarget(frame->cl, draw_target, VEC4(1, 0, 0, 1)); G_ClearRenderTarget(frame->cl, draw_target, VEC4(0, 0, 0, 1));
} }
//- Rect pass //- Rect pass
G_DumbMemoryLayoutSync(frame->cl, draw_target, G_Layout_DirectQueue_RenderTargetWrite); G_DumbMemoryLayoutSync(frame->cl, draw_target, G_Layout_DirectQueue_RenderTargetWrite);
if (G_CountBufferBytes(rects_buff) > 0) if (rects_count > 0)
{ {
/* Render rects */ /* Render rects */
G_Rasterize(frame->cl, G_Rasterize(frame->cl,
UI_DRectVS, UI_DRectPS, UI_DRectVS, UI_DRectPS,
1, G_QuadIndices(), rects_count, G_QuadIndices(),
1, &draw_target, 1, &draw_target,
draw_viewport, draw_scissor, draw_viewport, draw_scissor,
G_RasterMode_TriangleList); G_RasterMode_TriangleList);
/* Render rect wireframes */ /* Render rect wireframes */
if (AnyBit(frame->frame_flags, UI_FrameFlag_Debug)) if (AnyBit(frame->frame_flags, UI_FrameFlag_Debug))
{ {
G_SetConstant(frame->cl, UI_ShaderConst_DebugDraw, 1); G_SetConstant(frame->cl, UI_ShaderConst_DebugDraw, 1);
G_Rasterize(frame->cl, G_Rasterize(frame->cl,
UI_DRectVS, UI_DRectPS, UI_DRectVS, UI_DRectPS,
1, G_QuadIndices(), rects_count, G_QuadIndices(),
1, &draw_target, 1, &draw_target,
draw_viewport, draw_scissor, draw_viewport, draw_scissor,
G_RasterMode_WireTriangleList); G_RasterMode_WireTriangleList);
} }
} }
@ -1447,11 +1451,11 @@ void UI_EndFrame(UI_Frame *frame)
{ {
G_Rasterize(frame->cl, G_Rasterize(frame->cl,
UI_BlitVS, UI_BlitPS, UI_BlitVS, UI_BlitPS,
1, G_QuadIndices(), 1, G_QuadIndices(),
1, &backbuffer, 1, &backbuffer,
draw_viewport, draw_scissor, monitor_viewport, monitor_scissor,
G_RasterMode_TriangleList); G_RasterMode_TriangleList);
} }
G_DumbMemoryLayoutSync(frame->cl, backbuffer, G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present); G_DumbMemoryLayoutSync(frame->cl, backbuffer, G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present);

3
src/ui/ui_shaders.cgh
View File

@ -8,6 +8,9 @@ Struct(UI_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
G_Texture2DRef target_ro; G_Texture2DRef target_ro;
Vec2 cursor_pos;
G_StructuredBufferRef rects; G_StructuredBufferRef rects;
G_SamplerStateRef sampler; G_SamplerStateRef sampler;
}; };

7
src/ui/ui_shaders.g
View File

@ -130,6 +130,7 @@ VertexShader(UI_BlitVS, UI_BlitPSInput)
UI_BlitPSInput result; UI_BlitPSInput result;
result.sv_position = Vec4(NdcFromUv(uv).xy, 0, 1); result.sv_position = Vec4(NdcFromUv(uv).xy, 0, 1);
result.src_uv = uv; result.src_uv = uv;
return result; return result;
} }
@ -145,12 +146,6 @@ PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input)
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 result = tex.Sample(sampler, uv); Vec4 result = tex.Sample(sampler, uv);
G_PrintF(
"Bla: %F %F",
G_Fmt(input.sv_position),
G_Fmt(uv)
);
UI_BlitPSOutput output; UI_BlitPSOutput output;
output.SV_Target0 = result; output.SV_Target0 = result;
return output; return output;