diff --git a/src/base/base_inc.h b/src/base/base_inc.h index ae155bad..f8cc1737 100644 --- a/src/base/base_inc.h +++ b/src/base/base_inc.h @@ -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" diff --git a/src/base/base_math.h b/src/base/base_math.h index 92968740..8ad9aec4 100644 --- a/src/base/base_math.h +++ b/src/base/base_math.h @@ -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 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 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 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 diff --git a/src/base/base_string.c b/src/base/base_string.c index 1ef8f07a..439ef29f 100644 --- a/src/base/base_string.c +++ b/src/base/base_string.c @@ -2,6 +2,7 @@ //~ Conversion helpers //- Char conversion + String StringFromChar(Arena *arena, char c) { u8 *dst = PushStructNoZero(arena, u8); @@ -14,71 +15,188 @@ 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; - n /= base; - } while (n > 0); + /* Build backwards text starting from least significant digit */ + u8 *backwards_text = ArenaNext(scratch.arena, u8); + do + { + StringFromChar(scratch.arena, IntChars[n % base]); + ++result.len; + n /= base; + } while (n > 0); + + while (result.len < zfill) + { + StringFromChar(scratch.arena, '0'); + ++result.len; + } + + /* Reverse text into final string */ + result.text = PushStructsNoZero(arena, u8, result.len); + for (u64 i = 0; i < result.len; ++i) + { + result.text[i] = backwards_text[result.len - i - 1]; + } - while (len < zfill) - { - StringFromChar(scratch.arena, '0'); - ++len; } - - /* Reverse text into final string */ - u8 *final_text = PushStructsNoZero(arena, u8, len); - for (u64 i = 0; i < len; ++i) - { - final_text[i] = backwards_text[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) + result.len += StringFromUint(arena, (u64)n, base, zfill).len; + return result; +} + +String StringFromSints(Arena *arena, u64 sints_count, i64 *sints, u64 base, u64 zfill) +{ + 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 = len + uint_str.len, - .text = final_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 StringFromFloat(Arena *arena, f64 f, u32 precision) +{ + String result = ZI; + result.text = ArenaNext(arena, u8); + TempArena scratch = BeginScratch(arena); + { + if (IsF32Nan(f)) + { + result.len += PushString(arena, Lit("NaN")).len; + } + else if (f == F64Infinity) + { + result.len += PushString(arena, Lit("inf")).len; + } + else if (f == -F64Infinity) + { + result.len += PushString(arena, Lit("-inf")).len; + } + else + { + if (f < 0) + { + StringFromChar(arena, '-'); + f = -f; + ++result.len; + } + + /* Add one half of next precision level to round up */ + f += 0.5 / (f64)PowU64(10, (u8)precision); + + f64 part_whole = TruncF64(f); + f64 part_decimal = f - part_whole; + + /* Print whole part */ + { + /* Build backwards text starting from least significant digit */ + u8 *backwards_text = ArenaNext(scratch.arena, u8); + u64 backwards_text_len = 0; + do + { + u64 digit = (u64)RoundF64ToI64(ModF64(part_whole, 10.0)); + StringFromChar(scratch.arena, IntChars[digit % 10]); + ++backwards_text_len; + part_whole = TruncF64(part_whole / 10.0); + } while (part_whole > 0); + + /* Reverse text into final string */ + PushStructsNoZero(arena, u8, backwards_text_len); + for (u64 i = backwards_text_len; i-- > 0;) + { + result.text[result.len++] = backwards_text[i]; + } + } + + /* Print decimal part */ + if (precision > 0) + { + StringFromChar(arena, '.'); + for (u64 i = 0; i < precision; ++i) + { + part_decimal *= 10.0; + u64 digit = (u64)part_decimal; + part_decimal -= digit; + StringFromChar(arena, IntChars[digit % 10]); + } + 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 = StringFromU64(arena, (u64)ptr, 16, sizeof(ptr)); + String uint_str = StringFromUint(arena, (u64)ptr, 16, sizeof(ptr)); return (String) { .len = prepend.len + uint_str.len, @@ -86,98 +204,26 @@ String StringFromPtr(Arena *arena, void *ptr) }; } -//- Floating point conversion -String StringFromF64(Arena *arena, f64 f, u32 precision) -{ - TempArena scratch = BeginScratch(arena); - String result = ZI; - result.text = ArenaNext(arena, u8); - - if (IsF32Nan(f)) - { - result.len += PushString(arena, Lit("NaN")).len; - } - else if (f == F64Infinity) - { - result.len += PushString(arena, Lit("inf")).len; - } - else if (f == -F64Infinity) - { - result.len += PushString(arena, Lit("-inf")).len; - } - else - { - if (f < 0) - { - StringFromChar(arena, '-'); - f = -f; - ++result.len; - } - - /* Add one half of next precision level to round up */ - f += 0.5 / (f64)PowU64(10, (u8)precision); - - f64 part_whole = TruncF64(f); - f64 part_decimal = f - part_whole; - - /* Print whole part */ - { - /* Build backwards text starting from least significant digit */ - u8 *backwards_text = ArenaNext(scratch.arena, u8); - u64 backwards_text_len = 0; - do - { - u64 digit = (u64)RoundF64ToI64(ModF64(part_whole, 10.0)); - StringFromChar(scratch.arena, IntChars[digit % 10]); - ++backwards_text_len; - part_whole = TruncF64(part_whole / 10.0); - } while (part_whole > 0); - - /* Reverse text into final string */ - PushStructsNoZero(arena, u8, backwards_text_len); - for (u64 i = backwards_text_len; i-- > 0;) - { - result.text[result.len++] = backwards_text[i]; - } - } - - /* Print decimal part */ - if (precision > 0) - { - StringFromChar(arena, '.'); - for (u64 i = 0; i < precision; ++i) - { - part_decimal *= 10.0; - u64 digit = (u64)part_decimal; - part_decimal -= digit; - StringFromChar(arena, IntChars[digit % 10]); - } - result.len += (u64)precision + 1; - } - } - - EndScratch(scratch); - return result; -} - //- 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: { diff --git a/src/base/base_string.h b/src/base/base_string.h index 2fb13664..cf8da08e 100644 --- a/src/base/base_string.h +++ b/src/base/base_string.h @@ -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); diff --git a/src/gpu/gpu_dx12/gpu_dx12_core.c b/src/gpu/gpu_dx12/gpu_dx12_core.c index a6912cff..9b6d49d1 100644 --- a/src/gpu/gpu_dx12/gpu_dx12_core.c +++ b/src/gpu/gpu_dx12/gpu_dx12_core.c @@ -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; } } diff --git a/src/gpu/gpu_shader_core.cgh b/src/gpu/gpu_shader_core.cgh index 81de7a12..42c38264 100644 --- a/src/gpu/gpu_shader_core.cgh +++ b/src/gpu/gpu_shader_core.cgh @@ -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) diff --git a/src/pp/pp_vis/pp_vis_shaders.g b/src/pp/pp_vis/pp_vis_shaders.g index 6d628cd1..67f3baad 100644 --- a/src/pp/pp_vis/pp_vis_shaders.g +++ b/src/pp/pp_vis/pp_vis_shaders.g @@ -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; } diff --git a/src/pp/pp_vis/pp_vis_shaders.gh b/src/pp/pp_vis/pp_vis_shaders.gh index db69f89c..3fcbcf64 100644 --- a/src/pp/pp_vis/pp_vis_shaders.gh +++ b/src/pp/pp_vis/pp_vis_shaders.gh @@ -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); }; diff --git a/src/proto/proto_shaders.g b/src/proto/proto_shaders.g index e1c0f93c..7a52dba1 100644 --- a/src/proto/proto_shaders.g +++ b/src/proto/proto_shaders.g @@ -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; } diff --git a/src/ui/ui_shaders.g b/src/ui/ui_shaders.g index 4c60fbc1..db6e507d 100644 --- a/src/ui/ui_shaders.g +++ b/src/ui/ui_shaders.g @@ -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; diff --git a/src/ui/ui_shaders.gh b/src/ui/ui_shaders.gh index 88905e5c..74fefbbc 100644 --- a/src/ui/ui_shaders.gh +++ b/src/ui/ui_shaders.gh @@ -22,7 +22,7 @@ Struct(UI_DRectPSOutput) Struct(UI_BlitPSInput) { - Semantic(Vec4, SV_Position); + Semantic(Vec4, sv_position); Semantic(Vec2, src_uv); };