// O is your object's position
// P is the position of the object to face
// U is the nominal "up" vector (typically Vector3.Y)
// Note: this does not work when O is straight below or straight above P
Matrix RotateToFace(Vector3 O, Vector3 P, Vector3 U)
{
  Vector3 D = (O - P);
  Vector3 Right = Vector3.Cross(U, D);
  Vector3.Normalize(ref Right, out Right);
  Vector3 Backwards = Vector3.Cross(Right, U);
  Vector3.Normalize(ref Backwards, out Backwards);
  Vector3 Up = Vector3.Cross(Backwards, Right);
  Matrix rot = new Matrix(Right.X, Right.Y, Right.Z, 0, Up.X, Up.Y, Up.Z, 0, Backwards.X, Backwards.Y, Backwards.Z, 0, 0, 0, 0, 1);
  return rot;
}

public static class Transform
  {
    /// <summary>
    /// Calculates an orientation matrix for tilting the XY plane (i.e. the z-axis) towards a given normal vector and translating it to a new location.
    /// By default, the normal of the XY plane (and all 2D polygons in that plane) is Vector3.Backward (the z-axis).
    /// This method generates a rotation/translation matrix that can be used to rotate and translate a polygon or model's vertices
    /// around the origin so that the polygon's new normal or model's direction coincides with the vector passed as normal.
    /// </summary>
    /// <param name="translate">The new location of the shape or model.</param>
    /// <param name="normal">Specifes the desired 3D normal for a 2D shape or desired direction for a model to face once it is transformed by the resulting orientation matrix.</param>
    /// <param name="orientation">Resulting rotation/translation matrix for rotating/translating a 2D shape out of the XY plane or rotating a model around the origin, such that it has a normal whose direction is equivalent to that passed in through the normal parameter.</param>
    public static void RotateTowardsAndTranslate( ref Vector3 translate, ref Vector3 normal, out Matrix orientation )
    {
      Vector3 up, right, backward;
      backward    = Vector3.Normalize( normal ); //ensure normal is normalized to avoid problems
      right       = Vector3.Cross( backward, Vector3.Backward ); //cross up(normal) with positive Z axis as a default;
      if (right == Vector3.Zero) //normal coincides with or is opposite to the default orientation (shape in XY plane; normal = Vector3.Backward (positive Z-axis)), so there's no rotation. Right direction is chosen arbitrarily as the default right vector.
      {
        if (backward.Z > 0) //check whether we're viewing it from the front (normal.Z > 0; no rotation)
          right = Vector3.Right;
        else
          right = Vector3.Left; //shape is facing the other way, so we'll roll it over a half turn (180 degrees).  Since rotating the shape around the normal does not change the normal's direction, and that's our only constraint, the right direction is totally arbitrary.
      }
      up          = Vector3.Cross( backward, right );
      orientation = new Matrix( right.X, right.Y, right.Z, 0, up.X, up.Y, up.Z, 0, backward.X, backward.Y, backward.Z, 0, translate.X, translate.Y, translate.Z, 1 );
      //Setting up such a rotation and translation matrix really is this easy, you just set unit vectors for the right, up, and backward, and optionally the translation as well!
      //Use .NET Reflector to check the Right, Up, Backward, and Translation properties of the Matrix class to find the elements to which they correspond.  That's how I figured out which ones to set in the line above.
    }
  }