void enable_circle_indicator(bool enable)
{
if (enable == false && circle_indicator == null)
{
return;
}
if (enable && circle_indicator == null)
{
LineSet lines = new LineSet();
lines.UseFixedNormal = true;
lines.FixedNormal = Vector3f.AxisY;
DCurve3 curve = new DCurve3(Polygon2d.MakeCircle(gizmoInitialRadius, 64), 0, 2);
lines.Curves.Add(curve);
lines.Width = 1.0f;
lines.WidthType = LineWidthType.Pixel;
lines.Segments.Add(
new Segment3d(Vector3d.Zero, gizmoInitialRadius * diagonals[nRotationAxis]));
lines.Color = Colorf.DimGrey;
circle_indicator = new fLineSetGameObject(new GameObject(), lines, "circle");
circle_indicator.SetLayer(FPlatform.WidgetOverlayLayer, true);
circle_indicator.SetLocalRotation(Quaternionf.FromTo(Vector3f.AxisY, Frame3f.Identity.GetAxis(nRotationAxis)));
RootGameObject.AddChild(circle_indicator, false);
}
circle_indicator.SetVisible(enable);
}
public void Place(HUDStandardItem hudItem, float dx, float dy)
{
Frame3f initFrame = hudItem.GetObjectFrame();
Frame3f hudFrame = HUDUtil.GetSphereFrame(Radius, dx, dy);
hudItem.SetObjectFrame(
initFrame.Translated(hudFrame.Origin)
.Rotated(Quaternionf.FromTo(initFrame.Z, hudFrame.Z)));
}
public static void PlaceInSphere(HUDStandardItem hudItem, float fHUDRadius, Vector3f vHUDCenter, Vector3f vPlaceAt)
{
Frame3f initFrame = hudItem.GetObjectFrame();
Frame3f hudFrame = GetSphereFrame(fHUDRadius, vHUDCenter, vPlaceAt);
hudItem.SetObjectFrame(
initFrame.Translated(hudFrame.Origin)
.Rotated(Quaternionf.FromTo(initFrame.Z, hudFrame.Z)));
}
public static void PlaceInSphereWithNormal(HUDStandardItem hudItem, float fHUDRadius, float fAngleHorz, float fAngleVert, Vector3f vPointDir)
{
Frame3f initFrame = hudItem.GetObjectFrame();
Frame3f hudFrame = GetSphereFrame(fHUDRadius, fAngleHorz, fAngleVert);
hudItem.SetObjectFrame(
initFrame.Translated(hudFrame.Origin)
.Rotated(Quaternionf.FromTo(initFrame.Z, vPointDir)));
}
public static void PlaceInScene(HUDStandardItem hudItem, Vector3f vHUDCenter, Vector3f vPlaceAt)
{
Frame3f initFrame = hudItem.GetObjectFrame();
Vector3f n = (vPlaceAt - vHUDCenter).Normalized;
Frame3f frame = new Frame3f(vPlaceAt, n);
hudItem.SetObjectFrame(
initFrame.Translated(frame.Origin)
.Rotated(Quaternionf.FromTo(initFrame.Z, frame.Z)));
}
void update_snap_indicator(float fAngle, bool on_snap)
{
Quaternionf planeRotation = new Quaternionf(Vector3f.AxisY, fAngle * MathUtil.Rad2Degf);
Quaternionf alignAxisRotation = Quaternionf.FromTo(Vector3f.AxisY, Frame3f.Identity.GetAxis(nRotationAxis));
snap_indicator.SetLocalRotation(alignAxisRotation * planeRotation);
snap_indicator.SafeUpdateLines((lines) => {
lines.Color.a = (on_snap) ? 1.0f : 0.15f;
});
}
public void Place(HUDStandardItem hudItem, float dx, float dy)
{
Frame3f initFrame = hudItem.GetObjectFrame();
Frame3f hudFrame = VerticalCoordIsAngle ?
HUDUtil.GetCylinderFrameFromAngles(Radius, dx, dy) :
HUDUtil.GetCylinderFrameFromAngleHeight(Radius, dx, dy);
hudItem.SetObjectFrame(
initFrame.Translated(hudFrame.Origin)
.Rotated(Quaternionf.FromTo(initFrame.Z, hudFrame.Z)));
}
protected override void OnPointUpdated(ControlPoint pt, Frame3f prevFrameS, bool isFirst)
{
Vector3f basePt = GetPointPosition(BasePointID, CoordSpace.SceneCoords).Origin;
Vector3f frontPt = GetPointPosition(FrontPointID, CoordSpace.SceneCoords).Origin;
Vector3f topPt = GetPointPosition(TopPointID, CoordSpace.SceneCoords).Origin;
lastTargetFrameS = TargetSO.GetLocalFrame(CoordSpace.SceneCoords);
Frame3f previewFrameS = lastTargetFrameS;
// position next to original object
previewFrameS = previewFrameS.Translated(1.1f * (float)meshBounds.Width * Vector3f.AxisX);
Vector3f upAxis = (topPt - basePt).Normalized;
// construct a frame perp to upAxis at midpoint, and project original and current fw points
Frame3f upFrame = new Frame3f((topPt + basePt) * 0.5f, upAxis);
Vector3f origFW = upFrame.ProjectToPlane(initialFrontPt, 2);
origFW = (origFW - upFrame.Origin).Normalized;
Vector3f curFW = upFrame.ProjectToPlane(frontPt, 2);
curFW = (curFW - upFrame.Origin).Normalized;
//float angle = MathUtil.PlaneAngleSignedD(origFW, curFW, upAxis);
start_forward_pt_S = upFrame.FromFrameP(origFW);
current_forward_pt_S = upFrame.FromFrameP(curFW);
// construct rotation that aligns up axis with y-up
Quaternionf upRotate = Quaternionf.FromTo(upAxis, Vector3f.AxisY);
previewFrameS.Rotate(upRotate);
// now rotate so that forward dir points along -Z
//Quaternionf fwRotate = Quaternionf.AxisAngleD(Vector3f.AxisY, angle);
//curFW = upRotate * curFW;
Quaternionf fwRotate = Quaternionf.FromToConstrained(curFW, -Vector3f.AxisZ, Vector3f.AxisY);
previewFrameS.Rotate(fwRotate);
previewSO.SetLocalFrame(previewFrameS, CoordSpace.SceneCoords);
lastPreviewFrameS = previewFrameS;
}
/// <summary>
/// This is the action we give to the trim-scan tool, to run on accept
/// </summary>
public static void CropScanFromSelection(DMeshSO so, MeshFaceSelection selection, object tool)
{
DMesh3 beforeMesh = new DMesh3(so.Mesh);
DMesh3 mesh = so.Mesh;
// [RMS] if we are using the two-point tool, then we can use the user input points to
// try to figure out an up axis, by assuming the first point is on the base of the scan. Steps are:
// 1) guess a midpoint. Currently centroid of upper-half of geodesic selection.
// 2) construct up axis as (midpoint-basepoint). this axis to Y-up.
Vector3f upAxisS = Vector3f.AxisY;
TwoPointFaceSelectionTool ptool = tool as TwoPointFaceSelectionTool;
if (ptool != null)
{
var cache = ptool.SelectionCache;
Interval1d range = new Interval1d(cache.CurrentScalarThreshold / 2, cache.CurrentScalarThreshold);
List <int> triangles = new List <int>(selection.Count);
cache.FindTrianglesInScalarInterval(range, triangles);
Vector3d c = MeshMeasurements.Centroid(triangles, mesh.GetTriCentroid);
Vector3d cS = SceneTransforms.ObjectToSceneP(so, c);
Vector3d basePosS = ptool.SourcePositionS.Origin;
upAxisS = (Vector3f)(cS - basePosS).Normalized;
}
// crop scan and fill top hole
List <int> borderTris = selection.FindBorderTris();
MeshEditor editor = new MeshEditor(mesh);
editor.RemoveTriangles((tid) => { return(selection.IsSelected(tid) == false); }, true);
if (OGActions.FillHoleInScan)
{
SmoothedHoleFill fill = new SmoothedHoleFill(mesh)
{
TargetEdgeLength = 2.5f,
SmoothAlpha = 0.5f,
BorderHintTris = borderTris,
OffsetDirection = SceneTransforms.SceneToObjectN(so, upAxisS),
OffsetDistance = (ptool != null) ? 25.0 : 0.0
};
fill.Apply();
}
so.NotifyMeshEdited();
DMesh3 afterMesh = new DMesh3(so.Mesh);
so.GetScene().History.PushChange(new ReplaceEntireMeshChange(so, beforeMesh, afterMesh), true);
mesh = so.Mesh;
// Now we auto-align the scan so it points upwards, and then
// recenter pivot and shift to above ground plane
if (ptool != null)
{
Vector3d basePosS = ptool.SourcePositionS.Origin;
Quaternionf alignUp = Quaternionf.FromTo(upAxisS, Vector3f.AxisY);
// rotate part so that axis points up
Frame3f curF = so.GetLocalFrame(CoordSpace.SceneCoords);
Frame3f newF = curF.Rotated(alignUp);
TransformSOChange alignUpChange = new TransformSOChange(so, curF, newF, CoordSpace.SceneCoords);
basePosS = newF.FromFrameP(curF.ToFrameP(basePosS)); // map to new frame
so.GetScene().History.PushChange(alignUpChange, false);
// recenter pivot at bbox center
// [RMS] previously was using vertex centroid, but this is then affected by mesh density
// (maybe tri centroid? but bbox makes more sense...and below we assume box center)
Vector3d centerL = mesh.CachedBounds.Center;
Vector3d centerO = newF.FromFrameP(centerL);
Frame3f newPivotO = new Frame3f(centerO);
so.GetScene().History.PushChange(new RepositionPivotChangeOp(newPivotO, so), false);
// position above ground plane
AxisAlignedBox3d bounds = so.Mesh.CachedBounds;
float h = (float)bounds.Height;
Vector3f o = newPivotO.Origin;
Vector3f translateO = new Vector3f(-o.x, h * 0.5f - o.y + BaseHeightAboveGroundPlaneMM, -o.z);
//Vector3f translateO = new Vector3f(0, h * 0.5f - o.y + BaseHeightAboveGroundPlaneMM, 0);
newPivotO.Translate(translateO);
so.GetScene().History.PushChange(new TransformSOChange(so, newPivotO, CoordSpace.ObjectCoords), false);
// save base point in frame of scan
basePosS += translateO;
Vector3d basePosL = SceneTransforms.SceneToObjectP(so, basePosS);
OG.Scan.UserBasePoint = basePosL;
}
so.GetScene().History.PushInteractionCheckpoint();
}