public void Construct2()
{
Matrix34<double> m = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Assert.AreEqual(1.0, m.Column0Row0);
Assert.AreEqual(2.0, m.Column1Row0);
Assert.AreEqual(3.0, m.Column2Row0);
Assert.AreEqual(4.0, m.Column0Row1);
Assert.AreEqual(5.0, m.Column1Row1);
Assert.AreEqual(6.0, m.Column2Row1);
Assert.AreEqual(7.0, m.Column0Row2);
Assert.AreEqual(8.0, m.Column1Row2);
Assert.AreEqual(9.0, m.Column2Row2);
Assert.AreEqual(10.0, m.Column0Row3);
Assert.AreEqual(11.0, m.Column1Row3);
Assert.AreEqual(12.0, m.Column2Row3);
Assert.AreEqual(1.0, m.ReadOnlyColumnMajorValues[0]);
Assert.AreEqual(4.0, m.ReadOnlyColumnMajorValues[1]);
Assert.AreEqual(7.0, m.ReadOnlyColumnMajorValues[2]);
Assert.AreEqual(10.0, m.ReadOnlyColumnMajorValues[3]);
Assert.AreEqual(2.0, m.ReadOnlyColumnMajorValues[4]);
Assert.AreEqual(5.0, m.ReadOnlyColumnMajorValues[5]);
Assert.AreEqual(8.0, m.ReadOnlyColumnMajorValues[6]);
Assert.AreEqual(11.0, m.ReadOnlyColumnMajorValues[7]);
Assert.AreEqual(3.0, m.ReadOnlyColumnMajorValues[8]);
Assert.AreEqual(6.0, m.ReadOnlyColumnMajorValues[9]);
Assert.AreEqual(9.0, m.ReadOnlyColumnMajorValues[10]);
Assert.AreEqual(12.0, m.ReadOnlyColumnMajorValues[11]);
}
public void SetEffectMatrix(SCN0Node node, ModelPanelViewport v, float frame)
{
if (MapMode != MappingMethod.TexCoord)
{
switch (MapMode)
{
case MappingMethod.Projection:
_effectMatrix = Matrix34.ProjectionMapping(SCN0RefCamera, node, v, frame);
break;
case MappingMethod.EnvSpec:
_effectMatrix = Matrix34.EnvSpecMap(SCN0RefCamera, SCN0RefLight, node, v, frame);
break;
case MappingMethod.EnvLight:
_effectMatrix = Matrix34.EnvLightMap(SCN0RefLight, node, v, frame);
break;
case MappingMethod.EnvCamera:
_effectMatrix = Matrix34.EnvCamMap(SCN0RefCamera, node, v, frame);
break;
default:
_effectMatrix = Matrix.Identity;
break;
}
}
else
{
_effectMatrix = Matrix.Identity;
}
}
public void TestIdentity()
{
Matrix34 nativeMatrix = Matrix34.CreateIdentity();
Matrix3x4 managedMatrix = Matrix3x4.Identity;
// Compare native to managed identity
Assert.That(nativeMatrix.m00, Is.EqualTo(managedMatrix[0, 0]));
Assert.That(nativeMatrix.m01, Is.EqualTo(managedMatrix[0, 1]));
Assert.That(nativeMatrix.m02, Is.EqualTo(managedMatrix[0, 2]));
Assert.That(nativeMatrix.m03, Is.EqualTo(managedMatrix[0, 3]));
Assert.That(nativeMatrix.m10, Is.EqualTo(managedMatrix[1, 0]));
Assert.That(nativeMatrix.m11, Is.EqualTo(managedMatrix[1, 1]));
Assert.That(nativeMatrix.m12, Is.EqualTo(managedMatrix[1, 2]));
Assert.That(nativeMatrix.m13, Is.EqualTo(managedMatrix[1, 3]));
Assert.That(nativeMatrix.m20, Is.EqualTo(managedMatrix[2, 0]));
Assert.That(nativeMatrix.m21, Is.EqualTo(managedMatrix[2, 1]));
Assert.That(nativeMatrix.m22, Is.EqualTo(managedMatrix[2, 2]));
Assert.That(nativeMatrix.m23, Is.EqualTo(managedMatrix[2, 3]));
// Compare managed matrix to real values.
Assert.That(managedMatrix[0, 0], Is.EqualTo(1));
Assert.That(managedMatrix[0, 1], Is.EqualTo(0));
Assert.That(managedMatrix[0, 2], Is.EqualTo(0));
Assert.That(managedMatrix[0, 3], Is.EqualTo(0));
Assert.That(managedMatrix[1, 0], Is.EqualTo(0));
Assert.That(managedMatrix[1, 1], Is.EqualTo(1));
Assert.That(managedMatrix[1, 2], Is.EqualTo(0));
Assert.That(managedMatrix[1, 3], Is.EqualTo(0));
Assert.That(managedMatrix[2, 0], Is.EqualTo(0));
Assert.That(managedMatrix[2, 1], Is.EqualTo(0));
Assert.That(managedMatrix[2, 2], Is.EqualTo(1));
Assert.That(managedMatrix[2, 3], Is.EqualTo(0));
}
public void TestAddTranslation()
{
//managed operation
Vector3 point = new Vector3(1f, -1f, 0.5f);
Matrix3x4 matrix34 = new Matrix3x4(0f, 1f, 2f, 3f, 10f, 11f, 12f, 13f, 20f, 21f, 22f, 23f);
Matrix3x4 managedMatrix = matrix34;
Assert.IsTrue(!ReferenceEquals(matrix34, managedMatrix));
managedMatrix.AddTranslation(point);
//native operation
Vec3 point2 = new Vec3(point.x, point.y, point.z);
Matrix34 nativeMatrix = new Matrix34(0f, 1f, 2f, 3f, 10f, 11f, 12f, 13f, 20f, 21f, 22f, 23f);
nativeMatrix.AddTranslation(point2);
Assert.That(nativeMatrix.m00, Is.EqualTo(managedMatrix[0, 0]));
Assert.That(nativeMatrix.m01, Is.EqualTo(managedMatrix[0, 1]));
Assert.That(nativeMatrix.m02, Is.EqualTo(managedMatrix[0, 2]));
Assert.That(nativeMatrix.m03, Is.EqualTo(managedMatrix[0, 3]));
Assert.That(nativeMatrix.m10, Is.EqualTo(managedMatrix[1, 0]));
Assert.That(nativeMatrix.m11, Is.EqualTo(managedMatrix[1, 1]));
Assert.That(nativeMatrix.m12, Is.EqualTo(managedMatrix[1, 2]));
Assert.That(nativeMatrix.m13, Is.EqualTo(managedMatrix[1, 3]));
Assert.That(nativeMatrix.m20, Is.EqualTo(managedMatrix[2, 0]));
Assert.That(nativeMatrix.m21, Is.EqualTo(managedMatrix[2, 1]));
Assert.That(nativeMatrix.m22, Is.EqualTo(managedMatrix[2, 2]));
Assert.That(nativeMatrix.m23, Is.EqualTo(managedMatrix[2, 3]));
}
public void Matrix34()
{
string fs =
@"#version 330
uniform mat3x4 exampleMat34;
out vec3 FragColor;
void main()
{
FragColor = vec3(exampleMat34[1].x, exampleMat34[2].z, 0.0);
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
Matrix34 <float> m34 = new Matrix34 <float>(
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f);
Uniform <Matrix34 <float> > exampleMat34 = (Uniform <Matrix34 <float> >)sp.Uniforms["exampleMat34"];
Assert.AreEqual("exampleMat34", exampleMat34.Name);
Assert.AreEqual(UniformType.FloatMatrix34, exampleMat34.Datatype);
Assert.AreEqual(new Matrix34 <float>(), exampleMat34.Value);
exampleMat34.Value = m34;
Assert.AreEqual(m34, exampleMat34.Value);
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 255, 0);
}
}
public static Enemy Create(int type, Vec3 pos)
{
var enemy = Entity.Instantiate <Enemy>(pos, Quat.Identity, 0.5f, EnemyTypes [type].Geometry);
if (EnemyTypes[type].Material != null)
{
enemy.Material = Env.Engine.GetMaterialManager().LoadMaterial(EnemyTypes[type].Material);
}
// Rotate Z-Axis in degrees to have enemy facing forward.
enemy.Rotation = Quat.CreateRotationZ(Utils.Deg2Rad(90f));
var pfx = Env.ParticleManager.FindEffect("spaceship.Trails.blue_fire_trail");
enemy.LoadParticleEmitter(1, pfx, 0.5f);
// Get position of jet on enemy (Note: Non-Existing position means x, y and z are all 0).
Vec3 jetPosition = enemy.GetHelperPos(0, "particle_01");
// NOTE ON MATRIX34
// ----------------
// First Vec3 parameter indicates scale
// Second Quat parameter indicate rotation
// Third Vec3 parameter indicates position
// Scale, Rotate and Position particle effect to ensure it's shown at the back of the ship.
enemy.SetTM(1, Matrix34.Create(Vec3.One, Quat.CreateRotationX(Utils.Deg2Rad(270f)), jetPosition));
// Put into game loop.
GamePool.AddObjectToPool(enemy);
return(enemy);
}
public void Construct1()
{
Matrix34<double> m = new Matrix34<double>(1.0);
for (int i = 0; i < m.NumberOfComponents; ++i)
{
Assert.AreEqual(1.0, m.ReadOnlyColumnMajorValues[0], 1e-14);
}
}
internal UniformFloatMatrix34GL3x(string name, int location, ICleanableObserver observer)
: base(name, UniformType.FloatMatrix34)
{
_location = location;
_value = new Matrix34 <float>();
_dirty = true;
_observer = observer;
_observer.NotifyDirty(this);
}
// GameObject core;
public override void OnInitialize()
{
base.OnInitialize();
Health = new Health();
NativeEntity.LoadGeometry(0, AssetLibrary.Meshes.BasePlate);
NativeEntity.SetMaterial(AssetLibrary.Materials.BasePlate);
NativeEntity.LoadGeometry(1, AssetLibrary.Meshes.Diamond);
NativeEntity.SetSlotMaterial(1, AssetLibrary.Materials.BaseCore);
NativeEntity.SetSlotLocalTM(1, Matrix34.Create(Vec3.One, Quat.Identity, new Vec3(0, 0, 2f)));
}
public void TestNativeManagedEqualityMatrix3by4()
{
Matrix3x4 managedmatrix = new Matrix3x4(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
Matrix34 nativematrix = new Matrix34(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
//managed quaternion
Quaternion managedQuat = new Quaternion(managedmatrix);
//native quaternion
Quat nativeQuat = Quat.CreateQuatFromMatrix(nativematrix);
Assert.IsTrue(managedQuat == nativeQuat);
}
private void AddToGamePoolWithDoor(Vec3 position = null)
{
GamePool.AddObjectToPool(this);
if (position == null) // Get position via Engine EntitySystem.
{
position = this.Position;
}
// Create a door case as connector between tunnels.
_tunnelDoor = Door.Create(new Vec3(position.x, position.y, position.z), 0);
_tunnelDoor.Speed = LevelGeometry.GlobalGeomSpeed;
// Create random door types
int rand = Rand.NextInt(3);
if (rand != 0)
{
_tunnelDoor = Door.Create(new Vec3(position.x, position.y, position.z), rand);
_tunnelDoor.Speed = LevelGeometry.GlobalGeomSpeed;
}
ColorF lightColor = new ColorF(_randomizer.Next(0, 255), _randomizer.Next(0, 255), _randomizer.Next(0, 255));
// Till 'MaxValue' as the for-loop is quit when once the first empty position is discovered.
for (int i = 1; i < int.MaxValue; i++)
{
Vec3 helperPos = GetHelperPos(0, "Light_0" + i.ToString());
if (helperPos.x != 0 || helperPos.y != 0 || helperPos.z != 0)
{
CDLight light = new CDLight()
{
m_fRadius = 25f,
m_fAttenuationBulbSize = 0.1f,
m_BaseColor = lightColor,
m_BaseSpecMult = 1f
};
LoadLight(i, light);
SetTM(i, Matrix34.Create(Vec3.One, Quat.Identity, helperPos));
}
else
{
break;
}
}
}
public void TestTransformDirection()
{
//managed
Vector3 vector3 = new Vector3(0.2f, 0.2f, 0.2f);
Matrix3x4 matrix3x4 = Matrix3x4.Identity;
Vector3 transVector3 = matrix3x4.TransformDirection(vector3);
//native
Vec3 vec3 = new Vec3(vector3.x, vector3.y, vector3.z);
Matrix34 matrix34 = Matrix34.CreateIdentity();
Vec3 transVec3 = matrix34.TransformVector(vec3);
Assert.IsTrue(transVector3.x == transVec3.x, "x is different");
Assert.IsTrue(transVector3.y == transVec3.y, "y is different");
Assert.IsTrue(transVector3.z == transVec3.z, "z is different");
Assert.IsTrue(transVector3 == transVec3, "vector is different");
}
public void ConversionFromManagedToNative()
{
Matrix3x4 managedMatrix = new Matrix3x4(0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23);
Matrix34 nativeMatrix = managedMatrix;
Assert.That(nativeMatrix.m00, Is.EqualTo(managedMatrix[0, 0]));
Assert.That(nativeMatrix.m01, Is.EqualTo(managedMatrix[0, 1]));
Assert.That(nativeMatrix.m02, Is.EqualTo(managedMatrix[0, 2]));
Assert.That(nativeMatrix.m03, Is.EqualTo(managedMatrix[0, 3]));
Assert.That(nativeMatrix.m10, Is.EqualTo(managedMatrix[1, 0]));
Assert.That(nativeMatrix.m11, Is.EqualTo(managedMatrix[1, 1]));
Assert.That(nativeMatrix.m12, Is.EqualTo(managedMatrix[1, 2]));
Assert.That(nativeMatrix.m13, Is.EqualTo(managedMatrix[1, 3]));
Assert.That(nativeMatrix.m20, Is.EqualTo(managedMatrix[2, 0]));
Assert.That(nativeMatrix.m21, Is.EqualTo(managedMatrix[2, 1]));
Assert.That(nativeMatrix.m22, Is.EqualTo(managedMatrix[2, 2]));
Assert.That(nativeMatrix.m23, Is.EqualTo(managedMatrix[2, 3]));
}
public void TestMatrix3x4Construction()
{
Matrix34 nativeMatrix = new Matrix34(1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15);
Matrix4x4 managedMatrix = new Matrix4x4(nativeMatrix);
Assert.That(nativeMatrix.m00, Is.EqualTo(managedMatrix[0, 0]));
Assert.That(nativeMatrix.m01, Is.EqualTo(managedMatrix[0, 1]));
Assert.That(nativeMatrix.m02, Is.EqualTo(managedMatrix[0, 2]));
Assert.That(nativeMatrix.m03, Is.EqualTo(managedMatrix[0, 3]));
Assert.That(nativeMatrix.m10, Is.EqualTo(managedMatrix[1, 0]));
Assert.That(nativeMatrix.m11, Is.EqualTo(managedMatrix[1, 1]));
Assert.That(nativeMatrix.m12, Is.EqualTo(managedMatrix[1, 2]));
Assert.That(nativeMatrix.m13, Is.EqualTo(managedMatrix[1, 3]));
Assert.That(nativeMatrix.m20, Is.EqualTo(managedMatrix[2, 0]));
Assert.That(nativeMatrix.m21, Is.EqualTo(managedMatrix[2, 1]));
Assert.That(nativeMatrix.m22, Is.EqualTo(managedMatrix[2, 2]));
Assert.That(nativeMatrix.m23, Is.EqualTo(managedMatrix[2, 3]));
}
public void TestAddTranslation()
{
//managed operation
Vector3 point = new Vector3(1f, -1f, 0.5f);
Matrix3x4 matrix34 = new Matrix3x4(0f, 1f, 2f, 3f, 10f, 11f, 12f, 13f, 20f, 21f, 22f, 23f);
Matrix3x4 newMatrix = matrix34;
Assert.IsTrue(!ReferenceEquals(matrix34, newMatrix));
newMatrix.AddTranslation(point);
//native operation
Vec3 point2 = new Vec3(point.x, point.y, point.z);
Matrix34 nativeMatrix = new Matrix34(0f, 1f, 2f, 3f, 10f, 11f, 12f, 13f, 20f, 21f, 22f, 23f);
nativeMatrix.AddTranslation(point2);
Assert.IsTrue(newMatrix == nativeMatrix);
}
public void ConversionFromManagedToNative()
{
Matrix3x4 managedmatrix = new Matrix3x4(0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23);
Matrix34 nativeMatrix = managedmatrix;
Assert.That(true, Is.EqualTo(managedmatrix == nativeMatrix));
Assert.That(nativeMatrix.m00, Is.EqualTo(managedmatrix.m00));
Assert.That(nativeMatrix.m01, Is.EqualTo(managedmatrix.m01));
Assert.That(nativeMatrix.m02, Is.EqualTo(managedmatrix.m02));
Assert.That(nativeMatrix.m03, Is.EqualTo(managedmatrix.m03));
Assert.That(nativeMatrix.m10, Is.EqualTo(managedmatrix.m10));
Assert.That(nativeMatrix.m11, Is.EqualTo(managedmatrix.m11));
Assert.That(nativeMatrix.m12, Is.EqualTo(managedmatrix.m12));
Assert.That(nativeMatrix.m13, Is.EqualTo(managedmatrix.m13));
Assert.That(nativeMatrix.m20, Is.EqualTo(managedmatrix.m20));
Assert.That(nativeMatrix.m21, Is.EqualTo(managedmatrix.m21));
Assert.That(nativeMatrix.m22, Is.EqualTo(managedmatrix.m22));
Assert.That(nativeMatrix.m23, Is.EqualTo(managedmatrix.m23));
Assert.IsTrue(managedmatrix == nativeMatrix);
}
public void TestIdentity()
{
Assert.That(true, Is.EqualTo(Matrix3x4.Identity == Matrix34.CreateIdentity()));
Matrix3x4 managedmatrix = Matrix3x4.Identity;
Assert.That(true, Is.EqualTo(managedmatrix == Matrix3x4.Identity));
Assert.That(managedmatrix.m00, Is.EqualTo(1));
Assert.That(managedmatrix.m01, Is.EqualTo(0));
Assert.That(managedmatrix.m02, Is.EqualTo(0));
Assert.That(managedmatrix.m03, Is.EqualTo(0));
Assert.That(managedmatrix.m10, Is.EqualTo(0));
Assert.That(managedmatrix.m11, Is.EqualTo(1));
Assert.That(managedmatrix.m12, Is.EqualTo(0));
Assert.That(managedmatrix.m13, Is.EqualTo(0));
Assert.That(managedmatrix.m20, Is.EqualTo(0));
Assert.That(managedmatrix.m21, Is.EqualTo(0));
Assert.That(managedmatrix.m22, Is.EqualTo(1));
Assert.That(managedmatrix.m23, Is.EqualTo(0));
}
/// <summary>
/// Spawn this instance.
/// </summary>
public static Player Create(Vec3 pos)
{
var player = Entity.Instantiate <Player>(pos, Quat.Identity, 10, PlayerSkin.Geometry);
var particleEffect = Env.ParticleManager.FindEffect("spaceship.Trails.fire_trail");
player.LoadParticleEmitter(1, particleEffect, 0.03f);
// Get position where to spawn the particle effect.
Vec3 jetPosition = player.GetHelperPos(0, "particle_01");
// Rotate particle effect to ensure it's shown at the back of the ship.
player.SetTM(1, Matrix34.Create(Vec3.One, Quat.CreateRotationX(Utils.Deg2Rad(270f)), jetPosition));
// Rotate Z-Axis of player ship in degrees.
player.Rotation = new Quat(Matrix34.CreateRotationZ(Utils.Deg2Rad(180.0f)));
Hud.CurrentHud.SetEnergy(player.MaxLife);
GamePool.AddObjectToPool(player);
return(player);
}
public void TestMatrix3x4Construction()
{
//native parts
Vec3 scale = new Vec3(0.45f, 0.55f, 0.65f);
Quat rotation = new Quat(0.2f, 0.1f, 0.1f, 0.1f);
Vec3 position = new Vec3(0.1f, 0.2f, 0.3f);
Matrix34 nativeM34 = new Matrix34(scale, rotation, position);
//managed parts
Vector3 scale2 = new Vector3(0.45f, 0.55f, 0.65f);
Quaternion rotation2 = new Quaternion(0.2f, 0.1f, 0.1f, 0.1f);
Vector3 position2 = new Vector3(0.1f, 0.2f, 0.3f);
Matrix3x4 managedMatrix = new Matrix3x4(scale2, rotation2, position2);
Assert.IsTrue(scale == scale2, "Scale are not equal");
//TODO test fails
//Assert.IsTrue(rotation == rotation2, "Rotation are not equal");
Assert.IsTrue(position == position2, "Position are not equal");
//TODO test fails
//Assert.IsTrue(nativeM34 == (Matrix34)managedMatrix, "Native and managed matrix34 are not equal");
}
public void TestTransformPoint()
{
//managed
Vector3 point3 = new Vector3(0.2f, 0.2f, 0.2f);
Matrix3x4 matrix3x4 = Matrix3x4.Identity;
Vector3 transPoint3 = matrix3x4.TransformPoint(point3);
//native
Vec3 pt3 = new Vec3(point3.x, point3.y, point3.z);
Matrix34 matrix34 = Matrix34.CreateIdentity();
Vec3 transPt3 = matrix34.TransformPoint(pt3);
Assert.IsTrue(point3.x == pt3.x, "x is different");
Assert.IsTrue(point3.y == pt3.y, "y is different");
Assert.IsTrue(point3.z == pt3.z, "z is different");
Assert.IsTrue(point3 == pt3, "point is different");
Assert.IsTrue(transPoint3.x == transPt3.x, "x is different");
Assert.IsTrue(transPoint3.y == transPt3.y, "y is different");
Assert.IsTrue(transPoint3.z == transPt3.z, "z is different");
Assert.IsTrue(transPoint3 == transPt3, "point is different");
}
public void DoubleToFloat()
{
Matrix34<double> m = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Matrix34<float> mf = Matrix34<double>.DoubleToFloat(m);
Assert.AreEqual(1.0f, mf.Column0Row0, 1e-7);
Assert.AreEqual(2.0f, mf.Column1Row0, 1e-7);
Assert.AreEqual(3.0f, mf.Column2Row0, 1e-7);
Assert.AreEqual(4.0f, mf.Column0Row1, 1e-7);
Assert.AreEqual(5.0f, mf.Column1Row1, 1e-7);
Assert.AreEqual(6.0f, mf.Column2Row1, 1e-7);
Assert.AreEqual(7.0f, mf.Column0Row2, 1e-7);
Assert.AreEqual(8.0f, mf.Column1Row2, 1e-7);
Assert.AreEqual(9.0f, mf.Column2Row2, 1e-7);
Assert.AreEqual(10.0f, mf.Column0Row3, 1e-7);
Assert.AreEqual(11.0f, mf.Column1Row3, 1e-7);
Assert.AreEqual(12.0f, mf.Column2Row3, 1e-7);
}
public override string ToString()
{
if (HasSignal)
{
string ret = string.Format("{0} Handle:{1} Frame:{7} x:{3} y:{4} z:{5} Error:{6} Status:{8} {9}",
TimeStamp.ToLongTimeString(),
SensorIdx,
HasSignal,
Matrix14.ToString("F1").PadLeft(6, ' '),
Matrix24.ToString("F1").PadLeft(6, ' '),
Matrix34.ToString("F1").PadLeft(6, ' '),
Error.ToString("F1").PadLeft(4, ' '),
FrameNumber,
PortStatus,
Is6D ? "6D" : "5D");
if (PartiallyOutOfVolume)
{
ret += " PartiallyOutOfVolume";
}
return(ret);
}
else
{
string ret = string.Format("{0} Handle:{1} Status:{2}", TimeStamp.ToLongTimeString(), SensorIdx, PortStatus);
if (SensorCoilIsBroken)
{
ret += " Sensor is broken!";
}
if (OutOfVolume)
{
ret += " OutOfVolume!";
}
return(ret);
}
}
extern internal static void SetWorldTM(IntPtr ptr, Matrix34 tm);
extern public static void SetLocalTM(IntPtr ptr, Matrix34 tm);
public void TestMethods()
{
//we need 3 orthonormal vectors for equivalence test to pass
Vector3 right = new Vec3(1f, 0f, -1f);
right = right.Normalized;
Vector3 forward = new Vec3(1f, 1.4142136f, 1f);
forward = forward.Normalized;
Vector3 up = new Vec3(1f, -1.4142136f, 1f);
up = up.Normalized;
//native
Matrix34 nativematrix = new Matrix34(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
Quat nativeQuat = Quat.CreateQuatFromMatrix(nativematrix);
//managed
Matrix3x4 managedmatrix = new Matrix3x4(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
Quaternion managedQuat = Quat.CreateQuatFromMatrix(managedmatrix);
float radians = 1.57f;
//1 normalize
{
Quaternion test1a = managedQuat;
test1a.Normalize();
Quat test1b = nativeQuat;
test1b.Normalize();
Assert.IsTrue(Quat.IsEquivalent(test1a, test1b), "Normalize Equivalence test failed");
}
//2 Dot
//3 Difference
//4 CreateFromVectors
{
Matrix3x3 matrix33 = Matrix33.CreateFromVectors(right, forward, up);
Quat quat2a = Quat.CreateQuatFromMatrix(matrix33);
Vector3 right2 = new Vector3(right.x, right.y, right.z);
Vector3 forward2 = new Vector3(forward.x, forward.y, forward.z);
Vector3 up2 = new Vector3(up.x, up.y, up.z);
Quaternion quat2b = Quaternion.CreateFromVectors(right2, forward2, up2);
Assert.IsTrue(quat2a == quat2b, "CreateFromVectors equality failed");
Assert.IsTrue(Quat.IsEquivalent(quat2a, quat2b), "CreateFromVectors equivalence failed");
}
//5 SetLookOrientation
//5a
{
//compare to SetRotationVDir, up vector = (0,0,1)
//get 2 orthogonal vectors
Vector3 up5 = new Vector3(0f, 0f, 1f);
Vector3 forward5 = new Vector3(1f, 1.4142136f, 0f);
forward5 = forward5.Normalized;
Vector3 right5 = forward5.Cross(up5);
Quat nativeQuaternion2 = Quat.CreateIdentity();
nativeQuaternion2.SetRotationVDir(forward5);
Matrix33 nativeMatrix = Matrix33.CreateMatrix33(right5, forward5, up5);
Quat nativeQuaternion3 = Quat.CreateQuatFromMatrix(nativeMatrix);
Assert.IsTrue(Quat.IsEquivalent(nativeQuaternion2, nativeQuaternion3), "Native Quaternion constructor failed comparison with SetRotationVDir. Expected :" + ((Quaternion)nativeQuaternion2).ToString() + ", Actual :" + ((Quaternion)nativeQuaternion3).ToString());
}
//5b
{
// test new C# SetLookOrientation, DEV-3691
// rotate forward around x-y plane, z=0
// i) 20 values for x-y plane
// ii) 20 values for y-z plane
Vec3[] testVectors = new Vec3[40];
for (uint i = 0; i < 20; ++i)
{
radians = ((float)System.Math.PI) / 20.0f * i;
testVectors[i] = new Vec3((float)System.Math.Cos(radians), (float)System.Math.Sin(radians), 0f);
}
for (uint i = 20; i < 40; ++i)
{
radians = ((float)System.Math.PI) / 20.0f * i;
testVectors[i] = new Vec3(0f, (float)System.Math.Cos(radians), (float)System.Math.Sin(radians));
}
const float test_margin_error = 0.05f;
for (uint i = 0; i < testVectors.Length; ++i)
{
Vec3 forward5c = testVectors[i];
forward5c = forward5c.normalized();
Quat nativeQuat5c = Quat.CreateIdentity();
nativeQuat5c.SetRotationVDir(forward5c);
float dtPrdt1 = MathHelpers.Clamp(forward5c.Dot(nativeQuat5c.GetColumn1()), -1f, 1f);
Quaternion managedQuat5c = Quaternion.Identity;
Vector3 upManaged = Vector3.Up;
managedQuat5c.SetLookOrientation(forward5c, upManaged);
float dtPrdt2 = MathHelpers.Clamp(forward5c.Dot(managedQuat5c.Forward), -1f, 1f);
float diffFromNative = (float)(System.Math.Acos(dtPrdt1) * (180f / System.Math.PI));
float diffFromManaged = (float)(System.Math.Acos(dtPrdt2) * (180f / System.Math.PI));
float absoluteDiff = System.Math.Abs(diffFromManaged - diffFromNative);
Assert.IsTrue(absoluteDiff <= test_margin_error, "SetLookOrientation failed at loop index " + i + ".Absolute Difference:" + absoluteDiff + " Expected (Native) :" + diffFromNative + ", Actual (Managed) :" + diffFromManaged + ", Forward : " + NativeExtensions.PrintString(forward5c) + ", Up :" + upManaged.ToString());
}
{
//boundary case where axis are flipped when comparing native to managed
Quaternion quatManaged = Quaternion.Identity;
Vector3 upManaged = Vector3.Up;
Vector3 forwardManaged = new Vector3(-8.126793f, 3.401123f, -1.644333f);
forwardManaged = forwardManaged.Normalized;
quatManaged.SetLookOrientation(forwardManaged, upManaged);
Quat quatNative = Quat.CreateIdentity();
Vec3 forwardNative = new Vec3(-8.126793f, 3.401123f, -1.644333f);
forwardNative = forwardNative.normalized();
quatNative.SetRotationVDir(forwardNative);
bool isEqui1 = Quat.IsEquivalent(quatManaged, quatNative, 0.00999999776f);
Assert.IsTrue(isEqui1, String.Format("Native Quaternion {0} and Managed Quaternion {1} are not equivalent", ((Quaternion)quatNative).ToString(), quatManaged));
}
}
//6 SetFromTORotation(Vector3 , Vector3)
{
Vec3 fromVec = new Vec3(0.5f, 0.5f, 0.5f);
Vec3 toVec = new Vec3(0.5f, -0.5f, -0.5f);
Quat quat6a = Quat.CreateIdentity();
quat6a.SetRotationV0V1(fromVec, toVec);
Vector3 fromVec2 = new Vector3(fromVec.x, fromVec.y, fromVec.z);
Vector3 toVec2 = new Vector3(toVec.x, toVec.y, toVec.z);
Quaternion quat6b = Quaternion.Identity;
quat6b.SetFromToRotation(fromVec2, toVec2);
Assert.IsTrue(Quat.IsEquivalent(quat6a, quat6b), "SetFromToRotation failed");
}
//7 CreateRotationX(float)
{
Quat quat7a = Quat.CreateRotationX(radians);
Quaternion quat7b = Quaternion.CreateRotationX(radians);
Assert.IsTrue(Quat.IsEquivalent(quat7a, quat7b), "CreateRotationX failed");
}
//8 CreateRotationY(float)
{
Quat quat8a = Quat.CreateRotationY(radians + 0.1f);
Quaternion quat8b = Quaternion.CreateRotationY(radians + 0.1f);
Assert.IsTrue(Quat.IsEquivalent(quat8a, quat8b), "CreateRotationY failed");
}
//9 CreateRotationZ(float)
{
Quat quat9a = Quat.CreateRotationZ(radians + 0.1f);
Quaternion quat9b = Quaternion.CreateRotationZ(radians + 0.1f);
Assert.IsTrue(Quat.IsEquivalent(quat9a, quat9b), "CreateRotationZ failed");
}
//10 CreateRotationXYZ(Angles3)
{
Angles3 angles = new Vec3(radians, radians, radians);
Quat quat10a = Quat.CreateRotationXYZ(angles);
Quaternion quat10b = Quaternion.CreateRotationXYZ(angles);
Assert.IsTrue(Quat.IsEquivalent(quat10a, quat10b), "CreateRotationXYZ equivalence failed");
}
//11 Slerp(Quaternion, Quaternion, float)
{
float timeRatio = 0.5f;
Quat quat11a = Quat.CreateRotationX(radians);
Quat quat11b = Quat.CreateRotationY(radians);
Quat quat11c = Quat.CreateIdentity();
quat11c.SetSlerp(quat11a, quat11b, timeRatio);
Quaternion quat11d = Quaternion.CreateRotationX(radians);
Quaternion quat11e = Quaternion.CreateRotationY(radians);
Quaternion quat11f = Quaternion.Slerp(quat11d, quat11e, timeRatio);
Assert.IsTrue(Quat.IsEquivalent(quat11c, quat11f), "Slerp equivalence failed");
}
//12 Lerp(Quaternion, Quaternion, float)
{
float timeRatio = 0.5f;
Quat quat12a = Quat.CreateRotationX(radians);
Quat quat12b = Quat.CreateRotationY(radians);
Quat quat12c = Quat.CreateIdentity();
quat12c.SetNlerp(quat12a, quat12b, timeRatio);
Quaternion quat12d = Quaternion.CreateRotationX(radians);
Quaternion quat12e = Quaternion.CreateRotationY(radians);
Quaternion quat12f = Quaternion.Lerp(quat12d, quat12e, timeRatio);
Assert.IsTrue(Quat.IsEquivalent(quat12c, quat12f), "Lerp equivalence failed");
}
//13 Properties
{
Matrix3x3 matrix33 = Matrix33.CreateFromVectors(right, forward, up);
Quat quat13a = Quat.CreateQuatFromMatrix(matrix33);
Vector3 right2 = new Vector3(right.x, right.y, right.z);
Vector3 forward2 = new Vector3(forward.x, forward.y, forward.z);
Vector3 up2 = new Vector3(up.x, up.y, up.z);
Quaternion quat13b = Quaternion.CreateFromVectors(right2, forward2, up2);
Assert.IsTrue(quat13a == quat13b, "Quaternions equality test failed");
Assert.IsTrue(Quat.IsEquivalent(quat13a, quat13b), "Quaternions equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(right2, quat13b.Right), "Right equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(forward2, quat13b.Forward), "Forward equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(up2, quat13b.Up), "Up equivalence test failed");
//inversion
Quat invertNative = quat13a.GetInverted();
Quaternion invertManaged = quat13b.Inverted;
Assert.IsTrue(Quat.IsEquivalent(invertNative, invertManaged), "Inversion equivalence test failed");
//normalization
Quat normalNative = quat13a.GetNormalized();
Quaternion normalManaged = quat13b.Normalized;
Assert.IsTrue(Quat.IsEquivalent(normalNative, normalManaged), "Normalization test failed");
//length
float lengthNative = quat13a.GetLength();
float lengthManaged = quat13b.Length;
Assert.IsTrue(System.Math.Abs(lengthNative - lengthManaged) <= Single.Epsilon, "Length test failed");
//IsIdentity
Quaternion managedIdentity = Quaternion.Identity;
Assert.IsTrue(managedIdentity.IsIdentity, "Managed Identity test failed");
Quat nativeIdentity = new Quat();
nativeIdentity.SetIdentity();
Assert.IsTrue(nativeIdentity.IsIdentity(), "Native Identity test failed");
Assert.IsTrue(managedIdentity == nativeIdentity, "Identity comparison failed");
// yaw pitch roll
}
}
internal static extern void SetCameraMatrix(IntPtr cameraPtr, Matrix34 matrix);
/// <summary>
/// Creates new instance of <see cref="Quaternion"/> struct.
/// </summary>
/// <param name="matrix">
/// 3x4 matrix that contains representation of rotation.
/// </param>
public Quaternion(Matrix34 matrix)
: this(new Matrix33(matrix))
{
}
extern public static void SetWorldTM(IntPtr ptr, Matrix34 tm);
internal static extern void SetWorldTM(IntPtr ptr, Matrix34 tm);
public void Equals()
{
Matrix34<double> a = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Matrix34<double> b = new Matrix34<double>(0.0);
Matrix34<double> c = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Assert.IsTrue(a.Equals(c));
Assert.IsTrue(c.Equals(a));
Assert.IsTrue(a == c);
Assert.IsTrue(c == a);
Assert.IsFalse(c != a);
Assert.IsFalse(c != a);
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(b.Equals(a));
Assert.IsFalse(a == b);
Assert.IsFalse(b == a);
Assert.IsTrue(a != b);
Assert.IsTrue(b != a);
object objA = a;
object objB = b;
object objC = c;
Assert.IsTrue(a.Equals(objA));
Assert.IsTrue(a.Equals(objC));
Assert.IsFalse(a.Equals(objB));
Assert.IsTrue(objA.Equals(objC));
Assert.IsFalse(objA.Equals(objB));
Assert.IsFalse(a.Equals(null));
Assert.IsFalse(a.Equals(5));
}
/// <summary>
/// Creates new instance of type <see cref="QuaternionTranslation"/>.
/// </summary>
/// <param name="m">
/// <see cref="Matrix34"/> that represents both translation and orientation.
/// </param>
public QuaternionTranslation(Matrix34 m)
{
this.Q = new Quaternion(m);
this.T = m.Translation;
}
extern internal static void SetCameraMatrix(IntPtr cameraPtr, Matrix34 matrix);
public override bool OnInitialize()
{
_isRotationMatrix = _memberType == hkClassMember.Type.TYPE_ROTATION;
_value = *(bMatrix43 *)Data;
return(false);
}
public void Matrix34()
{
string fs =
@"#version 330
uniform mat3x4 exampleMat34;
out vec3 FragColor;
void main()
{
FragColor = vec3(exampleMat34[1].x, exampleMat34[2].z, 0.0);
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
Matrix34<float> m34 = new Matrix34<float>(
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f);
Uniform<Matrix34<float>> exampleMat34 = (Uniform<Matrix34<float>>)sp.Uniforms["exampleMat34"];
Assert.AreEqual("exampleMat34", exampleMat34.Name);
Assert.AreEqual(UniformType.FloatMatrix34, exampleMat34.Datatype);
Assert.AreEqual(new Matrix34<float>(), exampleMat34.Value);
exampleMat34.Value = m34;
Assert.AreEqual(m34, exampleMat34.Value);
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 255, 0);
}
}
extern internal static void SetLocalTM(IntPtr ptr, Matrix34 tm);
/// <summary>
/// </summary>
/// <param name="vx"> </param>
/// <param name="vy"> </param>
/// <param name="vz"> </param>
/// <param name="pos"></param>
public void SetFromVectors(Vector3 vx, Vector3 vy, Vector3 vz, Vector3 pos)
{
var m34 = new Matrix34
{
M00 = vx.X,
M01 = vy.X,
M02 = vz.X,
M03 = pos.X,
M10 = vx.Y,
M11 = vy.Y,
M12 = vz.Y,
M13 = pos.Y,
M20 = vx.Z,
M21 = vy.Z,
M22 = vz.Z,
M23 = pos.Z
};
this = new QuaternionTranslation(m34);
}
internal static extern void SetLocalTM(IntPtr ptr, Matrix34 tm);
public static extern void SetWorldTM(IntPtr ptr, Matrix34 tm);
public void CalcTransforms()
{
CalcFlags();
_transform = (Matrix)Matrix34.TextureMatrix(this);
}
public static extern void SetLocalTM(IntPtr ptr, Matrix34 tm);
/// <summary>
/// Sets position, rotation and scale of an entity slot, ba a matrix.
/// </summary>
/// <param name="slot">Slot.</param>
/// <param name="mx">Mx.</param>
public void SetTM(int slot, Matrix34 mx)
{
BaseEntity.SetSlotLocalTM(slot, mx);
}
public void TestGetHashCode()
{
Matrix34<double> a = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Matrix34<double> b = new Matrix34<double>(0.0);
Matrix34<double> c = new Matrix34<double>(
1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0,
10.0, 11.0, 12.0);
Assert.AreEqual(a.GetHashCode(), c.GetHashCode());
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
