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) { }