public static XbimMatrix3D CreateWorld(XbimVector3D position, XbimVector3D forward, XbimVector3D up)
{
// prepare vectors
forward.Normalize();
XbimVector3D vector = forward * -1;
XbimVector3D vector2 = XbimVector3D.CrossProduct(up, vector);
vector2.Normalize();
XbimVector3D vector3 = XbimVector3D.CrossProduct(vector, vector2);
// prepare matrix
XbimMatrix3D result = new XbimMatrix3D(
vector2.X, vector2.Y, vector2.Z, 0.0,
vector3.X, vector3.Y, vector3.Z, 0.0,
vector.X, vector.Y, vector.Z, 0.0,
position.X, position.Y, position.Z, 0.0);
return(result);
}
// Microsoft.Xna.Framework.Matrix
public static XbimMatrix3D CreateLookAt(XbimVector3D cameraPosition, XbimVector3D cameraTarget, XbimVector3D cameraUpVector)
{
// prepare vectors
XbimVector3D vector = cameraPosition - cameraTarget;
vector.Normalize();
XbimVector3D vector2 = XbimVector3D.CrossProduct(cameraUpVector, vector);
vector2.Normalize();
XbimVector3D vector3 = XbimVector3D.CrossProduct(vector, vector2);
// prepare matrix
XbimMatrix3D result = new XbimMatrix3D(
vector2.X, vector3.X, vector.X, 0.0,
vector2.Y, vector3.Y, vector.Y, 0.0,
vector2.Z, vector3.Z, vector.Z, 0.0,
-XbimVector3D.DotProduct(vector2, cameraPosition), -XbimVector3D.DotProduct(vector3, cameraPosition), -XbimVector3D.DotProduct(vector, cameraPosition), 1.0);
return(result);
}
/// <summary>
/// Builds a windows Matrix3D from an ObjectPlacement
/// Conversion fo c++ function CartesianTransform::ConvertMatrix3D from CartesianTransform.cpp
/// </summary>
/// <param name="objPlacement">IfcObjectPlacement object</param>
/// <returns>Matrix3D</returns>
protected XbimMatrix3D ConvertMatrix3D(IfcObjectPlacement objPlacement)
{
if(objPlacement is IfcLocalPlacement)
{
IfcLocalPlacement locPlacement = (IfcLocalPlacement)objPlacement;
if (locPlacement.RelativePlacement is IfcAxis2Placement3D)
{
IfcAxis2Placement3D axis3D = (IfcAxis2Placement3D)locPlacement.RelativePlacement;
XbimVector3D ucsXAxis = new XbimVector3D(axis3D.RefDirection.DirectionRatios[0], axis3D.RefDirection.DirectionRatios[1], axis3D.RefDirection.DirectionRatios[2]);
XbimVector3D ucsZAxis = new XbimVector3D(axis3D.Axis.DirectionRatios[0], axis3D.Axis.DirectionRatios[1], axis3D.Axis.DirectionRatios[2]);
ucsXAxis.Normalize();
ucsZAxis.Normalize();
XbimVector3D ucsYAxis = XbimVector3D.CrossProduct(ucsZAxis, ucsXAxis);
ucsYAxis.Normalize();
XbimPoint3D ucsCentre = axis3D.Location.XbimPoint3D();
XbimMatrix3D ucsTowcs = new XbimMatrix3D(ucsXAxis.X, ucsXAxis.Y, ucsXAxis.Z, 0,
ucsYAxis.X, ucsYAxis.Y, ucsYAxis.Z, 0,
ucsZAxis.X, ucsZAxis.Y, ucsZAxis.Z, 0,
ucsCentre.X, ucsCentre.Y, ucsCentre.Z , 1);
if (locPlacement.PlacementRelTo != null)
{
return XbimMatrix3D.Multiply(ucsTowcs, ConvertMatrix3D(locPlacement.PlacementRelTo));
}
else
return ucsTowcs;
}
else //must be 2D
{
throw new NotImplementedException("Support for Placements other than 3D not implemented");
}
}
else //probably a Grid
{
throw new NotImplementedException("Support for Placements other than Local not implemented");
}
}
/// <summary>
/// Calculates the Newell's Normal of the polygon of the loop
/// </summary>
/// <param name="loop"></param>
/// <returns></returns>
public static XbimVector3D NewellsNormal(this IfcPolyLoop loop)
{
double x = 0, y = 0, z = 0;
IfcCartesianPoint current = null, previous = null, first = null;
int count = 0;
int total = loop.Polygon.Count;
for (int i = 0; i <= total; i++)
{
if (i < total)
current = loop.Polygon[i];
else
current = loop.Polygon[0];
if (count > 0)
{
double xn = previous.X;
double yn = previous.Y;
double zn = previous.Z;
double xn1 = current.X;
double yn1 = current.Y;
double zn1 = current.Z;
x += (yn - yn1) * (zn + zn1);
y += (xn + xn1) * (zn - zn1);
z += (xn - xn1) * (yn + yn1);
}
else
first = current;
previous = current;
count++;
}
XbimVector3D v = new XbimVector3D(x, y, z);
v.Normalize();
return v;
}
public static XbimMatrix3D CreateWorld(XbimVector3D position, XbimVector3D forward, XbimVector3D up)
{
// prepare vectors
forward.Normalize();
XbimVector3D vector = forward * -1;
XbimVector3D vector2 = XbimVector3D.CrossProduct(up, vector);
vector2.Normalize();
XbimVector3D vector3 = XbimVector3D.CrossProduct(vector, vector2);
// prepare matrix
XbimMatrix3D result = new XbimMatrix3D(
vector2.X, vector2.Y, vector2.Z, 0.0,
vector3.X, vector3.Y, vector3.Z, 0.0,
vector.X, vector.Y, vector.Z, 0.0,
position.X, position.Y, position.Z, 0.0);
return result;
}
private static XbimMatrix3D ConvertCartesianTransformationOperator3DnonUniform(IfcCartesianTransformationOperator3DnonUniform ct3D)
{
XbimVector3D u3; //Z Axis Direction
XbimVector3D u2; //X Axis Direction
XbimVector3D u1; //Y axis direction
if (ct3D.Axis3 != null)
{
IfcDirection dir = ct3D.Axis3;
u3 = new XbimVector3D(dir.DirectionRatios[0], dir.DirectionRatios[1], dir.DirectionRatios[2]);
u3.Normalize();
}
else
u3 = new XbimVector3D(0, 0, 1);
if (ct3D.Axis1 != null)
{
IfcDirection dir = ct3D.Axis1;
u1 = new XbimVector3D(dir.DirectionRatios[0], dir.DirectionRatios[1], dir.DirectionRatios[2]);
u1.Normalize();
}
else
{
XbimVector3D defXDir = new XbimVector3D(1, 0, 0);
u1 = u3 != defXDir ? defXDir : new XbimVector3D(0, 1, 0);
}
XbimVector3D xVec = XbimVector3D.Multiply(XbimVector3D.DotProduct(u1, u3), u3);
XbimVector3D xAxis = XbimVector3D.Subtract(u1, xVec);
xAxis.Normalize();
if (ct3D.Axis2 != null)
{
IfcDirection dir = ct3D.Axis2;
u2 = new XbimVector3D(dir.DirectionRatios[0], dir.DirectionRatios[1], dir.DirectionRatios[2]);
u2.Normalize();
}
else
u2 = new XbimVector3D(0, 1, 0);
XbimVector3D tmp = XbimVector3D.Multiply(XbimVector3D.DotProduct(u2, u3), u3);
XbimVector3D yAxis = XbimVector3D.Subtract(u2, tmp);
tmp = XbimVector3D.Multiply(XbimVector3D.DotProduct(u2, xAxis), xAxis);
yAxis = XbimVector3D.Subtract(yAxis, tmp);
yAxis.Normalize();
u2 = yAxis;
u1 = xAxis;
XbimPoint3D lo = ct3D.LocalOrigin.XbimPoint3D(); //local origin
XbimMatrix3D matrix = new XbimMatrix3D(u1.X, u1.Y, u1.Z, 0,
u2.X, u2.Y, u2.Z, 0,
u3.X, u3.Y, u3.Z, 0,
lo.X, lo.Y, lo.Z, 1);
matrix.Scale(new XbimVector3D(ct3D.Scl, ct3D.Scl2, ct3D.Scl3));
return matrix;
}
