public AxisAlignedBox3f GetPrintMeshesBounds(bool bPrecise) { AxisAlignedBox3f b = AxisAlignedBox3f.Empty; foreach (PrintMeshSO so in PrintMeshes) { if (SceneUtil.IsVisible(so) == false) { continue; } if (bPrecise) { var xform = SceneTransforms.ObjectToSceneXForm(so); foreach (Vector3d v in so.Mesh.Vertices()) { b.Contain((Vector3f)xform.TransformP(v)); } } else { Box3f sobox = so.GetBoundingBox(CoordSpace.SceneCoords); if (sobox.Volume > 0) { foreach (Vector3d v in sobox.VerticesItr()) { b.Contain(v); } } } } return(b); }
//new Bounds(Vector3.zero, new Vector3(-1.31337f, -1.31337f, -1.31337f)); public static AxisAlignedBox3f GetBoundingBox(GameObject go) { Renderer r = go.GetComponent <Renderer>(); if (r != null) { return(r.bounds); } else if (go.HasChildren()) { AxisAlignedBox3f b = InvalidBounds; int i = 0; foreach (GameObject child_go in go.Children()) { if (i++ == 0) { b = GetBoundingBox(child_go); } else { b.Contain(GetBoundingBox(child_go)); } } return(b); } else { return(new AxisAlignedBox3f(go.transform.position, new Vector3(0.001f, 0.001f, 0.001f))); } }
/// <summary> /// Compute AABB of scene in given space. Note that this will *not* be the same box /// in world space as in scene space. /// This computation ignores SOs with zero volume. /// </summary> public AxisAlignedBox3f GetBoundingBox(CoordSpace eSpace, bool bIncludeBoundsObjects) { if (eSpace == CoordSpace.ObjectCoords) { eSpace = CoordSpace.SceneCoords; } AxisAlignedBox3f b = AxisAlignedBox3f.Empty; foreach (SceneObject so in SceneObjects) { Box3f sobox = so.GetBoundingBox(eSpace); if (sobox.Volume > 0) { foreach (Vector3d v in sobox.VerticesItr()) { b.Contain(v); } } } if (bIncludeBoundsObjects) { AxisAlignedBox3f sceneBounds = UnityUtil.GetGeometryBoundingBox(BoundsObjects, true); if (sceneBounds.Volume > 0) { if (eSpace == CoordSpace.WorldCoords) { for (int k = 0; k < 8; ++k) { b.Contain(ToWorldP(sceneBounds.Corner(k))); } } else { b.Contain(sceneBounds); } } } if (b.Volume == 0) { b = new AxisAlignedBox3f(1.0f); } return(b); }
public AxisAlignedBox3f GetBoundingBox(bool bIncludeBoundsObjects) { AxisAlignedBox3f b = UnityUtil.InvalidBounds; foreach (SceneObject so in SceneObjects) { b.Contain(so.GetTransformedBoundingBox()); } if (b == UnityUtil.InvalidBounds || bIncludeBoundsObjects) { UnityUtil.Combine(b, UnityUtil.GetBoundingBox(BoundsObjects)); } if (b == UnityUtil.InvalidBounds) { b.Contain(Vector3f.Zero); b.Expand(1.0f); } return(b); }
/// <summary> /// get combined MeshFilter bounding box of objects /// </summary> public static AxisAlignedBox3f GetGeometryBoundingBox(List <fGameObject> objects, bool bIncludeChildren = false) { AxisAlignedBox3f b = AxisAlignedBox3f.Empty; foreach (fGameObject go in objects) { b.Contain(GetGeometryBoundingBox(go, bIncludeChildren)); } return(b); }
public static AxisAlignedBox3f BoundsInFrame(Mesh m, Frame3f f) { AxisAlignedBox3f box = AxisAlignedBox3f.Empty; int N = m.vertexCount; for (int k = 0; k < N; ++k) { box.Contain(f.ToFrameP(m.vertices[k])); } return(box); }
// will return InvalidBounds if any element in list doesn't have a mesh public static AxisAlignedBox3f GetGeometryBoundingBox(List <GameObject> objects) { if (objects.Count == 0) { return(InvalidBounds); } AxisAlignedBox3f b = GetGeometryBoundingBox(objects[0]); foreach (GameObject go in objects) { b.Contain(GetGeometryBoundingBox(go)); } return(b); }
public static AxisAlignedBox3f GetBoundingBox(List <GameObject> objects) { if (objects.Count == 0) { return(InvalidBounds); } AxisAlignedBox3f b = GetBoundingBox(objects[0]); for (int i = 1; i < objects.Count; ++i) { b.Contain(GetBoundingBox(objects[i])); } return(b); }
// knows about our magic invalid value public static AxisAlignedBox3f Combine(AxisAlignedBox3f b1, AxisAlignedBox3f b2) { if (b1 == InvalidBounds) { return(b2); } else if (b2 == InvalidBounds) { return(b1); } AxisAlignedBox3f r = b1; r.Contain(b2); return(r); }
/// <summary> /// Get MeshFilter bounding box of GO. If bIncludeChildren = true, descend /// into children and return union of boxes /// </summary> public static AxisAlignedBox3f GetGeometryBoundingBox(GameObject go, bool bIncludeChildren = false) { MeshFilter f = go.GetComponent <MeshFilter>(); AxisAlignedBox3f b = (f != null) ? (AxisAlignedBox3f)f.mesh.bounds : AxisAlignedBox3f.Empty; if (bIncludeChildren && go.HasChildren()) { foreach (GameObject child_go in go.Children()) { AxisAlignedBox3f child_b = GetGeometryBoundingBox(child_go, true); b.Contain(child_b); } } return(b); }
public static Bounds GetLocalBoundingBox(IEnumerable <SceneObject> vObjects) { int i = 0; AxisAlignedBox3f b = AxisAlignedBox3f.Infinite; foreach (SceneObject so in vObjects) { if (i == 0) { b = so.GetLocalBoundingBox(); } else { b.Contain(so.GetLocalBoundingBox()); } } return(b); }
public virtual void Create(FScene parentScene, List <SceneObject> targets) { this.parentScene = parentScene; this.targets = targets; root = GameObjectFactory.CreateParentGO("TransformGizmo"); var xMaterial = Factory.MakeMaterial(AxisGizmoFlags.AxisTranslateX); var xHoverMaterial = Factory.MakeHoverMaterial(AxisGizmoFlags.AxisTranslateX); var yMaterial = Factory.MakeMaterial(AxisGizmoFlags.AxisTranslateY); var yHoverMaterial = Factory.MakeHoverMaterial(AxisGizmoFlags.AxisTranslateY); var zMaterial = Factory.MakeMaterial(AxisGizmoFlags.AxisTranslateZ); var zHoverMaterial = Factory.MakeHoverMaterial(AxisGizmoFlags.AxisTranslateZ); if (Factory.Supports(AxisGizmoFlags.AxisTranslateX)) { translate_x = append_widget(AxisGizmoFlags.AxisTranslateX, 0, "x_translate", xMaterial, xHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.AxisTranslateY)) { translate_y = append_widget(AxisGizmoFlags.AxisTranslateY, 1, "y_translate", yMaterial, yHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.AxisTranslateZ)) { translate_z = append_widget(AxisGizmoFlags.AxisTranslateZ, 2, "z_translate", zMaterial, zHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.AxisRotateX)) { rotate_x = append_widget(AxisGizmoFlags.AxisRotateX, 0, "x_rotate", xMaterial, xHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.AxisRotateY)) { rotate_y = append_widget(AxisGizmoFlags.AxisRotateY, 1, "y_rotate", yMaterial, yHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.AxisRotateZ)) { rotate_z = append_widget(AxisGizmoFlags.AxisRotateZ, 2, "z_rotate", zMaterial, zHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.PlaneTranslateX)) { translate_yz = append_widget(AxisGizmoFlags.PlaneTranslateX, 0, "yz_translate", xMaterial, xHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.PlaneTranslateY)) { translate_xz = append_widget(AxisGizmoFlags.PlaneTranslateY, 1, "xz_translate", yMaterial, yHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.PlaneTranslateZ)) { translate_xy = append_widget(AxisGizmoFlags.PlaneTranslateZ, 2, "xy_translate", zMaterial, zHoverMaterial); } if (Factory.Supports(AxisGizmoFlags.UniformScale)) { uniform_scale = append_widget(AxisGizmoFlags.UniformScale, 0, "uniform_scale", null, null); } gizmoGeomBounds = UnityUtil.GetGeometryBoundingBox(root, true); gizmoGeomBounds.Contain(Vector3d.Zero); initialGizmoRadius = gizmoGeomBounds.MaxDim; foreach (var widget in Widgets) { widget.Value.SetGizmoInitialRadius(initialGizmoRadius); } // disable shadows on widget components foreach (var go in GameObjects) { MaterialUtil.DisableShadows(go); } update_active(); eCurrentFrameMode = FrameType.LocalFrame; SetActiveFrame(eCurrentFrameMode); SetLayer((GizmoLayer == -1) ? FPlatform.WidgetOverlayLayer : GizmoLayer); // seems like possibly this geometry will be shown this frame, before PreRender() // is called, which means that on next frame the geometry will pop. // So we hide here and show in PreRender root.Hide(); }
public static void SwapUpDirection(FScene scene, List <PrintMeshSO> objects) { AxisAlignedBox3f sceneBounds = AxisAlignedBox3f.Empty; Vector3f sharedOrigin = Vector3f.Zero; foreach (var meshSO in objects) { sharedOrigin += meshSO.GetLocalFrame(CoordSpace.SceneCoords).Origin; sceneBounds.Contain(meshSO.GetBoundingBox(CoordSpace.SceneCoords).ToAABB()); } sharedOrigin /= objects.Count; foreach (var so in objects) { Frame3f curF = so.GetLocalFrame(CoordSpace.SceneCoords); UpDirection from = so.UpDirection; UpDirection to = (from == UpDirection.YUp) ? UpDirection.ZUp : UpDirection.YUp; Quaternionf rotate = Quaternionf.AxisAngleD(Vector3f.AxisX, (to == UpDirection.YUp) ? -90 : 90); Frame3f newF = curF; newF.RotateAround(sharedOrigin, rotate); TransformSOChange upChange = new TransformSOChange(so, newF, CoordSpace.SceneCoords) { OnApplyF = (x) => { so.UpDirection = to; }, OnRevertF = (x) => { so.UpDirection = from; } }; scene.History.PushChange(upChange, false); } AxisAlignedBox3f newSceneBounds = AxisAlignedBox3f.Empty; foreach (var meshSO in objects) { newSceneBounds.Contain(meshSO.GetBoundingBox(CoordSpace.SceneCoords).ToAABB()); } Vector3f startBase = sceneBounds.Center; startBase.y = 0; Vector3f newBase = newSceneBounds.Center; newBase.y = newSceneBounds.Min.y; Vector3f df = startBase - newBase; foreach (var so in objects) { Frame3f curF = so.GetLocalFrame(CoordSpace.SceneCoords); Frame3f newF = curF.Translated(df); TransformSOChange centerChange = new TransformSOChange(so, newF, CoordSpace.SceneCoords); scene.History.PushChange(centerChange, false); } // reposition pivots at base of List <Frame3f> setF = new List <Frame3f>(); foreach (var so in objects) { Frame3f objF = so.GetLocalFrame(CoordSpace.ObjectCoords); Vector3f center = so.GetBoundingBox(CoordSpace.SceneCoords).Center; center.y = 0; Frame3f sceneF = new Frame3f(center); setF.Add(sceneF); } for (int k = 0; k < objects.Count; ++k) { RepositionPivotChangeOp change = new RepositionPivotChangeOp(setF[k], objects[k], CoordSpace.SceneCoords); scene.History.PushChange(change, false); } }