add local position sample scene

com.unity.uiwidgets/Runtime/cupertino/action_sheet.cs

     }
 
     class _CupertinoAlertRenderElement : RenderObjectElement {
-        public _CupertinoAlertRenderElement(_CupertinoAlertRenderWidget widget) : base(widget) { }
+        public _CupertinoAlertRenderElement(_CupertinoAlertRenderWidget widget) : base(widget) {
+        }
 
         Element _contentElement;
         Element _actionsElement;
         }
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
-            bool isHit = false;
-            ;
-            if (this.contentSection.hitTest(result, position: position - contentSectionParentData.offset)) {
-                isHit = true;
-            }
-            else if (this.actionsSection.hitTest(result,
-                position: position - actionsSectionParentData.offset)) {
-                isHit = true;
-            }
-
-            return isHit;
+            return result.addWithPaintOffset(
+                offset: contentSectionParentData.offset,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                    D.assert(transformed == position - contentSectionParentData.offset);
+                    return this.contentSection.hitTest(resultIn, position: transformed);
+                }
+            ) || result.addWithPaintOffset(
+                offset: actionsSectionParentData.offset,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                    D.assert(transformed == position - actionsSectionParentData.offset);
+                    return this.actionsSection.hitTest(resultIn, position: transformed);
+                }
+            );
         }
     }
 

com.unity.uiwidgets/Runtime/cupertino/dialog.cs

 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null
         ) {
-            bool isHit = false;
-            ;
-            if (this.contentSection.hitTest(result, position: position - contentSectionParentData.offset)) {
-                isHit = true;
-            }
-            else if (this.actionsSection.hitTest(result, position: position - actionsSectionParentData.offset)) {
-                isHit = true;
-            }
-
-            return isHit;
+            return result.addWithPaintOffset(
+                offset: contentSectionParentData.offset,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                    D.assert(transformed == position - contentSectionParentData.offset);
+                    return this.contentSection.hitTest(resultIn, position: transformed);
+                }
+            ) || result.addWithPaintOffset(
+                offset: actionsSectionParentData.offset,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                    D.assert(transformed == position - actionsSectionParentData.offset);
+                    return this.actionsSection.hitTest(resultIn, position: transformed);
+                }
+            );
         }
     }
 

com.unity.uiwidgets/Runtime/gestures/events.cs

                 return untransformedDelta;
             }
 
-            transformedEndPosition ??= transformPosition(transform, untransformedEndPosition);
+            transformedEndPosition = transformedEndPosition ?? transformPosition(transform, untransformedEndPosition);
             Offset transformedStartPosition =
                 transformPosition(transform, untransformedEndPosition - untransformedDelta);
             return transformedEndPosition - transformedStartPosition;

