public void Add(IPoint3 p, IVector3 v)
{
ITuple3_Double _p = p.AsTupleDouble();
ITuple3_Double _v = v.AsTupleDouble();
this.Set(_p.X + _v.X, _p.Y + _v.Y, _p.Z + _v.Z);
}
/// <summary>
/// rotate vector with quaternion
/// </summary>
/// <param name="v"></param>
/// <param name="q"></param>
/// <returns>
/// the rotated vector
/// </returns>
private IPoint3 RotateVectorByQuaternion(IPoint3 v, IQuat q)
{
var qx = q.X; var qy = q.Y; var qz = q.Z; var qw = q.W;
// compute rotation matrix from q
// see: https://www.mathworks.com/help/aerotbx/ug/quatrotate.html
var m11 = 1 - 2 * qy * qy - 2 * qz * qz;
var m12 = 2 * (qx * qy + qw * qz);
var m13 = 2 * (qx * qz - qw * qy);
var m21 = 2 * (qx * qy - qw * qz);
var m22 = 1 - 2 * qx * qx - 2 * qz * qz;
var m23 = 2 * (qy * qz + qw * qx);
var m31 = 2 * (qx * qz + qw * qy);
var m32 = 2 * (qy * qz - qw * qx);
var m33 = 1 - 2 * qx * qx - 2 * qy * qy;
// matrix multiplication
var vx_rot = m11 * v.X + m12 * v.Y + m13 * v.Z;
var vy_rot = m21 * v.X + m22 * v.Y + m23 * v.Z;
var vz_rot = m31 * v.X + m32 * v.Y + m33 * v.Z;
return(Loader.Global.Point3.Create(vx_rot, vy_rot, vz_rot));
}
public void Sub(IPoint3 p, IVector3 v)
{
ITuple3_Double _p = p.AsTupleDouble();
ITuple3_Double _v = v.AsTupleDouble();
this.Set(_p.X - _v.X, _p.Y - _v.Y, _p.Z - _v.Z);
}
public override void Transform(IPoint3 p, IOpPoint3 pout)
{
ITuple3_Double _v = p.AsTupleDouble();
IOpTuple3_Double _vout = pout.AsOpTupleDouble();
_vout.Set(_v.X, _v.Y, _v.Y);
}
public void Sub(IPoint3 p1, IPoint3 p2)
{
ITuple3_Double _p1 = p1.AsTupleDouble();
ITuple3_Double _p2 = p2.AsTupleDouble();
this.Set(_p1.X - _p2.X, _p1.Y - _p2.Y, _p1.Z - _p2.Z);
}
public static IPoint3 GetPoint3Property(this IIGameProperty property)
{
IPoint3 value = Loader.Global.Point3.Create(0, 0, 0);
property.GetPropertyValue(value, 0);
return(value);
}
private IMatrix3 GetOffsetTM(IIGameNode gameNode, int key)
{
IPoint3 objOffsetPos = gameNode.MaxNode.ObjOffsetPos;
IQuat objOffsetQuat = gameNode.MaxNode.ObjOffsetRot;
IPoint3 objOffsetScale = gameNode.MaxNode.ObjOffsetScale.S;
// conversion: LH vs RH coordinate system (swap Y and Z)
var tmpSwap = objOffsetPos.Y;
objOffsetPos.Y = objOffsetPos.Z;
objOffsetPos.Z = tmpSwap;
tmpSwap = objOffsetQuat.Y;
objOffsetQuat.Y = objOffsetQuat.Z;
objOffsetQuat.Z = tmpSwap;
var objOffsetRotMat = Tools.Identity;
objOffsetQuat.MakeMatrix(objOffsetRotMat, true);
tmpSwap = objOffsetScale.Y;
objOffsetScale.Y = objOffsetScale.Z;
objOffsetScale.Z = tmpSwap;
// build the offset transform; equivalent in maxscript:
// offsetTM = (scaleMatrix $.objectOffsetScale) * ($.objectOffsetRot as matrix3) * (transMatrix $.objectOffsetPos)
IMatrix3 offsetTM = Tools.Identity;
offsetTM.Scale(objOffsetScale, false);
offsetTM.MultiplyBy(objOffsetRotMat);
offsetTM.Translate(objOffsetPos);
return(offsetTM);
}
public static IPoint3 GetPoint3Property(this IIPropertyContainer propertyContainer, int indexProperty)
{
IPoint3 value = Loader.Global.Point3.Create(0, 0, 0);
propertyContainer.GetProperty(indexProperty).GetPropertyValue(value, 0);
return(value);
}
public override int Proc(IntPtr hwnd, int msg, int point, int flags, IIPoint2 m)
{
Debug.Print("viewport point: " + m.X + ", " + m.Y);
switch (msg)
{
case 0: // MOUSE_ABORT see .\maxsdk\include\mouseman.h for all possible values
{
IGlobal global = Autodesk.Max.GlobalInterface.Instance;
IInterface14 ip = global.COREInterface14;
ip.PopCommandMode();
Debug.Print("mouse callback aborted");
}
break;
case 1: // MOUSE_POINT see .\maxsdk\include\mouseman.h for all possible values
{
if (point == 0)
{
IGlobal global = Autodesk.Max.GlobalInterface.Instance;
IInterface14 ip = global.COREInterface14;
IViewExp vp = ip.ActiveViewExp;
IPoint3 pt = vp.SnapPoint(m, m, null, SnapFlags.InPlane);
ip.PopCommandMode();
Debug.Print("3d point (in plane): " + pt.X + ", " + pt.Y + ", " + pt.Z);
}
// else if ... other points if you have more than one...
}
break;
default:
break;
}
return(1);
}
private static void FindMaxMinValues(ref float?xMaxValue, ref float?xMinValue,
ref float?yMaxValue, ref float?yMinValue,
ref float?zMaxValue, ref float?zMinValue,
IPoint3 pos)
{
//Find max and min X value
if (!xMaxValue.HasValue || pos.X > xMaxValue.Value)
{
xMaxValue = pos.X;
}
if (!xMinValue.HasValue || pos.X < xMinValue.Value)
{
xMinValue = pos.X;
}
//Find max and min Y value
if (!yMaxValue.HasValue || pos.Y > yMaxValue.Value)
{
yMaxValue = pos.Y;
}
if (!yMinValue.HasValue || pos.Y < yMinValue.Value)
{
yMinValue = pos.Y;
}
//Find max and min Z value
if (!zMaxValue.HasValue || pos.Z > zMaxValue.Value)
{
zMaxValue = pos.Z;
}
if (!zMinValue.HasValue || pos.Z < zMinValue.Value)
{
zMinValue = pos.Z;
}
}
public void Print(IIPropertyContainer propertyContainer, int logRank)
{
RaiseVerbose("propertyContainer=" + propertyContainer, logRank);
if (propertyContainer != null)
{
RaiseVerbose("propertyContainer.NumberOfProperties=" + propertyContainer.NumberOfProperties, logRank + 1);
for (int i = 0; i < propertyContainer.NumberOfProperties; i++)
{
var prop = propertyContainer.GetProperty(i);
if (prop != null)
{
RaiseVerbose("propertyContainer.GetProperty(" + i + ")=" + prop.Name, logRank + 1);
switch (prop.GetType_)
{
case PropType.StringProp:
string propertyString = "";
RaiseVerbose("prop.GetPropertyValue(ref propertyString, 0)=" + prop.GetPropertyValue(ref propertyString, 0), logRank + 2);
RaiseVerbose("propertyString=" + propertyString, logRank + 2);
break;
case PropType.IntProp:
int propertyInt = 0;
RaiseVerbose("prop.GetPropertyValue(ref propertyInt, 0)=" + prop.GetPropertyValue(ref propertyInt, 0), logRank + 2);
RaiseVerbose("propertyInt=" + propertyInt, logRank + 2);
break;
case PropType.FloatProp:
float propertyFloat = 0;
RaiseVerbose("prop.GetPropertyValue(ref propertyFloat, 0, true)=" + prop.GetPropertyValue(ref propertyFloat, 0, true), logRank + 2);
RaiseVerbose("propertyFloat=" + propertyFloat, logRank + 2);
RaiseVerbose("prop.GetPropertyValue(ref propertyFloat, 0, false)=" + prop.GetPropertyValue(ref propertyFloat, 0, false), logRank + 2);
RaiseVerbose("propertyFloat=" + propertyFloat, logRank + 2);
break;
case PropType.Point3Prop:
IPoint3 propertyPoint3 = Loader.Global.Point3.Create(0, 0, 0);
RaiseVerbose("prop.GetPropertyValue(ref propertyPoint3, 0)=" + prop.GetPropertyValue(propertyPoint3, 0), logRank + 2);
RaiseVerbose("propertyPoint3=" + Point3ToString(propertyPoint3), logRank + 2);
break;
case PropType.Point4Prop:
IPoint4 propertyPoint4 = Loader.Global.Point4.Create(0, 0, 0, 0);
RaiseVerbose("prop.GetPropertyValue(ref propertyPoint4, 0)=" + prop.GetPropertyValue(propertyPoint4, 0), logRank + 2);
RaiseVerbose("propertyPoint4=" + Point4ToString(propertyPoint4), logRank + 2);
break;
case PropType.UnknownProp:
default:
RaiseVerbose("Unknown property type", logRank + 2);
break;
}
}
else
{
RaiseVerbose("propertyContainer.GetProperty(" + i + ") IS NULL", logRank + 1);
}
}
}
}
public Point3d(IPoint3 p)
{
ITuple3_Double _p = p.AsTupleDouble();
this.X = _p.X;
this.Y = _p.Y;
this.Z = _p.Z;
}
public BuffPoint3d(IPoint3 other)
{
ITuple3_Double _other = other.AsTupleDouble();
this.x = _other.X;
this.y = _other.Y;
this.z = _other.Z;
}
public static Point3d ToPoint3d(this IPoint3 p)
{
if (p is Point3d)
{
return((Point3d)p);
}
return(new Point3d(p));
}
public void ProjectTo(IPoint3 p1, IVector3 where)
{
ITuple3_Double _p1 = p1.AsTupleDouble();
BuffVector3d aux = new BuffVector3d(where);
aux.ProjV(new Vector3d(_p1.X, _p1.Y, _p1.Z));
this.Set(aux.X, aux.Y, aux.Z);
}
public IPoint3 Mul(IPoint3 p)
{
ITuple3_Double _p = p.AsTupleDouble();
return(new Point3d(this.M00 * _p.X + this.M01 * _p.Y + this.M02 * _p.Z,
this.M10 * _p.X + this.M11 * _p.Y + this.M12 * _p.Z,
_p.Z));
}
public virtual void Transform(IPoint3 p, IOpPoint3 pout)
{
IOpTuple3_Double _vout = pout.AsOpTupleDouble();
Vector3d aux = this.Transform(p.ToPoint3d());
_vout.Set(aux.X, aux.Y, aux.Z);
}
public void Lineal(IPoint3 p2, double alpha, double beta)
{
ITuple3_Double _p2 = p2.AsTupleDouble();
this.Set(alpha * this.x + beta * _p2.X,
alpha * this.y + beta * _p2.Y,
alpha * this.z + beta * _p2.Z);
}
/// <summary>
/// create the cross product of 2 vectors
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static IPoint3 CrossProduct(this IPoint3 lhs, IPoint3 rhs)
{
// create a point3 via global interface from max sdk
return(AssemblyFunctions.GlobalInterface.Point3.Create
(lhs.Y * rhs.Z - lhs.Z * rhs.Y
, lhs.Z * rhs.X - lhs.X * rhs.Z
, lhs.X * rhs.Y - lhs.Y * rhs.X
));
}
public void Lineal(IPoint3 p1, IPoint3 p2, double alpha, double beta)
{
ITuple3_Double _p1 = p1.AsTupleDouble();
ITuple3_Double _p2 = p2.AsTupleDouble();
this.Set(alpha * _p1.X + beta * _p2.X,
alpha * _p1.Y + beta * _p2.Y,
alpha * _p1.Z + beta * _p2.Z);
}
private string Point3ToString(IPoint3 point)
{
if (point == null)
{
return("");
}
return("{ x=" + point.X + ", y=" + point.Y + ", z=" + point.Z + " }");
}
public static IEnumerable <Point3D> Points(this IObject obj)
{
for (int i = 0; i < obj.NumPoints; i++)
{
IPoint3 pnt = obj.GetPoint(i);
yield return(new Point3D(pnt.X, pnt.Y, pnt.Z));
}
}
/// <summary>
/// Extracts the transformation matrix from a line
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
public IMatrix3 GetTransform(Match values)
{
// Row 1
float row1x;
float.TryParse(values.Result("$5"), out row1x);
float row1y;
float.TryParse(values.Result("$6"), out row1y);
float row1z;
float.TryParse(values.Result("$7"), out row1z);
// Row 2
float row2x;
float.TryParse(values.Result("$8"), out row2x);
float row2y;
float.TryParse(values.Result("$9"), out row2y);
float row2z;
float.TryParse(values.Result("$10"), out row2z);
// Row 3
float row3x;
float.TryParse(values.Result("$11"), out row3x);
float row3y;
float.TryParse(values.Result("$12"), out row3y);
float row3z;
float.TryParse(values.Result("$13"), out row3z);
// Position
float posX;
float.TryParse(values.Result("$2"), out posX);
float posY;
float.TryParse(values.Result("$3"), out posY);
float posZ;
float.TryParse(values.Result("$4"), out posZ);
//posY = -posY;
IPoint3 row1 = global.Point3.Create(row1x, row1y, row1z);
IPoint3 row2 = global.Point3.Create(row2x, row2y, row2z);
IPoint3 row3 = global.Point3.Create(row3x, row3y, row3z);
IPoint3 position = global.Point3.Create(posX, posY, posZ);
IMatrix3 matrix = global.Matrix3.Create(row1, row2, row3, position);
return(matrix);
//return null;
}
public void Mul(IPoint3 p, IOpPoint3 pout)
{
ITuple3_Double _p = p.AsTupleDouble();
IOpTuple3_Double _vout = pout.AsOpTupleDouble();
_vout.Set(this.M00 * _p.X + this.M01 * _p.Y + this.M02 * _p.Z,
this.M10 * _p.X + this.M11 * _p.Y + this.M12 * _p.Z,
_p.Z);
}
public static ITuple3_Double AsTupleDouble(this IPoint3 v)
{
ITuple3_Double ret = v as ITuple3_Double;
if (ret != null)
{
return(ret);
}
return(VectorUtils.Convert <ITuple3_Double>(v));
}
public double InvLerp(IPoint3 p2, IPoint3 pLerp)
{
BuffVector3d v12 = new BuffVector3d();
v12.Sub(p2, this);
BuffVector3d v1Lerp = new BuffVector3d();
v1Lerp.Sub(pLerp, this);
return(v12.Proj(v1Lerp));
}
public IPoint3 Mul(IPoint3 p)
{
ITuple3_Double _p = p.AsTupleDouble();
double d = this.M30 * _p.X + this.M31 * _p.Y + this.M32 * _p.Z + this.M33;
return(new Point3d((this.M00 * _p.X + this.M01 * _p.Y + this.M02 * _p.Z + this.M03) / d,
(this.M10 * _p.X + this.M11 * _p.Y + this.M12 * _p.Z + this.M13) / d,
(this.M20 * _p.X + this.M21 * _p.Y + this.M22 * _p.Z + this.M23) / d));
}
public void Mul(IPoint3 p, IOpPoint3 pout)
{
ITuple3_Double _p = p.AsTupleDouble();
IOpTuple3_Double _vout = pout.AsOpTupleDouble();
double d = this.M30 * _p.X + this.M31 * _p.Y + this.M32 * _p.Z + this.M33;
_vout.Set((this.M00 * _p.X + this.M01 * _p.Y + this.M02 * _p.Z + this.M03) / d,
(this.M10 * _p.X + this.M11 * _p.Y + this.M12 * _p.Z + this.M13) / d,
(this.M20 * _p.X + this.M21 * _p.Y + this.M22 * _p.Z + this.M23) / d);
}
public ROD_ExportG()
{
maxGlobal = Autodesk.Max.GlobalInterface.Instance;
maxInterface = maxGlobal.COREInterface14;
IPoint3 U = maxGlobal.Point3.Create(1.0, 0.0, 0.0);
IPoint3 V = maxGlobal.Point3.Create(0.0, 0.0, 1.0);
IPoint3 N = maxGlobal.Point3.Create(0.0, -1.0, 0.0);
IPoint3 T = maxGlobal.Point3.Create(0.0, 0.0, 0.0);
_leftHanded = maxGlobal.Matrix3.Create(U, V, N, T);
_GleftHanded = maxGlobal.GMatrix.Create(_leftHanded);
}
private static IPoint3 CalculateWorldPosVerts(IPoint3 localPos, IPoint3 moveValue, IMatrix3 local)
{
//Convert to World space
var worldPos = local.PointTransform(localPos);
//Make changes
worldPos.X += moveValue.X;
worldPos.Y += moveValue.Y;
worldPos.Z += moveValue.Z;
//Invert the local matrix
var m3LocalInverse = m_Global.Inverse(local);
//Convert back to local space
return(m3LocalInverse.PointTransform(worldPos));
}
public static Color FromMaxColor(IPoint3 color)
{
return Color.FromArgb(ToColorChannel(color.X), ToColorChannel(color.Y), ToColorChannel(color.Z));
}
public static bool IsAlmostEqualTo(this IPoint3 current, IPoint3 other, float epsilon)
{
if (Math.Abs(current.X - other.X) > epsilon)
{
return false;
}
if (Math.Abs(current.Y - other.Y) > epsilon)
{
return false;
}
if (Math.Abs(current.Z - other.Z) > epsilon)
{
return false;
}
return true;
}
public Point3(IPoint3 pt)
: this(pt.X, pt.Y, pt.Z)
{
}
