Merge pull request #352 from UnityTech/master

update to latest master (merge bug fixes)

Editor/UIWidgetsPanelEditor.cs

         public override void OnInspectorGUI() {
             base.OnInspectorGUI();
             var pixelRatioProperty = this.serializedObject.FindProperty("devicePixelRatioOverride");
+            var antiAliasingProperty = this.serializedObject.FindProperty("hardwareAntiAliasing");
+            EditorGUILayout.PropertyField(antiAliasingProperty);
             this.serializedObject.ApplyModifiedProperties();
         }
     }

Runtime/editor/editor_window.cs

         protected override float queryDevicePixelRatio() {
             return EditorGUIUtility.pixelsPerPoint;
         }
+        
+        protected override int queryAntiAliasing() {
+            return defaultAntiAliasing;
+        }
 
         protected override Vector2 queryWindowSize() {
             return this.editorWindow.position.size;
 
         public void OnEnable() {
             this._devicePixelRatio = this.queryDevicePixelRatio();
+            this._antiAliasing = this.queryAntiAliasing();
             this.updatePhysicalSize();
             this.updateSafeArea();
             D.assert(this._surface == null);
             if (this._devicePixelRatio != this.queryDevicePixelRatio()) {
                 return true;
             }
+            
+            if (this._antiAliasing != this.queryAntiAliasing()) {
+                return true;
+            }
 
             var size = this.queryWindowSize();
             if (this._lastWindowWidth != size.x
             using (this.getScope()) {
                 if (this.displayMetricsChanged()) {
                     this._devicePixelRatio = this.queryDevicePixelRatio();
+                    this._antiAliasing = this.queryAntiAliasing();
 
                     var size = this.queryWindowSize();
                     this._lastWindowWidth = size.x;
         }
 
         protected abstract float queryDevicePixelRatio();
+        protected abstract int queryAntiAliasing();
         protected abstract Vector2 queryWindowSize();
 
         protected virtual Surface createSurface() {
 
             layerTree.frameSize = this._physicalSize;
             layerTree.devicePixelRatio = this._devicePixelRatio;
+            layerTree.antiAliasing = this._antiAliasing;
             this._rasterizer.draw(layerTree);
         }
 

Runtime/editor/rasterizer.cs

             D.assert(this._surface != null);
 
             var frame = this._surface.acquireFrame(
-                layerTree.frameSize, layerTree.devicePixelRatio);
+                layerTree.frameSize, layerTree.devicePixelRatio, layerTree.antiAliasing);
             if (frame == null) {
                 return false;
             }

Runtime/editor/surface.cs

     }
 
     public interface Surface : IDisposable {
-        SurfaceFrame acquireFrame(Size size, float devicePixelRatio);
+        SurfaceFrame acquireFrame(Size size, float devicePixelRatio, int antiAliasing);
 
         MeshPool getMeshPool();
     }
             this._drawToTargetFunc = drawToTargetFunc;
         }
 
-        public SurfaceFrame acquireFrame(Size size, float devicePixelRatio) {
-            this._createOrUpdateRenderTexture(size, devicePixelRatio);
+        public SurfaceFrame acquireFrame(Size size, float devicePixelRatio, int antiAliasing) {
+            this._createOrUpdateRenderTexture(size, devicePixelRatio, antiAliasing);
 
             return new SurfaceFrame(this._surface,
                 (frame, canvas) => this._presentSurface(canvas));
             return true;
         }
 
-        void _createOrUpdateRenderTexture(Size size, float devicePixelRatio) {
+        void _createOrUpdateRenderTexture(Size size, float devicePixelRatio, int antiAliasing) {
+                && this._surface.antiAliasing == antiAliasing
                 && this._surface.getRenderTexture() != null) {                
                 return;
             }
                 this._surface = null;
             }
 
-            this._surface = new GrSurface(size, devicePixelRatio, this._meshPool);
+            this._surface = new GrSurface(size, devicePixelRatio, antiAliasing, this._meshPool);
         }
     }
 
         public readonly float devicePixelRatio;
+        
+        public readonly int antiAliasing;
 
         readonly MeshPool _meshPool;
 
             return this._canvas;
         }
 
