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

move shader handles into gpu layer

Browse Source
This commit is contained in:
jacob 2025-12-09 18:04:32 -06:00
parent 8565cbea53
commit 1b02edb0b5
18 changed files with 219 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/base/base.cgh
View File

@ -465,7 +465,6 @@
#endif #endif
#endif #endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Scalar types //~ Scalar types
@ -715,9 +714,7 @@
#endif #endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ C <-> Shader interop types //~ Shader linkage types
//- Shader linkage
#if IsLanguageC #if IsLanguageC
Struct(VertexShader) { ResourceKey resource; }; Struct(VertexShader) { ResourceKey resource; };
@ -732,59 +729,6 @@
#define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__) #define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__)
#endif #endif
//- Shader resource references
Enum(ShaderRefKind)
{
ShaderRefKind_StructuredBuffer,
ShaderRefKind_RWStructuredBuffer,
ShaderRefKind_ByteAddressBuffer,
ShaderRefKind_RWByteAddressBuffer,
ShaderRefKind_Texture1D,
ShaderRefKind_RWTexture1D,
ShaderRefKind_Texture2D,
ShaderRefKind_RWTexture2D,
ShaderRefKind_Texture3D,
ShaderRefKind_RWTexture3D,
ShaderRefKind_SamplerState,
};
Struct(StructuredBufferRef) { u32 v; };
Struct(RWStructuredBufferRef) { u32 v; };
Struct(ByteAddressBufferRef) { u32 v; };
Struct(RWByteAddressBufferRef) { u32 v; };
Struct(Texture1DRef) { u32 v; };
Struct(RWTexture1DRef) { u32 v; };
Struct(Texture2DRef) { u32 v; };
Struct(RWTexture2DRef) { u32 v; };
Struct(Texture3DRef) { u32 v; };
Struct(RWTexture3DRef) { u32 v; };
Struct(SamplerStateRef) { u32 v; };
#define IsShaderRefNil(h) ((h).v == 0)
//- Shader constants
/*
* NOTE: D3d12 exposes 64 root constants, and vulkan 32 push constants.
* Other constants past the max can be used by the graphics
* implementation backend layer.
*/
#define NumGeneralPurposeShaderConstants (8)
#if IsLanguageC
#define ForceShaderConstant(type, name, slot) \
Enum(name##__shaderconstantenum) { name = slot }; \
Struct(name##__shaderconstanttype) { type v; }
#define ShaderConstant(type, name, slot) \
StaticAssert(sizeof(type) <= 4); \
StaticAssert(slot < NumGeneralPurposeShaderConstants); \
ForceShaderConstant(type, name, slot)
#elif IsLanguageG
#define ForceShaderConstant(type, name, slot) cbuffer name : register(b##slot) { type name; }
#define ShaderConstant(type, name, slot) ForceShaderConstant(type, name, slot)
#endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Exit callback types //~ Exit callback types

34
src/base/base_shader.gh
View File

@ -1,5 +1,5 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Shader math types //~ Math types
#define Pi ((f32)3.14159265358979323846) #define Pi ((f32)3.14159265358979323846)
#define Tau ((f32)6.28318530717958647693) #define Tau ((f32)6.28318530717958647693)
@ -21,42 +21,10 @@ typedef float4 Aabb;
typedef float4 Quad; typedef float4 Quad;
typedef float4x4 Mat4x4; typedef float4x4 Mat4x4;
////////////////////////////////////////////////////////////
//~ Dereference
/* TODO: Non-uniform resource access is assumed as the default behavior. We
* may want to add explicit "uniform" variants for optimization on AMD devices
* in the future. */
template<typename T> StructuredBuffer<T> StructuredBufferFromRef(StructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWStructuredBuffer<T> RWStructuredBufferFromRef(RWStructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
ByteAddressBuffer ByteAddressBufferFromRef(ByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
RWByteAddressBuffer RWByteAddressBufferFromRef(RWByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture1D<T> Texture1DFromRef(Texture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture3D<T> Texture3DFromRef(Texture3DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture1D<T> RWTexture1DFromRef(RWTexture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture2D<T> Texture2DFromRef(Texture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture2D<T> RWTexture2DFromRef(RWTexture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture3D<T> RWTexture3DFromRef(RWTexture3DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
SamplerState SamplerStateFromRef(SamplerStateRef h) { return SamplerDescriptorHeap[NonUniformResourceIndex(h.v)]; }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Countof //~ Countof
template<typename T, u32 N> u32 countof(T arr[N]) { return N; } template<typename T, u32 N> u32 countof(T arr[N]) { return N; }
template<typename T> u32 countof(StructuredBuffer<T> buff) { u32 result; buff.GetDimensions(result); return result; }
template<typename T> u32 countof(RWStructuredBuffer<T> buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(ByteAddressBuffer buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(RWByteAddressBuffer buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(Texture1D tex) { u32 result; tex.GetDimensions(result); return result; }
template<typename T> u32 countof(RWTexture1D<T> tex) { u32 result; tex.GetDimensions(result); return result; }
Vec2U32 countof(Texture2D tex) { Vec2U32 result; tex.GetDimensions(result.x, result.y); return result; }
template<typename T> Vec2U32 countof(RWTexture2D<T> tex) { Vec2U32 result; tex.GetDimensions(result.x, result.y); return result; }
Vec3U32 countof(Texture3D tex) { Vec3U32 result; tex.GetDimensions(result.x, result.y, result.z); return result; }
template<typename T> Vec3U32 countof(RWTexture3D<T> tex) { Vec3U32 result; tex.GetDimensions(result.x, result.y, result.z); return result; }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Color helpers //~ Color helpers

2
src/glyph_cache/glyph_cache.h
View File

@ -16,7 +16,7 @@ Struct(GC_RunRect)
f32 advance; f32 advance;
Vec2 size; Vec2 size;
Texture2DRef tex; G_Texture2DRef tex;
Rng2 uv; Rng2 uv;
}; };

2
src/gpu/gpu.lay
View File

@ -13,8 +13,8 @@
////////////////////////////// //////////////////////////////
//- Api //- Api
@IncludeC gpu_core.h
@IncludeC gpu_shader_core.cgh @IncludeC gpu_shader_core.cgh
@IncludeC gpu_core.h
@IncludeC gpu_common.h @IncludeC gpu_common.h
@IncludeG gpu_shader_core.cgh @IncludeG gpu_shader_core.cgh

68
src/gpu/gpu_core.h
View File

@ -430,7 +430,7 @@ Struct(G_SamplerResourceDesc)
Struct(G_RefDesc) Struct(G_RefDesc)
{ {
ShaderRefKind kind; G_RefKind kind;
u64 element_size; u64 element_size;
u64 element_offset; u64 element_offset;
@ -580,59 +580,59 @@ i32 G_CountDepth(G_ResourceHandle texture);
u32 G_PushRef(G_ArenaHandle arena, G_ResourceHandle resource, G_RefDesc desc); u32 G_PushRef(G_ArenaHandle arena, G_ResourceHandle resource, G_RefDesc desc);
#define G_PushStructuredBufferRef(arena, resource, type, ...) (StructuredBufferRef) { \ #define G_PushStructuredBufferRef(arena, resource, type, ...) (G_StructuredBufferRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \
} }
#define G_PushRWStructuredBufferRef(arena, resource, type, ...) (RWStructuredBufferRef) { \ #define G_PushRWStructuredBufferRef(arena, resource, type, ...) (G_RWStructuredBufferRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \
} }
#define G_PushByteAddressBufferRef(arena, resource, ...) (ByteAddressBufferRef) { \ #define G_PushByteAddressBufferRef(arena, resource, ...) (G_ByteAddressBufferRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_ByteAddressBuffer, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_ByteAddressBuffer, __VA_ARGS__ }) \
} }
#define G_PushRWByteAddressBufferRef(arena, resource, ...) (RWByteAddressBufferRef) { \ #define G_PushRWByteAddressBufferRef(arena, resource, ...) (G_RWByteAddressBufferRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_RWByteAddressBuffer, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_RWByteAddressBuffer, __VA_ARGS__ }) \
} }
#define G_PushTexture1DRef(arena, resource, ...) (Texture1DRef) { \ #define G_PushTexture1DRef(arena, resource, ...) (G_Texture1DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_Texture1D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_Texture1D, __VA_ARGS__ }) \
} }
#define G_PushRWTexture1DRef(arena, resource, ...) (RWTexture1DRef) { \ #define G_PushRWTexture1DRef(arena, resource, ...) (G_RWTexture1DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_RWTexture1D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_RWTexture1D, __VA_ARGS__ }) \
} }
#define G_PushTexture2DRef(arena, resource, ...) (Texture2DRef) { \ #define G_PushTexture2DRef(arena, resource, ...) (G_Texture2DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_Texture2D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_Texture2D, __VA_ARGS__ }) \
} }
#define G_PushRWTexture2DRef(arena, resource, ...) (RWTexture2DRef) { \ #define G_PushRWTexture2DRef(arena, resource, ...) (G_RWTexture2DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_RWTexture2D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_RWTexture2D, __VA_ARGS__ }) \
} }
#define G_PushTexture3DRef(arena, resource, ...) (Texture3DRef) { \ #define G_PushTexture3DRef(arena, resource, ...) (G_Texture3DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_Texture3D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_Texture3D, __VA_ARGS__ }) \
} }
#define G_PushRWTexture3DRef(arena, resource, ...) (RWTexture3DRef) { \ #define G_PushRWTexture3DRef(arena, resource, ...) (G_RWTexture3DRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_RWTexture3D, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_RWTexture3D, __VA_ARGS__ }) \
} }
#define G_PushSamplerStateRef(arena, resource, ...) (SamplerStateRef) { \ #define G_PushSamplerStateRef(arena, resource, ...) (G_SamplerStateRef) { \
.v = G_PushRef((arena), (resource), \ .v = G_PushRef((arena), (resource), \
(G_RefDesc) { .kind = ShaderRefKind_SamplerState, __VA_ARGS__ }) \ (G_RefDesc) { .kind = G_RefKind_SamplerState, __VA_ARGS__ }) \
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

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

