fix compilation errors in rendering

com.unity.uiwidgets/Runtime/foundation/debug.cs

 
         public static bool debugDisableOpacityLayers = false;
 
+        public static bool debugDisablePhysicalShapeLayers = false;
+
         public static bool debugPrintMarkNeedsPaintStacks = false;
 
         public static bool debugCheckIntrinsicSizes = false;

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

             D.assert(() => {
                 if (_debugActivePointers > 0) {
                     var paint = new Paint {
-                        color = new Color(0x00BBBB | ((0x04000000 * depth) & 0xFF000000)),
+                        color = new Color((uint)(0x00BBBB | ((0x04000000 * depth) & 0xFF000000))),
                     };
                     context.canvas.drawRect(offset & size, paint);
                 }

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

 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
 using UnityEngine;
+using Canvas = Unity.UIWidgets.ui.Canvas;
 using Color = Unity.UIWidgets.ui.Color;
 using Rect = Unity.UIWidgets.ui.Rect;
 
         }
 
         internal bool _subtreeNeedsAddToScene;
-
-        flow.Layer _engineLayer;
+        
+        protected EngineLayer engineLayer {
+            get { return _engineLayer; }
+            set {
+                _engineLayer = value;
+                if (!alwaysNeedsAddToScene) {
+                    if (parent != null && !parent.alwaysNeedsAddToScene) {
+                        parent.markNeedsAddToScene();
+                    }
+                }
+            }
+        }
+        
+        EngineLayer _engineLayer;
 
         internal virtual void updateSubtreeNeedsAddToScene() {
             _subtreeNeedsAddToScene = _needsAddToScene || alwaysNeedsAddToScene;
 
         internal abstract S find<S>(Offset regionOffset) where S : class;
 
-        internal abstract flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null);
+        internal abstract void addToScene(SceneBuilder builder, Offset layerOffset = null);
 
         internal void _addToSceneWithRetainedRendering(SceneBuilder builder) {
             if (!_subtreeNeedsAddToScene && _engineLayer != null) {
 
-            _engineLayer = addToScene(builder);
+            addToScene(builder);
             _needsAddToScene = false;
         }
 
             return null;
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
-            return null;
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
     public class TextureLayer : Layer {
         public TextureLayer(
             Rect rect,
-            Texture texture,
+            int textureId,
-            D.assert(texture != null);
-            this.texture = texture;
+            this.textureId = textureId;
-        public readonly Texture texture;
+        public readonly int textureId;
 
         public readonly bool freeze;
 
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
-                texture,
+                textureId,
-            return null;
         }
     }
 
 
         PictureLayer _highlightConflictingLayer(PhysicalModelLayer child) {
             PictureRecorder recorder = new PictureRecorder();
-            var canvas = new RecorderCanvas(recorder);
+            var canvas = new Canvas(recorder);
             canvas.drawPath(child.clipPath, new Paint() {
                 color = new Color(0xFFAA0000),
                 style = PaintingStyle.stroke,
             _lastChild = null;
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
-            return null;
         }
 
         public void addChildrenToScene(SceneBuilder builder, Offset childOffset = null) {
             return scene;
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
-            var engineLayer = builder.pushOffset(
+            engineLayer = builder.pushOffset(
-                (float) (layerOffset.dy + offset.dy));
+                (float) (layerOffset.dy + offset.dy),
+                oldLayer: engineLayer as OffsetEngineLayer);
-            return engineLayer;
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             return base.find<S>(regionOffset);
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             bool enabled = true;
             });
 
             if (enabled) {
-                builder.pushClipRect(clipRect.shift(layerOffset));
+                var shiftedClipRect = layerOffset == Offset.zero ? clipRect : clipRect.shift(layerOffset);
+                engineLayer = builder.pushClipRect(
+                    rect: shiftedClipRect,
+                    clipBehavior: clipBehavior,
+                    oldLayer: engineLayer as ClipRectEngineLayer);
+            }
+            else {
+                engineLayer = null;
             }
 
             addChildrenToScene(builder, layerOffset);
             }
-
-            return null;
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             return base.find<S>(regionOffset);
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             bool enabled = true;
             });
 
             if (enabled) {
-                builder.pushClipRRect(clipRRect.shift(layerOffset));
+                var shiftedClipRRect = layerOffset == Offset.zero ? clipRRect : clipRRect.shift(layerOffset);
+                engineLayer = builder.pushClipRRect(
+                    shiftedClipRRect,
+                    clipBehavior: clipBehavior,
+                    oldLayer: engineLayer as ClipRRectEngineLayer
+                    );
+            }
+            else {
+                engineLayer = null;
             }
 
             addChildrenToScene(builder, layerOffset);
             }