-        public GrSurface(Size size, float devicePixelRatio, MeshPool meshPool) {
+        public GrSurface(Size size, float devicePixelRatio, int antiAliasing, MeshPool meshPool) {
+            this.antiAliasing = antiAliasing;
 
             var desc = new RenderTextureDescriptor(
                 (int) this.size.width, (int) this.size.height,
             };
+            
+            if (antiAliasing != 0) {
+                desc.msaaSamples = antiAliasing;
+            }
 
             this._renderTexture = new RenderTexture(desc);
             this._renderTexture.hideFlags = HideFlags.HideAndDontSave;

Runtime/engine/UIWidgetsPanel.cs

         protected override float queryDevicePixelRatio() {
             return this._uiWidgetsPanel.devicePixelRatio;
         }
+        
+        protected override int queryAntiAliasing() {
+            return this._uiWidgetsPanel.antiAliasing;
+        }
 
         protected override Vector2 queryWindowSize() {
             var rect = this._uiWidgetsPanel.rectTransform.rect;
         IPointerEnterHandler, IPointerExitHandler, WindowHost {
         static Event _repaintEvent;
 
+        [Tooltip("set to zero if you want to use the default device pixel ratio of the target platforms; otherwise the " +
+                 "device pixel ratio will be forced to the given value on all devices.")]
+        
+        [Tooltip("set to true will enable the hardware anti-alias feature, which will improve the appearance of the UI greatly but " +
+                 "making it much slower. Enable it only when seriously required.")]
+        [SerializeField] protected bool hardwareAntiAliasing = false;
         WindowAdapter _windowAdapter;
         Texture _texture;
         Vector2 _lastMouseMove;
                     ? this.devicePixelRatioOverride
                     : this._displayMetrics.devicePixelRatio;
             }
+        }
+        
+        public int antiAliasing {
+            get { return this.hardwareAntiAliasing ? Window.defaultAntiAliasing : 0; }
         }
 
         public WindowPadding viewPadding {

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_impl.cs

                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskBounds,
-                filterMode: FilterMode.Bilinear
+                filterMode: FilterMode.Bilinear,
+                noMSAA: true
             );
 
             parentLayer.addLayer(maskLayer);
                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskLayer.layerBounds,
-                filterMode: FilterMode.Bilinear
+                filterMode: FilterMode.Bilinear,
+                noMSAA: true
             );
 
             parentLayer.addLayer(blurXLayer);
                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskLayer.layerBounds,
-                filterMode: FilterMode.Bilinear
+                filterMode: FilterMode.Bilinear,
+                noMSAA: true
             );
 
             parentLayer.addLayer(blurYLayer);
                             useMipMap = false,
                             autoGenerateMips = false
                         };
+                        
+                        if (this._renderTexture.antiAliasing != 0 && !subLayer.noMSAA) {
+                            desc.msaaSamples = this._renderTexture.antiAliasing;
+                        }
 
                         cmdBuf.GetTemporaryRT(subLayer.rtID, desc, subLayer.filterMode);
                         this._drawLayer(subLayer, cmdBuf);

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_shader_initializer.cs

+using Unity.UIWidgets.editor;
-        const bool enableComputeBuffer = false;
-
         const bool enableDebugLog = false;
 
         public static bool supportComputeBuffer;
         }
 
         static void InitShaders() {
-            supportComputeBuffer = enableComputeBuffer && SystemInfo.supportsComputeShaders && IsShaderSupported();
+            supportComputeBuffer = !WindowConfig.disableComputeBuffer && SystemInfo.supportsComputeShaders && IsShaderSupported();
 
             if (!supportComputeBuffer) {
                 DebugAssert(false, "init default shaders");

Runtime/ui/renderer/cmdbufferCanvas/rendering/render_layer.cs

             public int width;
             public int height;
             public FilterMode filterMode = FilterMode.Bilinear;
+            public bool noMSAA = false;
             public uiRect layerBounds;
             public uiPaint? layerPaint;
             public readonly List<RenderCmd> draws = new List<RenderCmd>(128);
 
             public static RenderLayer create(int rtID = 0, int width = 0, int height = 0,
                 FilterMode filterMode = FilterMode.Bilinear,
+                bool noMSAA = false, 
                 uiRect? layerBounds = null, uiPaint? layerPaint = null, bool ignoreClip = true) {
                 D.assert(layerBounds != null);
                 var newLayer = ObjectPool<RenderLayer>.alloc();
                 newLayer.filterMode = filterMode;
+                newLayer.noMSAA = noMSAA;
                 newLayer.layerBounds = layerBounds.Value;
                 newLayer.layerPaint = layerPaint;
                 newLayer.ignoreClip = ignoreClip;

Runtime/ui/renderer/compositeCanvas/flow/layer.cs

     public class PrerollContext {
         public RasterCache rasterCache;
         public float devicePixelRatio;
+        public int antiAliasing;
         public Rect cullRect;
         public Stopwatch frameTime;
     }

Runtime/ui/renderer/compositeCanvas/flow/layer_tree.cs

             get { return this._devicePixelRatio; }
             set { this._devicePixelRatio = value; }
         }
+        
+        int _antiAliasing;
+
+        public int antiAliasing {
+            get { return this._antiAliasing; }
+            set { this._antiAliasing = value; }
+        }
 
         static readonly Matrix3 _identityMatrix = Matrix3.I();
 
                 devicePixelRatio = frame.canvas().getDevicePixelRatio(),
+                antiAliasing = this.antiAliasing,
                 cullRect = Rect.largest,
                 frameTime = frame.context().frameTime()
             };

Runtime/ui/renderer/compositeCanvas/flow/picture_layer.cs

                 ctm[5] = ctm[5].alignToPixel(context.devicePixelRatio);
 
                 this._rasterCacheResult = context.rasterCache.getPrerolledImage(
-                    this._picture, ctm, context.devicePixelRatio, this._isComplex,
+                    this._picture, ctm, context.devicePixelRatio, context.antiAliasing, this._isComplex,
                     this._willChange);
             }
             else {

Runtime/ui/renderer/compositeCanvas/flow/raster_cache.cs

 using System;
 using System.Collections.Generic;
+using Unity.UIWidgets.editor;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using UnityEngine;
     }
 
     class _RasterCacheKey : IEquatable<_RasterCacheKey> {
-        internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio) {
+        internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio, int antiAliasing) {
             D.assert(picture != null);
             D.assert(matrix != null);
             this.picture = picture;
             this.matrix[2] = 0.0f;
             this.matrix[5] = 0.0f;
             this.devicePixelRatio = devicePixelRatio;
+            this.antiAliasing = antiAliasing;
         }
 
         public readonly Picture picture;
         public readonly float devicePixelRatio;
