vector printf format
This commit is contained in:
parent
4453d18d51
commit
eeec7e7191
@ -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"
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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:
|
||||
{
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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);
|
||||
};
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -22,7 +22,7 @@ Struct(UI_DRectPSOutput)
|
||||
|
||||
Struct(UI_BlitPSInput)
|
||||
{
|
||||
Semantic(Vec4, SV_Position);
|
||||
Semantic(Vec4, sv_position);
|
||||
Semantic(Vec2, src_uv);
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user