public virtual UpdateResult Update()

in src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual.cs [124:251]
94 lines of code
31 McCabe index (conditional complexity)

        public virtual UpdateResult Update(ServerCompositionTarget root, Matrix parentVisualTransform)
        {
            if (Parent == null && Root == null)
                return default;

            var wasVisible = IsVisibleInFrame;

            // Calculate new parent-relative transform
            if (_combinedTransformDirty)
            {
                CombinedTransformMatrix = MatrixUtils.ComputeTransform(Size, AnchorPoint, CenterPoint,
                    // HACK: Ignore RenderTransform set by the adorner layer
                    AdornedVisual != null ? Matrix.Identity : TransformMatrix,
                    Scale, RotationAngle, Orientation, Offset);
                _combinedTransformDirty = false;
            }

            var parentTransform = AdornedVisual?.GlobalTransformMatrix ?? parentVisualTransform;

            var newTransform = CombinedTransformMatrix * parentTransform;

            // Check if visual was moved and recalculate face orientation
            var positionChanged = false;
            if (GlobalTransformMatrix != newTransform)
            {
                _isBackface = Vector3.Transform(
                    new Vector3(0, 0, float.PositiveInfinity), MatrixUtils.ToMatrix4x4(GlobalTransformMatrix)).Z <= 0;
                positionChanged = true;
            }

            var oldTransformedContentBounds = TransformedOwnContentBounds;
            var oldCombinedTransformedClipBounds = _combinedTransformedClipBounds;

            if (_parent?.IsDirtyComposition == true)
            {
                IsDirtyComposition = true;
                _isDirtyForUpdate = true;
            }

            var invalidateOldBounds = _isDirtyForUpdate;
            var invalidateNewBounds = _isDirtyForUpdate;

            GlobalTransformMatrix = newTransform;

            var ownBounds = OwnContentBounds;
            
            // Since padding is applied in the current visual's coordinate space we expand bounds before transforming them
            if (Effect != null)
                ownBounds = ownBounds.Inflate(Effect.GetEffectOutputPadding());
            
            if (ownBounds != _oldOwnContentBounds || positionChanged)
            {
                _oldOwnContentBounds = ownBounds;
                if (ownBounds.IsZeroSize)
                    TransformedOwnContentBounds = default;
                else
                    TransformedOwnContentBounds =
                        ownBounds.TransformToAABB(GlobalTransformMatrix);
            }

            if (_clipSizeDirty || positionChanged)
            {
                LtrbRect? transformedVisualBounds = null;
                LtrbRect? transformedClipBounds = null;

                if (ClipToBounds)
                    transformedVisualBounds =
                        new LtrbRect(0, 0, Size.X, Size.Y).TransformToAABB(GlobalTransformMatrix);

                if (Clip != null)
                    transformedClipBounds = new LtrbRect(Clip.Bounds).TransformToAABB(GlobalTransformMatrix);

                if (transformedVisualBounds != null && transformedClipBounds != null)
                    _transformedClipBounds = transformedVisualBounds.Value.Intersect(transformedClipBounds.Value);
                else if (transformedVisualBounds != null)
                    _transformedClipBounds = transformedVisualBounds;
                else if (transformedClipBounds != null)
                    _transformedClipBounds = transformedClipBounds;
                else
                     _transformedClipBounds = null;
                 
                _clipSizeDirty = false;
            }

            _combinedTransformedClipBounds =
                (AdornerIsClipped ? AdornedVisual?._combinedTransformedClipBounds : null)
                ?? (Parent?.Effect == null ? Parent?._combinedTransformedClipBounds : null)
                ?? new LtrbRect(0, 0, Root!.PixelSize.Width, Root!.PixelSize.Height);

            if (_transformedClipBounds != null)
                _combinedTransformedClipBounds = _combinedTransformedClipBounds.Intersect(_transformedClipBounds.Value);

            EffectiveOpacity = Opacity * (Parent?.EffectiveOpacity ?? 1);

            IsHitTestVisibleInFrame = _parent?.IsHitTestVisibleInFrame != false
                                      && Visible
                                      && !_isBackface
                                      && !(_combinedTransformedClipBounds.IsZeroSize);

            IsVisibleInFrame = IsHitTestVisibleInFrame
                               && _parent?.IsVisibleInFrame != false
                               && EffectiveOpacity > 0.003;

            if (wasVisible != IsVisibleInFrame || positionChanged)
            {
                invalidateOldBounds |= wasVisible;
                invalidateNewBounds |= IsVisibleInFrame;
            }

            // Invalidate new bounds
            if (invalidateNewBounds)
                AddDirtyRect(TransformedOwnContentBounds.Intersect(_combinedTransformedClipBounds));

            if (invalidateOldBounds)
                AddDirtyRect(oldTransformedContentBounds.Intersect(oldCombinedTransformedClipBounds));


            _isDirtyForUpdate = false;
            
            // Update readback indices
            var i = Root!.Readback;
            ref var readback = ref GetReadback(i.WriteIndex);
            readback.Revision = root.Revision;
            readback.Matrix = GlobalTransformMatrix;
            readback.TargetId = Root.Id;
            readback.Visible = IsHitTestVisibleInFrame;
            return new(TransformedOwnContentBounds, invalidateNewBounds, invalidateOldBounds);
        }