doylet/DN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pull latest changes from the bar

Browse Source
This commit is contained in:
doylet
2026-03-26 22:31:23 +11:00
parent 9aa403d104
commit 1eacb72a77
7 changed files with 477 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Base/dn_base.cpp
+300 -38
View File
@@ -1154,7 +1154,8 @@ DN_API DN_Str8x64 DN_ArenaInfoStr8x64(DN_ArenaInfo info)
DN_Str8x32 used = DN_ByteCountStr8x32(info.used);
DN_Str8x32 commit = DN_ByteCountStr8x32(info.commit);
DN_Str8x32 reserve = DN_ByteCountStr8x32(info.reserve);
result = DN_Str8x64FromFmt("Blks/Used/Comm/Resv (%u/%.*s/%.*s/%.*s)", DN_Cast(DN_U32)info.blocks, DN_Str8PrintFmt(used), DN_Str8PrintFmt(commit), DN_Str8PrintFmt(reserve));
// NOTE: Blocks, Used, Commit, Reserve
result = DN_Str8x64FromFmt("B=%u U=%.*s C=%.*s R=%.*s", DN_Cast(DN_U32)info.blocks, DN_Str8PrintFmt(used), DN_Str8PrintFmt(commit), DN_Str8PrintFmt(reserve));
return result;
}
@@ -1533,7 +1534,10 @@ DN_API void DN_ErrSinkEndExitIfErrorF_(DN_ErrSink *err, DN_CallSite call_site, D
DN_API void DN_ErrSinkAppendFV_(DN_ErrSink *err, DN_U32 error_code, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Assert(err && err->stack_size);
if (!err)
return;
DN_Assert(err->stack_size);
DN_ErrSinkNode *node = err->stack + (err->stack_size - 1);
DN_AssertF(node, "Error sink must be begun by calling 'Begin' before using this function.");
@@ -1613,7 +1617,7 @@ DN_API DN_Arena *DN_TCMainArena()
return result;
}
DN_API DN_Arena *DN_TCTempArena(DN_Arena **conflicts, DN_U64 count)
DN_API DN_Arena *DN_TCTempArena(DN_Arena **conflicts, DN_USize count)
{
DN_TCCore *tc = DN_TCGet();
DN_Arena *candidates[] = {tc->temp_a_arena, tc->temp_b_arena};
@@ -1647,7 +1651,7 @@ DN_TCScratchCpp::~DN_TCScratchCpp()
}
#endif
DN_API DN_TCScratch DN_TCScratchBegin(DN_Arena **conflicts, DN_U64 count)
DN_API DN_TCScratch DN_TCScratchBegin(DN_Arena **conflicts, DN_USize count)
{
DN_TCScratch result = {};
result.arena = DN_TCTempArena(conflicts, count);
@@ -3228,7 +3232,7 @@ DN_API DN_Str8Slice DN_Str8BuilderBuildSlice(DN_Str8Builder const *builder, DN_A
}
// NOTE: DN_UTF
DN_API int DN_UTF8EncodeCodepoint(DN_U8 utf8[4], DN_U32 codepoint)
DN_API int DN_UTF8Encode(DN_U8 utf8[4], DN_U32 codepoint)
{
// NOTE: Table from https://www.reedbeta.com/blog/programmers-intro-to-unicode/
// ----------------------------------------+----------------------------+--------------------+
@@ -3269,7 +3273,96 @@ DN_API int DN_UTF8EncodeCodepoint(DN_U8 utf8[4], DN_U32 codepoint)
return 0;
}
DN_API int DN_UTF16EncodeCodepoint(DN_U16 utf16[2], DN_U32 codepoint)
DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream)
{
DN_UTF8DecodeResult result = {};
result.remaining = stream;
if (stream.size <= 0)
return result;
DN_U8 b0 = DN_Cast(DN_U8)stream.data[0];
DN_U8 b1 = DN_Cast(DN_U8)(stream.size >= 2 ? stream.data[1] : 0);
DN_U8 b2 = DN_Cast(DN_U8)(stream.size >= 3 ? stream.data[2] : 0);
DN_U8 b3 = DN_Cast(DN_U8)(stream.size >= 4 ? stream.data[3] : 0);
if ((b0 & 0b1000'0000) == 0) {
result.codepoint = b0;
result.success = true;
result.remaining = DN_Str8FromPtr(stream.data + 1, stream.size - 1);
return result;
}
if ((b0 & 0b1110'0000) == 0b1100'0000) {
if (stream.size < 2)
return result;
if ((b1 & 0b1100'0000) != 0b1000'0000)
return result;
DN_U32 cp = ((b0 & 0b0001'1111) << 6) | ((b1 & 0b0011'1111) << 0);
if (cp < 0x80)
return result;
result.codepoint = cp;
result.success = true;
result.remaining = DN_Str8FromPtr(stream.data + 2, stream.size - 2);
return result;
}
if ((b0 & 0b1111'0000) == 0b1110'0000) {
if (stream.size < 3)
return result;
if ((b1 & 0b1100'0000) != 0b1000'0000)
return result;
if ((b2 & 0b1100'0000) != 0b1000'0000)
return result;
DN_U32 cp = ((b0 & 0b0000'1111) << 12) | ((b1 & 0b0011'1111) << 6) | ((b2 & 0b0011'1111) << 0);
if (cp < 0x800)
return result;
result.codepoint = cp;
result.success = true;
result.remaining = DN_Str8FromPtr(stream.data + 3, stream.size - 3);
return result;
}
if ((b0 & 0b1111'1000) == 0b1111'0000) {
if (stream.size < 4)
return result;
if ((b1 & 0b1100'0000) != 0b1000'0000)
return result;
if ((b2 & 0b1100'0000) != 0b1000'0000)
return result;
if ((b3 & 0b1100'0000) != 0b1000'0000)
return result;
DN_U32 cp = ((b0 & 0b0000'0111) << 18) |
((b1 & 0b0011'1111) << 12) |
((b2 & 0b0011'1111) << 6) |
((b3 & 0b0011'1111) << 0);
if (cp < 0x10000 || cp > 0x10FFFF)
return result;
result.codepoint = cp;
result.success = true;
result.remaining = DN_Str8FromPtr(stream.data + 4, stream.size - 4);
return result;
}
return result;
}
DN_API bool DN_UTF8DecodeIterate(DN_UTF8DecodeIterator *it, DN_Str8 utf8)
{
if (it->init) {
it->codepoint_index++;
} else {
it->remaining = utf8;
it->init = true;
}
DN_UTF8DecodeResult decode = DN_UTF8Decode(it->remaining);
it->success = decode.success;
it->remaining = decode.remaining;
it->codepoint = decode.codepoint;
bool result = it->success;
return result;
}
DN_API int DN_UTF16Encode(DN_U16 utf16[2], DN_U32 codepoint)
{
// NOTE: Table from https://www.reedbeta.com/blog/programmers-intro-to-unicode/
// ----------------------------------------+------------------------------------+------------------+
@@ -4286,6 +4379,36 @@ DN_API DN_LogTypeParam DN_LogTypeParamFromType(DN_LogType type)
return result;
}
DN_API DN_F32 DN_F32Lerp(DN_F32 a, DN_F32 t, DN_F32 b)
{
DN_F32 result = a + ((b - a) * t);
return result;
}
DN_API DN_F32 DN_F32Floor(DN_F32 val)
{
DN_I32 val_i32 = DN_Cast(DN_I32) val;
if (val < 0 && val != DN_Cast(DN_F32) val_i32)
val_i32 -= 1;
DN_F32 result = DN_Cast(DN_F32)val_i32;
return result;
}
DN_API DN_F32 DN_F32Ceil(DN_F32 val)
{
DN_I32 val_i32 = DN_Cast(DN_I32)(val);
if (val > 0 && val != DN_Cast(DN_F32) val_i32)
val_i32 += 1;
DN_F32 result = DN_Cast(DN_F32) val_i32;
return result;
}
DN_API DN_F32 DN_F32RoundHalfUp(DN_F32 val)
{
DN_F32 result = val >= 0 ? DN_F32Floor(val + 0.5f) : DN_F32Ceil(val - 0.5f);
return result;
}
DN_API bool operator==(DN_V2I32 lhs, DN_V2I32 rhs)
{
bool result = (lhs.x == rhs.x) && (lhs.y == rhs.y);
@@ -4574,6 +4697,14 @@ DN_API DN_V2U16 &operator+=(DN_V2U16 &lhs, DN_V2U16 rhs)
return lhs;
}
DN_API DN_V2F32 DN_V2F32Lerp(DN_V2F32 a, DN_F32 t, DN_V2F32 b)
{
DN_V2F32 result = {};
result.x = a.x + ((b.x - a.x) * t);
result.y = a.y + ((b.y - a.y) * t);
return result;
}
DN_API bool operator!=(DN_V2F32 lhs, DN_V2F32 rhs)
{
bool result = !(lhs == rhs);
@@ -5094,6 +5225,15 @@ DN_API DN_V3F32 &operator+=(DN_V3F32 &lhs, DN_V3F32 rhs)
return lhs;
}
DN_API DN_V3F32 DN_V3F32Lerp(DN_V3F32 lhs, DN_F32 t01, DN_V3F32 rhs)
{
DN_V3F32 result = {};
result.x = lhs.x + ((rhs.x - lhs.x) * t01);
result.y = lhs.y + ((rhs.y - lhs.y) * t01);
result.z = lhs.z + ((rhs.z - lhs.z) * t01);
return result;
}
DN_API DN_F32 DN_V3_LengthSq(DN_V3F32 a)
{
DN_F32 result = DN_Squared(a.x) + DN_Squared(a.y) + DN_Squared(a.z);
@@ -5114,22 +5254,78 @@ DN_API DN_V3F32 DN_V3_Normalise(DN_V3F32 a)
return result;
}
DN_API DN_V4F32 DN_V4F32FromRGBU32(DN_U32 u32)
DN_API DN_V4F32 DN_V4F32Lerp(DN_V4F32 lhs, DN_F32 t01, DN_V4F32 rhs)
{
DN_V4F32 result = {};
result.x = lhs.x + (rhs.x - lhs.x) * t01;
result.y = lhs.y + (rhs.y - lhs.y) * t01;
result.z = lhs.z + (rhs.z - lhs.z) * t01;
result.w = lhs.w + (rhs.w - lhs.w) * t01;
return result;
}
DN_API bool DN_V4F32RGBA01IsValid(DN_V4F32 rgba01)
{
bool result = rgba01.r >= 0 && rgba01.r <= 1.f &&
rgba01.g >= 0 && rgba01.g <= 1.f &&
rgba01.b >= 0 && rgba01.b <= 1.f &&
rgba01.a >= 0 && rgba01.a <= 1.f;
return result;
}
DN_API DN_V4F32 DN_V4F32RGBA01FromRGBU32(DN_U32 u32)
{
DN_U8 r = (DN_U8)((u32 & 0x00FF0000) >> 16);
DN_U8 g = (DN_U8)((u32 & 0x0000FF00) >> 8);
DN_U8 b = (DN_U8)((u32 & 0x000000FF) >> 0);
DN_V4F32 result = DN_V4F32FromRGBU8(r, g, b);
DN_V4F32 result = DN_V4F32RGBA01FromRGBU8(r, g, b);
return result;
}
DN_API DN_V4F32 DN_V4F32FromRGBAU32(DN_U32 u32)
DN_API DN_V4F32 DN_V4F32RGBA01FromRGBAU32(DN_U32 u32)
{
DN_U8 r = (DN_U8)((u32 & 0xFF000000) >> 24);
DN_U8 g = (DN_U8)((u32 & 0x00FF0000) >> 16);
DN_U8 b = (DN_U8)((u32 & 0x0000FF00) >> 8);
DN_U8 a = (DN_U8)((u32 & 0x000000FF) >> 0);
DN_V4F32 result = DN_V4F32FromRGBAU8(r, g, b, a);
DN_V4F32 result = DN_V4F32RGBA01FromRGBAU8(r, g, b, a);
return result;
}
#define DN_SRGB_COEFFICIENT_F32 2.2f
DN_API DN_V4F32 DN_V4F32Linear01FromSRGB01(DN_V4F32 srgb01)
{
DN_Assert(srgb01.x >= 0.f && srgb01.x <= 1.f);
DN_Assert(srgb01.y >= 0.f && srgb01.y <= 1.f);
DN_Assert(srgb01.z >= 0.f && srgb01.z <= 1.f);
DN_Assert(srgb01.a >= 0.f && srgb01.a <= 1.f);
DN_V4F32 result = {};
result.r = DN_PowF32(srgb01.r, DN_SRGB_COEFFICIENT_F32);
result.g = DN_PowF32(srgb01.g, DN_SRGB_COEFFICIENT_F32);
result.b = DN_PowF32(srgb01.b, DN_SRGB_COEFFICIENT_F32);
result.a = srgb01.a;
return result;
}
DN_API DN_V4F32 DN_V4F32Linear01Desaturate(DN_V4F32 linear01, DN_F32 t01)
{
DN_F32 luminance = (linear01.r * DN_V3F32_RGB_LUMINANCE.r) + (linear01.g * DN_V3F32_RGB_LUMINANCE.g) + (linear01.b * DN_V3F32_RGB_LUMINANCE.b);
DN_V4F32 result = linear01;
result.rgb = DN_V3F32Lerp(result.rgb, t01, DN_V3F32From1N(luminance));
return result;
}
DN_API DN_V4F32 DN_V4F32SRGB01FromLinear01(DN_V4F32 linear01)
{
DN_Assert(linear01.x >= 0.f && linear01.x <= 1.f);
DN_Assert(linear01.y >= 0.f && linear01.y <= 1.f);
DN_Assert(linear01.z >= 0.f && linear01.z <= 1.f);
DN_Assert(linear01.a >= 0.f && linear01.a <= 1.f);
DN_V4F32 result = {};
result.r = DN_PowF32(linear01.r, 1.f / DN_SRGB_COEFFICIENT_F32);
result.g = DN_PowF32(linear01.g, 1.f / DN_SRGB_COEFFICIENT_F32);
result.b = DN_PowF32(linear01.b, 1.f / DN_SRGB_COEFFICIENT_F32);
result.a = linear01.a;
return result;
}
@@ -5554,16 +5750,80 @@ DN_API DN_M2x3 DN_M2x3Scale(DN_V2F32 scale)
DN_API DN_M2x3 DN_M2x3Rotate(DN_F32 radians)
{
DN_M2x3 result = {
{
DN_CosF32(radians),
DN_SinF32(radians),
0,
-DN_SinF32(radians),
DN_CosF32(radians),
0,
}
};
DN_M2x3 result = {{
DN_CosF32(radians), DN_SinF32(radians), 0,
-DN_SinF32(radians), DN_CosF32(radians), 0,
}};
return result;
}
DN_API DN_M2x3 DN_M2x3ProjFromV2F32(DN_V2F32 size, DN_M2x3ProjOrigin origin)
{
DN_M2x3 result = {};
// NOTE: Maps coordinates within a rectangle of `size` into NDC where (-1, +1) is top left, (+1, -1) is bot right
if (origin == DN_M2x3ProjOrigin_TopLeft) {
result = {{
2.f/size.w, 0, -1.f,
0, -2.f/size.h, +1.f,
}};
} else {
DN_Assert(origin == DN_M2x3ProjOrigin_Center);
result = {{
2.f/size.w, 0, 0.f,
0, -2.f/size.h, 0.f,
}};
}
return result;
}
DN_API DN_M2x3XForm DN_M2x3XFormFromM2x3(DN_M2x3 forward, DN_M2x3 inverse)
{
DN_M2x3XForm result = {};
result.forward = forward;
result.inverse = inverse;
return result;
}
DN_API DN_M2x3XForm DN_M2x3XFormFromTRS(DN_V2F32 pos, DN_V2F32 scale, DN_F32 rotate_rads, DN_V2F32 pivot_pos)
{
DN_M2x3XForm result = {};
result.forward = DN_M2x3Identity();
result.inverse = DN_M2x3Identity();
if (scale.x == 0)
scale.x = 1;
if (scale.y == 0)
scale.y = 1;
result.forward = DN_M2x3Mul(result.forward, DN_M2x3Translate(pivot_pos));
result.forward = DN_M2x3Mul(result.forward, DN_M2x3Rotate(rotate_rads));
result.forward = DN_M2x3Mul(result.forward, DN_M2x3Scale(scale));
result.forward = DN_M2x3Mul(result.forward, DN_M2x3Translate(-pivot_pos));
result.forward = DN_M2x3Mul(result.forward, DN_M2x3Translate(pos));
DN_V2F32 inverse_scale = DN_V2F32From1N(1) / scale;
result.inverse = DN_M2x3Mul(result.inverse, DN_M2x3Translate(-pos));
result.inverse = DN_M2x3Mul(result.inverse, DN_M2x3Translate(pivot_pos));
result.inverse = DN_M2x3Mul(result.inverse, DN_M2x3Scale(inverse_scale));
result.inverse = DN_M2x3Mul(result.inverse, DN_M2x3Rotate(-rotate_rads));
result.inverse = DN_M2x3Mul(result.inverse, DN_M2x3Translate(-pivot_pos));
return result;
}
DN_API DN_M2x3XForm DN_M2x3XFormIdentity()
{
DN_M2x3XForm result = {};
result.forward = DN_M2x3Identity();
result.inverse = DN_M2x3Identity();
return result;
}
DN_API DN_M2x3XForm DN_M2x3XFormMul(DN_M2x3XForm m1, DN_M2x3XForm m2)
{
DN_M2x3XForm result = {};
result.forward = DN_M2x3Mul(m1.forward, m2.forward);
result.inverse = DN_M2x3Mul(m2.inverse, m1.inverse);
return result;
}
@@ -5616,6 +5876,16 @@ DN_API DN_V2F32 DN_M2x3MulV2F32(DN_M2x3 m1, DN_V2F32 v2)
return result;
}
DN_API DN_Rect DN_M2x3MulRect(DN_M2x3 m1, DN_Rect rect)
{
DN_2V2F32 rect_range = DN_RectRange(rect);
DN_2V2F32 result_range = {};
result_range.min = DN_M2x3MulV2F32(m1, rect_range.min);
result_range.max = DN_M2x3MulV2F32(m1, rect_range.max);
DN_Rect result = DN_RectFrom2V2(result_range.min, result_range.max - result_range.min);
return result;
}
DN_API bool operator==(const DN_Rect &lhs, const DN_Rect &rhs)
{
bool result = (lhs.pos == rhs.pos) && (lhs.size == rhs.size);
@@ -5712,11 +5982,17 @@ DN_API DN_Rect DN_RectUnion(DN_Rect a, DN_Rect b)
return result;
}
DN_API DN_RectMinMax DN_RectGetMinMax(DN_Rect a)
DN_API DN_2V2F32 DN_RectRange(DN_Rect a)
{
DN_RectMinMax result = {};
result.min = a.pos;
result.max = a.pos + a.size;
DN_2V2F32 result = {};
result.min = a.pos;
result.max = a.pos + a.size;
return result;
}
DN_API bool DN_RectEq(DN_Rect lhs, DN_Rect rhs)
{
bool result = lhs.pos == rhs.pos && lhs.size == rhs.size;
return result;
}
@@ -5851,17 +6127,3 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2(DN_V2F32 origin_a, DN_V2F32 dir_a,
}
return result;
}
DN_API DN_V2F32 DN_LerpV2F32(DN_V2F32 a, DN_F32 t, DN_V2F32 b)
{
DN_V2F32 result = {};
result.x = a.x + ((b.x - a.x) * t);
result.y = a.y + ((b.y - a.y) * t);
return result;
}
DN_API DN_F32 DN_LerpF32(DN_F32 a, DN_F32 t, DN_F32 b)
{
DN_F32 result = a + ((b - a) * t);
return result;
}
Source/Base/dn_base.h
+88 -18
View File
@@ -228,6 +228,9 @@
#if !defined(DN_TanF32)
#define DN_TanF32(val) tanf(val)
#endif
#if !defined(DN_PowF32)
#define DN_PowF32(val, exp) powf(val, exp)
#endif
#endif
// NOTE: Math
@@ -836,6 +839,22 @@ struct DN_Pool
DN_U8 align;
};
struct DN_UTF8DecodeResult
{
bool success;
DN_Str8 remaining;
DN_U32 codepoint;
};
struct DN_UTF8DecodeIterator
{
bool init;
bool success;
DN_Str8 remaining;
DN_USize codepoint_index;
DN_U32 codepoint;
};
struct DN_NibbleFromU8Result
{
char nibble0;
@@ -1213,7 +1232,19 @@ union DN_V2F32
struct { DN_F32 w, h; };
DN_F32 data[2];
};
DN_DArrayStructDecl(DN_V2F32);
struct DN_2V2F32
{
DN_V2F32 min;
DN_V2F32 max;
};
struct DN_V2F32Array
{
DN_V2F32 *data;
DN_USize count;
DN_USize max;
};
union DN_V3F32
{
@@ -1231,7 +1262,13 @@ union DN_V4F32
DN_V3F32 xyz;
DN_F32 data[4];
};
DN_DArrayStructDecl(DN_V4F32);
struct DN_V4F32Array
{
DN_V4F32* data;
DN_USize count;
DN_USize max;
};
DN_MSVC_WARNING_POP
struct DN_M4
@@ -1245,16 +1282,23 @@ union DN_M2x3
DN_F32 row[2][3];
};
struct DN_M2x3XForm
{
DN_M2x3 forward;
DN_M2x3 inverse;
};
enum DN_M2x3ProjOrigin
{
DN_M2x3ProjOrigin_TopLeft,
DN_M2x3ProjOrigin_Center,
};
struct DN_Rect
{
DN_V2F32 pos, size;
};
struct DN_RectMinMax
{
DN_V2F32 min, max;
};
enum DN_RectCutClip
{
DN_RectCutClip_No,
@@ -1638,8 +1682,10 @@ DN_API DN_Str8 DN_Str8BuilderBuild
DN_API DN_Str8 DN_Str8BuilderBuildDelimited (DN_Str8Builder const *builder, DN_Str8 delimiter, DN_Arena *arena);
DN_API DN_Str8Slice DN_Str8BuilderBuildSlice (DN_Str8Builder const *builder, DN_Arena *arena);
DN_API int DN_EncodeUTF8Codepoint (DN_U8 utf8[4], DN_U32 codepoint);
DN_API int DN_EncodeUTF16Codepoint (DN_U16 utf16[2], DN_U32 codepoint);
DN_API int DN_UTF8Encode (DN_U8 utf8[4], DN_U32 codepoint);
DN_API int DN_UTF16Encode (DN_U16 utf16[2], DN_U32 codepoint);
DN_API DN_UTF8DecodeResult DN_UTF8Decode (DN_Str8 stream);
DN_API bool DN_UTF8DecodeIterate (DN_UTF8DecodeIterator *it, DN_Str8 utf8);
DN_API DN_U8 DN_U8FromHexNibble (char hex);
DN_API DN_NibbleFromU8Result DN_NibbleFromU8 (DN_U8 u8);
@@ -1756,6 +1802,11 @@ DN_API void DN_StackTracePrint
DN_API void DN_StackTraceReloadSymbols ();
#endif
DN_API DN_F32 DN_F32Lerp (DN_F32 a, DN_F32 t, DN_F32 b);
DN_API DN_F32 DN_F32Floor (DN_F32 val);
DN_API DN_F32 DN_F32Ceil (DN_F32 val);
DN_API DN_F32 DN_F32RoundHalfUp (DN_F32 val);
#define DN_V2I32Zero DN_Literal(DN_V2I32){{(DN_I32)(0), (DN_I32)(0)}}
#define DN_V2I32One DN_Literal(DN_V2I32){{(DN_I32)(1), (DN_I32)(1)}}
#define DN_V2I32From1N(x) DN_Literal(DN_V2I32){{(DN_I32)(x), (DN_I32)(x)}}
@@ -1827,8 +1878,9 @@ DN_API DN_V2U16& operator+=
#define DN_V2F32One DN_Literal(DN_V2F32){{(DN_F32)(1), (DN_F32)(1)}}
#define DN_V2F32From1N(x) DN_Literal(DN_V2F32){{(DN_F32)(x), (DN_F32)(x)}}
#define DN_V2F32From2N(x, y) DN_Literal(DN_V2F32){{(DN_F32)(x), (DN_F32)(y)}}
#define DN_V2F32FromV2I32(xy) DN_Literal(DN_V2F32){{(DN_F32)(xy).x, (DN_F32)(xy).y}}
#define DN_V2F32FromV2U32(xy) DN_Literal(DN_V2F32){{(DN_F32)(xy).x, (DN_F32)(xy).y}}
#define DN_V2F32FromV2(xy) DN_Literal(DN_V2F32){{(DN_F32)(xy).x, (DN_F32)(xy).y}}
DN_API DN_V2F32 DN_V2F32Lerp (DN_V2F32 a, DN_F32 t, DN_V2F32 b);
DN_API bool operator!= (DN_V2F32 lhs, DN_V2F32 rhs);
DN_API bool operator== (DN_V2F32 lhs, DN_V2F32 rhs);
@@ -1896,6 +1948,10 @@ DN_API DN_F32 DN_V2F32Area
#define DN_V3F32From3N(x, y, z) DN_Literal(DN_V3F32){{(DN_F32)(x), (DN_F32)(y), (DN_F32)(z)}}
#define DN_V3F32FromV2F32And1N(xy, z) DN_Literal(DN_V3F32){{(DN_F32)(xy.x), (DN_F32)(xy.y), (DN_F32)(z)}}
// NOTE: Grayscale co-efficients from:
// https://github.com/EpicGames/UnrealEngine/blob/260bb2e1c5610b31c63a36206eedd289409c5f11/Engine/Source/Runtime/Core/Private/Math/Color.cpp#L304
DN_V3F32 static const DN_V3F32_RGB_LUMINANCE = DN_V3F32From3N(0.3f, 0.59f, 0.11f);
DN_API bool operator== (DN_V3F32 lhs, DN_V3F32 rhs);
DN_API bool operator!= (DN_V3F32 lhs, DN_V3F32 rhs);
DN_API bool operator>= (DN_V3F32 lhs, DN_V3F32 rhs);
@@ -1919,6 +1975,7 @@ DN_API DN_V3F32& operator/=
DN_API DN_V3F32& operator/= (DN_V3F32 &lhs, DN_I32 rhs);
DN_API DN_V3F32& operator-= (DN_V3F32 &lhs, DN_V3F32 rhs);
DN_API DN_V3F32& operator+= (DN_V3F32 &lhs, DN_V3F32 rhs);
DN_API DN_V3F32 DN_V3F32Lerp (DN_V3F32 lhs, DN_F32 t01, DN_V3F32 rhs);
DN_API DN_F32 DN_V3F32LengthSq (DN_V3F32 a);
DN_API DN_F32 DN_V3F32Length (DN_V3F32 a);
DN_API DN_V3F32 DN_V3F32Normalise (DN_V3F32 a);
@@ -1926,11 +1983,19 @@ DN_API DN_V3F32 DN_V3F32Normalise
#define DN_V4F32From1N(x) DN_Literal(DN_V4F32){{(DN_F32)(x), (DN_F32)(x), (DN_F32)(x), (DN_F32)(x)}}
#define DN_V4F32From4N(x, y, z, w) DN_Literal(DN_V4F32){{(DN_F32)(x), (DN_F32)(y), (DN_F32)(z), (DN_F32)(w)}}
#define DN_V4F32FromV3And1N(xyz, w) DN_Literal(DN_V4F32){{xyz.x, xyz.y, xyz.z, w}}
#define DN_V4F32FromRGBAU8(r, g, b, a) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, a / 255.f}}
#define DN_V4F32FromRGBU8(r, g, b) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, 1.f}}
DN_API DN_V4F32 DN_V4F32FromRGBU32 (DN_U32 u32);
DN_API DN_V4F32 DN_V4F32FromRGBAU32 (DN_U32 u32);
#define DN_V4F32RGBA01FromRGBAU8(r, g, b, a) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, a / 255.f}}
#define DN_V4F32RGBA01FromRGBU8(r, g, b) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, 1.f}}
DN_API DN_V4F32 DN_V4F32Lerp (DN_V4F32 lhs, DN_F32 t01, DN_V4F32 rhs);
DN_API bool DN_V4F32RGBA01IsValid (DN_V4F32 rgba01);
DN_API DN_V4F32 DN_V4F32RGBA01FromRGBU32 (DN_U32 u32);
DN_API DN_V4F32 DN_V4F32RGBA01FromRGBAU32 (DN_U32 u32);
DN_API DN_V4F32 DN_V4F32Linear01FromSRGB01 (DN_V4F32 rgb01);
DN_API DN_V4F32 DN_V4F32Linear01Desaturate (DN_V4F32 linear01, DN_F32 t01);
DN_API DN_V4F32 DN_V4F32SRGB01FromLinear01 (DN_V4F32 linear01);
#define DN_V4F32FromV4Alpha(v4, alpha) DN_V4F32FromV3And1N(v4.xyz, alpha)
DN_API bool operator== (DN_V4F32 lhs, DN_V4F32 rhs);
DN_API bool operator!= (DN_V4F32 lhs, DN_V4F32 rhs);
DN_API bool operator<= (DN_V4F32 lhs, DN_V4F32 rhs);
@@ -1976,9 +2041,15 @@ DN_API DN_M2x3 DN_M2x3Translate
DN_API DN_V2F32 DN_M2x3ScaleGet (DN_M2x3 m2x3);
DN_API DN_M2x3 DN_M2x3Scale (DN_V2F32 scale);
DN_API DN_M2x3 DN_M2x3Rotate (DN_F32 radians);
DN_API DN_M2x3 DN_M2x3ProjFromV2F32 (DN_V2F32 size, DN_M2x3ProjOrigin origin);
DN_API DN_M2x3XForm DN_M2x3XFormFrom2M2x3 (DN_M2x3 forward, DN_M2x3 inverse);
DN_API DN_M2x3XForm DN_M2x3XFormFromTRS (DN_V2F32 pos, DN_V2F32 scale, DN_F32 rotate_rads, DN_V2F32 pivot_pos);
DN_API DN_M2x3XForm DN_M2x3XFormIdentity ();
DN_API DN_M2x3XForm DN_M2x3XFormMul (DN_M2x3XForm m1, DN_M2x3XForm m2);
DN_API DN_M2x3 DN_M2x3Mul (DN_M2x3 m1, DN_M2x3 m2);
DN_API DN_V2F32 DN_M2x3Mul2F32 (DN_M2x3 m1, DN_F32 x, DN_F32 y);
DN_API DN_V2F32 DN_M2x3MulV2F32 (DN_M2x3 m1, DN_V2F32 v2);
DN_API DN_Rect DN_M2x3MulRect (DN_M2x3 m1, DN_Rect rect);
#define DN_RectFrom2V2(pos, size) DN_Literal(DN_Rect){(pos), (size)}
#define DN_RectFrom4N(x, y, w, h) DN_Literal(DN_Rect){DN_Literal(DN_V2F32){{x, y}}, DN_Literal(DN_V2F32){{w, h}}}
@@ -1993,7 +2064,8 @@ DN_API DN_Rect DN_RectExpandV2
DN_API bool DN_RectIntersects (DN_Rect a, DN_Rect b);
DN_API DN_Rect DN_RectIntersection (DN_Rect a, DN_Rect b);
DN_API DN_Rect DN_RectUnion (DN_Rect a, DN_Rect b);
DN_API DN_RectMinMax DN_RectGetMinMax (DN_Rect a);
DN_API DN_2V2F32 DN_RectRange (DN_Rect a);
DN_API bool DN_RectEq (DN_Rect lhs, DN_Rect rhs);
DN_API DN_F32 DN_RectArea (DN_Rect a);
DN_API DN_V2F32 DN_RectInterpV2F32 (DN_Rect rect, DN_V2F32 t01);
DN_API DN_V2F32 DN_RectTopLeft (DN_Rect rect);
@@ -2020,6 +2092,4 @@ DN_API DN_Rect DN_RectCutCut
#define DN_RectCutInit(rect, side) DN_Literal(DN_RectCut){rect, side}
DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 (DN_V2F32 origin_a, DN_V2F32 dir_a, DN_V2F32 origin_b, DN_V2F32 dir_b);
DN_API DN_V2F32 DN_LerpV2F32 (DN_V2F32 a, DN_F32 t, DN_V2F32 b);
DN_API DN_F32 DN_LerpF32 (DN_F32 a, DN_F32 t, DN_F32 b);
#endif // !defined(DN_BASE_H)
Source/Base/dn_base_containers.h
+9 -9
View File
@@ -286,12 +286,12 @@ template <typename T> struct DN_DSMapResult
#define DN_CppDeclType
#endif
#define DN_PArrayResizeFromPool(ptr, size, max, pool, new_max) DN_CArrayResizeFromPool((void **)&(ptr), size, max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayResizeFromArena(ptr, size, max, arena, new_max) DN_CArrayResizeFromArena((void **)&(ptr), size, max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayGrowFromPool(ptr, size, max, pool, new_max) DN_CArrayGrowFromPool((void **)&(ptr), size, max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayGrowFromArena(ptr, size, max, arena, new_max) DN_CArrayGrowFromArena((void **)&(ptr), size, max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayGrowIfNeededFromPool(ptr, size, max, pool, add_count) DN_CArrayGrowIfNeededFromPool((void **)(ptr), size, max, sizeof((ptr)[0]), pool, add_count)
#define DN_PArrayGrowIfNeededFromArena(ptr, size, max, arena, add_count) DN_CArrayGrowIfNeededFromArena((void **)(ptr), size, max, sizeof((ptr)[0]), arena, add_count)
#define DN_PArrayResizeFromPool(ptr, size, max, pool, new_max) DN_CArrayResizeFromPool((void **)&(ptr), size, max, sizeof((*ptr)[0]), pool, new_max)
#define DN_PArrayResizeFromArena(ptr, size, max, arena, new_max) DN_CArrayResizeFromArena((void **)&(ptr), size, max, sizeof((*ptr)[0]), arena, new_max)
#define DN_PArrayGrowFromPool(ptr, size, max, pool, new_max) DN_CArrayGrowFromPool((void **)&(ptr), size, max, sizeof((*ptr)[0]), pool, new_max)
#define DN_PArrayGrowFromArena(ptr, size, max, arena, new_max) DN_CArrayGrowFromArena((void **)&(ptr), size, max, sizeof((*ptr)[0]), arena, new_max)
#define DN_PArrayGrowIfNeededFromPool(ptr, size, max, pool, add_count) DN_CArrayGrowIfNeededFromPool((void **)(ptr), size, max, sizeof((*ptr)[0]), pool, add_count)
#define DN_PArrayGrowIfNeededFromArena(ptr, size, max, arena, add_count) DN_CArrayGrowIfNeededFromArena((void **)(ptr), size, max, sizeof((*ptr)[0]), arena, add_count)
#define DN_PArrayMakeArray(ptr, size, max, count, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), count, z_mem)
#define DN_PArrayMakeArrayZ(ptr, size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), count, DN_ZMem_Yes)
#define DN_PArrayMake(ptr, size, max, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), 1, z_mem)
@@ -318,7 +318,7 @@ template <typename T> struct DN_DSMapResult
#define DN_LArrayMakeArray(c_array, size, count, z_mem) DN_PArrayMakeArray(c_array, size, DN_ArrayCountU(c_array), count, z_mem)
#define DN_LArrayMakeArrayZ(c_array, size, count) DN_PArrayMakeArrayZ(c_array, size, DN_ArrayCountU(c_array), count)
#define DN_LArrayMake(c_array, size, z_mem) DN_PArrayMake(c_array, size, DN_ArrayCountU(c_array), z_mem)
#define DN_LArrayMakeZ(c_array, size, max) DN_PArrayMakeZ(c_array, size, DN_ArrayCountU(c_array), max)
#define DN_LArrayMakeZ(c_array, size) DN_PArrayMakeZ(c_array, size, DN_ArrayCountU(c_array))
#define DN_LArrayAddArray(c_array, size, items, count, add) DN_PArrayAddArray(c_array, size, DN_ArrayCountU(c_array), items, count, add)
#define DN_LArrayAdd(c_array, size, item, add) DN_PArrayAdd(c_array, size, DN_ArrayCountU(c_array), item, add)
#define DN_LArrayAppendArray(c_array, size, items, count) DN_PArrayAppendArray(c_array, size, DN_ArrayCountU(c_array), items, count)
@@ -369,8 +369,8 @@ DN_API bool DN_CArrayResizeFromPool
DN_API bool DN_CArrayResizeFromArena (void **data, DN_USize *size, DN_USize *max, DN_USize data_size, DN_Arena *arena, DN_USize new_max);
DN_API bool DN_CArrayGrowFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_CArrayGrowFromArena (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_CArrayGrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool);
DN_API bool DN_CArrayGrowIfNeededFromArena (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Arena *pool);
DN_API bool DN_CArrayGrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize add_count);
DN_API bool DN_CArrayGrowIfNeededFromArena (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Arena *pool, DN_USize add_count);
DN_API void* DN_SinglyLLDetach (void **link, void **next);