Merge pull request #292 from UnityTech/removehardwareMSAA

Yuncong Zhang · web-flow · commit b39d79f52376 · 2019-08-28T10:21:06.000+08:00
remove all hardware-MSAA related codes
diff --git a/Editor/UIWidgetsPanelEditor.cs b/Editor/UIWidgetsPanelEditor.cs
@@ -9,9 +9,7 @@ public class UIWidgetsPanelEditor : RawImageEditor {
         public override void OnInspectorGUI() {
             base.OnInspectorGUI();
             var pixelRatioProperty = this.serializedObject.FindProperty("devicePixelRatioOverride");
-            var antiAliasingProperty = this.serializedObject.FindProperty("antiAliasingOverride");
             EditorGUILayout.PropertyField(pixelRatioProperty);
-            EditorGUILayout.PropertyField(antiAliasingProperty);
             this.serializedObject.ApplyModifiedProperties();
         }
     }
diff --git a/Runtime/editor/editor_window.cs b/Runtime/editor/editor_window.cs
@@ -92,10 +92,6 @@ protected override float queryDevicePixelRatio() {
             return EditorGUIUtility.pixelsPerPoint;
         }
 
-        protected override int queryAntiAliasing() {
-            return defaultAntiAliasing;
-        }
-
         protected override Vector2 queryWindowSize() {
             return this.editorWindow.position.size;
         }
