public static Line ToOriginCenteredLine(Point origin, Vector axis)
{
return(Line.ByStartPointEndPoint(origin.Add(axis.Scale(-axisScaleFactor)),
origin.Add(axis.Scale(axisScaleFactor))));
}
/// <summary>
/// Retrieves a list of InputNodes that need to be updated after the manipulator is moved. This method is called when MouseUp is triggered.
/// </summary>
/// <param name="offset">The offset vector with which the manipulator was moved by the user. This param is calculated as the vector between (Origin at MouseDown) and (Origin at MouseUp)</param>
/// <returns>A list of InputNodes and the new values that needs to be set to the corresponding input nodes</returns>
protected virtual List <(NodeModel inputNode, double amount)> InputNodesToUpdateAfterMove(Vector offset)
{
return(new List <(NodeModel, double)>());
}
public static Vector ToVector(this Vector3D vec)
{
return(Vector.ByCoordinates(vec.X, vec.Y, vec.Z));
}
public void CanPlaceFamilyInstanceByTypeAndCoordinateSystem()
{
// Arrange
var famType = ElementSelector.ByElementId(131610, true) as FamilyType;
var coordinateSystem = CoordinateSystem.ByOrigin(0, 0)
.Rotate(Autodesk.DesignScript.Geometry.Plane.ByOriginNormal(Point.ByCoordinates(0, 0), Vector.ByCoordinates(0, 0, 1)), 45);
var expectedFacingOrientation = Vector.ByCoordinates(-0.707, 0.707, 0.000);
// Act
var familyInstance = FamilyInstance.ByCoordinateSystem(famType, coordinateSystem);
var facingOrientation = familyInstance.InternalFamilyInstance.FacingOrientation;
// Assert
Assert.AreEqual(expectedFacingOrientation.X, facingOrientation.X, Tolerance);
Assert.AreEqual(expectedFacingOrientation.Y, facingOrientation.Y, Tolerance);
Assert.AreEqual(expectedFacingOrientation.Z, facingOrientation.Z, Tolerance);
}
/// <summary> /// This method is called when the Gizmo in action is moved during mouse /// move event. Derived class must use this notification to update the /// input nodes AND update the manipulator Origin based on the mouse move. /// </summary> /// <param name="gizmoInAction">The Gizmo in action.</param> /// <param name="offset">Offset amount by which Gizmo has moved.</param> protected abstract void OnGizmoMoved(IGizmo gizmoInAction, Vector offset);
public static Triple ToTriple(this Vector vector) => new Triple(vector.X, vector.Y, vector.Z);
public static Line ToOriginCenteredLine(Point origin, Vector axis)
{
return Line.ByStartPointEndPoint(origin.Add(axis.Scale(-axisScaleFactor)),
origin.Add(axis.Scale(axisScaleFactor)));
}
/// <summary>
/// Divides a BoundingBox into a grid of voxels.
/// </summary>
/// <param name="boundingBox"></param>
/// <param name="vectorSize"></param>
/// <returns></returns>
public static List <DS.Point> BoundingBoxToVoxels(DS.BoundingBox boundingBox, DS.Vector vectorSize)
{
DS.Point minPt = boundingBox.MinPoint;
List <DS.Point> VoxelPoints = new List <DS.Point>();
using (DS.Vector diagonal = DS.Vector.ByTwoPoints(boundingBox.MinPoint, boundingBox.MaxPoint))
{
int xMax = Convert.ToInt32(Math.Abs(diagonal.X / vectorSize.X));
int yMax = Convert.ToInt32(Math.Abs(diagonal.Y / vectorSize.Y));
int zMax = Convert.ToInt32(Math.Abs(diagonal.Z / vectorSize.Z));
var coordinates = from x in Enumerable.Range(0, xMax)
from y in Enumerable.Range(0, yMax)
from z in Enumerable.Range(0, zMax)
select new { x, y, z };
foreach (var coord in coordinates)
{
double x = (coord.x * vectorSize.X + minPt.X) + vectorSize.X * 0.5;
double y = (coord.y * vectorSize.Y + minPt.Y) + vectorSize.Y * 0.5;
double z = (coord.z * vectorSize.Z + minPt.Z) + vectorSize.Z * 0.5;
VoxelPoints.Add(DS.Point.ByCoordinates(x, y, z));
}
}
return(VoxelPoints);
}
/// <summary>
/// Returns the maximum or minimum bounding box corner depending of the rounding function.
/// </summary>
/// <param name="roundingFunction">Mat.Ceiling or Math.Floor. Any other will throw and exception</param>
/// <param name="point"></param>
/// <param name="vectorSize"></param>
/// <returns></returns>
private static DS.Point MaxMinBound(Func <double, double> roundingFunction, DS.Point point, DS.Vector vectorSize)
{
//if any vector component less or equal 0, original coordinated is used.
double x = (vectorSize.X <= 0) ? point.X : roundingFunction(point.X / vectorSize.X) * vectorSize.X;
double y = (vectorSize.Y <= 0) ? point.Y : roundingFunction(point.Y / vectorSize.Y) * vectorSize.Y;
double z = (vectorSize.Z <= 0) ? point.Z : roundingFunction(point.Z / vectorSize.Z) * vectorSize.Z;
return(DS.Point.ByCoordinates(x, y, z));
}
internal hMember(Geo.Line webAxis, Geo.Vector webNormal, string name = "0")
{
_webAxis = webAxis;
_webNormal = webNormal;
_name = name;
}
/// <summary>
/// Convert a DesignScript Vector to a Nucleus Vector
/// </summary>
/// <param name="vector"></param>
/// <returns></returns>
public static Vector Convert(DS.Vector vector)
{
return(new Vector(vector.X, vector.Y, vector.Z));
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
Geo.Point OP1 = this._webAxis.StartPoint;
Geo.Point OP2 = this._webAxis.EndPoint;
Geo.Vector webAxis = Geo.Vector.ByTwoPoints(OP1, OP2);
Geo.Vector normal = _webNormal;
Geo.Vector lateral = webAxis.Cross(normal);
lateral = lateral.Normalized();
lateral = lateral.Scale(1.75);
normal = normal.Normalized();
normal = normal.Scale(1.5);
Geo.Vector lateralR = Geo.Vector.ByCoordinates(lateral.X * -1, lateral.Y * -1, lateral.Z * -1);
Geo.Vector webAxisR = Geo.Vector.ByCoordinates(webAxis.X * -1, webAxis.Y * -1, webAxis.Z * -1);
Geo.Vector normalR = Geo.Vector.ByCoordinates(normal.X * -1, normal.Y * -1, normal.Z * -1);
Geo.Point p0 = OP1.Add(normal.Add(lateral));
Geo.Point p1 = OP2.Add(normal.Add(lateral));
Geo.Point p2 = OP1.Add(lateral);
Geo.Point p3 = OP2.Add(lateral);
Geo.Point p6 = OP1.Add(normal.Add(lateralR));
Geo.Point p7 = OP2.Add(normal.Add(lateralR));
Geo.Point p4 = OP1.Add(lateralR);
Geo.Point p5 = OP2.Add(lateralR);
lateral = lateral.Normalized().Scale(1.25);
lateralR = lateralR.Normalized().Scale(1.25);
Geo.Point p8 = OP1.Add(lateralR).Add(normal);
Geo.Point p9 = OP2.Add(lateralR).Add(normal);
Geo.Point p10 = OP1.Add(lateral).Add(normal);
Geo.Point p11 = OP2.Add(lateral).Add(normal);
//////////// // // // // // // // // // //
Geo.Point[] pts = { p0, p1, p2, p1, p2, p3, p2, p3, p4, p3, p4, p5, p4, p5, p6, p5, p6, p7, p0, p1, p10, p1, p10, p11, p6, p7, p8, p7, p8, p9 };
Geo.Vector[] vectors = { lateral, normal, lateral.Reverse(), normal.Reverse(), normal.Reverse() };
byte[] colors = { 100, 100, 100, 100, 110, 110, 110, 110, 110, 110 };
var faces = new List <List <int> >
{
new List <int> {
0, 1, 2
},
new List <int> {
3, 4, 5
},
new List <int> {
6, 7, 8
},
new List <int> {
9, 10, 11
},
new List <int> {
12, 13, 14
},
new List <int> {
15, 16, 17
},
new List <int> {
18, 19, 20
},
new List <int> {
21, 22, 23
},
new List <int> {
24, 25, 26
},
new List <int> {
27, 28, 29
}
};
for (int i = 0; i < faces.Count; i++)
{
package.AddTriangleVertex(pts[faces[i][0]].X, pts[faces[i][0]].Y, pts[faces[i][0]].Z);
package.AddTriangleVertex(pts[faces[i][1]].X, pts[faces[i][1]].Y, pts[faces[i][1]].Z);
package.AddTriangleVertex(pts[faces[i][2]].X, pts[faces[i][2]].Y, pts[faces[i][2]].Z);
package.AddTriangleVertexColor(colors[i], colors[i], colors[i], 255);
package.AddTriangleVertexColor(colors[i], colors[i], colors[i], 255);
package.AddTriangleVertexColor(colors[i], colors[i], colors[i], 255);
package.AddTriangleVertexNormal(vectors[i / 2].X, vectors[i / 2].Y, vectors[i / 2].Z);
package.AddTriangleVertexNormal(vectors[i / 2].X, vectors[i / 2].Y, vectors[i / 2].Z);
package.AddTriangleVertexNormal(vectors[i / 2].X, vectors[i / 2].Y, vectors[i / 2].Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
}
foreach (hOperation op in operations)
{
Geo.Point opPoint = this._webAxis.PointAtParameter(op._loc / this._webAxis.Length);
byte r = 255;
byte g = 66;
byte b = 57;
byte a = 255;
switch (op._type)
{
case Operation.WEB:
package.AddPointVertex(opPoint.X, opPoint.Y, opPoint.Z);
package.AddPointVertexColor(r, g, b, a);
lateral = lateral.Normalized().Scale(15.0 / 16.0);
lateralR = lateralR.Normalized().Scale(15.0 / 16.0);
package.AddPointVertex(opPoint.Add(lateral).X, opPoint.Add(lateral).Y, opPoint.Add(lateral).Z);
package.AddPointVertexColor(r, g, b, a);
package.AddPointVertex(opPoint.Add(lateralR).X, opPoint.Add(lateralR).Y, opPoint.Add(lateralR).Z);
package.AddPointVertexColor(r, g, b, a);
break;
case Operation.DIMPLE:
lateral = lateral.Normalized().Scale(1.0);
lateralR = lateralR.Normalized().Scale(1.0);
normal = normal.Normalized().Scale(0.75);
package.AddLineStripVertex(opPoint.Add(lateral.Add(normal)).X, opPoint.Add(lateral.Add(normal)).Y, opPoint.Add(lateral.Add(normal)).Z);
lateral = lateral.Normalized().Scale(2.5);
package.AddLineStripVertex(opPoint.Add(lateral.Add(normal)).X, opPoint.Add(lateral.Add(normal)).Y, opPoint.Add(lateral.Add(normal)).Z);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexCount(2);
lateral = lateral.Normalized().Scale(1.75);
package.AddPointVertex(opPoint.Add(lateral.Add(normal)).X, opPoint.Add(lateral.Add(normal)).Y, opPoint.Add(lateral.Add(normal)).Z);
package.AddPointVertexColor(r, g, b, a);
package.AddLineStripVertex(opPoint.Add(lateralR.Add(normal)).X, opPoint.Add(lateralR.Add(normal)).Y, opPoint.Add(lateralR.Add(normal)).Z);
lateralR = lateralR.Normalized().Scale(2.5);
package.AddLineStripVertex(opPoint.Add(lateralR.Add(normal)).X, opPoint.Add(lateralR.Add(normal)).Y, opPoint.Add(lateralR.Add(normal)).Z);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexCount(2);
lateralR = lateralR.Normalized().Scale(1.75);
package.AddPointVertex(opPoint.Add(lateralR.Add(normal)).X, opPoint.Add(lateralR.Add(normal)).Y, opPoint.Add(lateralR.Add(normal)).Z);
package.AddPointVertexColor(r, g, b, a);
break;
case Operation.SWAGE:
lateral = lateral.Normalized().Scale(1.25);
lateralR = lateralR.Normalized().Scale(1.25);
webAxis = webAxis.Normalized().Scale(.875);
webAxisR = webAxisR.Normalized().Scale(.875);
package.AddLineStripVertex(opPoint.Add(lateral.Add(webAxis)).X, opPoint.Add(lateral.Add(webAxis)).Y, opPoint.Add(lateral.Add(webAxis)).Z);
package.AddLineStripVertex(opPoint.Add(lateral.Add(webAxisR)).X, opPoint.Add(lateral.Add(webAxisR)).Y, opPoint.Add(lateral.Add(webAxisR)).Z);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexCount(2);
package.AddLineStripVertex(opPoint.Add(lateralR.Add(webAxis)).X, opPoint.Add(lateralR.Add(webAxis)).Y, opPoint.Add(lateralR.Add(webAxis)).Z);
package.AddLineStripVertex(opPoint.Add(lateralR.Add(webAxisR)).X, opPoint.Add(lateralR.Add(webAxisR)).Y, opPoint.Add(lateralR.Add(webAxisR)).Z);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexColor(r, g, b, a);
package.AddLineStripVertexCount(2);
break;
case Operation.BOLT:
lateral = lateral.Normalized().Scale(0.25);
lateralR = lateralR.Normalized().Scale(0.25);
webAxis = webAxis.Normalized().Scale(0.25);
webAxisR = webAxisR.Normalized().Scale(0.25);
normal = normal.Normalized().Scale(0.01);
normalR = normalR.Normalized().Scale(0.01);
Geo.Point[] boltPts = { opPoint.Add(lateral.Add(webAxis.Add(normal))), opPoint.Add(lateral.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxis.Add(normal))) };
package.AddTriangleVertex(boltPts[0].X, boltPts[0].Y, boltPts[0].Z);
package.AddTriangleVertex(boltPts[1].X, boltPts[1].Y, boltPts[1].Z);
package.AddTriangleVertex(boltPts[2].X, boltPts[2].Y, boltPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(boltPts[0].X, boltPts[0].Y, boltPts[0].Z);
package.AddTriangleVertex(boltPts[2].X, boltPts[2].Y, boltPts[2].Z);
package.AddTriangleVertex(boltPts[3].X, boltPts[3].Y, boltPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
boltPts = new Geo.Point[] { opPoint.Add(lateral.Add(webAxis.Add(normalR))), opPoint.Add(lateral.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxis.Add(normalR))) };
package.AddTriangleVertex(boltPts[0].X, boltPts[0].Y, boltPts[0].Z);
package.AddTriangleVertex(boltPts[1].X, boltPts[1].Y, boltPts[1].Z);
package.AddTriangleVertex(boltPts[2].X, boltPts[2].Y, boltPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(boltPts[0].X, boltPts[0].Y, boltPts[0].Z);
package.AddTriangleVertex(boltPts[2].X, boltPts[2].Y, boltPts[2].Z);
package.AddTriangleVertex(boltPts[3].X, boltPts[3].Y, boltPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
break;
case Operation.SERVICE_HOLE:
lateral = lateral.Normalized().Scale(0.5);
lateralR = lateralR.Normalized().Scale(0.5);
webAxis = webAxis.Normalized().Scale(0.5);
webAxisR = webAxisR.Normalized().Scale(0.5);
normal = normal.Normalized().Scale(0.01);
normalR = normalR.Normalized().Scale(0.01);
Geo.Point[] servicePts = new Geo.Point[] { opPoint.Add(lateral.Add(webAxis.Add(normal))), opPoint.Add(lateral.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxis.Add(normal))) };
package.AddTriangleVertex(servicePts[0].X, servicePts[0].Y, servicePts[0].Z);
package.AddTriangleVertex(servicePts[1].X, servicePts[1].Y, servicePts[1].Z);
package.AddTriangleVertex(servicePts[2].X, servicePts[2].Y, servicePts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(servicePts[0].X, servicePts[0].Y, servicePts[0].Z);
package.AddTriangleVertex(servicePts[2].X, servicePts[2].Y, servicePts[2].Z);
package.AddTriangleVertex(servicePts[3].X, servicePts[3].Y, servicePts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
servicePts = new Geo.Point[] { opPoint.Add(lateral.Add(webAxis.Add(normalR))), opPoint.Add(lateral.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxis.Add(normalR))) };
package.AddTriangleVertex(servicePts[0].X, servicePts[0].Y, servicePts[0].Z);
package.AddTriangleVertex(servicePts[1].X, servicePts[1].Y, servicePts[1].Z);
package.AddTriangleVertex(servicePts[2].X, servicePts[2].Y, servicePts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(servicePts[0].X, servicePts[0].Y, servicePts[0].Z);
package.AddTriangleVertex(servicePts[2].X, servicePts[2].Y, servicePts[2].Z);
package.AddTriangleVertex(servicePts[3].X, servicePts[3].Y, servicePts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
break;
case Operation.NOTCH:
lateral = lateral.Normalized().Scale(1.75);
lateralR = lateralR.Normalized().Scale(1.75);
webAxis = webAxis.Normalized().Scale(0.875);
webAxisR = webAxisR.Normalized().Scale(0.875);
normal = normal.Normalized().Scale(0.01);
normalR = normalR.Normalized().Scale(0.01);
Geo.Point[] notchPts = { opPoint.Add(lateral.Add(webAxis.Add(normal))), opPoint.Add(lateral.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxisR.Add(normal))), opPoint.Add(lateralR.Add(webAxis.Add(normal))) };
package.AddTriangleVertex(notchPts[0].X, notchPts[0].Y, notchPts[0].Z);
package.AddTriangleVertex(notchPts[1].X, notchPts[1].Y, notchPts[1].Z);
package.AddTriangleVertex(notchPts[2].X, notchPts[2].Y, notchPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(notchPts[0].X, notchPts[0].Y, notchPts[0].Z);
package.AddTriangleVertex(notchPts[2].X, notchPts[2].Y, notchPts[2].Z);
package.AddTriangleVertex(notchPts[3].X, notchPts[3].Y, notchPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
notchPts = new Geo.Point[] { opPoint.Add(lateral.Add(webAxis.Add(normalR))), opPoint.Add(lateral.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxisR.Add(normalR))), opPoint.Add(lateralR.Add(webAxis.Add(normalR))) };
package.AddTriangleVertex(notchPts[0].X, notchPts[0].Y, notchPts[0].Z);
package.AddTriangleVertex(notchPts[1].X, notchPts[1].Y, notchPts[1].Z);
package.AddTriangleVertex(notchPts[2].X, notchPts[2].Y, notchPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(notchPts[0].X, notchPts[0].Y, notchPts[0].Z);
package.AddTriangleVertex(notchPts[2].X, notchPts[2].Y, notchPts[2].Z);
package.AddTriangleVertex(notchPts[3].X, notchPts[3].Y, notchPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
break;
case Operation.LIP_CUT:
lateral = lateral.Normalized().Scale(1.75);
lateralR = lateralR.Normalized().Scale(1.75);
webAxis = webAxis.Normalized().Scale(0.875);
webAxisR = webAxisR.Normalized().Scale(0.875);
normal = normal.Normalized().Scale(1.51);
normalR = normalR.Normalized().Scale(0.01);
Geo.Vector lateral2 = lateral.Normalized().Scale(1.25);
Geo.Vector lateral2R = lateralR.Normalized().Scale(1.25);
Geo.Point[] lipPts = { opPoint.Add(webAxis).Add(lateral).Add(normal), opPoint.Add(webAxisR).Add(lateral).Add(normal), opPoint.Add(webAxis).Add(lateral2).Add(normal), opPoint.Add(webAxisR).Add(lateral2).Add(normal) };
package.AddTriangleVertex(lipPts[0].X, lipPts[0].Y, lipPts[0].Z);
package.AddTriangleVertex(lipPts[1].X, lipPts[1].Y, lipPts[1].Z);
package.AddTriangleVertex(lipPts[2].X, lipPts[2].Y, lipPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(lipPts[1].X, lipPts[1].Y, lipPts[1].Z);
package.AddTriangleVertex(lipPts[2].X, lipPts[2].Y, lipPts[2].Z);
package.AddTriangleVertex(lipPts[3].X, lipPts[3].Y, lipPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
lipPts = new Geo.Point[] { opPoint.Add(webAxis).Add(lateralR).Add(normal), opPoint.Add(webAxisR).Add(lateralR).Add(normal), opPoint.Add(webAxis).Add(lateral2R).Add(normal), opPoint.Add(webAxisR).Add(lateral2R).Add(normal) };
package.AddTriangleVertex(lipPts[0].X, lipPts[0].Y, lipPts[0].Z);
package.AddTriangleVertex(lipPts[1].X, lipPts[1].Y, lipPts[1].Z);
package.AddTriangleVertex(lipPts[2].X, lipPts[2].Y, lipPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(lipPts[1].X, lipPts[1].Y, lipPts[1].Z);
package.AddTriangleVertex(lipPts[2].X, lipPts[2].Y, lipPts[2].Z);
package.AddTriangleVertex(lipPts[3].X, lipPts[3].Y, lipPts[3].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexNormal(normal.X, normal.Y, normal.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
break;
case Operation.END_TRUSS:
lateral = lateral.Normalized().Scale(1.76);
lateralR = lateralR.Normalized().Scale(1.76);
if (opPoint.DistanceTo(this._webAxis.StartPoint) < opPoint.DistanceTo(this._webAxis.EndPoint))
{
webAxis = webAxis.Normalized().Scale(0.5);
}
else
{
webAxis = webAxisR.Normalized().Scale(0.5);
}
normal = normal.Normalized().Scale(1.50);
Geo.Vector normal2 = normal.Normalized().Scale(1.0);
Geo.Vector normal3 = normal.Normalized().Scale(0.5);
normalR = normalR.Normalized().Scale(0.01);
lateral2 = lateral.Normalized().Scale(1.25);
lateral2R = lateralR.Normalized().Scale(1.25);
Geo.Point[] endTrussPts = { opPoint.Add(lateral).Add(normal2), opPoint.Add(lateral).Add(normal).Add(webAxis), opPoint.Add(lateral).Add(normal) };
package.AddTriangleVertex(endTrussPts[0].X, endTrussPts[0].Y, endTrussPts[0].Z);
package.AddTriangleVertex(endTrussPts[1].X, endTrussPts[1].Y, endTrussPts[1].Z);
package.AddTriangleVertex(endTrussPts[2].X, endTrussPts[2].Y, endTrussPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
endTrussPts = new Geo.Point[] { opPoint.Add(lateral).Add(normal3), opPoint.Add(lateral).Add(webAxis), opPoint.Add(lateral) };
package.AddTriangleVertex(endTrussPts[0].X, endTrussPts[0].Y, endTrussPts[0].Z);
package.AddTriangleVertex(endTrussPts[1].X, endTrussPts[1].Y, endTrussPts[1].Z);
package.AddTriangleVertex(endTrussPts[2].X, endTrussPts[2].Y, endTrussPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexNormal(lateral.X, lateral.Y, lateral.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
endTrussPts = new Geo.Point[] { opPoint.Add(lateralR).Add(normal2), opPoint.Add(lateralR).Add(normal).Add(webAxis), opPoint.Add(lateralR).Add(normal) };
package.AddTriangleVertex(endTrussPts[0].X, endTrussPts[0].Y, endTrussPts[0].Z);
package.AddTriangleVertex(endTrussPts[1].X, endTrussPts[1].Y, endTrussPts[1].Z);
package.AddTriangleVertex(endTrussPts[2].X, endTrussPts[2].Y, endTrussPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
endTrussPts = new Geo.Point[] { opPoint.Add(lateralR).Add(normal3), opPoint.Add(lateralR).Add(webAxis), opPoint.Add(lateralR) };
package.AddTriangleVertex(endTrussPts[0].X, endTrussPts[0].Y, endTrussPts[0].Z);
package.AddTriangleVertex(endTrussPts[1].X, endTrussPts[1].Y, endTrussPts[1].Z);
package.AddTriangleVertex(endTrussPts[2].X, endTrussPts[2].Y, endTrussPts[2].Z);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexColor(r, g, b, a);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexNormal(lateralR.X, lateralR.Y, lateralR.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
break;
default:
package.AddPointVertex(opPoint.X, opPoint.Y, opPoint.Z);
package.AddPointVertexColor(r, g, b, a);
break;
}
}
}
// ██████╗ ██╗ ██╗██████╗ ██████╗███╗ ██╗███████╗████████╗██████╗
// ██╔══██╗██║ ██║██╔══██╗ ██╔════╝████╗ ██║██╔════╝╚══██╔══╝██╔══██╗
// ██████╔╝██║ ██║██████╔╝ ██║ ██╔██╗ ██║███████╗ ██║ ██████╔╝
// ██╔═══╝ ██║ ██║██╔══██╗ ██║ ██║╚██╗██║╚════██║ ██║ ██╔══██╗
// ██║ ╚██████╔╝██████╔╝ ╚██████╗██║ ╚████║███████║ ██║ ██║ ██║
// ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝╚═╝ ╚═══╝╚══════╝ ╚═╝ ╚═╝ ╚═╝
//
/// <summary>
/// Creates an hMember with its web lying along the webAxis, facing webNormal
/// </summary>
/// <param name="webAxis"></param>
/// <param name="webNormal"></param>
/// <param name="name"></param>
/// <returns name="hMember"></returns>
public static hMember ByLineVector(Geo.Line webAxis, Geo.Vector webNormal, string name = "0")
{
hMember member = new hMember(webAxis, webNormal.Normalized(), name);
return(member);
}
internal hMember(Geo.Line webAxis, string name = "0")
{
_webAxis = webAxis;
_webNormal = null;
_name = name;
}
internal sXYZ TosXYZ(Dyn.Vector dyv)
{
return(new sXYZ(dyv.X, dyv.Y, dyv.Z));
}
/// <summary> /// This method is called when the Gizmo in action is moved during mouse /// move event. Derived class can use this notification to update the /// input nodes. /// </summary> /// <param name="gizmoInAction">The Gizmo in action.</param> /// <param name="offset">Offset amount by which Gizmo has moved.</param> /// <returns>New expected position of the Gizmo</returns> protected abstract Point OnGizmoMoved(IGizmo gizmoInAction, Vector offset);
public static HM.Triple VectorToTriple(Geo.Vector v)
{
return(new HM.Triple(v.X, v.Y, v.Z));
}
public static Vector Duplicate(this Triple vector) => Vector.ByCoordinates(vector.X, vector.Y, vector.Z);