|
| 1 | +#define M_FLOAT_EPS 1e-8 |
| 2 | + |
| 3 | +#define mx_inversesqrt rsqrt |
| 4 | +#define mx_sin sin |
| 5 | +#define mx_cos cos |
| 6 | +#define mx_tan tan |
| 7 | +#define mx_asin asin |
| 8 | +#define mx_acos acos |
| 9 | +#define mx_radians radians |
| 10 | +#define mx_float_bits_to_int asint |
| 11 | + |
| 12 | +/// The GLSL we are piggybacking on has all its matrices transposed compared to Slang and the MaterialX spec. |
| 13 | +/// (The matrices are defined like mat3(1, 2, 3, 4, 5, 6, 7, 8, 9) where the spec says it should be row-major order, but GLSL creates it as col-major) |
| 14 | +/// So when GLSL code says "mul(M, v)" it means "v * transpose(M)", and since in Slang the matrices are stored |
| 15 | +/// in row-major order, we need to reverse the order of multiplication to get the same result. |
| 16 | +float2 mx_matrix_mul(float2 v, float2x2 m) { return mul(m, v); } |
| 17 | +float3 mx_matrix_mul(float3 v, float3x3 m) { return mul(m, v); } |
| 18 | +float4 mx_matrix_mul(float4 v, float4x4 m) { return mul(m, v); } |
| 19 | +float2 mx_matrix_mul(float2x2 m, float2 v) { return mul(v, m); } |
| 20 | +float3 mx_matrix_mul(float3x3 m, float3 v) { return mul(v, m); } |
| 21 | +float4 mx_matrix_mul(float4x4 m, float4 v) { return mul(v, m); } |
| 22 | +float2x2 mx_matrix_mul(float2x2 m1, float2x2 m2) { return mul(m2, m1); } |
| 23 | +float3x3 mx_matrix_mul(float3x3 m1, float3x3 m2) { return mul(m2, m1); } |
| 24 | +float4x4 mx_matrix_mul(float4x4 m1, float4x4 m2) { return mul(m2, m1); } |
| 25 | + |
| 26 | +float mx_square(float x) |
| 27 | +{ |
| 28 | + return x*x; |
| 29 | +} |
| 30 | + |
| 31 | +float2 mx_square(float2 x) |
| 32 | +{ |
| 33 | + return x*x; |
| 34 | +} |
| 35 | + |
| 36 | +float3 mx_square(float3 x) |
| 37 | +{ |
| 38 | + return x*x; |
| 39 | +} |
| 40 | + |
| 41 | +float3 mx_srgb_encode(float3 color) |
| 42 | +{ |
| 43 | + bool3 isAbove = (color > float3(0.0031308)); |
| 44 | + float3 linSeg = color * 12.92; |
| 45 | + float3 powSeg = 1.055 * pow(max(color, float3(0.0)), float3(1.0 / 2.4)) - 0.055; |
| 46 | + return select(isAbove, powSeg, linSeg); |
| 47 | +} |
| 48 | + |
| 49 | +/// Library assumes GLSL style mod (result has the sign of y), so cannot use fmod |
| 50 | +float mx_mod(float a, float b) { return (a - b * floor(a / b)); } |
| 51 | +float2 mx_mod(float2 a, float2 b) { return (a - b * floor(a / b)); } |
| 52 | +float3 mx_mod(float3 a, float3 b) { return (a - b * floor(a / b)); } |
| 53 | +float4 mx_mod(float4 a, float4 b) { return (a - b * floor(a / b)); } |
| 54 | +float2 mx_mod(float2 a, float b) { return (a - b * floor(a / b)); } |
| 55 | +float3 mx_mod(float3 a, float b) { return (a - b * floor(a / b)); } |
| 56 | +float4 mx_mod(float4 a, float b) { return (a - b * floor(a / b)); } |
| 57 | + |
| 58 | +/// The float3x3 and float4x4 inverse are taken from the Slang's SGL library |
| 59 | +/// https://github.com/shader-slang/sgl/ |
| 60 | +/// Specifically the matrix_math.h |
| 61 | +/// https://github.com/shader-slang/sgl/blob/main/src/sgl/math/matrix_math.h |
| 62 | +float3x3 mx_inverse(float3x3 m) |
| 63 | +{ |
| 64 | + float one_over_det = 1.f / determinant(m); |
| 65 | + |
| 66 | + float3x3 result; |
| 67 | + result[0][0] = +(m[1][1] * m[2][2] - m[1][2] * m[2][1]) * one_over_det; |
| 68 | + result[0][1] = -(m[0][1] * m[2][2] - m[0][2] * m[2][1]) * one_over_det; |
| 69 | + result[0][2] = +(m[0][1] * m[1][2] - m[0][2] * m[1][1]) * one_over_det; |
| 70 | + result[1][0] = -(m[1][0] * m[2][2] - m[1][2] * m[2][0]) * one_over_det; |
| 71 | + result[1][1] = +(m[0][0] * m[2][2] - m[0][2] * m[2][0]) * one_over_det; |
| 72 | + result[1][2] = -(m[0][0] * m[1][2] - m[0][2] * m[1][0]) * one_over_det; |
| 73 | + result[2][0] = +(m[1][0] * m[2][1] - m[1][1] * m[2][0]) * one_over_det; |
| 74 | + result[2][1] = -(m[0][0] * m[2][1] - m[0][1] * m[2][0]) * one_over_det; |
| 75 | + result[2][2] = +(m[0][0] * m[1][1] - m[0][1] * m[1][0]) * one_over_det; |
| 76 | + return result; |
| 77 | +} |
| 78 | + |
| 79 | +float4x4 mx_inverse(float4x4 m) |
| 80 | +{ |
| 81 | + float c00 = m[2][2] * m[3][3] - m[2][3] * m[3][2]; |
| 82 | + float c02 = m[2][1] * m[3][3] - m[2][3] * m[3][1]; |
| 83 | + float c03 = m[2][1] * m[3][2] - m[2][2] * m[3][1]; |
| 84 | + |
| 85 | + float c04 = m[1][2] * m[3][3] - m[1][3] * m[3][2]; |
| 86 | + float c06 = m[1][1] * m[3][3] - m[1][3] * m[3][1]; |
| 87 | + float c07 = m[1][1] * m[3][2] - m[1][2] * m[3][1]; |
| 88 | + |
| 89 | + float c08 = m[1][2] * m[2][3] - m[1][3] * m[2][2]; |
| 90 | + float c10 = m[1][1] * m[2][3] - m[1][3] * m[2][1]; |
| 91 | + float c11 = m[1][1] * m[2][2] - m[1][2] * m[2][1]; |
| 92 | + |
| 93 | + float c12 = m[0][2] * m[3][3] - m[0][3] * m[3][2]; |
| 94 | + float c14 = m[0][1] * m[3][3] - m[0][3] * m[3][1]; |
| 95 | + float c15 = m[0][1] * m[3][2] - m[0][2] * m[3][1]; |
| 96 | + |
| 97 | + float c16 = m[0][2] * m[2][3] - m[0][3] * m[2][2]; |
| 98 | + float c18 = m[0][1] * m[2][3] - m[0][3] * m[2][1]; |
| 99 | + float c19 = m[0][1] * m[2][2] - m[0][2] * m[2][1]; |
| 100 | + |
| 101 | + float c20 = m[0][2] * m[1][3] - m[0][3] * m[1][2]; |
| 102 | + float c22 = m[0][1] * m[1][3] - m[0][3] * m[1][1]; |
| 103 | + float c23 = m[0][1] * m[1][2] - m[0][2] * m[1][1]; |
| 104 | + |
| 105 | + float4 fac0 = float4(c00, c00, c02, c03); |
| 106 | + float4 fac1 = float4(c04, c04, c06, c07); |
| 107 | + float4 fac2 = float4(c08, c08, c10, c11); |
| 108 | + float4 fac3 = float4(c12, c12, c14, c15); |
| 109 | + float4 fac4 = float4(c16, c16, c18, c19); |
| 110 | + float4 fac5 = float4(c20, c20, c22, c23); |
| 111 | + |
| 112 | + float4 vec0 = float4(m[0][1], m[0][0], m[0][0], m[0][0]); |
| 113 | + float4 vec1 = float4(m[1][1], m[1][0], m[1][0], m[1][0]); |
| 114 | + float4 vec2 = float4(m[2][1], m[2][0], m[2][0], m[2][0]); |
| 115 | + float4 vec3 = float4(m[3][1], m[3][0], m[3][0], m[3][0]); |
| 116 | + |
| 117 | + float4 inv0 = float4(vec1 * fac0 - vec2 * fac1 + vec3 * fac2); |
| 118 | + float4 inv1 = float4(vec0 * fac0 - vec2 * fac3 + vec3 * fac4); |
| 119 | + float4 inv2 = float4(vec0 * fac1 - vec1 * fac3 + vec3 * fac5); |
| 120 | + float4 inv3 = float4(vec0 * fac2 - vec1 * fac4 + vec2 * fac5); |
| 121 | + |
| 122 | + float4 sign_a = float4(+1, -1, +1, -1); |
| 123 | + float4 sign_b = float4(-1, +1, -1, +1); |
| 124 | + // make matrix from columns |
| 125 | + float4x4 inverse = transpose(float4x4(inv0 * sign_a, inv1 * sign_b, inv2 * sign_a, inv3 * sign_b)); |
| 126 | + |
| 127 | + float4 row0 = float4(inverse[0][0], inverse[0][1], inverse[0][2], inverse[0][3]); |
| 128 | + float4 col0 = float4(inverse[0][0], inverse[1][0], inverse[2][0], inverse[3][0]); |
| 129 | + |
| 130 | + float4 dot0 = float4(col0 * row0); |
| 131 | + float dot1 = (dot0.x + dot0.y) + (dot0.z + dot0.w); |
| 132 | + |
| 133 | + float one_over_det = 1.f / dot1; |
| 134 | + |
| 135 | + return inverse * one_over_det; |
| 136 | +} |
| 137 | + |
| 138 | +float mx_atan(float y_over_x) |
| 139 | +{ |
| 140 | + return atan(y_over_x); |
| 141 | +} |
| 142 | + |
| 143 | +float mx_atan(float y, float x) |
| 144 | +{ |
| 145 | + return atan2(y, x); |
| 146 | +} |
| 147 | + |
| 148 | +float2 mx_atan(float2 y, float2 x) |
| 149 | +{ |
| 150 | + return atan2(y, x); |
| 151 | +} |
| 152 | + |
| 153 | +float3 mx_atan(float3 y, float3 x) |
| 154 | +{ |
| 155 | + return atan2(y, x); |
| 156 | +} |
| 157 | + |
| 158 | +float4 mx_atan(float4 y, float4 x) |
| 159 | +{ |
| 160 | + return atan2(y, x); |
| 161 | +} |
0 commit comments