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

vector printf format

Browse Source
This commit is contained in:
jacob 2025-12-11 14:16:56 -06:00
parent 4453d18d51
commit eeec7e7191
11 changed files with 463 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/base/base_inc.h
View File

@ -13,13 +13,13 @@
# include "base_wave.h"
# include "base_time.h"
# include "base_uid.h"
# include "base_math.h"
# include "base_string.h"
# include "base_cmdline.h"
# include "base_log.h"
# include "base_uni.h"
# include "base_gstat.h"
# include "base_buddy.h"
# include "base_math.h"
# include "base_rand.h"
# include "base_util.h"
# include "base_bitbuff.h"

21
src/base/base_math.h
View File

@ -23,6 +23,7 @@ Enum(Axis)
//- Vec2
Struct(Vec2) { f32 x, y; };
Struct(Vec2F64) { f64 x, y; };
Struct(Vec2I32) { i32 x, y; };
Struct(Vec2I64) { i64 x, y; };
Struct(Vec2U32) { i32 x, y; };
@ -31,16 +32,23 @@ Struct(Vec2U64) { u64 x, y; };
Struct(Vec2Array) { Vec2 *points; u64 count; };
#define VEC2(x, y) (Vec2) { (x), (y) }
#define VEC2F64(x, y) (Vec2F64) { (x), (y) }
#define VEC2I32(x, y) (Vec2I32) { (x), (y) }
#define VEC2I64(x, y) (Vec2I64) { (x), (y) }
#define VEC2U32(x, y) (Vec2U32) { (x), (y) }
#define VEC2U64(x, y) (Vec2U64) { (x), (y) }
#define Vec2FromVec(v) VEC2((v).x, (v).y)
#define Vec2F64FromVec(v) VEC2F64((v).x, (v).y)
#define Vec2I32FromVec(v) VEC2I32((v).x, (v).y)
#define Vec2I64FromVec(v) VEC2I64((v).x, (v).y)
#define Vec2U32FromVec(v) VEC2U32((v).x, (v).y)
#define Vec2U64FromVec(v) VEC2U64((v).x, (v).y)
//- Vec3
Struct(Vec3) { f32 x, y, z; };
Struct(Vec3F64) { f64 x, y, z; };
Struct(Vec3I32) { i32 x, y, z; };
Struct(Vec3I64) { i64 x, y, z; };
Struct(Vec3U32) { i32 x, y, z; };
@ -49,16 +57,23 @@ Struct(Vec3U64) { u64 x, y, z; };
Struct(Vec3Array) { Vec3 *points; u64 count; };
#define VEC3(x, y, z) (Vec3) { (x), (y), (z) }
#define VEC3F64(x, y, z) (Vec3F64) { (x), (y), (z) }
#define VEC3I32(x, y, z) (Vec3I32) { (x), (y), (z) }
#define VEC3I64(x, y, z) (Vec3I64) { (x), (y), (z) }
#define VEC3U32(x, y, z) (Vec3U32) { (x), (y), (z) }
#define VEC3U64(x, y, z) (Vec3U64) { (x), (y), (z) }
#define Vec3FromVec(v) VEC3((v).x, (v).y, (v).z)
#define Vec3F64FromVec(v) VEC3F64((v).x, (v).y, (v).z)
#define Vec3I32FromVec(v) VEC3I32((v).x, (v).y, (v).z)
#define Vec3I64FromVec(v) VEC3I64((v).x, (v).y, (v).z)
#define Vec3U32FromVec(v) VEC3U32((v).x, (v).y, (v).z)
#define Vec3U64FromVec(v) VEC3U64((v).x, (v).y, (v).z)
//- Vec4
Struct(Vec4) { f32 x, y, z, w; };
Struct(Vec4F64) { f64 x, y, z, w; };
Struct(Vec4I32) { i32 x, y, z, w; };
Struct(Vec4I64) { i64 x, y, z, w; };
Struct(Vec4U32) { i32 x, y, z, w; };
@ -67,12 +82,18 @@ Struct(Vec4U64) { u64 x, y, z, w; };
Struct(Vec4Array) { Vec4 *points; u64 count; };
#define VEC4(x, y, z, w) (Vec4) { (x), (y), (z), (w) }
#define VEC4F64(x, y, z, w) (Vec4F64) { (x), (y), (z), (w) }
#define VEC4I32(x, y, z, w) (Vec4I32) { (x), (y), (z), (w) }
#define VEC4I64(x, y, z, w) (Vec4I64) { (x), (y), (z), (w) }
#define VEC4U32(x, y, z, w) (Vec4U32) { (x), (y), (z), (w) }
#define VEC4U64(x, y, z, w) (Vec4U64) { (x), (y), (z), (w) }
#define Vec4FromVec(v) VEC4((v).x, (v).y, (v).z, (v).w)
#define Vec4F64FromVec(v) VEC4F64((v).x, (v).y, (v).z, (v).w)
#define Vec4I32FromVec(v) VEC4I32((v).x, (v).y, (v).z, (v).w)
#define Vec4I64FromVec(v) VEC4I64((v).x, (v).y, (v).z, (v).w)
#define Vec4U32FromVec(v) VEC4U32((v).x, (v).y, (v).z, (v).w)
#define Vec4U64FromVec(v) VEC4U64((v).x, (v).y, (v).z, (v).w)
////////////////////////////////////////////////////////////
//~ Range types