@ -247,8 +247,8 @@ void G_Bootstrap(void)
ID3D10Blob *blob = 0; ID3D10Blob *blob = 0;
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
D3D12_ROOT_PARAMETER params[G_D12_NumShaderConstants] = ZI; D3D12_ROOT_PARAMETER params[G_D12_NumConstants] = ZI;
for (i32 slot = 0; slot < G_D12_NumShaderConstants; ++slot) for (i32 slot = 0; slot < G_D12_NumConstants; ++slot)
{ {
D3D12_ROOT_PARAMETER *param = &params[slot]; D3D12_ROOT_PARAMETER *param = &params[slot];
param->ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; param->ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
@ -1061,25 +1061,25 @@ u32 G_PushRef(G_ArenaHandle arena_handle, G_ResourceHandle resource_handle, G_Re
G_D12_Resource *resource = G_D12_ResourceFromHandle(resource_handle); G_D12_Resource *resource = G_D12_ResourceFromHandle(resource_handle);
u32 result = 0; u32 result = 0;
ShaderRefKind kind = ref_desc.kind; G_RefKind kind = ref_desc.kind;
b32 is_buffer = kind == ShaderRefKind_StructuredBuffer || b32 is_buffer = kind == G_RefKind_StructuredBuffer ||
kind == ShaderRefKind_RWStructuredBuffer || kind == G_RefKind_RWStructuredBuffer ||
kind == ShaderRefKind_ByteAddressBuffer || kind == G_RefKind_ByteAddressBuffer ||
kind == ShaderRefKind_RWByteAddressBuffer; kind == G_RefKind_RWByteAddressBuffer;
b32 is_sampler = kind == ShaderRefKind_SamplerState; b32 is_sampler = kind == G_RefKind_SamplerState;
b32 is_texture = !is_buffer && !is_sampler; b32 is_texture = !is_buffer && !is_sampler;
b32 is_raw = kind == ShaderRefKind_ByteAddressBuffer || b32 is_raw = kind == G_RefKind_ByteAddressBuffer ||
kind == ShaderRefKind_RWByteAddressBuffer; kind == G_RefKind_RWByteAddressBuffer;
b32 is_uav = kind == ShaderRefKind_RWStructuredBuffer || b32 is_uav = kind == G_RefKind_RWStructuredBuffer ||
kind == ShaderRefKind_RWByteAddressBuffer || kind == G_RefKind_RWByteAddressBuffer ||
kind == ShaderRefKind_RWTexture1D || kind == G_RefKind_RWTexture1D ||
kind == ShaderRefKind_RWTexture2D || kind == G_RefKind_RWTexture2D ||
kind == ShaderRefKind_RWTexture3D; kind == G_RefKind_RWTexture3D;
@ -1526,9 +1526,9 @@ void G_CommitCommandListEx(G_CommandListHandle cl_handle, u64 fence_ops_count, G
G_D12_Pipeline *bound_pipeline = 0; G_D12_Pipeline *bound_pipeline = 0;
/* Constants state */ /* Constants state */
u64 slotted_constants[G_D12_NumShaderConstants]; u64 slotted_constants[G_D12_NumConstants];
u64 bound_compute_constants[G_D12_NumShaderConstants]; u64 bound_compute_constants[G_D12_NumConstants];
u64 bound_graphics_constants[G_D12_NumShaderConstants]; u64 bound_graphics_constants[G_D12_NumConstants];
for (i32 i = 0; i < countof(slotted_constants); ++i) { slotted_constants[i] = 0; } /* Zero initialze all constant slots */ for (i32 i = 0; i < countof(slotted_constants); ++i) { slotted_constants[i] = 0; } /* Zero initialze all constant slots */
for (i32 i = 0; i < countof(bound_compute_constants); ++i) { bound_compute_constants[i] = U64Max; } for (i32 i = 0; i < countof(bound_compute_constants); ++i) { bound_compute_constants[i] = U64Max; }
for (i32 i = 0; i < countof(bound_graphics_constants); ++i) { bound_graphics_constants[i] = U64Max; } for (i32 i = 0; i < countof(bound_graphics_constants); ++i) { bound_graphics_constants[i] = U64Max; }

6
src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh
View File

@ -5,10 +5,10 @@
//~ Global constants //~ Global constants
/* Slots below assume they won't overlap user defined constants */ /* Slots below assume they won't overlap user defined constants */
StaticAssert(NumGeneralPurposeShaderConstants == 8); StaticAssert(G_NumGeneralPurposeConstants == 8);
ForceShaderConstant(RWByteAddressBufferRef, G_D12_DebugPrintBuff, 8); G_ForceDeclConstant(G_RWByteAddressBufferRef, G_D12_DebugPrintBuff, 8);
#define G_D12_NumShaderConstants (9) #define G_D12_NumConstants (9)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookimpl Shader printf //~ @hookimpl Shader printf

107
src/gpu/gpu_shader_core.cgh
View File

@ -1,17 +1,112 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Shared static handles (common resources available to all shaders) //~ Ref types
Enum(G_RefKind)
{
G_RefKind_StructuredBuffer,
G_RefKind_RWStructuredBuffer,
G_RefKind_ByteAddressBuffer,
G_RefKind_RWByteAddressBuffer,
G_RefKind_Texture1D,
G_RefKind_RWTexture1D,
G_RefKind_Texture2D,
G_RefKind_RWTexture2D,
G_RefKind_Texture3D,
G_RefKind_RWTexture3D,
G_RefKind_SamplerState,
};
Struct(G_StructuredBufferRef) { u32 v; };
Struct(G_RWStructuredBufferRef) { u32 v; };
Struct(G_ByteAddressBufferRef) { u32 v; };
Struct(G_RWByteAddressBufferRef) { u32 v; };
Struct(G_Texture1DRef) { u32 v; };
Struct(G_RWTexture1DRef) { u32 v; };
Struct(G_Texture2DRef) { u32 v; };
Struct(G_RWTexture2DRef) { u32 v; };
Struct(G_Texture3DRef) { u32 v; };
Struct(G_RWTexture3DRef) { u32 v; };
Struct(G_SamplerStateRef) { u32 v; };
#define G_IsRefNil(r) ((r).v == 0)
////////////////////////////////////////////////////////////
//~ Constant types
/*
* NOTE: D3d12 exposes 64 root constants, and vulkan 32 push constants.
* Other constants past the max can be used by the graphics
* implementation backend layer.
*/
#define G_NumGeneralPurposeConstants (8)
#if IsLanguageC #if IsLanguageC
#define G_SharedRef(type, v) ((type) { (v) }) #define G_ForceDeclConstant(type, name, slot) \
Enum(name##__shaderconstantenum) { name = slot }; \
Struct(name##__shaderconstanttype) { type v; }
#define G_DeclConstant(type, name, slot) \
StaticAssert(sizeof(type) <= 4); \
StaticAssert(slot < G_NumGeneralPurposeConstants); \
G_ForceDeclConstant(type, name, slot)
#elif IsLanguageG #elif IsLanguageG
#define G_SharedRef(type, v) (type(v)) #define G_ForceDeclConstant(type, name, slot) cbuffer name : register(b##slot) { type name; }
#define G_DeclConstant(type, name, slot) G_ForceDeclConstant(type, name, slot)
#endif #endif
#define G_BasicPointSampler G_SharedRef(SamplerStateRef, 1) ////////////////////////////////////////////////////////////
#define G_BasicNoiseTexture G_SharedRef(Texture3DRef, 2) //~ Resource dereference
#if IsLanguageG
/* TODO: Non-uniform resource access is assumed as the default behavior. We
* may want to add explicit "uniform" variants for optimization on AMD devices
* in the future. */
template<typename T> StructuredBuffer<T> G_StructuredBufferFromRef(G_StructuredBufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> RWStructuredBuffer<T> G_RWStructuredBufferFromRef(G_RWStructuredBufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
ByteAddressBuffer G_ByteAddressBufferFromRef(G_ByteAddressBufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
RWByteAddressBuffer G_RWByteAddressBufferFromRef(G_RWByteAddressBufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> Texture1D<T> G_Texture1DFromRef(G_Texture1DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> Texture3D<T> G_Texture3DFromRef(G_Texture3DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> RWTexture1D<T> G_RWTexture1DFromRef(G_RWTexture1DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> Texture2D<T> G_Texture2DFromRef(G_Texture2DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> RWTexture2D<T> G_RWTexture2DFromRef(G_RWTexture2DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
template<typename T> RWTexture3D<T> G_RWTexture3DFromRef(G_RWTexture3DRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v)]; }
SamplerState G_SamplerStateFromRef(G_SamplerStateRef r) { return SamplerDescriptorHeap[NonUniformResourceIndex(r.v)]; }
#endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookdecl Shader printf //~ Size helpers
#if IsLanguageG
template<typename T> u32 countof(StructuredBuffer<T> buff) { u32 result; buff.GetDimensions(result); return result; }
template<typename T> u32 countof(RWStructuredBuffer<T> buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(ByteAddressBuffer buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(RWByteAddressBuffer buff) { u32 result; buff.GetDimensions(result); return result; }
u32 countof(Texture1D tex) { u32 result; tex.GetDimensions(result); return result; }
template<typename T> u32 countof(RWTexture1D<T> tex) { u32 result; tex.GetDimensions(result); return result; }
Vec2U32 countof(Texture2D tex) { Vec2U32 result; tex.GetDimensions(result.x, result.y); return result; }
template<typename T> Vec2U32 countof(RWTexture2D<T> tex) { Vec2U32 result; tex.GetDimensions(result.x, result.y); return result; }
Vec3U32 countof(Texture3D tex) { Vec3U32 result; tex.GetDimensions(result.x, result.y, result.z); return result; }
template<typename T> Vec3U32 countof(RWTexture3D<T> tex) { Vec3U32 result; tex.GetDimensions(result.x, result.y, result.z); return result; }
#endif
////////////////////////////////////////////////////////////
//~ Static refs
#if IsLanguageC
#define G_StaticRef(type, v) ((type) { (v) })
#elif IsLanguageG
#define G_StaticRef(type, v) (type(v))
#endif
#define G_BasicPointSampler G_StaticRef(G_SamplerStateRef, 1)
#define G_BasicNoiseTexture G_StaticRef(G_Texture3DRef, 2)
////////////////////////////////////////////////////////////
//~ @hookdecl Debug printf
#if IsLanguageG #if IsLanguageG

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

@ -568,14 +568,14 @@ void V_TickForever(WaveLaneCtx *lane)
G_Layout_DirectQueue_ShaderReadWrite, G_Layout_DirectQueue_ShaderReadWrite,
.flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget .flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget
); );
Texture2DRef draw_target_ro = G_PushTexture2DRef(frame->gpu_arena, draw_target); G_Texture2DRef draw_target_ro = G_PushTexture2DRef(frame->gpu_arena, draw_target);
RWTexture2DRef draw_target_rw = G_PushRWTexture2DRef(frame->gpu_arena, draw_target); G_RWTexture2DRef draw_target_rw = G_PushRWTexture2DRef(frame->gpu_arena, draw_target);
/* Verts */ /* Verts */
G_ResourceHandle dverts_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dverts_arena)); G_ResourceHandle dverts_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dverts_arena));
G_ResourceHandle dvert_idxs_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dvert_idxs_arena)); G_ResourceHandle dvert_idxs_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dvert_idxs_arena));
StructuredBufferRef dverts_ro = G_PushStructuredBufferRef(frame->gpu_arena, dverts_buff, V_DVert); G_StructuredBufferRef dverts_ro = G_PushStructuredBufferRef(frame->gpu_arena, dverts_buff, V_DVert);
G_IndexBufferDesc dvert_idxs_ib = G_IdxBuff32(dvert_idxs_buff); G_IndexBufferDesc dvert_idxs_ib = G_IdxBuff32(dvert_idxs_buff);
/* Params */ /* Params */
V_DParams params = ZI; V_DParams params = ZI;
@ -587,7 +587,7 @@ void V_TickForever(WaveLaneCtx *lane)
params.world_to_draw_xf = world_to_draw_xf; params.world_to_draw_xf = world_to_draw_xf;
} }
G_ResourceHandle params_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params)); G_ResourceHandle params_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params));
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);
/* Constants */ /* Constants */
G_SetConstant(frame->cl, V_ShaderConst_Params, params_ro); G_SetConstant(frame->cl, V_ShaderConst_Params, params_ro);

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