@@ -192,7 +188,6 @@ public void onViewMetricsChanged() {
 
         public void OnEnable() {
             this._devicePixelRatio = this.queryDevicePixelRatio();
-            this._antiAliasing = this.queryAntiAliasing();
             this.updatePhysicalSize();
             this.updateSafeArea();
             D.assert(this._surface == null);
@@ -276,10 +271,6 @@ protected bool displayMetricsChanged() {
                 return true;
             }
 
-            if (this._antiAliasing != this.queryAntiAliasing()) {
-                return true;
-            }
-
             var size = this.queryWindowSize();
             if (this._lastWindowWidth != size.x
                 || this._lastWindowHeight != size.y) {
@@ -298,7 +289,6 @@ public virtual void OnGUI(Event evt = null) {
             using (this.getScope()) {
                 if (this.displayMetricsChanged()) {
                     this._devicePixelRatio = this.queryDevicePixelRatio();
-                    this._antiAliasing = this.queryAntiAliasing();
 
                     var size = this.queryWindowSize();
                     this._lastWindowWidth = size.x;
@@ -323,7 +313,6 @@ public virtual GUIContent titleContent {
         }
 
         protected abstract float queryDevicePixelRatio();
-        protected abstract int queryAntiAliasing();
         protected abstract Vector2 queryWindowSize();
 
         protected virtual Surface createSurface() {
@@ -520,7 +509,6 @@ public override void render(Scene scene) {
 
             layerTree.frameSize = this._physicalSize;
             layerTree.devicePixelRatio = this._devicePixelRatio;
-            layerTree.antiAliasing = this._antiAliasing;
             this._rasterizer.draw(layerTree);
         }
 
diff --git a/Runtime/editor/rasterizer.cs b/Runtime/editor/rasterizer.cs
@@ -63,7 +63,7 @@ bool _drawToSurface(LayerTree layerTree) {
             D.assert(this._surface != null);
 
             var frame = this._surface.acquireFrame(
-                layerTree.frameSize, layerTree.devicePixelRatio, layerTree.antiAliasing);
+                layerTree.frameSize, layerTree.devicePixelRatio);
             if (frame == null) {
                 return false;
             }
diff --git a/Runtime/editor/surface.cs b/Runtime/editor/surface.cs
@@ -54,7 +54,7 @@ bool _performSubmit() {
     }
 
     public interface Surface : IDisposable {
-        SurfaceFrame acquireFrame(Size size, float devicePixelRatio, int antiAliasing);
+        SurfaceFrame acquireFrame(Size size, float devicePixelRatio);
 
         MeshPool getMeshPool();
     }
@@ -104,8 +104,8 @@ public WindowSurfaceImpl(DrawToTargetFunc drawToTargetFunc = null) {
             this._drawToTargetFunc = drawToTargetFunc;
         }
 
-        public SurfaceFrame acquireFrame(Size size, float devicePixelRatio, int antiAliasing) {
-            this._createOrUpdateRenderTexture(size, devicePixelRatio, antiAliasing);
+        public SurfaceFrame acquireFrame(Size size, float devicePixelRatio) {
+            this._createOrUpdateRenderTexture(size, devicePixelRatio);
 
             return new SurfaceFrame(this._surface,
                 (frame, canvas) => this._presentSurface(canvas));
@@ -151,11 +151,10 @@ protected bool _presentSurface(Canvas canvas) {
             return true;
         }
 
-        void _createOrUpdateRenderTexture(Size size, float devicePixelRatio, int antiAliasing) {
+        void _createOrUpdateRenderTexture(Size size, float devicePixelRatio) {
             if (this._surface != null
                 && this._surface.size == size
                 && this._surface.devicePixelRatio == devicePixelRatio
-                && this._surface.antiAliasing == antiAliasing
                 && this._surface.getRenderTexture() != null) {                
                 return;
             }
@@ -165,16 +164,14 @@ void _createOrUpdateRenderTexture(Size size, float devicePixelRatio, int antiAli
                 this._surface = null;
             }
 
-            this._surface = new GrSurface(size, devicePixelRatio, antiAliasing, this._meshPool);
+            this._surface = new GrSurface(size, devicePixelRatio, this._meshPool);
         }
     }
 
     public class GrSurface : IDisposable {
         public readonly Size size;
 
         public readonly float devicePixelRatio;
-        
-        public readonly int antiAliasing;
 
         readonly MeshPool _meshPool;
 
@@ -195,10 +192,9 @@ public Canvas getCanvas() {
             return this._canvas;
         }
 
-        public GrSurface(Size size, float devicePixelRatio, int antiAliasing, MeshPool meshPool) {
+        public GrSurface(Size size, float devicePixelRatio, MeshPool meshPool) {
             this.size = size;
             this.devicePixelRatio = devicePixelRatio;
-            this.antiAliasing = antiAliasing;
 
             var desc = new RenderTextureDescriptor(
                 (int) this.size.width, (int) this.size.height,
@@ -207,10 +203,6 @@ public GrSurface(Size size, float devicePixelRatio, int antiAliasing, MeshPool m
                 autoGenerateMips = false,
             };
 
-            if (antiAliasing != 0) {
-                desc.msaaSamples = antiAliasing;
-            }
-
             this._renderTexture = new RenderTexture(desc);
             this._renderTexture.hideFlags = HideFlags.HideAndDontSave;
 
diff --git a/Runtime/engine/UIWidgetsPanel.cs b/Runtime/engine/UIWidgetsPanel.cs
@@ -66,10 +66,6 @@ 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;
             // Here we use ReferenceEquals instead of "==" due to
@@ -111,7 +107,6 @@ public class UIWidgetsPanel : RawImage, IPointerDownHandler, IPointerUpHandler,
         static Event _repaintEvent;
 
         [SerializeField] protected float devicePixelRatioOverride;
-        [SerializeField] protected int antiAliasingOverride = Window.defaultAntiAliasing;
         WindowAdapter _windowAdapter;
         Texture _texture;
         Vector2 _lastMouseMove;
@@ -170,10 +165,6 @@ public float devicePixelRatio {
             }
         }
 
-        public int antiAliasing {
-            get { return this.antiAliasingOverride >= 0 ? this.antiAliasingOverride : QualitySettings.antiAliasing; }
-        }
-
         public WindowPadding viewPadding {
             get { return this._displayMetrics.viewPadding; }
         }
diff --git a/Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_impl.cs b/Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_impl.cs
@@ -408,8 +408,7 @@ RenderLayer _createMaskLayer(RenderLayer parentLayer, uiRect maskBounds,
                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskBounds,
-                filterMode: FilterMode.Bilinear,
-                noMSAA: true
+                filterMode: FilterMode.Bilinear
             );
 
             parentLayer.addLayer(maskLayer);
@@ -449,8 +448,7 @@ RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigmaX, float sigmaY,
                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskLayer.layerBounds,
-                filterMode: FilterMode.Bilinear,
-                noMSAA: true
+                filterMode: FilterMode.Bilinear
             );
 
             parentLayer.addLayer(blurXLayer);
@@ -460,8 +458,7 @@ RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigmaX, float sigmaY,
                 width: textureWidth,
                 height: textureHeight,
                 layerBounds: maskLayer.layerBounds,
-                filterMode: FilterMode.Bilinear,
-                noMSAA: true
+                filterMode: FilterMode.Bilinear
             );
 
             parentLayer.addLayer(blurYLayer);
@@ -1098,13 +1095,9 @@ void _drawLayer(RenderLayer layer, CommandBuffer cmdBuf) {
                             subLayer.width, subLayer.height,
                             RenderTextureFormat.Default, 24) {
                             useMipMap = false,
-                            autoGenerateMips = 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);
 
diff --git a/Runtime/ui/renderer/cmdbufferCanvas/rendering/render_layer.cs b/Runtime/ui/renderer/cmdbufferCanvas/rendering/render_layer.cs
@@ -9,7 +9,6 @@ internal class RenderLayer : PoolObject {
             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);
@@ -39,14 +38,13 @@ public Vector4 viewport {
 
             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) {
+                uiRect? layerBounds = null, uiPaint? layerPaint = null, bool ignoreClip = true) {
                 D.assert(layerBounds != null);
                 var newLayer = ObjectPool<RenderLayer>.alloc();
                 newLayer.rtID = rtID;
                 newLayer.width = width;
                 newLayer.height = height;
                 newLayer.filterMode = filterMode;
-                newLayer.noMSAA = noMSAA;
                 newLayer.layerBounds = layerBounds.Value;
                 newLayer.layerPaint = layerPaint;
                 newLayer.ignoreClip = ignoreClip;
diff --git a/Runtime/ui/renderer/compositeCanvas/flow/layer.cs b/Runtime/ui/renderer/compositeCanvas/flow/layer.cs
@@ -4,7 +4,6 @@ namespace Unity.UIWidgets.flow {
     public class PrerollContext {
         public RasterCache rasterCache;
         public float devicePixelRatio;
-        public int antiAliasing;
         public Rect cullRect;
         public Stopwatch frameTime;
     }
diff --git a/Runtime/ui/renderer/compositeCanvas/flow/layer_tree.cs b/Runtime/ui/renderer/compositeCanvas/flow/layer_tree.cs
@@ -23,20 +23,12 @@ public float devicePixelRatio {
             set { this._devicePixelRatio = value; }
         }
 
-        int _antiAliasing;
-
-        public int antiAliasing {
-            get { return this._antiAliasing; }
-            set { this._antiAliasing = value; }
-        }
-
         static readonly Matrix3 _identityMatrix = Matrix3.I();
 
         public void preroll(CompositorContext.ScopedFrame frame, bool ignoreRasterCache = false) {
             var prerollContext = new PrerollContext {
                 rasterCache = ignoreRasterCache ? null : frame.context().rasterCache(),
                 devicePixelRatio = frame.canvas().getDevicePixelRatio(),
-                antiAliasing = this.antiAliasing,
                 cullRect = Rect.largest,
                 frameTime = frame.context().frameTime()
             };
diff --git a/Runtime/ui/renderer/compositeCanvas/flow/picture_layer.cs b/Runtime/ui/renderer/compositeCanvas/flow/picture_layer.cs
@@ -38,7 +38,7 @@ public override void preroll(PrerollContext context, Matrix3 matrix) {
                 ctm[5] = ctm[5].alignToPixel(context.devicePixelRatio);
 
                 this._rasterCacheResult = context.rasterCache.getPrerolledImage(
-                    this._picture, ctm, context.devicePixelRatio, context.antiAliasing, this._isComplex,
+                    this._picture, ctm, context.devicePixelRatio, this._isComplex,
                     this._willChange);
             }
             else {
diff --git a/Runtime/ui/renderer/compositeCanvas/flow/raster_cache.cs b/Runtime/ui/renderer/compositeCanvas/flow/raster_cache.cs
@@ -47,7 +47,7 @@ public void draw(Canvas canvas) {
     }
 
     class _RasterCacheKey : IEquatable<_RasterCacheKey> {
-        internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio, int antiAliasing) {
+        internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio) {
             D.assert(picture != null);
             D.assert(matrix != null);
             this.picture = picture;
@@ -67,7 +67,6 @@ internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio
             this.matrix[2] = 0.0f;
             this.matrix[5] = 0.0f;
             this.devicePixelRatio = devicePixelRatio;
-            this.antiAliasing = antiAliasing;
         }
 
         public readonly Picture picture;
@@ -76,8 +75,6 @@ internal _RasterCacheKey(Picture picture, Matrix3 matrix, float devicePixelRatio
 
         public readonly float devicePixelRatio;
 
-        public readonly int antiAliasing;
-
         public bool Equals(_RasterCacheKey other) {
             if (ReferenceEquals(null, other)) {
                 return false;
@@ -89,8 +86,7 @@ public bool Equals(_RasterCacheKey other) {
 
             return Equals(this.picture, other.picture) &&
                    Equals(this.matrix, other.matrix) &&
-                   this.devicePixelRatio.Equals(other.devicePixelRatio) &&
-                   this.antiAliasing.Equals(other.antiAliasing);
+                   this.devicePixelRatio.Equals(other.devicePixelRatio);
         }
 
         public override bool Equals(object obj) {
@@ -114,7 +110,6 @@ public override int GetHashCode() {
                 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;
             }
         }
@@ -151,7 +146,7 @@ public MeshPool meshPool {
         }
 
         public RasterCacheResult getPrerolledImage(
-            Picture picture, Matrix3 transform, float devicePixelRatio, int antiAliasing, bool isComplex,
+            Picture picture, Matrix3 transform, float devicePixelRatio, bool isComplex,
             bool willChange) {
             if (this.threshold == 0) {
                 return null;
@@ -165,7 +160,7 @@ public RasterCacheResult getPrerolledImage(
                 return null;
             }
 
-            _RasterCacheKey cacheKey = new _RasterCacheKey(picture, transform, devicePixelRatio, antiAliasing);
+            _RasterCacheKey cacheKey = new _RasterCacheKey(picture, transform, devicePixelRatio);
 
             var entry = this._cache.putIfAbsent(cacheKey, () => new _RasterCacheEntry());
 
@@ -179,7 +174,7 @@ public RasterCacheResult getPrerolledImage(
             if (entry.image == null) {
                 D.assert(this._meshPool != null);
                 entry.image =
-                    this._rasterizePicture(picture, transform, devicePixelRatio, antiAliasing, this._meshPool);
+                    this._rasterizePicture(picture, transform, devicePixelRatio, this._meshPool);
             }
 
             return entry.image;
@@ -224,7 +219,7 @@ static bool _canRasterizePicture(Picture picture) {
         }
 
         RasterCacheResult _rasterizePicture(Picture picture, Matrix3 transform, float devicePixelRatio,
-            int antiAliasing, MeshPool meshPool) {
+            MeshPool meshPool) {
             var bounds = transform.mapRect(picture.paintBounds).roundOut(devicePixelRatio);
 
             var desc = new RenderTextureDescriptor(
@@ -235,10 +230,6 @@ RasterCacheResult _rasterizePicture(Picture picture, Matrix3 transform, float de
                 autoGenerateMips = false,
             };
 
-            if (antiAliasing != 0) {
-                desc.msaaSamples = antiAliasing;
-            }
-
             var renderTexture = new RenderTexture(desc);
             renderTexture.hideFlags = HideFlags.HideAndDontSave;
 
diff --git a/Runtime/ui/window.cs b/Runtime/ui/window.cs
@@ -134,20 +134,12 @@ public static bool hasInstance {
 
         internal static Window _instance;
 
-        public const int defaultAntiAliasing = 4;
-
         public float devicePixelRatio {
             get { return this._devicePixelRatio; }
         }
 
         protected float _devicePixelRatio = 1.0f;
 
-        public int antiAliasing {
-            get { return this._antiAliasing; }
-        }
-
-        protected int _antiAliasing = defaultAntiAliasing;
-
         public Size physicalSize {
             get { return this._physicalSize; }
         }
diff --git a/Tests/Editor/CanvasAndLayers.cs b/Tests/Editor/CanvasAndLayers.cs

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,7 @@ public class UIWidgetsPanelEditor : RawImageEditor {`
`9`	`9`	`public override void OnInspectorGUI() {`
`10`	`10`	`base.OnInspectorGUI();`
`11`	`11`	`var pixelRatioProperty = this.serializedObject.FindProperty("devicePixelRatioOverride");`
`12`		`- var antiAliasingProperty = this.serializedObject.FindProperty("antiAliasingOverride");`
`13`	`12`	`EditorGUILayout.PropertyField(pixelRatioProperty);`
`14`		`- EditorGUILayout.PropertyField(antiAliasingProperty);`
`15`	`13`	`this.serializedObject.ApplyModifiedProperties();`
`16`	`14`	`}`
`17`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ bool _drawToSurface(LayerTree layerTree) {`
`63`	`63`	`D.assert(this._surface != null);`
`64`	`64`
`65`	`65`	`var frame = this._surface.acquireFrame(`
`66`		`- layerTree.frameSize, layerTree.devicePixelRatio, layerTree.antiAliasing);`
	`66`	`+ layerTree.frameSize, layerTree.devicePixelRatio);`
`67`	`67`	`if (frame == null) {`
`68`	`68`	`return false;`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@ namespace Unity.UIWidgets.flow {`
`4`	`4`	`public class PrerollContext {`
`5`	`5`	`public RasterCache rasterCache;`
`6`	`6`	`public float devicePixelRatio;`
`7`		`- public int antiAliasing;`
`8`	`7`	`public Rect cullRect;`
`9`	`8`	`public Stopwatch frameTime;`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public override void preroll(PrerollContext context, Matrix3 matrix) {`
`38`	`38`	`ctm[5] = ctm[5].alignToPixel(context.devicePixelRatio);`
`39`	`39`
`40`	`40`	`this._rasterCacheResult = context.rasterCache.getPrerolledImage(`
`41`		`- this._picture, ctm, context.devicePixelRatio, context.antiAliasing, this._isComplex,`
	`41`	`+ this._picture, ctm, context.devicePixelRatio, this._isComplex,`
`42`	`42`	`this._willChange);`
`43`	`43`	`}`
`44`	`44`	`else {`