+        
+        public readonly int antiAliasing;
 
         public bool Equals(_RasterCacheKey other) {
             if (ReferenceEquals(null, other)) {
 
             return Equals(this.picture, other.picture) &&
                    Equals(this.matrix, other.matrix) &&
-                   this.devicePixelRatio.Equals(other.devicePixelRatio);
+                   this.devicePixelRatio.Equals(other.devicePixelRatio) &&
+                   this.antiAliasing.Equals(other.antiAliasing);
         }
 
         public override bool Equals(object obj) {
                 var hashCode = (this.picture != null ? this.picture.GetHashCode() : 0);
                 hashCode = (hashCode * 397) ^ (this.matrix != null ? this.matrix.GetHashCode() : 0);
                 hashCode = (hashCode * 397) ^ this.devicePixelRatio.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.antiAliasing.GetHashCode();
                 return hashCode;
             }
         }
         }
 
         public RasterCacheResult getPrerolledImage(
-            Picture picture, Matrix3 transform, float devicePixelRatio, bool isComplex,
+            Picture picture, Matrix3 transform, float devicePixelRatio, int antiAliasing, bool isComplex,
             bool willChange) {
             if (this.threshold == 0) {
                 return null;
                 return null;
             }
 
-            _RasterCacheKey cacheKey = new _RasterCacheKey(picture, transform, devicePixelRatio);
+            _RasterCacheKey cacheKey = new _RasterCacheKey(picture, transform, devicePixelRatio, antiAliasing);
 
             var entry = this._cache.putIfAbsent(cacheKey, () => new _RasterCacheEntry());
 
             if (entry.image == null) {
                 D.assert(this._meshPool != null);
                 entry.image =
-                    this._rasterizePicture(picture, transform, devicePixelRatio, this._meshPool);
+                    this._rasterizePicture(picture, transform, devicePixelRatio, antiAliasing, this._meshPool);
             }
 
             return entry.image;
                 return false;
             }
 
+            if (Window.instance.windowConfig.disableRasterCache) {
+                return false;
+            }
+            
             var bounds = picture.paintBounds;
             if (bounds.isEmpty) {
                 return false;
                 return false;
             }
 