-
-            return null;
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             return base.find<S>(regionOffset);
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             bool enabled = true;
             });
 
             if (enabled) {
-                builder.pushClipPath(clipPath.shift(layerOffset));
+                var shiftedPath = layerOffset == Offset.zero ? clipPath : clipPath.shift(layerOffset);
+                engineLayer = builder.pushClipPath(
+                    shiftedPath,
+                    clipBehavior: clipBehavior,
+                    oldLayer: engineLayer as ClipPathEngineLayer);
+            }
+            else {
+                engineLayer = null;
             }
 
             addChildrenToScene(builder, layerOffset);
             }
-
-            return null;
         }
     }
 
             return base.find<S>(new Offset(result[0], result[1]));
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             _lastEffectiveTransform = _transform;
             builder.pushTransform(_lastEffectiveTransform.toMatrix3());
             addChildrenToScene(builder);
             builder.pop();
-            return null;
         }
 
         public override void applyTransform(Layer child, Matrix4 transform) {
             }
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             bool enabled = true;
             });
             if (enabled) {
-                builder.pushOpacity(alpha, offset: offset + layerOffset);
+                engineLayer = builder.pushOpacity(
+                    alpha, 
+                    offset: offset + layerOffset,
+                    oldLayer: engineLayer as OpacityEngineLayer);
+            }
+            else {
+                engineLayer = null;
             }
 
             addChildrenToScene(builder, layerOffset);
-
-            return null;
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             }
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
-            builder.pushBackdropFilter(filter);
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
+            D.assert(filter != null);
+            engineLayer = builder.pushBackdropFilter(
+                filter: filter,
+                oldLayer: engineLayer as BackdropFilterEngineLayer);
+            
-            return null;
         }
     }
 
             return base.find<S>(regionOffset - offset);
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             D.assert(offset != null);
             if (_lastOffset != Offset.zero) {
                 builder.pop();
             }
-
-            return null;
         }
 
         public override void applyTransform(Layer child, Matrix4 transform) {
         }
 
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             D.assert(link != null);
                 _inverseDirty = true;
-                return null;
             }
 
             _establishTransform();
             }
 
             _inverseDirty = true;
-            return null;
         }
 
         public override void applyTransform(Layer child, Matrix4 transform) {
             return null;
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
+            D.assert(optionsMask != null);
+
-
-            builder.addPerformanceOverlay(optionsMask, overlayRect.shift(layerOffset));
-            return null;
+            
+            var shiftedOverlayRect = layerOffset == Offset.zero ? overlayRect : overlayRect.shift(layerOffset);
+            builder.addPerformanceOverlay(optionsMask, shiftedOverlayRect);
+            //TODO: add implementations
+            //builder.setRasterizerTracingThreshold(rasterizerThreshold);
+            //builder.setCheckerboardRasterCacheImages(checkerboardRasterCacheImages);
+            //builder.setCheckerboardOffscreenLayers(checkerboardOffscreenLayers);
         }
     }
 
             return base.find<S>(regionOffset);
         }
 
-        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+        internal override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
+            
+            D.assert(clipPath != null);
+            D.assert(color != null);
+            D.assert(shadowColor != null);
-            builder.pushPhysicalShape(
-                path: clipPath.shift(layerOffset),
-                elevation: elevation,
-                color: color,
-                shadowColor: shadowColor,
-                clipBehavior: clipBehavior);
+            bool enabled = true;
+            D.assert(() => {
+                enabled = !D.debugDisablePhysicalShapeLayers;
+                return true;
+            });
+            if (enabled) {
+                engineLayer = builder.pushPhysicalShape(
+                    path: layerOffset == Offset.zero ? clipPath : clipPath.shift(layerOffset),
+                    elevation: elevation,
+                    color: color,
+                    shadowColor: shadowColor,
+                    clipBehavior: clipBehavior,
+                    oldLayer: engineLayer as PhysicalShapeEngineLayer);
+            }
+            else {
+                engineLayer = null;
+            }
+            
-
-            builder.pop();
-            return null;
+            if (enabled) {
+                builder.pop();
+            }
         }
 
 

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

 
             _currentLayer = new PictureLayer(estimatedBounds);
             _recorder = new PictureRecorder();