@ -1,15 +1,15 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constant types //~ Constant types
ShaderConstant(StructuredBufferRef, V_ShaderConst_Params, 0); G_DeclConstant(G_StructuredBufferRef, V_ShaderConst_Params, 0);
Struct(V_DParams) Struct(V_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
Texture2DRef target_ro; G_Texture2DRef target_ro;
RWTexture2DRef target_rw; G_RWTexture2DRef target_rw;
StructuredBufferRef quads; G_StructuredBufferRef quads;
StructuredBufferRef shape_verts; G_StructuredBufferRef shape_verts;
Xform world_to_draw_xf; Xform world_to_draw_xf;
}; };

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

@ -3,8 +3,8 @@
ComputeShader2D(V_BackdropCS, 8, 8) ComputeShader2D(V_BackdropCS, 8, 8)
{ {
V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = G_StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw); RWTexture2D<Vec4> target = G_RWTexture2DFromRef<Vec4>(params.target_rw);
Vec2U32 target_pos = SV_DispatchThreadID; Vec2U32 target_pos = SV_DispatchThreadID;
Vec2I32 target_size = params.target_size; Vec2I32 target_size = params.target_size;
@ -23,9 +23,9 @@ ComputeShader2D(V_BackdropCS, 8, 8)
VertexShader(V_DQuadVS, V_DQuadPSInput) VertexShader(V_DQuadVS, V_DQuadPSInput)
{ {
V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = G_StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DQuad> quads = StructuredBufferFromRef<V_DQuad>(params.quads); StructuredBuffer<V_DQuad> quads = G_StructuredBufferFromRef<V_DQuad>(params.quads);
RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw); RWTexture2D<Vec4> target = G_RWTexture2DFromRef<Vec4>(params.target_rw);
V_DQuad quad = quads[SV_InstanceID]; V_DQuad quad = quads[SV_InstanceID];
@ -45,8 +45,8 @@ VertexShader(V_DQuadVS, V_DQuadPSInput)
PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input) PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input)
{ {
V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = G_StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DQuad> quads = StructuredBufferFromRef<V_DQuad>(params.quads); StructuredBuffer<V_DQuad> quads = G_StructuredBufferFromRef<V_DQuad>(params.quads);
V_DQuad quad = quads[input.quad_idx]; V_DQuad quad = quads[input.quad_idx];
Vec4 final_color = 0; Vec4 final_color = 0;
@ -64,9 +64,9 @@ PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input)
VertexShader(V_DVertVS, V_DVertPSInput) VertexShader(V_DVertVS, V_DVertPSInput)
{ {
V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = G_StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DVert> verts = StructuredBufferFromRef<V_DVert>(params.shape_verts); StructuredBuffer<V_DVert> verts = G_StructuredBufferFromRef<V_DVert>(params.shape_verts);
RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw); RWTexture2D<Vec4> target = G_RWTexture2DFromRef<Vec4>(params.target_rw);
V_DVert vert = verts[SV_VertexID]; V_DVert vert = verts[SV_VertexID];

6
src/proto/proto.c
View File

@ -28,13 +28,11 @@ void PT_RunForever(WaveLaneCtx *lane)
.flags = G_ResourceFlag_AllowShaderReadWrite); .flags = G_ResourceFlag_AllowShaderReadWrite);
/* Push resource handles */ /* Push resource handles */
Texture2DRef final_target_rhandle = G_PushTexture2DRef(gpu_frame_arena, final_target); G_Texture2DRef final_target_rhandle = G_PushTexture2DRef(gpu_frame_arena, final_target);
RWTexture2DRef final_target_rwhandle = G_PushRWTexture2DRef(gpu_frame_arena, final_target); G_RWTexture2DRef final_target_rwhandle = G_PushRWTexture2DRef(gpu_frame_arena, final_target);
/* Prep test pass */ /* Prep test pass */
{ {
G_SetConstant(cl, PT_ShaderConst_TestTargetWidth, final_target_size.x);
G_SetConstant(cl, PT_ShaderConst_TestTargetHeight, final_target_size.y);
G_SetConstant(cl, PT_ShaderConst_TestTarget, final_target_rwhandle); G_SetConstant(cl, PT_ShaderConst_TestTarget, final_target_rwhandle);
G_SetConstant(cl, PT_ShaderConst_TestConst, 3.123); G_SetConstant(cl, PT_ShaderConst_TestConst, 3.123);
G_SetConstant(cl, PT_ShaderConst_BlitSampler, G_BasicPointSampler); G_SetConstant(cl, PT_ShaderConst_BlitSampler, G_BasicPointSampler);

14
src/proto/proto_shaders.cgh
View File

@ -1,15 +1,13 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constants //~ Constants
ShaderConstant(Texture3DRef, PT_ShaderConst_NoiseTex, 0); G_DeclConstant(G_Texture3DRef, PT_ShaderConst_NoiseTex, 0);
/* Test shader */ /* Test shader */
ShaderConstant(i32, PT_ShaderConst_TestTargetWidth, 1); G_DeclConstant(G_RWTexture2DRef, PT_ShaderConst_TestTarget, 1);
ShaderConstant(i32, PT_ShaderConst_TestTargetHeight, 2); G_DeclConstant(G_StructuredBufferRef, PT_ShaderConst_TestBuff, 2);
ShaderConstant(RWTexture2DRef, PT_ShaderConst_TestTarget, 3); G_DeclConstant(f32, PT_ShaderConst_TestConst, 3);
ShaderConstant(StructuredBufferRef, PT_ShaderConst_TestBuff, 4);
ShaderConstant(f32, PT_ShaderConst_TestConst, 5);
/* Blit shader */ /* Blit shader */
ShaderConstant(SamplerStateRef, PT_ShaderConst_BlitSampler, 6); G_DeclConstant(G_SamplerStateRef, PT_ShaderConst_BlitSampler, 4);
ShaderConstant(Texture2DRef, PT_ShaderConst_BlitSrc, 7); G_DeclConstant(G_Texture2DRef, PT_ShaderConst_BlitSrc, 5);

12
src/proto/proto_shaders.g
View File

@ -8,10 +8,10 @@ Struct(TestStruct)
ComputeShader2D(PT_TestCS, 8, 8) ComputeShader2D(PT_TestCS, 8, 8)
{ {
StructuredBuffer<TestStruct> sb = StructuredBufferFromRef<TestStruct>(PT_ShaderConst_TestBuff); StructuredBuffer<TestStruct> sb = G_StructuredBufferFromRef<TestStruct>(PT_ShaderConst_TestBuff);
RWTexture2D<Vec4> target_tex = RWTexture2DFromRef<Vec4>(PT_ShaderConst_TestTarget); RWTexture2D<Vec4> target_tex = G_RWTexture2DFromRef<Vec4>(PT_ShaderConst_TestTarget);
Vec2U32 target_tex_size = Vec2(PT_ShaderConst_TestTargetWidth, PT_ShaderConst_TestTargetHeight ); Vec2U32 target_tex_size = countof(target_tex);
Vec2I32 id = SV_DispatchThreadID; Vec2I32 id = SV_DispatchThreadID;
if (id.x < target_tex_size.x && id.y < target_tex_size.y) if (id.x < target_tex_size.x && id.y < target_tex_size.y)
@ -51,9 +51,9 @@ VertexShader(PT_BlitVS, PT_BlitPSInput)
PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input) PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input)
{ {
SamplerState sampler = SamplerStateFromRef(PT_ShaderConst_BlitSampler); SamplerState sampler = G_SamplerStateFromRef(PT_ShaderConst_BlitSampler);
Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(PT_ShaderConst_BlitSrc); Texture2D<Vec4> tex = G_Texture2DFromRef<Vec4>(PT_ShaderConst_BlitSrc);
Texture3D<u32> noise = Texture3DFromRef<u32>(PT_ShaderConst_NoiseTex); Texture3D<u32> noise = G_Texture3DFromRef<u32>(PT_ShaderConst_NoiseTex);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 tex_col = tex.Sample(sampler, uv); Vec4 tex_col = tex.Sample(sampler, uv);

8
src/ui/ui_core.c
View File

@ -406,7 +406,7 @@ UI_Key UI_BuildBoxEx(UI_Key key)
} }
void UI_SetRawTexture(UI_Key key, Texture2DRef tex, Vec2 uv0, Vec2 uv1) void UI_SetRawTexture(UI_Key key, G_Texture2DRef tex, Vec2 uv0, Vec2 uv1)
{ {
UI_Frame *frame = UI_CurrentFrame(); UI_Frame *frame = UI_CurrentFrame();
UI_CmdNode *n = PushStruct(frame->arena, UI_CmdNode); UI_CmdNode *n = PushStruct(frame->arena, UI_CmdNode);
@ -1378,11 +1378,11 @@ void UI_EndFrame(UI_Frame *frame)
G_Layout_DirectQueue_RenderTargetWrite, G_Layout_DirectQueue_RenderTargetWrite,
.flags = G_ResourceFlag_AllowRenderTarget .flags = G_ResourceFlag_AllowRenderTarget
); );
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 */
G_ResourceHandle rects_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena)); G_ResourceHandle rects_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena));
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);
/* Params */ /* Params */
UI_DParams params = ZI; UI_DParams params = ZI;
@ -1392,7 +1392,7 @@ void UI_EndFrame(UI_Frame *frame)
params.rects = rects_ro; params.rects = rects_ro;
} }
G_ResourceHandle params_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params)); G_ResourceHandle params_buff = G_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params));
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);
/* Constants */ /* Constants */
G_SetConstant(frame->cl, UI_ShaderConst_Params, params_ro); G_SetConstant(frame->cl, UI_ShaderConst_Params, params_ro);