+            //https://forum.unity.com/threads/rendertexture-create-failed-rendertexture-too-big.58667/
+            if (picture.paintBounds.size.width > WindowConfig.MaxRasterImageSize ||
+                picture.paintBounds.size.height > WindowConfig.MaxRasterImageSize) {
+                return false;
+            }
+
-            MeshPool meshPool) {
+            int antiAliasing, MeshPool meshPool) {
             var bounds = transform.mapRect(picture.paintBounds).roundOut(devicePixelRatio);
 
             var desc = new RenderTextureDescriptor(
                 useMipMap = false,
                 autoGenerateMips = false,
             };
+            
+            if (antiAliasing != 0) {
+                desc.msaaSamples = antiAliasing;
+            }
 
             var renderTexture = new RenderTexture(desc);
             renderTexture.hideFlags = HideFlags.HideAndDontSave;

Runtime/ui/txt/emoji.cs

 
         public const int rowCount = 36;
         public const int colCount = 37;
+        public static float advanceFactor = 1.3f;
+        public static float sizeFactor = 1.2f;
-            return Rect.fromLTWH(fontSize * 0.05f, descent - fontSize, fontSize * 0.9f, fontSize * 0.9f);
+            return Rect.fromLTWH((advanceFactor - sizeFactor) / 2 * fontSize,
+                descent - fontSize * sizeFactor,
+                fontSize * sizeFactor,
+                fontSize * sizeFactor);
         }
 
         public static Rect getUVRect(int code) {

Runtime/ui/txt/layout.cs

             char startingChar = text[0];
             float totalWidth = 0;
             if (char.IsHighSurrogate(startingChar) || EmojiUtils.isSingleCharEmoji(startingChar)) {
-                float advance = style.fontSize + style.letterSpacing;
+                float advance = style.fontSize * EmojiUtils.advanceFactor + style.letterSpacing;
                 for (int i = 0; i < text.Length; i++) {
                     char ch = text[i];
                     if (char.IsHighSurrogate(ch) || EmojiUtils.isSingleCharNonEmptyEmoji(ch)) {
             char startingChar = text[start];
             float currentAdvance = offset;
             if (char.IsHighSurrogate(startingChar) || EmojiUtils.isSingleCharEmoji(startingChar)) {
-                float advance = style.fontSize + style.letterSpacing;
+                float advance = style.fontSize * EmojiUtils.advanceFactor + style.letterSpacing;
                 for (int i = 0; i < count; i++) {
                     char ch = text[start + i];
                     if (char.IsHighSurrogate(ch) || EmojiUtils.isSingleCharNonEmptyEmoji(ch)) {
             char startingChar = text[start];
             float totalWidths = 0;
             if (char.IsHighSurrogate(startingChar) || EmojiUtils.isSingleCharEmoji(startingChar)) {
-                float advance = style.fontSize + style.letterSpacing;
+                float advance = style.fontSize * EmojiUtils.advanceFactor + style.letterSpacing;
                 for (int i = 0; i < count; i++) {
                     char ch = text[start + i];
                     if (char.IsHighSurrogate(ch) || EmojiUtils.isSingleCharNonEmptyEmoji(ch)) {
                     x += letterSpaceHalfLeft;
                     advances[i] = letterSpaceHalfLeft;
 
-
+                    float advance = style.fontSize * EmojiUtils.advanceFactor;
-                    var maxX = metrics.descent - metrics.ascent + x;
-                    var minY = metrics.ascent;
+                    var maxX = advance + x;
+                    var minY = -style.fontSize * EmojiUtils.sizeFactor;
-                    float advance = style.fontSize;
                     x += advance;
 
                     advances[i] += advance;

Runtime/ui/window.cs

 using System;
 using System.Collections.Generic;
 using Unity.UIWidgets.async;
+using Unity.UIWidgets.editor;
 using Unity.UIWidgets.foundation;
 using UnityEngine;
 
         }
 
         internal static Window _instance;
+        
+        public const int defaultAntiAliasing = 4;
 
         public float devicePixelRatio {
             get { return this._devicePixelRatio; }
+        
+        public int antiAliasing {
+            get { return this._antiAliasing; }
+        }
+
+        protected int _antiAliasing = defaultAntiAliasing;
+
+        public WindowConfig windowConfig = WindowConfig.defaultConfig;
 
         protected Size _physicalSize = Size.zero;
 

Samples/UIWidgetsGallery/GalleryMain.cs

 using UIWidgetsGallery.gallery;
 using Unity.UIWidgets.engine;
-using Unity.UIWidgets.material;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

Runtime/editor/window_config.cs

+using Unity.UIWidgets.foundation;
+
+namespace Unity.UIWidgets.editor {
+    public class WindowConfig {
+        public readonly bool disableRasterCache;
+
+        public static float MaxRasterImageSize = 4096;
+
+        static bool? _disableComputeBuffer = null;
+
+        public static bool disableComputeBuffer {
+            //disable compute buffer by default for now
+            get { return _disableComputeBuffer ?? true; }
+            set {
+                D.assert(_disableComputeBuffer == null
+                    || _disableComputeBuffer == value
+                    , () => "The global settings of [disableComputeBuffer] cannot be initiated for multiple times!");
+
+                _disableComputeBuffer = value;
+            }
+        }
+
+        public WindowConfig(bool disableRasterCache) {
+            this.disableRasterCache = disableRasterCache;
+        }
+
+        public static readonly WindowConfig defaultConfig = new WindowConfig(
+            disableRasterCache: false
+        );
+    }
+}

Runtime/editor/window_config.cs.meta

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