private void TransformTarget()

in Assets/MRTK/SDK/Features/UX/Scripts/BoundsControl/BoundsControl.cs [1184:1295]
103 lines of code
28 McCabe index (conditional complexity)

        private void TransformTarget(HandleType transformType)
        {
            if (transformType != HandleType.None)
            {
                currentGrabPoint = (currentPointer.Rotation * grabPointInPointer) + currentPointer.Position;
                bool isNear = currentPointer is IMixedRealityNearPointer;


                TransformFlags transformUpdated = 0;
                if (transformType == HandleType.Rotation)
                {
                    Vector3 initDir = Vector3.ProjectOnPlane(initialGrabPoint - Target.transform.position, currentRotationAxis).normalized;
                    Vector3 currentDir = Vector3.ProjectOnPlane(currentGrabPoint - Target.transform.position, currentRotationAxis).normalized;
                    Quaternion goal = Quaternion.FromToRotation(initDir, currentDir) * initialRotationOnGrabStart;
                    MixedRealityTransform constraintRotation = MixedRealityTransform.NewRotate(goal);
                    if (EnableConstraints && constraintsManager != null)
                    {
                        constraintsManager.ApplyRotationConstraints(ref constraintRotation, true, isNear);
                    }
                    if (elasticsManager != null)
                    {
                        transformUpdated = elasticsManager.ApplyTargetTransform(constraintRotation, TransformFlags.Rotate);
                    }
                    if (!transformUpdated.HasFlag(TransformFlags.Rotate))
                    {
                        Target.transform.rotation = smoothingActive ? 
                            Smoothing.SmoothTo(Target.transform.rotation, constraintRotation.Rotation, rotateLerpTime, Time.deltaTime) : 
                            constraintRotation.Rotation;
                    }
                }
                else if (transformType == HandleType.Scale)
                {
                    Vector3 scaleFactor = Target.transform.localScale;
                    if (ScaleHandlesConfig.ScaleBehavior == HandleScaleMode.Uniform)
                    {
                        float initialDist = Vector3.Dot(initialGrabPoint - oppositeCorner, diagonalDir);
                        float currentDist = Vector3.Dot(currentGrabPoint - oppositeCorner, diagonalDir);
                        float scaleFactorUniform = 1 + (currentDist - initialDist) / initialDist;
                        scaleFactor = new Vector3(scaleFactorUniform, scaleFactorUniform, scaleFactorUniform);
                    }
                    else // non-uniform scaling
                    {
                        // get diff from center point of box
                        Vector3 initialDist = (initialGrabPoint - oppositeCorner);
                        Vector3 currentDist = (currentGrabPoint - oppositeCorner);
                        Vector3 grabDiff = (currentDist - initialDist);
                        scaleFactor = Vector3.one + grabDiff.Div(initialDist);
                    }

                    // If non-uniform scaling or uniform scaling only on the non-flattened axes
                    if (ScaleHandlesConfig.ScaleBehavior != HandleScaleMode.Uniform || !UniformScaleOnFlattenedAxis)
                    {
                        FlattenModeType determinedType = FlattenAxis == FlattenModeType.FlattenAuto ? VisualUtils.DetermineAxisToFlatten(TargetBounds.bounds.extents) : FlattenAxis;
                        if (determinedType == FlattenModeType.FlattenX)
                        {
                            scaleFactor.x = 1;
                        }
                        if (determinedType == FlattenModeType.FlattenY)
                        {
                            scaleFactor.y = 1;
                        }
                        if (determinedType == FlattenModeType.FlattenZ)
                        {
                            scaleFactor.z = 1;
                        }
                    }

                    Vector3 newScale = initialScaleOnGrabStart.Mul(scaleFactor);
                    MixedRealityTransform clampedTransform = MixedRealityTransform.NewScale(newScale);
                    if (EnableConstraints && constraintsManager != null)
                    {
                        constraintsManager.ApplyScaleConstraints(ref clampedTransform, true, isNear);
                    }

                    if (elasticsManager != null)
                    {
                        transformUpdated = elasticsManager.ApplyTargetTransform(clampedTransform, TransformFlags.Scale);
                    }
                    if (!transformUpdated.HasFlag(TransformFlags.Scale))
                    {
                        Target.transform.localScale = smoothingActive ? 
                            Smoothing.SmoothTo(Target.transform.localScale, clampedTransform.Scale, scaleLerpTime, Time.deltaTime) : 
                            clampedTransform.Scale;
                    }

                    var originalRelativePosition = initialPositionOnGrabStart - oppositeCorner;
                    var newPosition = originalRelativePosition.Div(initialScaleOnGrabStart).Mul(Target.transform.localScale) + oppositeCorner;
                    Target.transform.position = smoothingActive ? Smoothing.SmoothTo(Target.transform.position, newPosition, scaleLerpTime, Time.deltaTime) : newPosition;
                }
                else if (transformType == HandleType.Translation)
                {
                    Vector3 translateVectorAlongAxis = Vector3.Project(currentGrabPoint - initialGrabPoint, currentTranslationAxis);

                    var goal = initialPositionOnGrabStart + translateVectorAlongAxis;
                    MixedRealityTransform constraintTranslate = MixedRealityTransform.NewTranslate(goal);
                    if (EnableConstraints && constraintsManager != null)
                    {
                        constraintsManager.ApplyTranslationConstraints(ref constraintTranslate, true, isNear);
                    }
                    if (elasticsManager != null)
                    {
                        transformUpdated = elasticsManager.ApplyTargetTransform(constraintTranslate, TransformFlags.Move);
                    }
                    if (!transformUpdated.HasFlag(TransformFlags.Move))
                    {
                        Target.transform.position = smoothingActive ? 
                            Smoothing.SmoothTo(Target.transform.position, constraintTranslate.Position, translateLerpTime, Time.deltaTime) : 
                            constraintTranslate.Position;
                    } 
                }
            }
        }