8
src/ui/ui_core.h
View File

@ -109,7 +109,7 @@ Enum(UI_BoxFlag)
X(Font, GC_FontKey) \ X(Font, GC_FontKey) \
X(FontSize, u32) \ X(FontSize, u32) \
X(Text, String) \ X(Text, String) \
X(BackgroundTexture, Texture2DRef) \ X(BackgroundTexture, G_Texture2DRef) \
X(BackgroundTextureUv0, Vec2) \ X(BackgroundTextureUv0, Vec2) \
X(BackgroundTextureUv1, Vec2) \ X(BackgroundTextureUv1, Vec2) \
/* --------------------------------------- */ \ /* --------------------------------------- */ \
@ -232,7 +232,7 @@ Struct(UI_Cmd)
struct struct
{ {
UI_Key key; UI_Key key;
Texture2DRef tex; G_Texture2DRef tex;
Vec2 uv0; Vec2 uv0;
Vec2 uv1; Vec2 uv1;
} set_raw_texture; } set_raw_texture;
@ -268,7 +268,7 @@ Struct(UI_Box)
//- Cmd data //- Cmd data
UI_BoxDesc desc; UI_BoxDesc desc;
Texture2DRef raw_texture; G_Texture2DRef raw_texture;
Vec2 raw_texture_uv0; Vec2 raw_texture_uv0;
Vec2 raw_texture_uv1; Vec2 raw_texture_uv1;
@ -443,7 +443,7 @@ UI_Style UI_PopStyle(UI_StyleDesc desc);
UI_Key UI_BuildBoxEx(UI_Key key); UI_Key UI_BuildBoxEx(UI_Key key);
#define UI_BuildBox() UI_BuildBoxEx(UI_TransKey()) #define UI_BuildBox() UI_BuildBoxEx(UI_TransKey())
void UI_SetRawTexture(UI_Key key, Texture2DRef tex, Vec2 uv0, Vec2 uv1); void UI_SetRawTexture(UI_Key key, G_Texture2DRef tex, Vec2 uv0, Vec2 uv1);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Report //~ Report

