01 February 2018

C# – Passing method delegates as arguments.

I wanted to pass a method to execute to a helper method that created a response on API requests. If the method succeeded, it should return it's result; if an exception was thrown, it should return a 500 with the error. This is what I came up with:

/// <summary>
/// For methods that don't have a return value.
/// </summary>
protected HttpResponseMessage Respond(HttpRequestMessage request, Action method,
          HttpStatusCode errorStatusCode, string errorMessage)
{
    try
    {
        method();
        return request.CreateResponse(HttpStatusCode.OK);
    }
    catch
    {
        return request.CreateErrorResponse(errorStatusCode, errorMessage);
    }
}

/// <summary>
/// For methods that do have a return value.
/// </summary>
protected HttpResponseMessage Respond(HttpRequestMessage request, Func method,
          HttpStatusCode errorStatusCode, string errorMessage)
{
    try
    {
        return request.CreateResponse(HttpStatusCode.OK, method());
    }
    catch
    {
        return request.CreateErrorResponse(errorStatusCode, errorMessage);
    }
}

Now, I can respond to an API request in a single line:

return Respond(Request, () => Repo.Update(c), HttpStatusCode.InternalServerError, "Failed!");

30 November 2017

Math – 3D line-triangle intersection

The following is a very simple but effective method I found to find the intersection point of a line with a triangle. I used it to determine the height of a point on the terrain.

The first part finds the intersection point:
private float? GetIntersectionY(Vector3 a, Vector3 b, Vector3 c, Vector3 pp) {
  //First, define a ray that will definitely intersect if the triangle lies beneath the point.
  var p = new Vector3(pp.X, 100, pp.Z);
  var q = new Vector3(p.X, p.Y - 100, p.Z);

  //Then, find the intersection.
  var normal = Vector3.CrossProduct(b - a, c - a).Normalized();
  float dist1 = Vector3.DotProduct(p - a, normal);
  float dist2 = Vector3.DotProduct(q - a, normal);

  if (dist1 == dist2 || dist1 * dist2 >= 0) //Parallel; no intersection.
    return null;

  var intersection = p + (q - p) * (-dist1 / (dist2 - dist1));

  //Verify that this point lies inside the triangle.
  if (SameSide(p, a, b, c) && SameSide(p, b, a, c) && SameSide(p, c, a, b))
    return intersection.Y;
  else
    return null;
}

The second part, as the above function already indicates, determines that the point really lies within the triangle, and not just within the mathematical plane. The linked sited explains well how this works.
private static bool SameSide(Vector3 p1, Vector3 p2, Vector3 a, Vector3 b) {
  //It only worked right for me when all the points had the same height though.
  var _p1 = new Vector3(p1.X, 0, p1.Z);
  var _p2 = new Vector3(p2.X, 0, p2.Z);
  var _a = new Vector3(a.X, 0, a.Z);
  var _b = new Vector3(b.X, 0, b.Z);

  //The check.
  var cp1 = Vector3.CrossProduct(_b - _a, _p1 - _a);
  var cp2 = Vector3.CrossProduct(_b - _a, _p2 - _a);
  return Vector3.DotProduct(cp1, cp2) >= 0;
}

21 November 2017

Math – Align a rotation matrix with a normal

Angle and axis

I found this method when I needed to rotate a vehicle to be positioned on the terrain. I had the positions of the wheels, and used those to calculate the vehicle's normal. Then I found the following method to calculate the angle and rotation axis:

var axis = new Vector3(0, 1, 0); //Up vector
float angle = Vector3.DotProduct(normal, axis).Acos(); //I do like extension methods.
var transformation = new Matrix();

if (angle.Absolute() > 0.001f) {
  axis = Vector3.CrossProduct(normal, axis).Normalized();
  transformation.Rotate(angle, axis); //See below.
}

Rotate the matrix

Then the glRotatef function is used to use these values, but that's from the old fixed pipeline OpenGL, and I was using the new OpenGL with shaders and all that. I then found this function that applies the rotation to a matrix:

float rad = angle.ToRadians();
float c = rad.Cos();
float s = rad.Sin();
float t = 1 - c;

float x = axis.X;
float y = axis.Y;
float z = axis.Z;

var rotation = new Matrix();
rotation.M[0, 0] = c + x * x * t;
rotation.M[0, 1] = y * x * t + z * s;
rotation.M[0, 2] = z * x * t - y * s;

rotation.M[1, 0] = x * y * t - z * s;
rotation.M[1, 1] = c + y * y * t;
rotation.M[1, 2] = z * y * t + x * s;

rotation.M[2, 0] = x * z * t + y * s;
rotation.M[2, 1] = y * z * t - x * s;
rotation.M[2, 2] = z * z * t + c;

SetMatrix((this * rotation).M); //This just overwrites the 16 values of this matrix.

See also

Using quaternions to create a rotation matrix