com.unity.uiwidgets/Runtime/gestures/tap.cs

             if (this.onTapDown != null) {
                 TapDownDetails details = new TapDownDetails(
                     globalPosition: down.position,
-                    localPosition: down.localDelta,
+                    localPosition: down.localPosition,
                     kind: down.kind,
                     device: down.device
                 );

com.unity.uiwidgets/Runtime/material/input_decorator.cs

             if (this.prefix != null) {
                 boxToBaseline[this.prefix] = this._layoutLineBox(this.prefix, boxConstraints);
             }
+
+
+
+
-                                                  _boxSize(this.icon).width
-                                                  + this.contentPadding.left
-                                                  + _boxSize(this.prefixIcon).width
-                                                  + _boxSize(this.prefix).width
-                                                  + _boxSize(this.suffix).width
-                                                  + _boxSize(this.suffixIcon).width
-                                                  + this.contentPadding.right));
+                _boxSize(this.icon).width
+                + this.contentPadding.left
+                + _boxSize(this.prefixIcon).width
+                + _boxSize(this.prefix).width
+                + _boxSize(this.suffix).width
+                + _boxSize(this.suffixIcon).width
+                + this.contentPadding.right));
             if (this.label != null) {
                 boxToBaseline[this.label] = this._layoutLineBox(this.label,
                     boxConstraints.copyWith(maxWidth: inputWidth)
 
             height = layout.containerHeight ?? 0.0f;
             baseline = (this.decoration.isCollapsed || !this.decoration.border.isOutline
-                           ? layout.inputBaseline
-                           : layout.outlineBaseline) ?? 0.0f;
+                ? layout.inputBaseline
+                : layout.outlineBaseline) ?? 0.0f;
 
             if (this.icon != null) {
                 float x = 0.0f;
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
             D.assert(position != null);
             foreach (RenderBox child in this._children) {
-                if (child.hitTest(result, position: position - _boxParentData(child).offset)) {
+                Offset offset = _boxParentData(child).offset;
+                bool isHit = result.addWithPaintOffset(
+                    offset: offset,
+                    position: position,
+                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                        D.assert(transformed == position - offset);
+                        return child.hitTest(resultIn, position: transformed);
+                    }
+                );
+                if (isHit) {
                     return true;
                 }
             }
         public readonly TextAlign? textAlign;
 
         public readonly bool isFocused;
-        
+
         public readonly bool expands;
 
         public readonly bool isEmpty;
         public InputDecoration decoration {
             get {
                 this._effectiveDecoration = this._effectiveDecoration ?? this.widget.decoration.applyDefaults(
-                                                Theme.of(this.context).inputDecorationTheme
-                                            );
+                    Theme.of(this.context).inputDecorationTheme
+                );
                 return this._effectiveDecoration;
             }
         }
                     (4.0f + 0.75f * inlineLabelStyle.fontSize) * MediaQuery.textScaleFactorOf(context);
                 if (this.decoration.filled == true) {
                     contentPadding = decorationContentPadding ?? (decorationIsDense
-                                         ? EdgeInsets.fromLTRB(12.0f, 8.0f, 12.0f, 8.0f)
-                                         : EdgeInsets.fromLTRB(12.0f, 12.0f, 12.0f, 12.0f));
+                        ? EdgeInsets.fromLTRB(12.0f, 8.0f, 12.0f, 8.0f)
+                        : EdgeInsets.fromLTRB(12.0f, 12.0f, 12.0f, 12.0f));
-                                         ? EdgeInsets.fromLTRB(0.0f, 8.0f, 0.0f, 8.0f)
-                                         : EdgeInsets.fromLTRB(0.0f, 12.0f, 0.0f, 12.0f));
+                        ? EdgeInsets.fromLTRB(0.0f, 8.0f, 0.0f, 8.0f)
+                        : EdgeInsets.fromLTRB(0.0f, 12.0f, 0.0f, 12.0f));
-                                     ? EdgeInsets.fromLTRB(12.0f, 20.0f, 12.0f, 12.0f)
-                                     : EdgeInsets.fromLTRB(12.0f, 24.0f, 12.0f, 16.0f));
+                    ? EdgeInsets.fromLTRB(12.0f, 20.0f, 12.0f, 12.0f)
+                    : EdgeInsets.fromLTRB(12.0f, 24.0f, 12.0f, 16.0f));
             }
 
             return new _Decorator(

com.unity.uiwidgets/Runtime/material/list_tile.cs

             bool isTwoLine = !this.isThreeLine && hasSubtitle;
             bool isOneLine = !this.isThreeLine && !hasSubtitle;
             BoxConstraints maxIconHeightConstrains = new BoxConstraints(
-                maxHeight: this.isDense ? 48.0f: 56.0f
+                maxHeight: this.isDense ? 48.0f : 56.0f
             );
             BoxConstraints looseConstraints = this.constraints.loosen();
             BoxConstraints iconConstraints = looseConstraints.enforce(maxIconHeightConstrains);
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
             D.assert(position != null);
             foreach (RenderBox child in this._children) {
-                BoxParentData parentData = (BoxParentData) child.parentData;
-                if (child.hitTest(result, position: position - parentData.offset)) {
+                BoxParentData parentData = child.parentData as BoxParentData;
+                bool isHit = result.addWithPaintOffset(
+                    offset: parentData.offset,
+                    position: position,
+                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                        D.assert(transformed == position - parentData.offset);
+                        return child.hitTest(resultIn, position: transformed);
+                    }
+                );
+                if (isHit) {
                     return true;
                 }
             }

com.unity.uiwidgets/Runtime/rendering/box.cs

 
         public float? getDistanceToBaseline(TextBaseline baseline, bool onlyReal = false) {
             D.assert(!_debugDoingBaseline,
-                () => "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
+                () =>
+                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
             D.assert(!this.debugNeedsLayout);
             D.assert(() => {
                 RenderObject parent = (RenderObject) this.parent;
 
         public virtual float? getDistanceToActualBaseline(TextBaseline baseline) {
             D.assert(_debugDoingBaseline,
-                () => "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
+                () =>
+                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
 
             this._cachedBaselines = this._cachedBaselines ?? new Dictionary<TextBaseline, float?>();
             return this._cachedBaselines.putIfAbsent(baseline, () => this.computeDistanceToActualBaseline(baseline));
             D.assert(_debugDoingBaseline,
-                () => "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
+                () =>
+                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
 
             return null;
         }
             if (det == 0) {
                 return Offset.zero;
             }
+
             Vector3 n = new Vector3(0, 0, 1);
             Vector3 i = transform.perspectiveTransform(new Vector3(0, 0, 0));
             Vector3 d = transform.perspectiveTransform(new Vector3(0, 0, 1)) - i;
         public bool defaultHitTestChildren(BoxHitTestResult result, Offset position = null) {
             ChildType child = this.lastChild;
             while (child != null) {
-                ParentDataType childParentData = (ParentDataType) child.parentData;
-                if (child.hitTest(result, position: position - childParentData.offset)) {
+                ParentDataType childParentData = child.parentData as ParentDataType;
+                bool isHit = result.addWithPaintOffset(
+                    offset: childParentData.offset,
+                    position: position,
+                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                        D.assert(transformed == position - childParentData.offset);
+                        return child.hitTest(resultIn, position: transformed);
+                    }
+                );
+                if (isHit) {
                     return true;
                 }
 

com.unity.uiwidgets/Runtime/rendering/proxy_box.cs

         }
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
-            if (this.transformHitTests) {
-                var transform = this._effectiveTransform;
-                var inverse = Matrix4.tryInvert(transform);
-
-                if (inverse == null) {
-                    return false;
+            D.assert(!this.transformHitTests || this._effectiveTransform != null);
+            return result.addWithPaintTransform(
+                transform: this.transformHitTests ? this._effectiveTransform : null,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset positionIn) => {
+                    return base.hitTestChildren(resultIn, position: positionIn);
-
-                position = MatrixUtils.transformPoint(inverse, position);
-            }
-
-            return base.hitTestChildren(result, position: position);
+            );
         }
 
         public override void paint(PaintingContext context, Offset offset) {
         }
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
-            if (this.size.isEmpty) {
+            if (this.size.isEmpty || this.child?.size?.isEmpty == true)
-            }
-
-            Matrix4 inverse = Matrix4.tryInvert(this._transform);
-            
-            if (inverse == null) {
-                return false;
-            }
-
-            position = MatrixUtils.transformPoint(inverse, position);
-            return base.hitTestChildren(result, position: position);
+            return result.addWithPaintTransform(
+                transform: this._transform,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset positionIn) => {
+                    return base.hitTestChildren(resultIn, position: positionIn);
+                }
+            );
         }
 
         public override void applyPaintTransform(RenderObject child, Matrix4 transform) {
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
             D.assert(!this.debugNeedsLayout);
-            if (this.transformHitTests) {
-                position = new Offset(
-                    position.dx - this.translation.dx * this.size.width,
-                    position.dy - this.translation.dy * this.size.height
-                );
-            }
-
-            return base.hitTestChildren(result, position: position);
+            return result.addWithPaintOffset(
+                offset: this.transformHitTests
+                    ? new Offset(this.translation.dx * this.size.width, this.translation.dy * this.size.height)
+                    : null,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset positionIn) => {
+                    return base.hitTestChildren(resultIn, position: positionIn);
+                }
+            );
         }
 
         public override void paint(PaintingContext context, Offset offset) {
                 this.onPointerSignal((PointerSignalEvent) evt);
                 return;
             }
-            
+
             if (this.onPointerScroll != null && evt is PointerScrollEvent) {
                 this.onPointerScroll((PointerScrollEvent) evt);
             }
         }
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position) {
-            Matrix4 inverse = Matrix4.tryInvert(this.getCurrentTransform());
-            if (inverse == null) {
-                return false;
-            }
-
-            position = MatrixUtils.transformPoint(inverse, position);
-            return base.hitTestChildren(result, position: position);
+            return result.addWithPaintTransform(
+                transform: this.getCurrentTransform(),
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset positionIn) => {
+                    return base.hitTestChildren(resultIn, position: positionIn);
+                }
+            );
         }
 
         public override void paint(PaintingContext context, Offset offset) {

com.unity.uiwidgets/Runtime/rendering/rotated_box.cs

             if (this.child == null || this._paintTransform == null) {
                 return false;
             }
-            
-            var inverse = new Matrix4().inverted(this._paintTransform);
-            return this.child.hitTest(result, position:MatrixUtils.transformPoint(inverse, position));
+
+            return result.addWithPaintTransform(
+                transform: this._paintTransform,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset positionIn) => {
+                    return this.child.hitTest(resultIn, position: positionIn);
+                }
+            );
         }
 
         void _paintChild(PaintingContext context, Offset offset) {

com.unity.uiwidgets/Runtime/rendering/shifted_box.cs

         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
             if (this.child != null) {
                 var childParentData = (BoxParentData) this.child.parentData;
-                return this.child.hitTest(result, position - childParentData.offset);
+                return result.addWithPaintOffset(
+                    offset: childParentData.offset,
+                    position: position,
+                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                        D.assert(transformed == position - childParentData.offset);
+                        return this.child.hitTest(resultIn, position: transformed);
+                    }
+                );
             }
 
             return false;
         }
 
         protected override void debugPaintSize(PaintingContext context, Offset offset) {
-           base.debugPaintSize(context, offset);
+            base.debugPaintSize(context, offset);
             D.assert(() => {
                 Paint paint;
                 if (this.child != null && !this.child.size.isEmpty) {
                     }
 
                     if (childParentData.offset.dx > 0.0) {
-
                         float headSize = Mathf.Min(childParentData.offset.dx * 0.2f, 10.0f);
                         float x = offset.dx;
                         float y = offset.dy + this.size.height / 2.0f;
                         path.lineTo(x += headSize, y += -headSize);
                         path.lineTo(x += -headSize, y += -headSize);
                         path.lineTo(x += 0.0f, y += headSize);
-                        
+
                         path.moveTo(x = offset.dx + this.size.width, y = offset.dy + this.size.height / 2.0f);
                         path.lineTo(x += -childParentData.offset.dx + headSize, y += 0.0f);
                         path.lineTo(x += 0.0f, y += headSize);
                         path.close();
                         context.canvas.drawPath(path, paint);
                     }
-                } else {
+                }
+                else {
                     paint = new Paint {
                         color = new ui.Color(0x90909090),
                     };
 
             context.pushClipRect(this.needsCompositing, offset, Offset.zero & this.size, base.paint);
             D.assert(() => {
-                DebugOverflowIndicatorMixin.paintOverflowIndicator(this, context, offset, this._overflowContainerRect, this._overflowChildRect);
+                DebugOverflowIndicatorMixin.paintOverflowIndicator(this, context, offset, this._overflowContainerRect,
+                    this._overflowChildRect);
                 return true;
             });
         }

com.unity.uiwidgets/Runtime/rendering/sliver_padding.cs

                     paintOffset: childParentData.paintOffset,
                     hitTest: this.child.hitTest
                 );
-                return this.child.hitTest(result,
-                    mainAxisPosition: mainAxisPosition - this.childMainAxisPosition(this.child),
-                    crossAxisPosition: crossAxisPosition - this.childCrossAxisPosition(this.child));
             }
 
             return false;