217
src/base/base_string.c
View File

@ -2,6 +2,7 @@
//~ Conversion helpers
//- Char conversion
String StringFromChar(Arena *arena, char c)
{
u8 *dst = PushStructNoZero(arena, u8);
@ -14,85 +15,98 @@ String StringFromChar(Arena *arena, char c)
}
//- Unsigned int conversion
String StringFromU64(Arena *arena, u64 n, u64 base, u64 zfill)
String StringFromUint(Arena *arena, u64 n, u64 base, u64 zfill)
{
/* Base too large */
Assert(base <= (countof(IntChars) - 1));
String result = ZI;
TempArena scratch = BeginScratch(arena);
{
/* Build backwards text starting from least significant digit */
u64 len = 0;
u8 *backwards_text = ArenaNext(scratch.arena, u8);
do
{
StringFromChar(scratch.arena, IntChars[n % base]);
++len;
++result.len;
n /= base;
} while (n > 0);
while (len < zfill)
while (result.len < zfill)
{
StringFromChar(scratch.arena, '0');
++len;
++result.len;
}
/* Reverse text into final string */
u8 *final_text = PushStructsNoZero(arena, u8, len);
for (u64 i = 0; i < len; ++i)
result.text = PushStructsNoZero(arena, u8, result.len);
for (u64 i = 0; i < result.len; ++i)
{
final_text[i] = backwards_text[len - i - 1];
result.text[i] = backwards_text[result.len - i - 1];
}
}
EndScratch(scratch);
return result;
}
return (String)
String StringFromUints(Arena *arena, u64 uints_count, u64 *uints, u64 base, u64 zfill)
{
String result = ZI;
result.text = ArenaNext(arena, u8);
result.len += StringFromChar(arena, '(').len;
for (u64 uint_idx = 0; uint_idx < uints_count; ++uint_idx)
{
.len = len,
.text = final_text
};
result.len += StringFromUint(arena, uints[uint_idx], base, zfill).len;
if (uint_idx + 1 < uints_count)
{
result.len += PushString(arena, Lit(", ")).len;
}
}
result.len += StringFromChar(arena, ')').len;
return result;
}
//- Signed int conversion
String StringFromI64(Arena *arena, i64 n, u64 base, u64 zfill)
String StringFromSint(Arena *arena, i64 n, u64 base, u64 zfill)
{
u8 *final_text = ArenaNext(arena, u8);
u8 len = 0;
String result = ZI;
result.text = ArenaNext(arena, u8);
if (n < 0)
{
/* Push sign */
StringFromChar(arena, '-');
len = 1;
result.len += StringFromChar(arena, '-').len;
n = -n;
}
/* Push unsigned number */
String uint_str = StringFromU64(arena, n, base, zfill);
return (String)
{
.len = len + uint_str.len,
.text = final_text
};
result.len += StringFromUint(arena, (u64)n, base, zfill).len;
return result;
}
//- Pointer conversion
String StringFromPtr(Arena *arena, void *ptr)
String StringFromSints(Arena *arena, u64 sints_count, i64 *sints, u64 base, u64 zfill)
{
String prepend = PushString(arena, Lit("0x"));
String uint_str = StringFromU64(arena, (u64)ptr, 16, sizeof(ptr));
return (String)
String result = ZI;
result.text = ArenaNext(arena, u8);
result.len += StringFromChar(arena, '(').len;
for (u64 sint_idx = 0; sint_idx < sints_count; ++sint_idx)
{
.len = prepend.len + uint_str.len,
.text = prepend.text
};
result.len += StringFromSint(arena, sints[sint_idx], base, zfill).len;
if (sint_idx + 1 < sints_count)
{
result.len += PushString(arena, Lit(", ")).len;
}
}
result.len += StringFromChar(arena, ')').len;
return result;
}
//- Floating point conversion
String StringFromF64(Arena *arena, f64 f, u32 precision)
String StringFromFloat(Arena *arena, f64 f, u32 precision)
{
TempArena scratch = BeginScratch(arena);
String result = ZI;
result.text = ArenaNext(arena, u8);
TempArena scratch = BeginScratch(arena);
{
if (IsF32Nan(f))
{
result.len += PushString(arena, Lit("NaN")).len;
@ -155,29 +169,61 @@ String StringFromF64(Arena *arena, f64 f, u32 precision)
result.len += (u64)precision + 1;
}
}
}
EndScratch(scratch);
return result;
}
String StringFromFloats(Arena *arena, u64 floats_count, f64 *floats, u32 precision)
{
String result = ZI;
result.text = ArenaNext(arena, u8);
result.len += StringFromChar(arena, '(').len;
for (u64 float_idx = 0; float_idx < floats_count; ++float_idx)
{
result.len += StringFromFloat(arena, floats[float_idx], precision).len;
if (float_idx + 1 < floats_count)
{
result.len += PushString(arena, Lit(", ")).len;
}
}
result.len += StringFromChar(arena, ')').len;
return result;
}
//- Pointer conversion
String StringFromPtr(Arena *arena, void *ptr)
{
String prepend = PushString(arena, Lit("0x"));
String uint_str = StringFromUint(arena, (u64)ptr, 16, sizeof(ptr));
return (String)
{
.len = prepend.len + uint_str.len,
.text = prepend.text
};
}
//- Handle conversion
String StringFromhandle(Arena *arena, u64 v0, u64 v1)
{
String result = ZI;
result.text = ArenaNext(arena, u8);
result.len += PushString(arena, Lit("h")).len;
result.len += StringFromU64(arena, v0, 16, 0).len;
result.len += StringFromUint(arena, v0, 16, 0).len;
result.len += PushString(arena, Lit("x")).len;
result.len += StringFromU64(arena, v1, 16, 0).len;
result.len += StringFromUint(arena, v1, 16, 0).len;
return result;
}
//- Uid conversion
String StringFromUid(Arena *arena, Uid uid)
{
String result = ZI;
result.text = ArenaNext(arena, u8);
result.len += StringFromU64(arena, (uid.hi >> 32), 16, 8).len;
result.len += StringFromUint(arena, (uid.hi >> 32), 16, 8).len;
return result;
}
@ -189,15 +235,14 @@ String StringFromUid(Arena *arena, Uid uid)
String PushString(Arena *arena, String src)
{
String str = {
.len = src.len,
.text = PushStructsNoZero(arena, u8, src.len)
};
CopyBytes(str.text, src.text, src.len);
return str;
String result = ZI;
result.len = src.len;
result.text = PushStructsNoZero(arena, u8, src.len);
CopyBytes(result.text, src.text, src.len);
return result;
}
String PushStringToBuff(String dst, String src)
String CopyString(String dst, String src)
{
String result = ZI;
result.len = MinU64(dst.len, src.len);
@ -588,17 +633,67 @@ String FormatString(Arena *arena, String fmt, FmtArgArray args)
case FmtArgKind_Uint:
{
parsed_arg = StringFromU64(arena, arg.value.uint, 10, arg.z);
parsed_arg = StringFromUint(arena, arg.value.uints.x, 10, arg.z);
} break;
case FmtArgKind_Uint2:
{
parsed_arg = StringFromUints(arena, 2, &arg.value.uints.x, 10, arg.z);
} break;
case FmtArgKind_Uint3:
{
parsed_arg = StringFromUints(arena, 3, &arg.value.uints.x, 10, arg.z);
} break;
case FmtArgKind_Uint4:
{
parsed_arg = StringFromUints(arena, 4, &arg.value.uints.x, 10, arg.z);
} break;
case FmtArgKind_Sint:
{
parsed_arg = StringFromI64(arena, arg.value.sint, 10, arg.z);
parsed_arg = StringFromSint(arena, arg.value.sints.x, 10, arg.z);
} break;
case FmtArgKind_Sint2:
{
parsed_arg = StringFromSints(arena, 2, &arg.value.sints.x, 10, arg.z);
} break;
case FmtArgKind_Sint3:
{
parsed_arg = StringFromSints(arena, 3, &arg.value.sints.x, 10, arg.z);
} break;
case FmtArgKind_Sint4:
{
parsed_arg = StringFromSints(arena, 4, &arg.value.sints.x, 10, arg.z);
} break;
case FmtArgKind_Float:
{
parsed_arg = StringFromFloat(arena, arg.value.floats.x, arg.p);
} break;
case FmtArgKind_Float2:
{
parsed_arg = StringFromFloats(arena, 2, &arg.value.floats.x, arg.p);
} break;
case FmtArgKind_Float3:
{
parsed_arg = StringFromFloats(arena, 3, &arg.value.floats.x, arg.p);
} break;
case FmtArgKind_Float4:
{
parsed_arg = StringFromFloats(arena, 4, &arg.value.floats.x, arg.p);
} break;
case FmtArgKind_Hex:
{
parsed_arg = StringFromU64(arena, arg.value.sint, 16, arg.z);
parsed_arg = StringFromUint(arena, arg.value.uints.x, 16, arg.z);
} break;
case FmtArgKind_Ptr:
@ -606,11 +701,6 @@ String FormatString(Arena *arena, String fmt, FmtArgArray args)
parsed_arg = StringFromPtr(arena, arg.value.ptr);
} break;
case FmtArgKind_Float:
{
parsed_arg = StringFromF64(arena, arg.value.f, arg.p);
} break;
case FmtArgKind_Handle:
{
parsed_arg = StringFromhandle(arena, arg.value.handle.h64[0], arg.value.handle.h64[1]);
@ -689,17 +779,26 @@ FmtArgArray FmtArgsFromVaList(Arena *arena, va_list args)
{
default:
{
/* Last arg reached */
/* End/Invalid arg reached */
done = 1;
} break;
case FmtArgKind_Char:
case FmtArgKind_String:
case FmtArgKind_Uint:
case FmtArgKind_Uint2:
case FmtArgKind_Uint3:
case FmtArgKind_Uint4:
case FmtArgKind_Sint:
case FmtArgKind_Sint2:
case FmtArgKind_Sint3:
case FmtArgKind_Sint4:
case FmtArgKind_Float:
case FmtArgKind_Float2:
case FmtArgKind_Float3:
case FmtArgKind_Float4:
case FmtArgKind_Hex:
case FmtArgKind_Ptr:
case FmtArgKind_Float:
case FmtArgKind_Uid:
case FmtArgKind_Handle:
{

71
src/base/base_string.h
View File

@ -9,17 +9,30 @@ Enum(FmtArgKind)
FmtArgKind_None,
/* Arbitrary magic numbers for argument validation */
FmtArgKind_Char = 0x0f5281df,
FmtArgKind_String = 0x0a5ffa9a,
FmtArgKind_Uint = 0x0746f19b,
FmtArgKind_Sint = 0x08603694,
FmtArgKind_Hex = 0x0a3d0792,
FmtArgKind_Ptr = 0x0c4519e4,
FmtArgKind_Float = 0x04814143,
FmtArgKind_Uid = 0x3d1cd407,
FmtArgKind_Handle = 0x6ead3bec,
FmtArgKind_Char = 0xf5281df,
FmtArgKind_String = 0xa5ffa9a,
FmtArgKind_End = 0x0ecbc5ae
FmtArgKind_Uint = 0x746f19b,
FmtArgKind_Uint2 = 0x83429d9,
FmtArgKind_Uint3 = 0x1b4b749,
FmtArgKind_Uint4 = 0xf8eb3cf,
FmtArgKind_Sint = 0x8603694,
FmtArgKind_Sint2 = 0x335a803,
FmtArgKind_Sint3 = 0xe5e4ab1,
FmtArgKind_Sint4 = 0xe1fd7ad,
FmtArgKind_Float = 0x4814143,
FmtArgKind_Float2 = 0x4260065,
FmtArgKind_Float3 = 0x0d28ab7,
FmtArgKind_Float4 = 0x76fe314,
FmtArgKind_Hex = 0xa3d0792,
FmtArgKind_Ptr = 0xc4519e4,
FmtArgKind_Uid = 0xd1cd407,
FmtArgKind_Handle = 0xead3bec,
FmtArgKind_End = 0xecbc5ae
};
Struct(FmtArg)
@ -31,10 +44,10 @@ Struct(FmtArg)
{
u8 c;
String string;
u64 uint;
i64 sint;
Vec4U64 uints;
Vec4I64 sints;
Vec4F64 floats;
void *ptr;
f64 f;
Uid uid;
struct
{
@ -65,10 +78,11 @@ Struct(CodepointIter)
//~ Conversion helpers
String StringFromChar(Arena *arena, char c);
String StringFromU64(Arena *arena, u64 n, u64 base, u64 zfill);
String StringFromI64(Arena *arena, i64 n, u64 base, u64 zfill);
String StringFromUint(Arena *arena, u64 n, u64 base, u64 zfill);
String StringFromUints(Arena *arena, u64 uints_count, u64 *uints, u64 base, u64 zfill);
String StringFromSint(Arena *arena, i64 n, u64 base, u64 zfill);
String StringFromFloat(Arena *arena, f64 f, u32 precision);
String StringFromPtr(Arena *arena, void *ptr);
String StringFromF64(Arena *arena, f64 f, u32 precision);
String StringFromhandle(Arena *arena, u64 v0, u64 v1);
String StringFromUid(Arena *arena, Uid uid);
@ -76,7 +90,7 @@ String StringFromUid(Arena *arena, Uid uid);
//~ String helpers
String PushString(Arena *arena, String src);
String PushStringToBuff(String dst, String src);
String CopyString(String dst, String src);
String RepeatString(Arena *arena, String src, u64 count);
String CatString(Arena *arena, String str1, String str2);
StringArray SplitString(Arena *arena, String str, String delim);
@ -108,13 +122,28 @@ String StringFromList(Arena *arena, StringList l, String separator);
#define FmtChar(v, ...) FMTARG(FmtArgKind_Char, .value.c = (v), __VA_ARGS__)
#define FmtString(v, ...) FMTARG(FmtArgKind_String, .value.string = (v), __VA_ARGS__)
#define FmtUint(v, ...) FMTARG(FmtArgKind_Uint, .value.uint = (v), __VA_ARGS__)
#define FmtSint(v, ...) FMTARG(FmtArgKind_Sint, .value.sint = (v), __VA_ARGS__)
#define FmtHex(v, ...) FMTARG(FmtArgKind_Hex, .value.uint = (v), __VA_ARGS__)
#define FmtUint(v, ...) FMTARG(FmtArgKind_Uint, .value.uints = VEC4U64((v), 0, 0, 0), __VA_ARGS__)
#define FmtUint2(v, ...) FMTARG(FmtArgKind_Uint2, .value.uints = VEC4U64((v).x, (v).y, 0, 0), __VA_ARGS__)
#define FmtUint3(v, ...) FMTARG(FmtArgKind_Uint3, .value.uints = VEC4U64((v).x, (v).y, (v).z, 0), __VA_ARGS__)
#define FmtUint4(v, ...) FMTARG(FmtArgKind_Uint4, .value.uints = VEC4U64((v).x, (v).y, (v).z, (v).w), __VA_ARGS__)
#define FmtSint(v, ...) FMTARG(FmtArgKind_Sint, .value.sints = VEC4I64((v), 0, 0, 0), __VA_ARGS__)
#define FmtSint2(v, ...) FMTARG(FmtArgKind_Sint2, .value.sints = VEC4I64((v).x, (v).y, 0, 0), __VA_ARGS__)
#define FmtSint3(v, ...) FMTARG(FmtArgKind_Sint3, .value.sints = VEC4I64((v).x, (v).y, (v).z, 0), __VA_ARGS__)
#define FmtSint4(v, ...) FMTARG(FmtArgKind_Sint4, .value.sints = VEC4I64((v).x, (v).y, (v).z, (v).w), __VA_ARGS__)
#define FmtFloat(v, ...) FMTARG(FmtArgKind_Float, .value.floats = VEC4F64((v), 0, 0, 0), __VA_ARGS__)
#define FmtFloat2(v, ...) FMTARG(FmtArgKind_Float2, .value.floats = VEC4F64((v).x, (v).y, 0, 0), __VA_ARGS__)
#define FmtFloat3(v, ...) FMTARG(FmtArgKind_Float3, .value.floats = VEC4F64((v).x, (v).y, (v).z, 0), __VA_ARGS__)
#define FmtFloat4(v, ...) FMTARG(FmtArgKind_Float4, .value.floats = VEC4F64((v).x, (v).y, (v).z, (v).w), __VA_ARGS__)
#define FmtHex(v, ...) FMTARG(FmtArgKind_Hex, .value.uints.x = (v), __VA_ARGS__)
#define FmtPtr(v, ...) FMTARG(FmtArgKind_Ptr, .value.ptr = (v), __VA_ARGS__)
#define FmtFloat(v, ...) FMTARG(FmtArgKind_Float, .value.f = (v), __VA_ARGS__)
#define FmtHandle(v, ...) FMTARG(FmtArgKind_Handle, .value.handle.h64[0] = (v).idx, .value.handle.h64[1] = (v).gen, __VA_ARGS__)
#define FmtUid(v, ...) FMTARG(FmtArgKind_Uid, .value.uid = (v), __VA_ARGS__)
#define FmtEnd FMTARG(FmtArgKind_End) /* Denotes end of VA list */
String FormatString(Arena *arena, String fmt, FmtArgArray args);

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

@ -2925,27 +2925,86 @@ void G_D12_CollectionWorkerEntry(WaveLaneCtx *lane)
G_FmtArgKind gpu_kind = (G_FmtArgKind)(*at);
at += 1;
u32 gpu_value = *(u32 *)at;
at += 4;
FmtArg *dst = &args.args[arg_idx];
switch (gpu_kind)
{
case G_FmtArgKind_U32:
/* Translate unsigned args */
case G_FmtArgKind_Uint:
{
dst->kind = FmtArgKind_Uint;
dst->value.uint = gpu_value;
u32 gpu_value = *(u32 *)at;
*dst = FmtUint(gpu_value);
at += 4;
} break;
case G_FmtArgKind_I32:
case G_FmtArgKind_Uint2:
{
dst->kind = FmtArgKind_Sint;
dst->value.sint = (i32)gpu_value;
Vec2U32 gpu_value = *(Vec2U32 *)at;
*dst = FmtUint2(gpu_value);
at += 8;
} break;
case G_FmtArgKind_F32:
case G_FmtArgKind_Uint3:
{
dst->kind = FmtArgKind_Float;
dst->value.f = *(f32 *)&gpu_value;
dst->p = 6;
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 */
case G_FmtArgKind_Sint:
{
i32 gpu_value = *(i32 *)at;
*dst = FmtSint(gpu_value);
at += 4;
} break;
case G_FmtArgKind_Sint2:
{
Vec2I32 gpu_value = *(Vec2I32 *)at;
*dst = FmtSint2(gpu_value);
at += 8;
} break;
case G_FmtArgKind_Sint3:
{
Vec3I32 gpu_value = *(Vec3I32 *)at;
*dst = FmtSint3(gpu_value);
at += 12;
} break;
case G_FmtArgKind_Sint4:
{
Vec4I32 gpu_value = *(Vec4I32 *)at;
*dst = FmtSint4(gpu_value);
at += 16;
} 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;
}
}

87
src/gpu/gpu_shader_core.cgh
View File

@ -112,24 +112,56 @@ G_ForceDeclConstant(G_RWByteAddressBufferRef, G_ShaderConst_PrintBufferRef, 8)
Enum(G_FmtArgKind)
{
G_FmtArgKind_None,
G_FmtArgKind_U32,
G_FmtArgKind_I32,
G_FmtArgKind_F32,
G_FmtArgKind_End,
G_FmtArgKind_BEGINSIZE1,
G_FmtArgKind_Uint,
G_FmtArgKind_Sint,
G_FmtArgKind_Float,
G_FmtArgKind_BEGINSIZE2,
G_FmtArgKind_Uint2,
G_FmtArgKind_Sint2,
G_FmtArgKind_Float2,
G_FmtArgKind_BEGINSIZE3,
G_FmtArgKind_Uint3,
G_FmtArgKind_Sint3,
G_FmtArgKind_Float3,
G_FmtArgKind_BEGINSIZE4,
G_FmtArgKind_Uint4,
G_FmtArgKind_Sint4,
G_FmtArgKind_Float4,
};
Struct(G_FmtArg)
{
G_FmtArgKind kind;
u32 v;
Vec4U32 v;
};
#if IsLanguageG && GPU_SHADER_PRINT
G_FmtArg G_Fmt(u32 v) { G_FmtArg result; result.kind = G_FmtArgKind_U32; result.v = v; return result; }
G_FmtArg G_Fmt(i32 v) { G_FmtArg result; result.kind = G_FmtArgKind_I32; result.v = v; return result; }
G_FmtArg G_Fmt(f32 v) { G_FmtArg result; result.kind = G_FmtArgKind_F32; result.v = asuint(v); return result; }
G_FmtArg G_FmtEnd(void) { G_FmtArg result; result.kind = G_FmtArgKind_End; result.v = 0; return result; }
G_FmtArg G_Fmt(u32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Uint; result.v.x = v; return result; }
G_FmtArg G_Fmt(Vec2U32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Uint2; result.v.xy = v.xy; return result; }
G_FmtArg G_Fmt(Vec3U32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Uint3; result.v.xyz = v.xyz; return result; }
G_FmtArg G_Fmt(Vec4U32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Uint4; result.v.xyzw = v.xyzw; return result; }
G_FmtArg G_Fmt(i32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Sint; result.v.x = v; return result; }
G_FmtArg G_Fmt(Vec2I32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Sint2; result.v.xy = v.xy; return result; }
G_FmtArg G_Fmt(Vec3I32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Sint3; result.v.xyz = v.xyz; return result; }
G_FmtArg G_Fmt(Vec4I32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Sint4; result.v.xyzw = v.xyzw; return result; }
G_FmtArg G_Fmt(f32 v) { G_FmtArg result; result.kind = G_FmtArgKind_Float; result.v.x = asuint(v); return result; }
G_FmtArg G_Fmt(Vec2 v) { G_FmtArg result; result.kind = G_FmtArgKind_Float2; result.v.xy = asuint(v.xy); return result; }
G_FmtArg G_Fmt(Vec3 v) { G_FmtArg result; result.kind = G_FmtArgKind_Float3; result.v.xyz = asuint(v.xyz); return result; }
G_FmtArg G_Fmt(Vec4 v) { G_FmtArg result; result.kind = G_FmtArgKind_Float4; result.v.xyzw = asuint(v.xyzw); return result; }
G_FmtArg G_FmtEnd(void) { G_FmtArg result; result.kind = G_FmtArgKind_End; return result; }
Struct(G_TempPrintBuffer)
{
@ -229,15 +261,40 @@ Struct(G_FmtArg)
++__char_idx; \
} \
G_FmtArg __args[] = { __VA_ARGS__ }; \
__tmp.chars_count = __tmp.bytes_count; \
__tmp.chars_count = __char_idx; \
__tmp.args_count = (countof(__args) - 1); \
for (u32 __arg_idx = 0; __arg_idx < __tmp.args_count; ++__arg_idx) \
{ \
G_PushPrintByte(__tmp, __args[__arg_idx].kind); \
G_PushPrintByte(__tmp, __args[__arg_idx].v >> 0); \
G_PushPrintByte(__tmp, __args[__arg_idx].v >> 8); \
G_PushPrintByte(__tmp, __args[__arg_idx].v >> 16); \
G_PushPrintByte(__tmp, __args[__arg_idx].v >> 24); \
G_FmtArg __arg = __args[__arg_idx]; \
G_PushPrintByte(__tmp, __arg.kind); \
if (__arg.kind > G_FmtArgKind_BEGINSIZE1) \
{ \
G_PushPrintByte(__tmp, __arg.v.x >> 0); \
G_PushPrintByte(__tmp, __arg.v.x >> 8); \
G_PushPrintByte(__tmp, __arg.v.x >> 16); \
G_PushPrintByte(__tmp, __arg.v.x >> 24); \
} \
if (__arg.kind > G_FmtArgKind_BEGINSIZE2) \
{ \
G_PushPrintByte(__tmp, __arg.v.y >> 0); \
G_PushPrintByte(__tmp, __arg.v.y >> 8); \
G_PushPrintByte(__tmp, __arg.v.y >> 16); \
G_PushPrintByte(__tmp, __arg.v.y >> 24); \
} \
if (__arg.kind > G_FmtArgKind_BEGINSIZE3) \
{ \
G_PushPrintByte(__tmp, __arg.v.z >> 0); \
G_PushPrintByte(__tmp, __arg.v.z >> 8); \
G_PushPrintByte(__tmp, __arg.v.z >> 16); \
G_PushPrintByte(__tmp, __arg.v.z >> 24); \
} \
if (__arg.kind > G_FmtArgKind_BEGINSIZE4) \
{ \
G_PushPrintByte(__tmp, __arg.v.w >> 0); \
G_PushPrintByte(__tmp, __arg.v.w >> 8); \
G_PushPrintByte(__tmp, __arg.v.w >> 16); \
G_PushPrintByte(__tmp, __arg.v.w >> 24); \
} \
} \
G_CommitPrint(__tmp); \
} while (0)

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

@ -35,7 +35,7 @@ VertexShader(V_DQuadVS, V_DQuadPSInput)
Vec2 target_pos = 0;
V_DQuadPSInput result;
result.SV_Position = Vec4(NdcFromPos(target_pos, countof(target)).xy, 0, 1);
result.sv_position = Vec4(NdcFromPos(target_pos, countof(target)).xy, 0, 1);
result.quad_idx = SV_InstanceID;
return result;
}
@ -73,7 +73,7 @@ VertexShader(V_DVertVS, V_DVertPSInput)
Vec2 target_pos = vert.pos;
V_DVertPSInput result;
result.SV_Position = Vec4(NdcFromPos(target_pos, countof(target)).xy, 0, 1);
result.sv_position = Vec4(NdcFromPos(target_pos, countof(target)).xy, 0, 1);
result.color_lin = vert.color_lin;
return result;
}

4
src/pp/pp_vis/pp_vis_shaders.gh
View File

@ -3,7 +3,7 @@
Struct(V_DQuadPSInput)
{
Semantic(Vec4, SV_Position);
Semantic(Vec4, sv_position);
Semantic(nointerpolation u32, quad_idx);
};
@ -18,7 +18,7 @@ Struct(V_DQuadPSOutput)
Struct(V_DVertPSInput)
{
Semantic(Vec4, SV_Position);
Semantic(Vec4, sv_position);
Semantic(Vec4, color_lin);
};

4
src/proto/proto_shaders.g
View File

@ -25,7 +25,7 @@ ComputeShader2D(PT_TestCS, 8, 8)
Struct(PT_BlitPSInput)
{
Semantic(Vec4, SV_Position);
Semantic(Vec4, sv_position);
Semantic(Vec2, src_uv);
};
@ -41,7 +41,7 @@ VertexShader(PT_BlitVS, PT_BlitPSInput)
{
Vec2 uv = RectUvFromVertexId(SV_VertexID);
PT_BlitPSInput result;
result.SV_Position = Vec4(NdcFromUv(uv).xy, 0, 1);
result.sv_position = Vec4(NdcFromUv(uv).xy, 0, 1);
result.src_uv = uv;
return result;
}

10
src/ui/ui_shaders.g
View File

@ -128,7 +128,7 @@ VertexShader(UI_BlitVS, UI_BlitPSInput)
{
Vec2 uv = RectUvFromVertexId(SV_VertexID);
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;
return result;
}
@ -146,11 +146,9 @@ PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input)
Vec4 result = tex.Sample(sampler, uv);
G_PrintF(
"Hello there! (%F, %F), (%F, %F)",
G_Fmt(input.SV_Position.x),
G_Fmt(input.SV_Position.y),
G_Fmt(uv.x),
G_Fmt(uv.y)
"Bla: %F %F",
G_Fmt(input.sv_position),
G_Fmt(uv)
);
UI_BlitPSOutput output;

2
src/ui/ui_shaders.gh
View File

@ -22,7 +22,7 @@ Struct(UI_DRectPSOutput)
Struct(UI_BlitPSInput)
{
Semantic(Vec4, SV_Position);
Semantic(Vec4, sv_position);
Semantic(Vec2, src_uv);
};