示例#1
0
        void DrawAngleHandle(TwirlDeformer twirl)
        {
            var radiusDistanceOffset = HandleUtility.GetHandleSize(twirl.Axis.position + twirl.Axis.right * twirl.Outer) * DeformEditorSettings.ScreenspaceSliderHandleCapSize * 2f;

            angleHandle.angle             = twirl.Angle;
            angleHandle.radius            = twirl.Outer + radiusDistanceOffset;
            angleHandle.fillColor         = Color.clear;
            angleHandle.angleHandleColor  = DeformEditorSettings.SolidHandleColor;
            angleHandle.radiusHandleColor = Color.clear;

            var matrix = Matrix4x4.TRS(twirl.transform.position, twirl.transform.rotation, twirl.transform.lossyScale);

            using (new Handles.DrawingScope(matrix))
            {
                DeformHandles.Circle(Vector3.zero, Vector3.forward, Vector3.right, angleHandle.radius);

                Handles.color = DeformEditorSettings.SolidHandleColor;

                using (var check = new EditorGUI.ChangeCheckScope())
                {
                    using (new Handles.DrawingScope(matrix * Matrix4x4.Rotate(Quaternion.LookRotation(Vector3.right, Vector3.forward))))
                    {
                        angleHandle.DrawHandle();
                        if (check.changed)
                        {
                            Undo.RecordObject(twirl, "Changed Angle");
                            twirl.Angle = angleHandle.angle;
                        }
                    }
                }
            }
        }
示例#2
0
        private void DrawRadiusHandle(CylindrifyDeformer cylindrify)
        {
            var position = Vector3.up * cylindrify.Radius;

            var axis = cylindrify.Axis;

            using (new Handles.DrawingScope(Matrix4x4.TRS(axis.position, axis.rotation, axis.lossyScale)))
            {
                var size = HandleUtility.GetHandleSize(position) * DeformEditorSettings.ScreenspaceSliderHandleCapSize;

                DeformHandles.Circle(Vector3.zero, Vector3.forward, Vector3.up, cylindrify.Radius);

                DeformHandles.Line(position + Vector3.forward * size, position + Vector3.forward * size * 5f, DeformHandles.LineMode.Light);
                DeformHandles.Line(position - Vector3.forward * size, position - Vector3.forward * size * 5f, DeformHandles.LineMode.Light);

                using (var check = new EditorGUI.ChangeCheckScope())
                {
                    var newWorldPosition = DeformHandles.Slider(position, Vector3.up);
                    if (check.changed)
                    {
                        Undo.RecordObject(cylindrify, "Changed Radius");
                        cylindrify.Radius = cylindrify.Axis.position.y;
                    }
                }
            }
        }
示例#3
0
        public override void OnSceneGUI()
        {
            base.OnSceneGUI();

            var ripple = target as RippleDeformer;

            DrawMagnitudeHandle(ripple);

            if (ripple.Mode == BoundsMode.Limited)
            {
                boundsHandle.HandleColor           = DeformEditorSettings.SolidHandleColor;
                boundsHandle.ScreenspaceHandleSize = DeformEditorSettings.ScreenspaceSliderHandleCapSize;
                if (boundsHandle.DrawHandle(ripple.OuterRadius, ripple.InnerRadius, ripple.Axis, Vector3.up))
                {
                    Undo.RecordObject(ripple, "Changed Bounds");
                    ripple.OuterRadius = boundsHandle.Top;
                    ripple.InnerRadius = boundsHandle.Bottom;
                }
            }

            DrawCurve(ripple);

            using (new Handles.DrawingScope(Matrix4x4.TRS(ripple.Axis.position, ripple.Axis.rotation, ripple.Axis.lossyScale)))
            {
                DeformHandles.Line
                (
                    Vector3.up * ripple.InnerRadius,
                    RipplePoint(ripple, Vector3.up * ripple.InnerRadius, ripple.Mode == BoundsMode.Limited),
                    DeformHandles.LineMode.LightDotted
                );

                var limited = ripple.Mode == BoundsMode.Limited;

                var innerCirlePosition = new Vector3
                {
                    x = 0f,
                    y = 0f,
                    z = RipplePoint(ripple, Vector3.up * ripple.InnerRadius, limited).z
                };

                var outerCirlePosition = new Vector3
                {
                    x = 0f,
                    y = 0f,
                    z = RipplePoint(ripple, Vector3.up * ripple.OuterRadius, limited).z
                };

                DeformHandles.Circle(innerCirlePosition, Vector3.forward, Vector3.right, ripple.InnerRadius);
                DeformHandles.Circle(outerCirlePosition, Vector3.forward, Vector3.right, ripple.OuterRadius);
            }

            EditorApplication.QueuePlayerLoopUpdate();
        }
示例#4
0
        private void DrawRadiusHandle(MeltDeformer melt)
        {
            var scaledRadius = melt.Radius;

            var bottomPosition = Vector3.forward * melt.Bottom;

            using (new Handles.DrawingScope(Matrix4x4.TRS(melt.Axis.position, melt.Axis.rotation, melt.Axis.lossyScale)))
            {
                DeformHandles.Circle(bottomPosition, Vector3.forward, Vector3.right, scaledRadius);

                var radiusWorldPosition = (Vector3.forward * melt.Bottom) + Vector3.up * scaledRadius;

                using (var check = new EditorGUI.ChangeCheckScope())
                {
                    var newRadiusWorldPosition = DeformHandles.Slider(radiusWorldPosition, Vector3.up);
                    if (check.changed)
                    {
                        Undo.RecordObject(melt, "Changed Radius");
                        melt.Radius = newRadiusWorldPosition.y;
                    }
                }
            }
        }