protected void CenterExtrusionPoints(CSGPlane buildPlane)
        {
            if (!HaveHeight)
            {
                return;
            }

            var center = GetShapeBounds().Center;

            brushPosition = buildPlane.Project(center);
            var height0 = buildPlane.Distance(extrusionPoints[0].Position);
            var height1 = buildPlane.Distance(extrusionPoints[1].Position);

            extrusionPoints[0].Position = brushPosition + (buildPlane.normal * height0);
            extrusionPoints[1].Position = brushPosition + (buildPlane.normal * height1);
        }
Exemplo n.º 2
0
        public static bool IntersectsWithShapePolygon(ShapePolygon shapePolygon, CSGPlane polygonPlane, Ray ray)
        {
            var intersection = polygonPlane.Intersection(ray);
            var vertices     = shapePolygon.Vertices;

            for (int v0 = vertices.Length - 1, v1 = 0; v1 < vertices.Length; v0 = v1, v1++)
            {
                var vertex0 = vertices[v0];
                var vertex1 = vertices[v1];
                var delta   = (vertex1 - vertex0);
                var length  = delta.sqrMagnitude;
                if (length <= MathConstants.EqualityEpsilonSqr)
                {
                    continue;
                }

                var tangent = delta / Mathf.Sqrt(length);
                var normal  = Vector3.Cross(polygonPlane.normal, tangent);
                var plane   = new CSGPlane(normal, vertex0);
                if (plane.Distance(intersection) < MathConstants.DistanceEpsilon)
                {
                    return(false);
                }
            }
            return(true);
        }
        public static float DistanceToLine(CSGPlane cameraPlane, Vector2 mousePoint, Vector3 point1, Vector3 point2)
        {
            var dist1 = cameraPlane.Distance(point1);
            var dist2 = cameraPlane.Distance(point2);

            if (dist1 < 0 && dist2 > 0)
            {
                point1 = cameraPlane.Intersection(point1, point2);
            }
            else
            if (dist2 < 0 && dist1 > 0)
            {
                point2 = cameraPlane.Intersection(point1, point2);
            }

            return(DistanceToLine(mousePoint, point1, point2) * 0.5f);
        }
        public static float DistanceToLine(CSGPlane cameraPlane, Vector2 mousePoint, Vector3 point1, Vector3 point2)
        {
            var dist1 = cameraPlane.Distance(point1);
            var dist2 = cameraPlane.Distance(point2);

            if (dist1 < 0 && dist2 > 0)
            {
                point1 = cameraPlane.LineIntersection(point1, point2);
            }
            else
            if (dist2 < 0 && dist1 > 0)
            {
                point2 = cameraPlane.LineIntersection(point1, point2);
            }

            float value = DistancePointLine(mousePoint, point1, point2) / 2.5f;            // * 0.5f;

            return(value);
        }
        protected void GrabHeightHandle(SceneView sceneView, int index, bool ignoreFirstMouseUp = false)
        {
            var camera = sceneView.camera;

            if (camera == null)
            {
                return;
            }

            var assume2DView = CSGSettings.Assume2DView(camera);

            firstClick                        = ignoreFirstMouseUp;
            editMode                          = EditMode.ExtrudeShape;
            GUIUtility.hotControl             = extrusionPoints[index].ID;
            GUIUtility.keyboardControl        = extrusionPoints[index].ID;
            EditorGUIUtility.editingTextField = false;
            EditorGUIUtility.SetWantsMouseJumping(1);

            var     surfaceDirection = buildPlane.normal;
            var     closestAxisForward = GeometryUtility.SnapToClosestAxis(-camera.transform.forward);
            var     closestAxisArrow = GeometryUtility.SnapToClosestAxis(surfaceDirection);
            Vector3 tangent, normal;
            float   dot = Mathf.Abs(Vector3.Dot(closestAxisForward, closestAxisArrow));

            if (dot != 1)
            {
                Vector3 v1, v2;
                if (closestAxisForward.x == 0 && closestAxisForward.y == 0)
                {
                    v1 = new Vector3(1, 0, 0);
                    v2 = new Vector3(0, 1, 0);
                }
                else
                if (closestAxisForward.x == 0 && closestAxisForward.z == 0)
                {
                    v1 = new Vector3(1, 0, 0);
                    v2 = new Vector3(0, 0, 1);
                }
                else
                //if (closestAxisForward.y == 0 && closestAxisForward.z == 0)
                {
                    v1 = new Vector3(0, 1, 0);
                    v2 = new Vector3(0, 0, 1);
                }

                var   backward = -camera.transform.forward;
                float dot1     = Vector3.Dot(backward, v1);
                float dot2     = Vector3.Dot(backward, v2);
                if (dot1 < dot2)
                {
                    tangent = v1;
                }
                else
                {
                    tangent = v2;
                }
            }
            else
            {
                tangent = GeometryUtility.SnapToClosestAxis(Vector3.Cross(surfaceDirection, -camera.transform.forward));
            }

            normal = Vector3.Cross(surfaceDirection, tangent);

            if (assume2DView)
            {
                normal = -camera.transform.forward;
            }

            if (normal == MathConstants.zeroVector3)
            {
                normal = GeometryUtility.SnapToClosestAxis(-camera.transform.forward);
            }

            movePlane = new CSGPlane(normal, extrusionPoints[index].Position);
            if (!assume2DView && Mathf.Abs(movePlane.Distance(camera.transform.position)) < 2.0f)
            {
                var new_tangent = Vector3.Cross(normal, closestAxisForward);
                if (new_tangent != MathConstants.zeroVector3)
                {
                    tangent   = new_tangent;
                    normal    = Vector3.Cross(surfaceDirection, tangent);
                    movePlane = new CSGPlane(normal, extrusionPoints[index].Position);
                }
            }

            movePolygonDirection = haveForcedDirection ? forcedDirection : buildPlane.normal;

            if (!isFinished)
            {
                RealtimeCSG.CSGGrid.SetForcedGrid(camera, movePlane);
            }

            var plane = new CSGPlane(buildPlane.normal, extrusionPoints[index].Position);

            heightPosition = Event.current.mousePosition;

            heightHandleOffset = (plane.Distance(GetHeightHandlePosition(sceneView, extrusionPoints[index].Position)) * movePolygonDirection);

            if (float.IsInfinity(heightHandleOffset.x) || float.IsNaN(heightHandleOffset.x) ||
                float.IsInfinity(heightHandleOffset.y) || float.IsNaN(heightHandleOffset.y) ||
                float.IsInfinity(heightHandleOffset.z) || float.IsNaN(heightHandleOffset.z))
            {
                heightHandleOffset = Vector3.zero;
            }
        }