public void CheckMatrixReferenceEquality()
{
vec2 v2_1 = new vec2(1, 0);
vec2 v2_2 = new vec2(1, 0);
vec2 v2_3 = new vec2(0, 0);
mat2 m2_1 = new mat2(v2_1, v2_2);
mat2 m2_2 = new mat2(v2_1, v2_2);
mat2 m2_3 = new mat2(v2_1, v2_3);
vec3 v3_1 = new vec3(1, 0, 1);
vec3 v3_2 = new vec3(1, 0, 1);
vec3 v3_3 = new vec3(0, 0, 1);
mat3 m3_1 = new mat3(v3_1, v3_2, v3_2);
mat3 m3_2 = new mat3(v3_1, v3_2, v3_2);
mat3 m3_3 = new mat3(v3_1, v3_2, v3_3);
vec4 v4_1 = new vec4(1, 0, 1, 1);
vec4 v4_2 = new vec4(1, 0, 1, 1);
vec4 v4_3 = new vec4(0, 0, 1, 1);
mat4 m4_1 = new mat4(v4_1, v4_2, v4_2, v4_2);
mat4 m4_2 = new mat4(v4_1, v4_2, v4_2, v4_2);
mat4 m4_3 = new mat4(v4_1, v4_2, v4_2, v4_3);
Assert.AreEqual(m2_1.GetHashCode(), m2_2.GetHashCode(), "Error Hashcodes are not the Same");
Assert.AreNotEqual(m2_1.GetHashCode(), m2_3.GetHashCode(), "Error Hashcodes are the Same");
Assert.AreEqual(m3_1.GetHashCode(), m3_2.GetHashCode(), "Error Hashcodes are not the Same");
Assert.AreNotEqual(m3_1.GetHashCode(), m3_3.GetHashCode(), "Error Hashcodes are the Same");
Assert.AreEqual(m4_1.GetHashCode(), m4_2.GetHashCode(), "Error Hashcodes are not the Same");
Assert.AreNotEqual(m4_1.GetHashCode(), m4_3.GetHashCode(), "Error Hashcodes are the Same");
}
public void Simple()
{
/*
* 1 2
* 3 4
*/
var m1 = new mat2(1, 3, 2, 4);
/*
* 5 7
* 6 8
*/
var m2 = new mat2(5, 6, 7, 8);
/*
* 1 2 * 5 7 = 17 23
* 3 4 6 8 39 53
*/
var r = m1 * m2;
Assert.AreEqual(r.m00, 17);
Assert.AreEqual(r.m01, 39);
Assert.AreEqual(r.m10, 23);
Assert.AreEqual(r.m11, 53);
}
public DebuggerProxy(mat2 m)
{
m00 = m.m00;
m01 = m.m01;
m10 = m.m10;
m11 = m.m11;
}
public static int Main(string[] args)
{
mat2 m = (1, 2, 0, -1);
poly p1 = (0, 0, 0, 2);
poly p2 = (0, 0, 3);
var r0 = p2.Derivative;
var r1 = p1 << 1;
var r2 = p1 >> 1;
var r3 = p1 + p2;
var r4 = p1 - p2;
var r5 = p1 * p2;
var r6 = p1 / p2;
var r7 = p1 % p2;
mat3 mat = (
1, 1, 1,
1, 0, 1,
1, 0, 1
);
vec3 b = (0, 4, 2);
var x = mat.Solve(b);
poly p3 = (-1, 1);
poly p4 = (-1, 0, 1);
poly p5 = (-1, 0, 0, 1);
poly p6 = (0, 0, 0, 0, 0, 0, 1);
poly p7 = (2, 1, 8, 3);
return(0);
}
/// <summary>
/// Gets the transposed matrix.
/// <para>获取转置矩阵。</para>
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 transpose(mat2 m)
{
vec2 col0 = m.col0;
vec2 col1 = m.col1;
return(new mat2(
new vec2(col0.x, col1.x),
new vec2(col0.y, col1.y)
));
}
internal override void SetValue(ValueType value)
{
if (value.GetType() != typeof(mat2))
{
throw new ArgumentException(string.Format("[{0}] not match [{1}]'s value.",
value.GetType().Name, this.GetType().Name));
}
this.Value = (mat2)value;
}
public void Set(string name, mat2 val, bool transpose = false, bool keep_layout = true)
{
if (Values.TryGetValue(name, out var v))
{
v.Set(val, transpose, keep_layout);
}
else
{
Values.Add(name, new Value(val, transpose)); Keys.AddLast(name);
}
}
public override void mainImage(out vec4 fragColor, vec2 fragCoord)
{
//get coords and direction
vec2 uv = fragCoord.xy / iResolution.xy - .5f;
uv.y *= iResolution.y / iResolution.x;
vec3 dir = new vec3(uv * zoom, 1f);
float time = iGlobalTime * speed + .25f;
//mouse rotation
float a1 = .5f + iMouse.x / iResolution.x * 2f;
float a2 = .8f + iMouse.y / iResolution.y * 2f;
mat2 rot1 = new mat2(cos(a1), sin(a1), -sin(a1), cos(a1));
mat2 rot2 = new mat2(cos(a2), sin(a2), -sin(a2), cos(a2));
dir.xz *= rot1;
dir.xy *= rot2;
vec3 from = new vec3(1f, .5f, 0.5f);
from += new vec3(time * 2f, time, -2f);
from.xz *= rot1;
from.xy *= rot2;
//volumetric rendering
float s = 0.1f, fade = 1f;
vec3 v = new vec3(0f);
for (int r = 0; r < volsteps; r++)
{
vec3 p = from + s * dir * .5f;
p = abs(new vec3(tile) - mod(p, new vec3(tile * 2f))); // tiling fold
float pa, a = pa = 0f;
for (int i = 0; i < iterations; i++)
{
p = abs(p) / dot(p, p) - formuparam; // the magic formula
a += abs(length(p) - pa); // absolute sum of average change
pa = length(p);
}
float dm = max(0f, darkmatter - a * a * .001f); //dark matter
a *= a * a; // add contrast
if (r > 6)
{
fade *= 1f - dm; // dark matter, don't render near
}
//v+=vec3(dm,dm*.5,0.);
v += fade;
v += new vec3(s, s * s, s * s * s * s) * a * brightness * fade; // coloring based on distance
fade *= distfading; // distance fading
s += stepsize;
}
v = mix(new vec3(length(v)), v, saturation); //color adjust
fragColor = new vec4(v * .01f, 1f);
}
public static float[] serialize(this mat2 value, float[] array = null)
{
array = array ?? new float[4];
if (array.Length != 4)
{
throw new ArgumentException("Invalid array length.");
}
for (var c = 0; c < 4; ++c)
{
array[c] = value[c / 2, c % 2];
}
return(array);
}
public void CanMultiplyByVector()
{
var m = new mat2(new[]
{
new vec2(1f, 2f),
new vec2(3f, 4f)
});
var v = new vec2(5f, 6f);
// 1 3 * 5 = 5 18 = 23
// 2 4 6 10 24 = 34
Assert.AreEqual(new vec2(23f, 34f), m * v, "Rank 2 Matrix * Vector results are incorrect.");
}
/// <summary>
/// Gets the inversed matrix.
/// <para>获取逆矩阵。</para>
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 inverse(mat2 m)
{
float OneOverDeterminant = (1f) / (
+m[0][0] * m[1][1]
- m[1][0] * m[0][1]);
mat2 Inverse = new mat2(
+m[1][1] * OneOverDeterminant,
-m[0][1] * OneOverDeterminant,
-m[1][0] * OneOverDeterminant,
+m[0][0] * OneOverDeterminant);
return Inverse;
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 inverse(mat2 m)
{
float OneOverDeterminant = (1f) / (
+m[0][0] * m[1][1]
- m[1][0] * m[0][1]);
mat2 Inverse = new mat2(
+m[1][1] * OneOverDeterminant,
-m[0][1] * OneOverDeterminant,
-m[1][0] * OneOverDeterminant,
+m[0][0] * OneOverDeterminant);
return(Inverse);
}
/// <summary>
/// </summary>
/// <param name="uniformName"></param>
/// <param name="m"></param>
public int glUniform(string uniformName, mat2 m)
{
int location = GetUniformLocation(uniformName);
if (location >= 0)
{
if (glUniformMatrix2fv == null)
{
glUniformMatrix2fv = OpenGL.GetDelegateFor <OpenGL.glUniformMatrix2fv>();
}
float[] array = m.ToArray();
glUniformMatrix2fv(location, 1, false, array);
}
return(location);
}
/// <summary>
/// </summary>
/// <param name="uniformName"></param>
/// <param name="m"></param>
internal int glUniform(string uniformName, mat2 m)
{
int location = GetUniformLocation(uniformName);
if (location >= 0)
{
if (glUniformMatrix2fv == null)
{
glUniformMatrix2fv = GL.Instance.GetDelegateFor("glUniformMatrix2fv", GLDelegates.typeof_void_int_int_bool_floatN) as GLDelegates.void_int_int_bool_floatN;
}
float[] array = m.ToArray();
glUniformMatrix2fv(location, 1, false, array);
}
return(location);
}
public void MatrixIsColumnMajor()
{
// A pretty critical test as this is fundamental.
var m = new mat2(new[] {
new vec2(1f, 2f),
new vec2(3f, 4f)
});
// 1 3
// 2 4
Assert.AreEqual(1f, m[0][0], "Matrix does not implement column major semantics");
Assert.AreEqual(2f, m[0][1], "Matrix does not implement column major semantics");
Assert.AreEqual(3f, m[1][0], "Matrix does not implement column major semantics");
Assert.AreEqual(4f, m[1][1], "Matrix does not implement column major semantics");
Assert.AreEqual(1f, m[0, 0], "Matrix does not implement column major semantics");
Assert.AreEqual(2f, m[0, 1], "Matrix does not implement column major semantics");
Assert.AreEqual(3f, m[1, 0], "Matrix does not implement column major semantics");
Assert.AreEqual(4f, m[1, 1], "Matrix does not implement column major semantics");
Assert.AreEqual(new vec2(1f, 2f), m[0], "Matrix does not implement column major semantics");
Assert.AreEqual(new vec2(3f, 4f), m[1], "Matrix does not implement column major semantics");
}
/// <summary>
/// </summary>
/// <param name="uniformName"></param>
/// <param name="matrixes"></param>
internal int glUniform(string uniformName, mat2[] matrixes)
{
int location = GetUniformLocation(uniformName);
if (location >= 0)
{
if (glUniformMatrix2fv == null)
{
glUniformMatrix2fv = GL.Instance.GetDelegateFor("glUniformMatrix2fv", GLDelegates.typeof_void_int_int_bool_floatN) as GLDelegates.void_int_int_bool_floatN;
}
var values = new float[matrixes.Length * 4];
for (int index = 0, i = 0; i < matrixes.Length; i++)
{
mat2 matrix = matrixes[i];
values[index++] = matrix.col0.x;
values[index++] = matrix.col0.y;
values[index++] = matrix.col1.x;
values[index++] = matrix.col1.y;
}
glUniformMatrix2fv(location, matrixes.Length, false, values);
}
return(location);
}
/// <summary>
/// Gets the transposed matrix.
/// <para>获取转置矩阵。</para>
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 transpose(mat2 m)
{
vec2 col0 = m.col0;
vec2 col1 = m.col1;
return new mat2(
new vec2(col0.x, col1.x),
new vec2(col0.y, col1.y)
);
}
/// <summary>Returns the determinant of m. </summary>
protected float determinant(mat2 m)
{
throw _invalidAccess;
}
/// <summary>
/// Returns a matrix that is the transpose
/// of m. The input matrix is not
/// modified.
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 transpose(mat2 m)
{
return(null);
}
/// <summary>
/// Returns a matrix that is the inverse of
/// m. The input matrix is not modified.
/// The values in the returned matrix are
/// undefined if the input matrix is
/// singular or poorly conditioned (nearly
/// singular).
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public static mat2 inverse(mat2 m)
{
return(null);
}
/// <summary>
/// Multiply matrix x by matrix y
/// component-wise, i.e., result[i][j] is the
/// scalar product of x[i][j] and y[i][j].
/// Note: To get linear-algebraic matrix
/// multiplication, use the multiply
/// operator (*).
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static mat2 matrixCompMult(mat2 x, mat2 y)
{
return(null);
}
protected extern mat2 inverse(mat2 m);
public extern mat4(mat2 matrix);
/// <summary>
/// Returns a matrix that is the transpose of m.
/// The input matrix m is not modified.
/// </summary>
protected mat2 transpose(mat2 m)
{
throw _invalidAccess;
}
protected extern mat2 transpose(mat2 m);
/// <summary>
/// Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product of x[i][j] and y[i][j].
/// Note: to get linear algebraic matrix multiplication, use the multiply operator (*).
/// </summary>
protected mat2 matrixCompMult(mat2 x, mat2 y)
{
throw _invalidAccess;
}
/// <summary>Returns the determinant of m. </summary>
protected float determinant(mat2 m)
{
throw _invalidAccess;
}
public extern mat3(mat2 matrix);
/// <summary>
/// </summary>
/// <param name="uniformName"></param>
/// <param name="m"></param>
public int SetUniformMatrix2(string uniformName, mat2[] m)
{
int location = GetUniformLocation(uniformName);
if (location >= 0)
{
if (glUniformMatrix2fv == null) { glUniformMatrix2fv = OpenGL.GetDelegateFor<OpenGL.glUniformMatrix2fv>(); }
var values = new float[m.Length * 4];
for (int index = 0, i = 0; i < m.Length; i++)
{
float[] array = m[i].ToArray();
for (int j = 0; j < 4; j++)
{
values[index++] = array[j];
}
}
glUniformMatrix2fv(location, m.Length / 4, false, values);
}
return location;
}
/// <summary>initialized the matrix with the upperleft part of m
/// sets the lower right diagonal component(s) to 1, everything else to 0</summary>
public mat4x3(mat2 m)
{
throw _invalidAccess;
}
protected mat2 matrixCompMult(mat2 x, mat2 y)
{
throw new NotImplementedException();
}
public mat3(mat2 matrix)
{
throw new NotImplementedException();
}
// Matrix Functions
protected extern mat2 matrixCompMult(mat2 x, mat2 y);
protected mat2 transpose(mat2 m)
{
throw new NotImplementedException();
}
protected extern mat2 determinant(mat2 m);
protected mat2 determinant(mat2 m)
{
throw new NotImplementedException();
}
protected mat2 inverse(mat2 m)
{
throw new NotImplementedException();
}
/// <summary>initialized the matrix with the upperleft part of m
/// sets the lower right diagonal component(s) to 1, everything else to 0</summary>
public mat3x4(mat2 m)
{
throw _invalidAccess;
}
