vector printf format

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"

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 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

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,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);
+        result.text = PushStructsNoZero(arena, u8, result.len);
-    for (u64 i = 0; i < len; ++i)
+        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,
+        result.len += StringFromUint(arena, uints[uint_idx], base, zfill).len;
-        .text = final_text
+        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);
+    String result = ZI;
-    u8 len = 0;
+    result.text = ArenaNext(arena, u8);
     if (n < 0)
     {
-        /* Push sign */
+        result.len += StringFromChar(arena, '-').len;
-        StringFromChar(arena, '-');
-        len = 1;
         n = -n;
     }
-    /* Push unsigned number */
+    result.len += StringFromUint(arena, (u64)n, base, zfill).len;
-    String uint_str = StringFromU64(arena, n, base, zfill);
+    return result;
-    return (String)
-    {
-        .len = len + uint_str.len,
-        .text = final_text
-    };
 }
 
-//- Pointer conversion
+String StringFromSints(Arena *arena, u64 sints_count, i64 *sints, u64 base, u64 zfill)
-String StringFromPtr(Arena *arena, void *ptr)
 {
-    String prepend = PushString(arena, Lit("0x"));
+    String result = ZI;
-    String uint_str = StringFromU64(arena, (u64)ptr, 16, sizeof(ptr));
+    result.text = ArenaNext(arena, u8);
-    return (String)
+    result.len += StringFromChar(arena, '(').len;
+    for (u64 sint_idx = 0; sint_idx < sints_count; ++sint_idx)
     {
-        .len = prepend.len + uint_str.len,
+        result.len += StringFromSint(arena, sints[sint_idx], base, zfill).len;
-        .text = prepend.text
+        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 = {
+    String result = ZI;
-        .len = src.len,
+    result.len = src.len;
-        .text = PushStructsNoZero(arena, u8, src.len)
+    result.text = PushStructsNoZero(arena, u8, src.len);
-    };
+    CopyBytes(result.text, src.text, src.len);
-    CopyBytes(str.text, src.text, src.len);
+    return result;
-    return str;
 }
 
-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:
                 {

src/base/base_string.h

@@ -9,17 +9,30 @@ Enum(FmtArgKind)
     FmtArgKind_None,
 
     /* Arbitrary magic numbers for argument validation */
-    FmtArgKind_Char    = 0x0f5281df,
+    FmtArgKind_Char     = 0xf5281df,
-    FmtArgKind_String  = 0x0a5ffa9a,
+    FmtArgKind_String   = 0xa5ffa9a,
-    FmtArgKind_Uint    = 0x0746f19b,
-    FmtArgKind_Sint    = 0x08603694,
-    FmtArgKind_Hex     = 0x0a3d0792,
-    FmtArgKind_Ptr     = 0x0c4519e4,
-    FmtArgKind_Float   = 0x04814143,
-    FmtArgKind_Uid     = 0x3d1cd407,
-    FmtArgKind_Handle  = 0x6ead3bec,
 
-    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;
+        Vec4U64 uints;
-        i64 sint;
+        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 StringFromUint(Arena *arena, u64 n, u64 base, u64 zfill);
-String StringFromI64(Arena *arena, i64 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);

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;
+                                        u32 gpu_value = *(u32 *)at;
-                                        dst->value.uint = gpu_value;
+                                        *dst = FmtUint(gpu_value);
+                                        at += 4;
                                     } break;
-                                    case G_FmtArgKind_I32:
+                                    case G_FmtArgKind_Uint2:
                                     {
-                                        dst->kind = FmtArgKind_Sint;
+                                        Vec2U32 gpu_value = *(Vec2U32 *)at;
-                                        dst->value.sint = (i32)gpu_value;
+                                        *dst = FmtUint2(gpu_value);
+                                        at += 8;
                                     } break;
-                                    case G_FmtArgKind_F32:
+                                    case G_FmtArgKind_Uint3:
                                     {
-                                        dst->kind = FmtArgKind_Float;
+                                        Vec3U32 gpu_value = *(Vec3U32 *)at;
-                                        dst->value.f = *(f32 *)&gpu_value;
+                                        *dst = FmtUint3(gpu_value);
-                                        dst->p = 6;
+                                        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;
                                 }
                             }

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(u32 v)       { G_FmtArg result;    result.kind = G_FmtArgKind_Uint;      result.v.x = 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(Vec2U32 v)   { G_FmtArg result;    result.kind = G_FmtArgKind_Uint2;     result.v.xy = v.xy;                 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_Fmt(Vec3U32 v)   { G_FmtArg result;    result.kind = G_FmtArgKind_Uint3;     result.v.xyz = v.xyz;               return result; }
-    G_FmtArg G_FmtEnd(void)     { G_FmtArg result;    result.kind = G_FmtArgKind_End;    result.v = 0;          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_FmtArg __arg = __args[__arg_idx];                             \
-            G_PushPrintByte(__tmp, __args[__arg_idx].v >>  0);              \
+            G_PushPrintByte(__tmp, __arg.kind);                             \
-            G_PushPrintByte(__tmp, __args[__arg_idx].v >>  8);              \
+            if (__arg.kind > G_FmtArgKind_BEGINSIZE1)                       \
-            G_PushPrintByte(__tmp, __args[__arg_idx].v >> 16);              \
+            {                                                               \
-            G_PushPrintByte(__tmp, __args[__arg_idx].v >> 24);              \
+                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)

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;
 }

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);
 };
 

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;
 }

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)",
+        "Bla: %F %F",
-        G_Fmt(input.SV_Position.x),
+        G_Fmt(input.sv_position),
-        G_Fmt(input.SV_Position.y),
+        G_Fmt(uv)
-        G_Fmt(uv.x),
-        G_Fmt(uv.y)
     );
 
     UI_BlitPSOutput output;

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);
 };