462 lines
9.6 KiB
C
462 lines
9.6 KiB
C
/* date = March 31st 2021 2:19 am */
|
|
|
|
#ifndef GFX_MATH_H
|
|
#define GFX_MATH_H
|
|
|
|
internal r32
|
|
Smoothstep(r32 T)
|
|
{
|
|
r32 Result = (T * T * (3 - (2 * T)));
|
|
return Result;
|
|
}
|
|
internal r32
|
|
Smoothstep(r32 T, r32 A, r32 B)
|
|
{
|
|
return LerpR32(Smoothstep(T), A, B);
|
|
}
|
|
internal v3
|
|
Smoothstep(v3 P)
|
|
{
|
|
v3 R = {};
|
|
R.x = Smoothstep(P.x);
|
|
R.y = Smoothstep(P.y);
|
|
R.z = Smoothstep(P.z);
|
|
return R;
|
|
}
|
|
|
|
internal v3
|
|
AbsV3(v3 P)
|
|
{
|
|
v3 Result = {};
|
|
Result.x = Abs(P.x);
|
|
Result.y = Abs(P.y);
|
|
Result.z = Abs(P.z);
|
|
return Result;
|
|
}
|
|
|
|
internal v2
|
|
FloorV2(v2 P)
|
|
{
|
|
v2 Result = {};
|
|
Result.x = FloorR32(P.x);
|
|
Result.y = FloorR32(P.y);
|
|
return Result;
|
|
}
|
|
internal v3
|
|
FloorV3(v3 P)
|
|
{
|
|
v3 Result = {};
|
|
Result.x = FloorR32(P.x);
|
|
Result.y = FloorR32(P.y);
|
|
Result.z = FloorR32(P.z);
|
|
return Result;
|
|
}
|
|
|
|
internal v2
|
|
FractV2(v2 P)
|
|
{
|
|
v2 Result = {};
|
|
Result.x = FractR32(P.x);
|
|
Result.y = FractR32(P.y);
|
|
return Result;
|
|
}
|
|
internal v3
|
|
FractV3(v3 P)
|
|
{
|
|
v3 Result = {};
|
|
Result.x = FractR32(P.x);
|
|
Result.y = FractR32(P.y);
|
|
Result.z = FractR32(P.z);
|
|
return Result;
|
|
}
|
|
|
|
internal v2
|
|
SinV2(v2 P)
|
|
{
|
|
v2 Result = {};
|
|
Result.x = SinR32(P.x);
|
|
Result.y = SinR32(P.y);
|
|
return Result;
|
|
}
|
|
internal v3
|
|
SinV3(v3 P)
|
|
{
|
|
v3 Result = {};
|
|
Result.x = SinR32(P.x);
|
|
Result.y = SinR32(P.y);
|
|
Result.y = SinR32(P.z);
|
|
return Result;
|
|
}
|
|
|
|
internal r32
|
|
Hash1(v2 P)
|
|
{
|
|
v2 Result = FractV2( P * 0.3183099f ) * 50.f;
|
|
return FractR32(P.x * P.y * (P.x + P.y));
|
|
}
|
|
|
|
internal r32
|
|
Hash1(r32 N)
|
|
{
|
|
return FractR32(N * 17.0f * FractR32(N * 0.3183099f));
|
|
}
|
|
|
|
internal v2
|
|
Hash2(r32 N)
|
|
{
|
|
v2 P = V2MultiplyPairwise(SinV2(v2{N,N+1.0f}), v2{43758.5453123f,22578.1459123f});
|
|
return FractV2(P);
|
|
}
|
|
|
|
internal v2
|
|
Hash2(v2 P)
|
|
{
|
|
v2 K = v2{ 0.3183099f, 0.3678794f };
|
|
v2 Kp = v2{K.y, K.x};
|
|
v2 R = V2MultiplyPairwise(P, K) + Kp;
|
|
return FractV2( K * 16.0f * FractR32( P.x * P.y * (P.x + P.y)));
|
|
}
|
|
|
|
internal v3
|
|
Hash3(v2 P)
|
|
{
|
|
v3 Q = v3{};
|
|
Q.x = V2Dot(P, v2{127.1f, 311.7f});
|
|
Q.y = V2Dot(P, v2{267.5f, 183.3f});
|
|
Q.z = V2Dot(P, v2{419.2f, 371.9f});
|
|
return FractV3(SinV3(Q) * 43758.5453f);
|
|
}
|
|
|
|
internal r32
|
|
HashV3ToR32(v3 P)
|
|
{
|
|
v3 Pp = FractV3(P * 0.3183099f + v3{0.1f, 0.1f, 0.1f});
|
|
Pp *= 17.0f;
|
|
r32 Result = FractR32(Pp.x * Pp.y * Pp.z * (Pp.x + Pp.y + Pp.z));
|
|
return Result;
|
|
}
|
|
|
|
internal r32
|
|
Random(v2 N)
|
|
{
|
|
v2 V = v2{12.9898f, 4.1414f};
|
|
return FractR32(SinR32(V2Dot(N, V)) * 43758.5453);
|
|
}
|
|
|
|
internal r32
|
|
Noise2D(v2 P)
|
|
{
|
|
v2 IP = FloorV2(P);
|
|
v2 U = FractV2(P);
|
|
U = V2MultiplyPairwise(U, U);
|
|
U = V2MultiplyPairwise(U, ((U * 2.0f) + v2{-3, -3}));
|
|
|
|
r32 A = LerpR32(U.x, Random(IP), Random(IP + v2{1.0f, 0}));
|
|
r32 B = LerpR32(U.x, Random(IP + v2{0, 1}), Random(IP + v2{1, 1}));
|
|
r32 Res = LerpR32(U.y, A, B);
|
|
|
|
return Res * Res;
|
|
}
|
|
|
|
internal r32
|
|
Noise3D(v3 P)
|
|
{
|
|
P = AbsV3(P);
|
|
v3 PFloor = FloorV3(P);
|
|
v3 PFract = FractV3(P);
|
|
v3 F = Smoothstep(PFract);
|
|
|
|
r32 Result = LerpR32(F.z,
|
|
LerpR32(F.y,
|
|
LerpR32(F.x,
|
|
HashV3ToR32(PFloor + v3{0, 0, 0}),
|
|
HashV3ToR32(PFloor + v3{1, 0, 0})),
|
|
LerpR32(F.x,
|
|
HashV3ToR32(PFloor + v3{0, 1, 0}),
|
|
HashV3ToR32(PFloor + v3{1, 1, 0}))),
|
|
LerpR32(F.y,
|
|
LerpR32(F.x,
|
|
HashV3ToR32(PFloor + v3{0, 0, 1}),
|
|
HashV3ToR32(PFloor + v3{1, 0, 1})),
|
|
LerpR32(F.x,
|
|
HashV3ToR32(PFloor + v3{0, 1, 1}),
|
|
HashV3ToR32(PFloor + v3{1, 1, 1}))));
|
|
|
|
Assert(Result >= 0 && Result <= 1);
|
|
return Result;
|
|
}
|
|
|
|
internal r32
|
|
Noise3D_(v3 Pp)
|
|
{
|
|
v3 P = FloorV3(Pp);
|
|
v3 W = FractV3(Pp);
|
|
|
|
//v3 U = W * W * W * (W * (W * 6.0f - 15.0f) + 10.0f);
|
|
v3 U = V3MultiplyPairwise(W, W * 6.0f - v3{15, 15, 15});
|
|
U = U + v3{10, 10, 10};
|
|
U = V3MultiplyPairwise(U, W);
|
|
U = V3MultiplyPairwise(U, W);
|
|
U = V3MultiplyPairwise(U, W);
|
|
|
|
r32 N = P.x + 317.0f * P.y + 157.0f * P.z;
|
|
|
|
r32 A = Hash1(N + 0.0f);
|
|
r32 B = Hash1(N + 1.0f);
|
|
r32 C = Hash1(N + 317.0f);
|
|
r32 D = Hash1(N + 317.0f);
|
|
r32 E = Hash1(N + 157.0f);
|
|
r32 F = Hash1(N + 158.0f);
|
|
r32 G = Hash1(N + 474.0f);
|
|
r32 H = Hash1(N + 475.0f);
|
|
|
|
r32 K0 = A;
|
|
r32 K1 = B - A;
|
|
r32 K2 = C - A;
|
|
r32 K3 = E - A;
|
|
r32 K4 = A - B - C + D;
|
|
r32 K5 = A - C - E + G;
|
|
r32 K6 = A - B - E + F;
|
|
r32 K7 = A + B + C - D + E - F - G + H;
|
|
|
|
return -1.0f + 2.0f * (K0 +
|
|
K1 * U.x +
|
|
K2 * U.y +
|
|
K3 * U.z +
|
|
K4 * U.x * U.y +
|
|
K5 * U.y + U.z +
|
|
K6 * U.z * U.x +
|
|
K7 * U.x * U.y * U.z);
|
|
}
|
|
|
|
internal r32
|
|
Fbm2D(v2 P)
|
|
{
|
|
r32 R = 0;
|
|
r32 Amp = 1.0;
|
|
r32 Freq = 1.0;
|
|
for (u32 i = 0; i < 3; i++)
|
|
{
|
|
R += Amp * Noise2D(P * Freq);
|
|
Amp *= 0.5f;
|
|
Freq *= 1.0f / 0.5f;
|
|
}
|
|
return R;
|
|
}
|
|
|
|
global m44 M3 = m44{
|
|
0.00f, 0.80f, 0.60f, 0,
|
|
-0.80f, 0.36f, -0.48f, 0,
|
|
-0.60f, -0.48f, 0.64f, 0,
|
|
0, 0, 0, 1
|
|
};
|
|
|
|
internal r32
|
|
Fbm3D(v3 P)
|
|
{
|
|
v3 X = P;
|
|
r32 F = 2.0f;
|
|
r32 S = 0.5f;
|
|
r32 A = 0.0f;
|
|
r32 B = 0.5f;
|
|
for (u32 i = 0; i < 4; i++)
|
|
{
|
|
r32 N = Noise3D(X);
|
|
A += B * N;
|
|
B *= S;
|
|
v4 Xp = M3 * ToV4Point(X);
|
|
X = Xp.xyz * F;
|
|
}
|
|
|
|
return A;
|
|
}
|
|
|
|
internal r32
|
|
Fbm3D(v3 P, r32 T)
|
|
{
|
|
v3 Tt = v3{T, T, T};
|
|
r32 SinT = SinR32(T);
|
|
v3 Tv = v3{SinT, SinT, SinT};
|
|
v3 Pp = P;
|
|
r32 F = 0.0;
|
|
|
|
F += 0.500000f * Noise3D(Pp + Tt); Pp = Pp * 2.02;
|
|
//F += 0.031250f * Noise3D(Pp); Pp = Pp * 2.01;
|
|
F += 0.300000f * Noise3D(Pp - Tt); Pp = Pp * 2.03;
|
|
F += 0.125000f * Noise3D(Pp); Pp = Pp * 2.01;
|
|
F += 0.062500f * Noise3D(Pp + Tt); Pp = Pp * 2.04;
|
|
//F += 0.015625f * Noise3D(Pp + Tv);
|
|
r32 D = 0.9875f;
|
|
|
|
F = F / D;
|
|
return F;
|
|
}
|
|
|
|
internal r32
|
|
Voronoise(v2 P, r32 U, r32 V)
|
|
{
|
|
r32 K = 1.0f + 63.0f + PowR32(1.0f - V, 6.0f);
|
|
|
|
v2 I = FloorV2(P);
|
|
v2 F = FractV2(P);
|
|
|
|
v2 A = v2{0, 0};
|
|
for (s32 y = -2; y <= 2; y++)
|
|
{
|
|
for (s32 x = -2; x <= 2; x++)
|
|
{
|
|
v2 G = v2{(r32)x, (r32)y};
|
|
v3 O = V3MultiplyPairwise(Hash3(I + G), v3{U, U, 1.0f});
|
|
v2 D = G - F + O.xy;
|
|
r32 W = PowR32(1.0f - Smoothstep(V2Mag(D), 0.0f, 1.414f), K);
|
|
A += v2{O.z * W, W};
|
|
}
|
|
}
|
|
|
|
return A.x / A.y;
|
|
}
|
|
|
|
|
|
v4 RGBToHSV(v4 In)
|
|
{
|
|
v4 Result = {};
|
|
|
|
r32 Min = Min(In.r, Min(In.g, In.b));
|
|
r32 Max = Max(In.r, Max(In.g, In.b));
|
|
|
|
r32 V = Max;
|
|
r32 Delta = Max - Min;
|
|
r32 S = 0;
|
|
r32 H = 0;
|
|
if( Max != 0 )
|
|
{
|
|
S = Delta / Max;
|
|
|
|
if( In.r == Max )
|
|
{
|
|
H = ( In.g - In.b ) / Delta; // between yellow & magenta
|
|
}
|
|
else if( In.g == Max )
|
|
{
|
|
H = 2 + ( In.b - In.r ) / Delta; // between cyan & yellow
|
|
}
|
|
else
|
|
{
|
|
H = 4 + ( In.r - In.g ) / Delta; // between magenta & cyan
|
|
}
|
|
H *= 60; // degrees
|
|
if( H < 0 )
|
|
H += 360;
|
|
Result = v4{H, S, V, 1};
|
|
}
|
|
else
|
|
{
|
|
// r = g = b = 0
|
|
// s = 0, v is undefined
|
|
S = 0;
|
|
H = -1;
|
|
Result = v4{H, S, 1, 1};
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
v4 HSVToRGB (v4 In)
|
|
{
|
|
float Hue = In.x;
|
|
/*
|
|
while (Hue > 360.0f) { Hue -= 360.0f; }
|
|
while (Hue < 0.0f) { Hue += 360.0f; }
|
|
*/
|
|
Hue = ModR32(Hue, 360.0f);
|
|
if (Hue < 0) { Hue += 360.0f; }
|
|
if (Hue == MinR32) { Hue = 0; }
|
|
if (Hue == MaxR32) { Hue = 360; }
|
|
Assert(Hue >= 0 && Hue < 360);
|
|
|
|
float Sat = In.y;
|
|
float Value = In.z;
|
|
|
|
float hh, p, q, t, ff;
|
|
long i;
|
|
v4 Result = {};
|
|
Result.a = In.a;
|
|
|
|
if(Sat <= 0.0f) { // < is bogus, just shuts up warnings
|
|
Result.r = Value;
|
|
Result.g = Value;
|
|
Result.b = Value;
|
|
return Result;
|
|
}
|
|
hh = Hue;
|
|
if(hh >= 360.0f) hh = 0.0f;
|
|
hh /= 60.0f;
|
|
i = (long)hh;
|
|
ff = hh - i;
|
|
p = Value * (1.0f - Sat);
|
|
q = Value * (1.0f - (Sat * ff));
|
|
t = Value * (1.0f - (Sat * (1.0f - ff)));
|
|
|
|
switch(i) {
|
|
case 0:
|
|
{Result.r = Value;
|
|
Result.g = t;
|
|
Result.b = p;
|
|
}break;
|
|
|
|
case 1:
|
|
{
|
|
Result.r = q;
|
|
Result.g = Value;
|
|
Result.b = p;
|
|
}break;
|
|
|
|
case 2:
|
|
{
|
|
Result.r = p;
|
|
Result.g = Value;
|
|
Result.b = t;
|
|
}break;
|
|
|
|
case 3:
|
|
{
|
|
Result.r = p;
|
|
Result.g = q;
|
|
Result.b = Value;
|
|
}break;
|
|
|
|
case 4:
|
|
{
|
|
Result.r = t;
|
|
Result.g = p;
|
|
Result.b = Value;
|
|
}break;
|
|
|
|
case 5:
|
|
default:
|
|
{
|
|
Result.r = Value;
|
|
Result.g = p;
|
|
Result.b = q;
|
|
}break;
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
internal pixel
|
|
V4ToRGBPixel(v4 C)
|
|
{
|
|
C.x = Clamp01(C.x);
|
|
C.y = Clamp01(C.y);
|
|
C.z = Clamp01(C.z);
|
|
|
|
pixel Result = {};
|
|
Result.R = (u8)(C.x * 255);
|
|
Result.G = (u8)(C.y * 255);
|
|
Result.B = (u8)(C.z * 255);
|
|
return Result;
|
|
}
|
|
|
|
#endif //GFX_MATH_H
|