16 October 2017

C# - Using a joypad input device without DirectX

While looking for a way to use my joypad in a C# application, everything I found used DirectInput to do it. As it turns out however, a single simple Windows API call is all that is needed:

internal enum JoypadErrors : uint
{
    None = 0, //NOERROR
    BadDeviceID = 2,
    InvalidParameter = 11,
    BadParameter = 165, //PARMS
    Fault = 166, //NOCANDO
    Unplugged = 167
}

[Flags]
internal enum JoypadFlags : uint //Calibration flags left out.
{
    X = 1,
    Y = 2,
    Z = 4,
    R = 8,
    U = 16,
    V = 32,
    POV = 64,
    Buttons = 128,
    RawData = 256,
    POVCTS = 512,
    Centered = 1024,
    All = X | Y | Z | R | U | V | POV | Buttons
}

[Flags]
internal enum JoypadButtons : uint
{
    I = 1,
    II = 2,
    III = 4,
    IV = 8,
    V = 16,
    VI = 32,
    VII = 64,
    VIII = 128,
    IX = 256,
    X = 512,
    XI = 1024,
    XII = 2048,
    XIII = 4096,
    XIV = 8192,
    XV = 16384,
    XVI = 32768
    //This goes on until button 32.
}

internal struct JoyInfoEx
{
    public int Size;
    public JoypadFlags Flags;
    public int X;
    public int Y;
    public int Z;
    public int R;
    public int U;
    public int V;
    public JoypadButtons Buttons;
    public int ButtonNumber;
    public int POV;
    public int Reserved1;
    public int Reserved2;
}

[DllImport("winmm", EntryPoint = "joyGetPosEx", SetLastError = true)]
private static extern JoypadErrors JoyGetPosEx(uint id, ref JoyInfoEx info);

You ask this function for the current state of the joypad's controls like so:

var info = new JoyInfoEx();
info.Size = Marshal.SizeOf(info); //Don't forget.
info.Flags = JoypadFlags.All; //What you want to get.
var result = JoyGetPosEx(0, ref info); //And that's it.

What do the received values mean? This is how they map to my Trustmaster Firestorm:

The 10 buttons are obvious. All the pressed ones are combined into a single value, so you need to extract them using a bitwise operation.

The point-of-view control returns a value between 0 and 31500, representing an angle in degrees. When unused, it returns 65565.

The left and right stick both have two axes. They all return a value between 0 and 65565. When centered on an axis, it's value is 32767.

And thats all there's to it. You get to work with the values you got.

19 September 2017

Math - rotate a 2D point

I needed a way to rotate a point (x; y) by a certain angle. This turned out to be an easy task:
Vector2 Rotate(Vector2 point, double angle)
{
  double rad = angle * (Math.PI / 180); //First, convert from degrees to radians.
  
  double sin = Math.Sin(rad); //Then, get the sine and
  double cos = Math.Cos(rad); //cosine of this angle.
  
  return new Vector2 //Finally, calculate the rotated point.
  {
    X = point.X * cos - point.Y * sin,
    Y = point.X * sin + point.Y * cos
  };
}

30 August 2017

Math – Calculate the distance between two points in 3D space

Always usefull in 3D development is a method to calculate the distance between two vectors. It's not very hard either, using the Pythagorean theorem. Here is how to do it in C# for two vectors, a and b:
public float Distance(Vector3 a, Vector3 b) =>
  (float)Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2) + Math.Pow(a.Z - b.Z, 2));

09 April 2017

Math – Calculate a transformation matrix

Suppose you have a translation, a rotation and a scaling matrix; how do you combine them into one transformation matrix — also model matrix — used to render some object? The order in which they are combined is also important. The following method will first rotate and scale the object, then move it. Rotation is the most complex transformation, and is done with quaternions.

//"Position", "Scale" and "Rotation" are all Vector3's.
Quaternion rot = null;
if (Rotation != null)
{
    var rotX = new Quaternion(Rotation.X, 1, 0, 0);
    var rotY = new Quaternion(Rotation.Y, 0, 1, 0);
    var rotZ = new Quaternion(Rotation.Z, 0, 0, 1);
    rot = rotX * rotY * rotZ;
}

var model = new Matrix();
model.Rotate(rot);
model.Scale(Scale);
model.Translate(Position);

The Matrix class was also mentioned in the post about quaternions. You can find the Matrix.Rotate method there as well. Compared to that, translation and scaling are pretty simple:

//An overload of this method takes a Vector3, and checks it for NULL.
public void Translate(float x, float y, float z)
{
    M[0, 3] += x;
    M[1, 3] += y;
    M[2, 3] += z;
}

//Also has an overload that takes a Vector3.
public void Scale(float x, float y, float z)
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            M[i, j] *= x;
            M[i, j] *= y;
            M[i, j] *= z;
        }
    }
}