-            _canvas = new RecorderCanvas(_recorder);
+            _canvas = new Canvas(_recorder);
             _containerLayer.append(_currentLayer);
         }
 
             }
             else {
                 canvas.save();
-                canvas.concat(effectiveTransform.toMatrix3());
+                canvas.transform(effectiveTransform._m4storage);
                 painter(this, offset);
                 canvas.restore();
             }

com.unity.uiwidgets/Runtime/ui2/compositing.cs

 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using AOT;
+using JetBrains.Annotations;
+using Unity.UIWidgets.widgets;
 using UnityEngine;
 
 namespace Unity.UIWidgets.ui {
             return layer;
         }
 
+        public ClipRectEngineLayer pushClipRect(
+            Rect rect,
+            Clip clipBehavior = Clip.antiAlias,
+            ClipRectEngineLayer oldLayer = null) {
+            D.assert(clipBehavior != Clip.none);
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "pushClipRect"));
+            ClipRectEngineLayer layer = new ClipRectEngineLayer(SceneBuilder_pushClipRect(_ptr, rect.left, rect.right, rect.top, rect.bottom, (int)clipBehavior));
+            D.assert(_debugPushLayer(layer));
+            return layer;
+        }
+
+        public unsafe ClipRRectEngineLayer pushClipRRect(
+            RRect rrect,
+            Clip clipBehavior = Clip.antiAlias,
+            ClipRRectEngineLayer oldLayer = null) {
+            D.assert(clipBehavior != Clip.none);
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "pushClipRRect"));
+            fixed (float* rrectPtr = rrect._value32) {
+                ClipRRectEngineLayer layer =
+                    new ClipRRectEngineLayer(SceneBuilder_pushClipRRect(_ptr, rrectPtr, (int) clipBehavior));
+                D.assert(_debugPushLayer(layer));
+                return layer;
+            }
+        }
+
+        public ClipPathEngineLayer pushClipPath(
+            Path path,
+            Clip clipBehavior = Clip.antiAlias,
+            ClipPathEngineLayer oldLayer = null) {
+            D.assert(clipBehavior != Clip.none);
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "pushClipPath"));
+            ClipPathEngineLayer layer = new ClipPathEngineLayer(SceneBuilder_pushClipPath(_ptr, path._ptr, (int)clipBehavior));
+            D.assert(_debugPushLayer(layer));
+            return layer;
+        }
+
+        public OpacityEngineLayer pushOpacity(
+            int alpha,
+            Offset offset = null,
+            OpacityEngineLayer oldLayer = null) {
+            offset = offset ?? Offset.zero;
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "pushOpacity"));
+            OpacityEngineLayer layer = new OpacityEngineLayer(SceneBuilder_pushOpacity(_ptr, alpha, offset.dx, offset.dy));
+            D.assert(_debugPushLayer(layer));
+            return layer;
+        }
+
+        public BackdropFilterEngineLayer pushBackdropFilter(
+            ImageFilter filter,
+            BackdropFilterEngineLayer oldLayer = null) {
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "pushBackdropFilter"));
+            BackdropFilterEngineLayer layer = new BackdropFilterEngineLayer(SceneBuilder_pushBackdropFilter(_ptr, filter._toNativeImageFilter()._ptr));
+            D.assert(_debugPushLayer(layer));
+            return layer;
+        }
+
+        public PhysicalShapeEngineLayer pushPhysicalShape(
+            Path path,
+            float elevation,
+            Color color,
+            Color shadowColor,
+            Clip clipBehavior = Clip.none,
+            PhysicalShapeEngineLayer oldLayer = null) {
+            D.assert(_debugCheckCanBeUsedAsOldLayer(oldLayer, "PhysicalShapeEngineLayer"));
+            PhysicalShapeEngineLayer layer = new PhysicalShapeEngineLayer(SceneBuilder_pushPhysicalShape(_ptr, path._ptr, elevation, color.value, shadowColor?.value ?? 0xFF000000, (int)clipBehavior));
+            D.assert(_debugPushLayer(layer));
+            return layer;
+        }
+
         public void pop() {
             if (_layerStack.isNotEmpty()) {
                 _layerStack.removeLast();
             SceneBuilder_addRetained(_ptr, wrapper._ptr);
         }
 
+        public void addPerformanceOverlay(int enabledOptions, Rect bounds) {
+            SceneBuilder_addPerformanceOverlay(enabledOptions, bounds.left, bounds.right, bounds.top, bounds.bottom);
+        }
+
         public void addPicture(
             Offset offset,
             Picture picture,
 
         [DllImport(NativeBindings.dllName)]
         static extern IntPtr SceneBuilder_pushOffset(IntPtr ptr, float dx, float dy);
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr SceneBuilder_pushClipRect(IntPtr ptr, float left, float right, float top, float bottom,
+            int clipBehavior);*/
+        static IntPtr SceneBuilder_pushClipRect(IntPtr ptr, float left, float right, float top, float bottom,
+            int clipBehavior) {
+            D.assert(false, () => "SceneBuilder_pushClipRect is not implemented yet!");
+            return IntPtr.Zero;
+        }
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern unsafe IntPtr SceneBuilder_pushClipRRect(IntPtr ptr, float* rrect, int clipBehavior);*/
+        static unsafe IntPtr SceneBuilder_pushClipRRect(IntPtr ptr, float* rrect, int clipBehavior) {
+            D.assert(false, () => "SceneBuilder_pushClipRRect is not implemented yet!");
+            return IntPtr.Zero;
+        }
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr SceneBuilder_pushClipPath(IntPtr ptr, IntPtr path, int clipBehavior);*/
+        static unsafe IntPtr SceneBuilder_pushClipPath(IntPtr ptr, IntPtr path, int clipBehavior) {
+            D.assert(false, () => "SceneBuilder_pushClipPath is not implemented yet!");
+            return IntPtr.Zero;
+        }
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr SceneBuilder_pushOpacity(IntPtr ptr, int alpha, float dx, float dy);*/
+        static IntPtr SceneBuilder_pushOpacity(IntPtr ptr, int alpha, float dx, float dy) {
+            D.assert(false, () => "SceneBuilder_pushOpacity is not implemented yet!");
+            return IntPtr.Zero;
+        }
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr SceneBuilder_pushBackdropFilter(IntPtr ptr, IntPtr filter);*/
+
+        static IntPtr SceneBuilder_pushBackdropFilter(IntPtr ptr, IntPtr filter) {
+            D.assert(false, () => "SceneBuilder_pushBackdropFilter is not implemented yet!");
+            return IntPtr.Zero;
+        }
+        
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern void SceneBuilder_addPerformanceOverlay(int enabledOptions, float left, float right, float top,
+            float bottom);*/
+
+        static void SceneBuilder_addPerformanceOverlay(int enabledOptions, float left, float right, float top,
+            float bottom) {
+            D.assert(false, () => "SceneBuilder_addPerformanceOverlay is not implemented yet!");
+        }
+
+        /*
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr SceneBuilder_pushPhysicalShape(IntPtr ptr, IntPtr path, float evelation, uint color,
+            uint shadowColor, int clipBehavior);*/
+
+        static IntPtr SceneBuilder_pushPhysicalShape(IntPtr ptr, IntPtr path, float elevation, uint color,
+            uint shadowColor, int clipBehavior) {
+            D.assert(false, () => "SceneBuilder_pushPhysicalShape is not implemented yet!");
+            return IntPtr.Zero;
+        }
+        
 
         [DllImport(NativeBindings.dllName)]
         static extern void SceneBuilder_pop(IntPtr ptr);

com.unity.uiwidgets/Runtime/ui2/painting.cs

         internal const int _kTypeBlur = 0;
         internal const int _kTypeMatrix = 1;
 
-        internal _ImageFilter _toNativeImageFilter() => _nativeFilter = _nativeFilter ?? _makeNativeImageFilter();
+        public _ImageFilter _toNativeImageFilter() => _nativeFilter = _nativeFilter ?? _makeNativeImageFilter();
 
         _ImageFilter _makeNativeImageFilter() {
             if (_data == null) {
         }
     }
 
-    class _ImageFilter : NativeWrapper {
+    public class _ImageFilter : NativeWrapper {
         _ImageFilter(IntPtr ptr, ImageFilter creator) : base(ptr) {
             this.creator = creator;
         }