public static Matrix2x2d operator -(Matrix2x2d m1, Matrix2x2d m2)
{
Matrix2x2d kSum = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++) {
for (int iCol = 0; iCol < 2; iCol++) {
kSum.m[iRow,iCol] = m1.m[iRow,iCol] - m2.m[iRow,iCol];
}
}
return kSum;
}
public static Matrix2x2d operator *(Matrix2x2d m1, Matrix2x2d m2)
{
Matrix2x2d kProd = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++) {
for (int iCol = 0; iCol < 2; iCol++) {
kProd.m[iRow,iCol] = m1.m[iRow,0] * m2.m[0,iCol] + m1.m[iRow,1] * m2.m[1,iCol];
}
}
return kProd;
}
public static Matrix2x2d operator *(Matrix2x2d m, double s)
{
Matrix2x2d kProd = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++) {
for (int iCol = 0; iCol < 2; iCol++) {
kProd.m[iRow,iCol] = m.m[iRow,iCol] * s;
}
}
return kProd;
}
protected override void UpdateNode()
{
var localToCamera = (Matrix4x4d)GodManager.Instance.WorldToCamera * LocalToWorld;
var localToScreen = (Matrix4x4d)GodManager.Instance.CameraToScreen * localToCamera;
var invLocalToCamera = localToCamera.Inverse();
DeformedCameraPosition = invLocalToCamera * Vector3d.zero; // TODO : Really? zero?
DeformedFrustumPlanes = Frustum.GetFrustumPlanes(localToScreen);
LocalCameraPosition = Deformation.DeformedToLocal(DeformedCameraPosition);
var m = Deformation.LocalToDeformedDifferential(LocalCameraPosition, true);
var left = DeformedFrustumPlanes[0].XYZ().Normalized();
var right = DeformedFrustumPlanes[1].XYZ().Normalized();
var fov = (float)MathUtility.Safe_Acos(-left.Dot(right));
SplitDistance = SplitFactor * Screen.width / 1024.0f * Mathf.Tan(40.0f * Mathf.Deg2Rad) / Mathf.Tan(fov / 2.0f);
DistanceFactor = (float)Math.Max((new Vector3d(m.m[0, 0], m.m[1, 0], m.m[2, 0])).Magnitude(), (new Vector3d(m.m[0, 1], m.m[1, 1], m.m[2, 1])).Magnitude());
if (SplitDistance < 1.1f || !MathUtility.IsFinite(SplitDistance))
{
SplitDistance = 1.1f;
}
// initializes data structures for horizon occlusion culling
if (UseHorizonCulling && LocalCameraPosition.z <= TerrainQuadRoot.ZMax)
{
var deformedDirection = invLocalToCamera * Vector3d.forward;
var localDirection = (Deformation.DeformedToLocal(deformedDirection) - LocalCameraPosition).XY().Normalized();
LocalCameraDirection = new Matrix2x2d(localDirection.y, -localDirection.x, -localDirection.x, -localDirection.y);
for (int i = 0; i < HORIZON_SIZE; ++i)
{
Horizon[i] = float.NegativeInfinity;
}
}
TerrainQuadRoot.UpdateLOD();
//Manager.GetSkyNode().SetUniforms(TerrainMaterial);
//Manager.GetSunNode().SetUniforms(TerrainMaterial);
Body.SetUniforms(TerrainMaterial);
Deformation.SetUniforms(this, TerrainMaterial);
//if (Manager.GetOceanNode() != null)
// Manager.GetOceanNode().SetUniforms(TerrainMaterial);
//else
TerrainMaterial.SetFloat("_Ocean_DrawBRDF", 0.0f);
//if (Manager.GetPlantsNode() != null)
// Manager.GetPlantsNode().SetUniforms(TerrainMaterial);
}
public override double MahalanobisDistance(double x, double y)
{
Matrix2x2d C = (new Matrix2x2d(Covariance)).Inverse;
Vector2d xm = new Vector2d(x - Mean[0], y - Mean[1]);
Vector2d xmTC = new Vector2d();
xmTC.x = xm.x * C.m00 + xm.y * C.m10;
xmTC.y = xm.x * C.m01 + xm.y * C.m11;
return(Math.Sqrt(Vector2d.Dot(xmTC, xm)));
}
public static Matrix2x2d operator -(Matrix2x2d m1, Matrix2x2d m2)
{
Matrix2x2d kSum = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++)
{
for (int iCol = 0; iCol < 2; iCol++)
{
kSum.m[iRow, iCol] = m1.m[iRow, iCol] - m2.m[iRow, iCol];
}
}
return(kSum);
}
public static Matrix2x2d operator *(Matrix2x2d m, double s)
{
Matrix2x2d kProd = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++)
{
for (int iCol = 0; iCol < 2; iCol++)
{
kProd.m[iRow, iCol] = m.m[iRow, iCol] * s;
}
}
return(kProd);
}
public static Matrix2x2d operator *(Matrix2x2d m1, Matrix2x2d m2)
{
Matrix2x2d kProd = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++)
{
for (int iCol = 0; iCol < 2; iCol++)
{
kProd.m[iRow, iCol] = m1.m[iRow, 0] * m2.m[0, iCol] + m1.m[iRow, 1] * m2.m[1, iCol];
}
}
return(kProd);
}
public Matrix2x2d Transpose()
{
Matrix2x2d kTranspose = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++)
{
for (int iCol = 0; iCol < 2; iCol++)
{
kTranspose.m[iRow, iCol] = m[iCol, iRow];
}
}
return(kTranspose);
}
public static Matrix2x2d PolarDecomposition(Matrix2x2d m)
{
Matrix2x2d q = m + new Matrix2x2d(m.m11, -m.m10, -m.m01, m.m00);
Vector2d c0 = q.GetColumn(0);
Vector2d c1 = q.GetColumn(1);
double s = c0.Magnitude;
q.SetColumn(0, c0 / s);
q.SetColumn(1, c1 / s);
return(q);
}
public void Transpose()
{
Matrix2x2d m = new Matrix2x2d();
for (int i = 0; i < HALF_SIZE; i++)
{
for (int j = 0; j < HALF_SIZE; j++)
{
m[j, i] = i + j * HALF_SIZE;
}
}
Assert.AreEqual(Indexed2x2().Transpose, m);
}
public void IndexAssignedTo()
{
Matrix2x2d m = new Matrix2x2d();
for (int i = 0; i < SIZE; i++)
{
m[i] = i;
}
for (int i = 0; i < SIZE; i++)
{
Assert.AreEqual(i, m[i]);
}
}
public void CreatedFromArray2()
{
double[,] d = new double[, ] {
{ 0, 2 },
{ 1, 3 }
};
Matrix2x2d m = new Matrix2x2d(d);
for (int i = 0; i < SIZE; i++)
{
Assert.AreEqual(i, m[i]);
}
}
Matrix2x2d Random2x2(int seed)
{
Random rnd = new Random(seed);
Matrix2x2d m = new Matrix2x2d();
for (int i = 0; i < HALF_SIZE; i++)
{
for (int j = 0; j < HALF_SIZE; j++)
{
m[i, j] = rnd.NextDouble();
}
}
return(m);
}
/// <summary>
/// Resuelve las ecuaciones:
/// u * uux + v * vvx = pox
/// u * uuy + v * vvy = poy
/// Ayuda a determinar las coordenadas del punto <c>po</c> segun el plano formado por <c>uu</c> y <c>vv</c>.
/// </summary>
internal static void Resolve(Vector2d uu, Vector2d vv, Vector2d po,
out double u, out double v)
{
// Resuelve la ecuacion:
// u * uux + v * vvx = pox
// u * uuy + v * vvy = poy
//
// Se replantea como:
//
// / \ / \ / \
// | uux vvx | | u | | pox |
// | | * | | = | |
// | uuy vvy | | v | | poy |
// \ / \ / \ /
//
// Si se toma el primera y segunda ecuacion, se multiplican
// por uuy y uux respectivamente y se restan:
// (u * uux * uuy + v * vvx * uuy) - (u * uuy * uux + v * vvy * uux) = pox * uuy - poy * uux
// Simplificando:
// v * vvx * uuy - v * vvy * uux = pox * uuy - poy * uux
// despejando v:
// v = (pox * uuy - poy * uux) / (vvx * uuy - vvy * uux)
// Y despejando u en cualquier ecuacion:
// u = (pox - v * vvx) / uux
// Por estabilidad numerica se intenta que los divisores esten lo mas alejados
// posible del 0.
/*v = (po.X * uu.Y - po.Y * uu.X) / (vv.X * uu.Y - vv.Y * uu.X);
*
* if (Math.Abs(uu.X) > Math.Abs(uu.Y))
* {
* u = (po.X - v * vv.X) / uu.X;
* }
* else
* {
* u = (po.Y - v * vv.Y) / uu.Y;
* }*/
// Se resuelve como un cambio de coordenadas.
Matrix2x2d m = new Matrix2x2d(uu, vv);
m.Inv();
Point2d ret = m * po;
u = ret.X;
v = ret.Y;
}
//public bool Inverse(ref Matrix2x2d mInv, double tolerance = 1e-06)
public bool Inverse(ref Matrix2x2d mInv, double tolerance)
{
double det = Determinant();
if (System.Math.Abs(det) <= tolerance)
{
return(false);
}
double invDet = 1.0 / det;
mInv.m[0, 0] = m[1, 1] * invDet;
mInv.m[0, 1] = -m[0, 1] * invDet;
mInv.m[1, 0] = -m[1, 0] * invDet;
mInv.m[1, 1] = m[0, 0] * invDet;
return(true);
}
public void Index2AssignedTo()
{
Matrix2x2d m = new Matrix2x2d();
for (int i = 0; i < HALF_SIZE; i++)
{
for (int j = 0; j < HALF_SIZE; j++)
{
m[i, j] = i + j * HALF_SIZE;
}
}
for (int i = 0; i < HALF_SIZE; i++)
{
for (int j = 0; j < HALF_SIZE; j++)
{
Assert.AreEqual(i + j * HALF_SIZE, m[i, j]);
}
}
}
public Matrix2x2d(Matrix2x2d m)
{
System.Array.Copy(m.m, this.m, 4);
}
public Matrix2x2d Transpose()
{
Matrix2x2d kTranspose = new Matrix2x2d();
for (int iRow = 0; iRow < 2; iRow++) {
for (int iCol = 0; iCol < 2; iCol++) {
kTranspose.m[iRow,iCol] = m[iCol,iRow];
}
}
return kTranspose;
}
public override void UpdateNode()
{
TerrainMaterial.renderQueue = (int)ParentBody.RenderQueue + ParentBody.RenderQueueOffset;
// NOTE : Body shape dependent...
LocalToWorld = Matrix4x4d.ToMatrix4x4d(ParentBody.transform.localToWorldMatrix) * FaceToLocal;
TangentFrameToWorld = new Matrix3x3d(LocalToWorld.m[0, 0], LocalToWorld.m[0, 1], LocalToWorld.m[0, 2],
LocalToWorld.m[1, 0], LocalToWorld.m[1, 1], LocalToWorld.m[1, 2],
LocalToWorld.m[2, 0], LocalToWorld.m[2, 1], LocalToWorld.m[2, 2]);
LocalToCamera = GodManager.Instance.View.WorldToCameraMatrix * LocalToWorld;
LocalToScreen = GodManager.Instance.View.CameraToScreenMatrix * LocalToCamera;
var invLocalToCamera = LocalToCamera.Inverse();
DeformedCameraPosition = invLocalToCamera * Vector3d.zero;
DeformedFrustumPlanes = Frustum3d.GetFrustumPlanes(LocalToScreen); // NOTE : Extract frustum planes from LocalToScreen matrix...
LocalCameraPosition = Deformation.DeformedToLocal(DeformedCameraPosition);
DeformedLocalToTangent = Deformation.DeformedToTangentFrame(GodManager.Instance.View.WorldCameraPosition) * LocalToWorld * Deformation.LocalToDeformedDifferential(LocalCameraPosition);
var m = Deformation.LocalToDeformedDifferential(LocalCameraPosition, true);
var left = DeformedFrustumPlanes[0].xyz.Normalized();
var right = DeformedFrustumPlanes[1].xyz.Normalized();
var fov = (float)Functions.Safe_Acos(-left.Dot(right));
SplitDistance = SplitFactor * Screen.width / 1024.0f * Mathf.Tan(40.0f * Mathf.Deg2Rad) / Mathf.Tan(fov / 2.0f);
DistanceFactor = (float)Math.Max(new Vector3d(m.m[0, 0], m.m[1, 0], m.m[2, 0]).Magnitude(), new Vector3d(m.m[0, 1], m.m[1, 1], m.m[2, 1]).Magnitude());
if (SplitDistance < 1.1f || SplitDistance > 128.0f || !Functions.IsFinite(SplitDistance))
{
SplitDistance = 1.1f;
}
var splitDistanceBlending = SplitDistance + 1.0f;
DistanceBlending = new Vector2(splitDistanceBlending, 2.0f * SplitDistance - splitDistanceBlending);
// Initializes data structures for horizon occlusion culling
if (UseHorizonCulling && LocalCameraPosition.z <= TerrainQuadRoot.ZMax)
{
var deformedDirection = invLocalToCamera * Vector3d.forward;
var localDirection = (Deformation.DeformedToLocal(deformedDirection) - LocalCameraPosition).Normalized();
LocalCameraDirection = new Matrix2x2d(localDirection.y, -localDirection.x, -localDirection.x, -localDirection.y);
for (var i = 0; i < HORIZON_SIZE; ++i)
{
Horizon[i] = float.NegativeInfinity;
}
}
if (ParentBody.UpdateLOD)
{
TerrainQuadRoot.UpdateLOD();
}
SetUniforms(TerrainMaterial);
}
protected override void UpdateNode()
{
TerrainMaterial.renderQueue = (int)ParentBody.RenderQueue + ParentBody.RenderQueueOffset;
if (ParentBody.GetBodyDeformationType() == BodyDeformationType.Spherical)
{
LocalToWorld = Matrix4x4d.ToMatrix4x4d(ParentBody.transform.localToWorldMatrix) * FaceToLocal;
}
else
{
LocalToWorld = FaceToLocal;
}
TangentFrameToWorld = new Matrix3x3d(LocalToWorld.m[0, 0], LocalToWorld.m[0, 1], LocalToWorld.m[0, 2],
LocalToWorld.m[1, 0], LocalToWorld.m[1, 1], LocalToWorld.m[1, 2],
LocalToWorld.m[2, 0], LocalToWorld.m[2, 1], LocalToWorld.m[2, 2]);
var localToCamera = GodManager.Instance.WorldToCamera * LocalToWorld;
var invLocalToCamera = localToCamera.Inverse();
DeformedCameraPosition = invLocalToCamera * Vector3d.zero;
DeformedFrustumPlanes = Frustum.GetFrustumPlanes(GodManager.Instance.CameraToScreen * localToCamera); // NOTE : Extract frustum planes from LocalToScreen matrix...
LocalCameraPosition = Deformation.DeformedToLocal(DeformedCameraPosition);
var m = Deformation.LocalToDeformedDifferential(LocalCameraPosition, true);
var left = DeformedFrustumPlanes[0].XYZ().Normalized();
var right = DeformedFrustumPlanes[1].XYZ().Normalized();
var fov = (float)MathUtility.Safe_Acos(-left.Dot(right));
SplitDistance = SplitFactor * Screen.width / 1024.0f * Mathf.Tan(40.0f * Mathf.Deg2Rad) / Mathf.Tan(fov / 2.0f);
DistanceFactor = (float)Math.Max((new Vector3d(m.m[0, 0], m.m[1, 0], m.m[2, 0])).Magnitude(), (new Vector3d(m.m[0, 1], m.m[1, 1], m.m[2, 1])).Magnitude());
if (SplitDistance < 1.1f || !MathUtility.IsFinite(SplitDistance))
{
SplitDistance = 1.1f;
}
// initializes data structures for horizon occlusion culling
if (UseHorizonCulling && LocalCameraPosition.z <= TerrainQuadRoot.ZMax)
{
var deformedDirection = invLocalToCamera * Vector3d.forward;
var localDirection = (Deformation.DeformedToLocal(deformedDirection) - LocalCameraPosition).xy.Normalized();
LocalCameraDirection = new Matrix2x2d(localDirection.y, -localDirection.x, -localDirection.x, -localDirection.y);
for (byte i = 0; i < HORIZON_SIZE; ++i)
{
Horizon[i] = float.NegativeInfinity;
}
}
TerrainQuadRoot.UpdateLOD();
SetUniforms(TerrainMaterial);
if (ParentBody.AtmosphereEnabled)
{
if (ParentBody.Atmosphere != null)
{
ParentBody.Atmosphere.SetUniforms(TerrainMaterial);
}
}
if (ParentBody.OceanEnabled)
{
if (ParentBody.Ocean != null)
{
ParentBody.Ocean.SetUniforms(TerrainMaterial);
}
else
{
TerrainMaterial.SetFloat("_Ocean_DrawBRDF", 0.0f);
}
}
else
{
TerrainMaterial.SetFloat("_Ocean_DrawBRDF", 0.0f);
}
Deformation.SetUniforms(this, TerrainMaterial);
//if (Manager.GetPlantsNode() != null)
// Manager.GetPlantsNode().SetUniforms(TerrainMaterial);
}
public Matrix2x2d(Matrix2x2d m)
{
System.Array.Copy(m.m, this.m, 4);
}
//public Matrix2x2d Inverse(double tolerance = 1e-06)
public Matrix2x2d Inverse(double tolerance)
{
Matrix2x2d kInverse = new Matrix2x2d();
Inverse(ref kInverse, tolerance);
return kInverse;
}
//public bool Inverse(ref Matrix2x2d mInv, double tolerance = 1e-06)
public bool Inverse(ref Matrix2x2d mInv, double tolerance)
{
double det = Determinant();
if (System.Math.Abs(det) <= tolerance) {
return false;
}
double invDet = 1.0 / det;
mInv.m[0,0] = m[1,1] * invDet;
mInv.m[0,1] = -m[0,1] * invDet;
mInv.m[1,0] = -m[1,0] * invDet;
mInv.m[1,1] = m[0,0] * invDet;
return true;
}
public bool Equals(Matrix2x2d other)
{
return(this == other);
}