12
src/ui/ui_shaders.cgh
View File

@ -1,14 +1,14 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constant types //~ Constant types
ShaderConstant(StructuredBufferRef, UI_ShaderConst_Params, 0); G_DeclConstant(G_StructuredBufferRef, UI_ShaderConst_Params, 0);
ShaderConstant(b32, UI_ShaderConst_DebugDraw, 1); G_DeclConstant(b32, UI_ShaderConst_DebugDraw, 1);
Struct(UI_DParams) Struct(UI_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
Texture2DRef target_ro; G_Texture2DRef target_ro;
StructuredBufferRef rects; G_StructuredBufferRef rects;
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -25,7 +25,7 @@ Struct(UI_DRect)
f32 border; f32 border;
Vec2 tex_uv0; Vec2 tex_uv0;
Vec2 tex_uv1; Vec2 tex_uv1;
Texture2DRef tex; G_Texture2DRef tex;
f32 tl_rounding; f32 tl_rounding;
f32 tr_rounding; f32 tr_rounding;

20
src/ui/ui_shaders.g
View File

@ -6,8 +6,8 @@
VertexShader(UI_DRectVS, UI_DRectPSInput) VertexShader(UI_DRectVS, UI_DRectPSInput)
{ {
UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = G_StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
StructuredBuffer<UI_DRect> rects = StructuredBufferFromRef<UI_DRect>(params.rects); StructuredBuffer<UI_DRect> rects = G_StructuredBufferFromRef<UI_DRect>(params.rects);
UI_DRect rect = rects[SV_InstanceID]; UI_DRect rect = rects[SV_InstanceID];
Vec2 rect_uv = RectUvFromVertexId(SV_VertexID); Vec2 rect_uv = RectUvFromVertexId(SV_VertexID);
@ -31,9 +31,9 @@ VertexShader(UI_DRectVS, UI_DRectPSInput)
PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = G_StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
StructuredBuffer<UI_DRect> rects = StructuredBufferFromRef<UI_DRect>(params.rects); StructuredBuffer<UI_DRect> rects = G_StructuredBufferFromRef<UI_DRect>(params.rects);
SamplerState sampler = SamplerStateFromRef(G_BasicPointSampler); SamplerState sampler = G_SamplerStateFromRef(G_BasicPointSampler);
UI_DRect rect = rects[input.rect_idx]; UI_DRect rect = rects[input.rect_idx];
@ -91,9 +91,9 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
background_color = border_color; background_color = border_color;
} }
else if (!IsShaderRefNil(rect.tex)) else if (!G_IsRefNil(rect.tex))
{ {
Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(rect.tex); Texture2D<Vec4> tex = G_Texture2DFromRef<Vec4>(rect.tex);
background_color = tex.Sample(sampler, input.tex_uv); background_color = tex.Sample(sampler, input.tex_uv);
} }
else else
@ -138,9 +138,9 @@ VertexShader(UI_BlitVS, UI_BlitPSInput)
PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input) PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input)
{ {
UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = G_StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(params.target_ro); Texture2D<Vec4> tex = G_Texture2DFromRef<Vec4>(params.target_ro);
SamplerState sampler = SamplerStateFromRef(G_BasicPointSampler); SamplerState sampler = G_SamplerStateFromRef(G_BasicPointSampler);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 result = tex.Sample(sampler, uv); Vec4 result = tex.Sample(sampler, uv);