com.unity.uiwidgets/Runtime/rendering/stack.cs

                 D.assert(child.parentData == childParentData);
                 child = childParentData.nextSibling;
             }
+
-        
+
         public delegate float mainChildSizeGetter(RenderBox child);
 
         float _getIntrinsicDimension(mainChildSizeGetter getter) {
         protected override float? computeDistanceToActualBaseline(TextBaseline baseline) {
             return this.defaultComputeDistanceToHighestActualBaseline(baseline);
         }
-        
-        public static bool layoutPositionedChild(RenderBox child, StackParentData childParentData, Size size, Alignment alignment) {
+
+        public static bool layoutPositionedChild(RenderBox child, StackParentData childParentData, Size size,
+            Alignment alignment) {
             D.assert(childParentData.isPositioned);
             D.assert(child.parentData == childParentData);
 
             if (childParentData.left != null && childParentData.right != null)
-                childConstraints = childConstraints.tighten(width: size.width - childParentData.right - childParentData.left);
+                childConstraints =
+                    childConstraints.tighten(width: size.width - childParentData.right - childParentData.left);
-                childConstraints = childConstraints.tighten(height: size.height - childParentData.bottom - childParentData.top);
+                childConstraints =
+                    childConstraints.tighten(height: size.height - childParentData.bottom - childParentData.top);
             else if (childParentData.height != null)
                 childConstraints = childConstraints.tighten(height: childParentData.height);
 
             if (childParentData.left != null) {
                 x = childParentData.left;
-            } else if (childParentData.right != null) {
+            }
+            else if (childParentData.right != null) {
-            } else {
+            }
+            else {
                 x = alignment.alongOffset(size - child.size as Offset).dx;
             }
 
             float? y;
             if (childParentData.top != null) {
                 y = childParentData.top;
-            } else if (childParentData.bottom != null) {
+            }
+            else if (childParentData.bottom != null) {
-            } else {
+            }
+            else {
                 y = alignment.alongOffset(size - child.size as Offset).dy;
             }
 
             D.assert(position != null);
             RenderBox child = this._childAtIndex();
             StackParentData childParentData = (StackParentData) child.parentData;
-            return child.hitTest(result, position: position - childParentData.offset);
+            return result.addWithPaintOffset(
+                offset: childParentData.offset,
+                position: position,
+                hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                    D.assert(transformed == position - childParentData.offset);
+                    return child.hitTest(resultIn, position: transformed);
+                }
+            );
         }
 
         public override void paintStack(PaintingContext context, Offset offset) {

com.unity.uiwidgets/Runtime/rendering/table.cs

                 float deficit = tableWidth - maxWidthConstraint;
 
                 int availableColumns = this.columns;
-                
+
                 //(Xingwei Zhu) this deficit is double and set to be 0.00000001f in flutter.
                 //since we use float by default, making it larger should make sense in most cases
                 float minimumDeficit = 0.0001f;
                         if (flexes[x] != null) {
                             //(Xingwei Zhu) in case deficit * flexes[x].Value / totalFlex => 0 if deficit is really small, leading to dead loop,
                             //we amend it with a default larger value to ensure that this loop will eventually end
-                            float newWidth = widths[x] - Mathf.Max(minimumDeficit, deficit * flexes[x].Value / totalFlex);
+                            float newWidth =
+                                widths[x] - Mathf.Max(minimumDeficit, deficit * flexes[x].Value / totalFlex);
                             D.assert(newWidth.isFinite());
                             if (newWidth <= minWidths[x]) {
                                 deficit -= widths[x] - minWidths[x];
                 RenderBox child = this._children[index];
                 if (child != null) {
                     BoxParentData childParentData = (BoxParentData) child.parentData;
-                    if (child.hitTest(result, position: position - childParentData.offset)) {
+                    bool isHit = result.addWithPaintOffset(
+                        offset: childParentData.offset,
+                        position: position,
+                        hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                            D.assert(transformed == position - childParentData.offset);
+                            return child.hitTest(resultIn, position: transformed);
+                        }
+                    );
+                    if (isHit) {
                         return true;
                     }
                 }
             D.assert(this._rows == this._rowTops.Count - 1);
             D.assert(this._columns == this._columnLefts.Count);
             if (this.border != null) {
-                Rect borderRect = Rect.fromLTWH(offset.dx, offset.dy, this.size.width, this._rowTops[this._rowTops.Count - 1]);
+                Rect borderRect = Rect.fromLTWH(offset.dx, offset.dy, this.size.width,
+                    this._rowTops[this._rowTops.Count - 1]);
                 List<float> rows = this._rowTops.GetRange(1, this._rowTops.Count - 2);
                 List<float> columns = this._columnLefts.GetRange(1, this._columnLefts.Count - 1);
                 this.border.paint(context.canvas, borderRect, rows: rows, columns: columns);

com.unity.uiwidgets/Runtime/rendering/viewport.cs

                 bool isHit = result.addWithPaintTransform(
                     transform: transform,
                     position: null, // Manually adapting from box to sliver position below.
-                    hitTest: (BoxHitTestResult result, Offset _) => {
+                    hitTest: (BoxHitTestResult resultIn, Offset _) => {
                         return child.hitTest(
                             sliverResult,
                             mainAxisPosition: this.computeChildMainAxisPosition(child, mainAxisPosition),

com.unity.uiwidgets/Runtime/widgets/overlay.cs

         internal _Theatre(Key key = null,
             int skipCount = 0,
             List<Widget> children = null) : base(key, children) {
-            D.assert(offstage != null);
-            D.assert(!offstage.Any((child) => child == null));
-            this.onstage = onstage;
-            this.offstage = offstage;
+            D.assert(skipCount != null);
+            D.assert(skipCount >= 0);
+            D.assert(children != null);
+            D.assert(children.Count() >= skipCount);
+            this.skipCount = skipCount;
         }
 
         public readonly int skipCount;
 
     class _TheatreElement : MultiChildRenderObjectElement {
         public _TheatreElement(_Theatre widget) : base(widget) {
-            D.assert(!WidgetsD.debugChildrenHaveDuplicateKeys(widget, ((_Theatre) widget).offstage));
         }
 
         public new _Theatre widget {
             return RenderStack.getIntrinsicDimension(this._firstOnstageChild,
                 (RenderBox child) => child.getMinIntrinsicWidth(height));
         }
-        
+
         protected override float computeMaxIntrinsicWidth(float height) {
             return RenderStack.getIntrinsicDimension(this._firstOnstageChild,
                 (RenderBox child) => child.getMaxIntrinsicWidth(height));
                     candidate += childParentData.offset.dy;
                     if (result != null) {
                         result = Math.Min(result.Value, candidate.Value);
-                    } else {
+                    }
+                    else {
+
+
             return result;
         }
 
                 if (!childParentData.isPositioned) {
                     child.layout(nonPositionedConstraints, parentUsesSize: true);
                     childParentData.offset = this._resolvedAlignment.alongOffset(this.size - child.size as Offset);
-                } else {
-                    this._hasVisualOverflow = RenderStack.layoutPositionedChild(child, childParentData, this.size, this._resolvedAlignment) || _hasVisualOverflow;
+                }
+                else {
+                    this._hasVisualOverflow =
+                        RenderStack.layoutPositionedChild(child, childParentData, this.size, this._resolvedAlignment) ||
+                        _hasVisualOverflow;
                 }
 
                 D.assert(child.parentData == childParentData);
                 if (childParentData.offset.dx != 0 || childParentData.offset.dy != 0) {
                     i = i;
                 }
+
                 bool isHit = result.addWithPaintOffset(
                     offset: childParentData.offset,
                     position: position,
                 child = childParentData.nextSibling;
             }
         }
-        
+
-            } else {
+            }
+            else {
                 this.paintStack(context, offset);
             }
         }
             }
         }
 
-        public override Rect describeApproximatePaintClip(RenderObject child)  => this._hasVisualOverflow ? Offset.zero & this.size : null;
+        public override Rect describeApproximatePaintClip(RenderObject child) =>
+            this._hasVisualOverflow ? Offset.zero & this.size : null;
-                base.debugFillProperties(properties);
-                properties.add(new IntProperty("skipCount", this.skipCount));
-                properties.add(new EnumProperty<TextDirection>("textDirection", this.textDirection));
+            base.debugFillProperties(properties);
+            properties.add(new IntProperty("skipCount", this.skipCount));
+            properties.add(new EnumProperty<TextDirection>("textDirection", this.textDirection));
-        
-        // bool hitTestChildren(BoxHitTestResult result, { Offset position }) {
-        //     RenderBox child = _lastOnstageChild;
-        //     for (int i = 0; i < _onstageChildCount; i++) {
-        //         assert(child != null);
-        //         final StackParentData childParentData = child.parentData as StackParentData;
-        //         final bool isHit = result.addWithPaintOffset(
-        //             offset: childParentData.offset,
-        //             position: position,
-        //             hitTest: (BoxHitTestResult result, Offset transformed) {
-        //             assert(transformed == position - childParentData.offset);
-        //             return child.hitTest(result, position: transformed);
-        //         },
-        //         );
-        //         if (isHit)
-        //             return true;
-        //         child = childParentData.previousSibling;
-        //     }
-        //     return false;
-        // }
     }
 }

com.unity.uiwidgets/Runtime/widgets/single_child_scroll_view.cs

             DragStartBehavior dragStartBehavior = DragStartBehavior.start
         ) : base(key: key) {
             D.assert(!(controller != null && primary == true),
-                () => "Primary ScrollViews obtain their ScrollController via inheritance from a PrimaryScrollController widget. " +
-                "You cannot both set primary to true and pass an explicit controller.");
+                () =>
+                    "Primary ScrollViews obtain their ScrollController via inheritance from a PrimaryScrollController widget. " +
+                    "You cannot both set primary to true and pass an explicit controller.");
             this.scrollDirection = scrollDirection;
             this.reverse = reverse;
             this.padding = padding;
 
         AxisDirection _getDirection(BuildContext context) {
             return AxisDirectionUtils.getAxisDirectionFromAxisReverseAndDirectionality(context, this.scrollDirection,
-                       this.reverse) ?? AxisDirection.down;
+                this.reverse) ?? AxisDirection.down;
         }
 
         public override Widget build(BuildContext context) {
 
         protected override bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
             if (this.child != null) {
-                Offset transformed = position + (-this._paintOffset);
-                return this.child.hitTest(result, position: transformed);
+                return result.addWithPaintOffset(
+                    offset: this._paintOffset,
+                    position: position,
+                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
+                        D.assert(transformed == position + (-this._paintOffset));
+                        return this.child.hitTest(result, position: transformed);
+                    }
+                );
             }
 
             return false;

Samples/UIWidgetsSamples_2019_4/Assets/ReduxSample/LocalPositionSample.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.UIWidgets.engine;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
+using Unity.UIWidgets.material;
+using Unity.UIWidgets.painting;
+using Unity.UIWidgets.rendering;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEngine;
+
+public class LocalPositionSample : UIWidgetsPanel
+{
+    protected override void OnEnable()
+    {
+        base.OnEnable();
+    }
+
+    protected override Widget createWidget()
+    {
+        {
+            return new MaterialApp(
+                title: "Flutter Demo",
+                theme: new ThemeData(
+                    primarySwatch: Colors.blue
+                ),
+                home: new MyHomePage(title: "Local Position Test"));
+        }
+    }
+
+    public class MyHomePage : StatefulWidget
+    {
+        public MyHomePage(string title, Key key = null) : base(key: key)
+        {
+            this.title = title;
+        }
+
+        public readonly string title;
+
+        public override State createState()
+        {
+            return new _MyHomePageState();
+        }
+    }
+
+    public class _MyHomePageState : State<MyHomePage>
+    {
+        Offset _globalPostion = Offset.zero;
+        Offset _localPostion = Offset.zero;
+
+        void _checkPosition(TapUpDetails tapUpDetails)
+        {
+            setState(() =>
+            {
+                _globalPostion = tapUpDetails.globalPosition;
+                _localPostion = tapUpDetails.localPosition;
+            });
+        }
+
+        void _checkPosition(TapDownDetails tapUpDetails)
+        {
+            setState(() =>
+            {
+                _globalPostion = tapUpDetails.globalPosition;
+                _localPostion = tapUpDetails.localPosition;
+            });
+        }
+
+        public override Widget build(BuildContext context)
+        {
+            return new Scaffold(
+                appBar: new AppBar(
+                    title: new Text(widget.title)
+                ),
+                body: new Center(
+                    child: new Column(
+                        mainAxisAlignment: MainAxisAlignment.center,
+                        children: new List<Widget>()
+                        {
+                            new Text(
+                                "Tap to get global position and local position:"
+                            ),
+                            new Text(
+                                $"global position: {_globalPostion}",
+                                style: Theme.of(context).textTheme.headline
+                            ),
+                            new Text(
+                                $"local position: {_localPostion}",
+                                style: Theme.of(context).textTheme.headline
+                            ),
+                            new GestureDetector(
+                                onTapUp: _checkPosition,
+                                child: new Container(
+                                    margin: EdgeInsets.all(10),
+                                    padding: EdgeInsets.all(10),
+                                    decoration: new BoxDecoration(color: Colors.red),
+                                    child: new Text("On Tap Up")
+                                )
+                            ),
+                            new GestureDetector(
+                                onTapDown: _checkPosition,
+                                child: new Container(
+                                    margin: EdgeInsets.all(10),
+                                    padding: EdgeInsets.all(30),
+                                    decoration: new BoxDecoration(Colors.orange),
+                                    child: new Text("on Tap Down")
+                                )
+                            ),
+                            new GestureDetector(
+                                onTapDown: _checkPosition,
+                                child: new Container(
+                                    padding: EdgeInsets.all(30),
+                                    decoration: new BoxDecoration(Colors.pink),
+                                    child: new Text("on Tap Down with 0 margin")
+                                )
+                            )
+                        }
+                    )
+                )
+            );
+        }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/ReduxSample/LocalPositionSample.cs.meta

+fileFormatVersion: 2
+guid: 4c6d96aaa15e54a47a53543e4c7ab81b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Samples/UIWidgetsSamples_2019_4/Assets/Scenes/LocalPosition.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &166246262
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 166246265}
+  - component: {fileID: 166246264}
+  - component: {fileID: 166246263}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &166246263
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 166246262}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &166246264
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 166246262}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!4 &166246265
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 166246262}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1173156216
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1173156217}
+  - component: {fileID: 1173156219}
+  - component: {fileID: 1173156218}
+  m_Layer: 5
+  m_Name: RawImage
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1173156217
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1173156216}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1656596898}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 626.3, y: 431.9}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1173156218
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1173156216}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4c6d96aaa15e54a47a53543e4c7ab81b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Texture: {fileID: 0}
+  m_UVRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  devicePixelRatioOverride: 0
+  hardwareAntiAliasing: 0
+--- !u!222 &1173156219
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1173156216}
+  m_CullTransparentMesh: 0
+--- !u!1 &1514114434
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1514114436}
+  - component: {fileID: 1514114435}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1514114435
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1514114434}
+  m_Enabled: 1
+  serializedVersion: 10
+  m_Type: 1
+  m_Shape: 0
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+    m_CullingMatrixOverride:
+      e00: 1
+      e01: 0
+      e02: 0
+      e03: 0
+      e10: 0
+      e11: 1
+      e12: 0
+      e13: 0
+      e20: 0
+      e21: 0
+      e22: 1
+      e23: 0
+      e30: 0
+      e31: 0
+      e32: 0
+      e33: 1
+    m_UseCullingMatrixOverride: 0
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingLayerMask: 1
+  m_Lightmapping: 4
+  m_LightShadowCasterMode: 0
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_UseBoundingSphereOverride: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1514114436
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1514114434}
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!1 &1656596894
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1656596898}
+  - component: {fileID: 1656596897}
+  - component: {fileID: 1656596896}
+  - component: {fileID: 1656596895}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1656596895
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1656596894}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &1656596896
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1656596894}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &1656596897
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1656596894}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &1656596898
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1656596894}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 1173156217}
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!1 &1824294904
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1824294907}
+  - component: {fileID: 1824294906}
+  - component: {fileID: 1824294905}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1824294905
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1824294904}
+  m_Enabled: 1
+--- !u!20 &1824294906
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1824294904}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1824294907
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1824294904}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Samples/UIWidgetsSamples_2019_4/Assets/Scenes/LocalPosition.unity.meta

+fileFormatVersion: 2
+guid: 16f587e6d84ea4240b2a20ef51388ade
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: