Tmp store.

Runtime/editor/editor_window.cs

 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEditor;
+using UnityEditor.Experimental.UIElements;
 using UnityEngine;
 
 namespace Unity.UIWidgets.editor {
         }
         
         protected override int queryAntiAliasing() {
-            return 4;
+            return Window.DefaultAntiAliasing;
         }
 
         protected override Vector2 queryWindowSize() {
             D.assert(this._surface == null);
             this._surface = this.createSurface();
 
-            this._rasterizer.setup(this._surface);
+            this._rasterizer.setup(this._surface, this._antiAliasing);
             _windowAdapters.Add(this);
             this._alive = true;
         }
         protected abstract Vector2 queryWindowSize();
 
         protected virtual Surface createSurface() {
-            return new EditorWindowSurface();
+            return new EditorWindowSurface(antiAliasing: this.antiAliasing);
         }
 
         void _beginFrame() {

Runtime/editor/rasterizer.cs

 using System;
 using Unity.UIWidgets.flow;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.editor {
     public class Rasterizer {
             this._compositorContext = new CompositorContext();
         }
 
-        public void setup(Surface surface) {
+        public void setup(Surface surface, int antiAliasing = Window.DefaultAntiAliasing) {
-            this._compositorContext.onGrContextCreated(this._surface);
+            this._compositorContext.onGrContextCreated(this._surface, antiAliasing);
         }
 
         public void teardown() {

Runtime/editor/surface.cs

 
         readonly SubmitCallback _submitCallback;
 
-        public SurfaceFrame(GrSurface surface, SubmitCallback submitCallback) {
+        int _antiAliasing;
+
+        public SurfaceFrame(GrSurface surface, SubmitCallback submitCallback, int antiAliasing = Window.DefaultAntiAliasing) {
+            this._antiAliasing = antiAliasing;
         }
 
         public void Dispose() {
         }
 
         public Canvas getCanvas() {
-            return this._surface != null ? this._surface.getCanvas() : null;
+            return this._surface != null ? this._surface.getCanvas(this._antiAliasing) : null;
         }
 
         public bool submit() {
         GrSurface _surface;
         readonly DrawToTargetFunc _drawToTargetFunc;
         MeshPool _meshPool = new MeshPool();
+        int _antiAliasing;
-        public EditorWindowSurface(DrawToTargetFunc drawToTargetFunc = null) {
+        public EditorWindowSurface(DrawToTargetFunc drawToTargetFunc = null, int antiAliasing = Window.DefaultAntiAliasing) {
+            this._antiAliasing = antiAliasing;
         }
 
         public SurfaceFrame acquireFrame(Size size, float devicePixelRatio) {
-                (frame, canvas) => this._presentSurface(canvas));
+                (frame, canvas) => this._presentSurface(canvas, this._antiAliasing));
         }
 
         public MeshPool getMeshPool() {
             }
         }
 
-        protected bool _presentSurface(Canvas canvas) {
+        protected bool _presentSurface(Canvas canvas, int antiAliasing) {
-            this._surface.getCanvas().flush();
-            this._surface.getCanvas().reset();
+            this._surface.getCanvas(antiAliasing).flush();
+            this._surface.getCanvas(antiAliasing).reset();
 
             var screenRect = new Rect(0, 0,
                 this._surface.size.width / this._surface.devicePixelRatio,
                 this._surface = null;
             }
 
-            this._surface = new GrSurface(size, devicePixelRatio, this._meshPool);
+            this._surface = new GrSurface(size, devicePixelRatio, this._meshPool, this._antiAliasing);
         }
     }
 
             return this._renderTexture;
         }
 
-        public Canvas getCanvas() {
+        public Canvas getCanvas(int antiAliasing) {
-                    this._renderTexture, this.devicePixelRatio, this._meshPool);
+                    this._renderTexture, this.devicePixelRatio, this._meshPool, antiAliasing);
-        public GrSurface(Size size, float devicePixelRatio, MeshPool meshPool) {
+        public GrSurface(Size size, float devicePixelRatio, MeshPool meshPool, int antiAliasing) {
             this.size = size;
             this.devicePixelRatio = devicePixelRatio;
 
                 autoGenerateMips = false,
             };
 
-            if (Window.instance.antiAliasing != 0) {
-                desc.msaaSamples = Window.instance.antiAliasing;
+            if (antiAliasing != 0) {
+                desc.msaaSamples = antiAliasing;
             }
 
             this._renderTexture = new RenderTexture(desc);

Runtime/engine/UIWidgetsPanel.cs

         }
 
         protected override Surface createSurface() {
-            return new EditorWindowSurface(this._uiWidgetsPanel.applyRenderTexture);
+            return new EditorWindowSurface(this._uiWidgetsPanel.applyRenderTexture, this._antiAliasing);
         }
 
         public override GUIContent titleContent {
         static Event _repaintEvent;
 
         [SerializeField] protected float devicePixelRatioOverride;
-        [SerializeField] protected int antiAliasingOverride = 4;
+        [SerializeField] protected int antiAliasingOverride = Window.DefaultAntiAliasing;
         WindowAdapter _windowAdapter;
         Texture _texture;
         Vector2 _lastMouseMove;
         
         public int antiAliasing {
             get {
-                return this.antiAliasingOverride >= 0 ? this.antiAliasingOverride : 4;
+                return this.antiAliasingOverride >= 0 ? this.antiAliasingOverride : Window.DefaultAntiAliasing;
             }
         }
 

Runtime/flow/compositor_context.cs

 
         readonly RasterCache _rasterCache;
         readonly Stopwatch _frameTime;
+        int _antiAliasing;
 
         public CompositorContext() {
             this._rasterCache = new RasterCache();
             return new ScopedFrame(this, canvas, instrumentation_enabled);
         }
 
-        public void onGrContextCreated(Surface surface) {
+        public void onGrContextCreated(Surface surface, int antiAliasing) {
+            this._antiAliasing = antiAliasing;
+            this._rasterCache.antiAliasing = this._antiAliasing;
         }
 
         public void onGrContextDestroyed() {

Runtime/flow/raster_cache.cs

 
         MeshPool _meshPool;
 
+        public int antiAliasing {
+            set { this._antiAliasing = value; }
+        }
+        int _antiAliasing = Window.DefaultAntiAliasing;
+
         public MeshPool meshPool {
             set { this._meshPool = value; }
         }
                 autoGenerateMips = false,
             };
 
-            if (Window.instance.antiAliasing != 0) {
-                desc.msaaSamples = Window.instance.antiAliasing;
+            if (this._antiAliasing != 0) {
+                desc.msaaSamples = this._antiAliasing;
-            var canvas = new CommandBufferCanvas(renderTexture, devicePixelRatio, meshPool);
+            var canvas = new CommandBufferCanvas(renderTexture, devicePixelRatio, meshPool, this._antiAliasing);
             canvas.translate(-bounds.left, -bounds.top);
             canvas.concat(transform);
             canvas.drawPicture(picture);

Runtime/ui/painting/canvas_impl.cs

         readonly float _fringeWidth;
         readonly float _devicePixelRatio;
         readonly MeshPool _meshPool;
+        readonly int _antiAliasing;
-        public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
+        public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, int antiAliasing, MeshPool meshPool) {
             D.assert(renderTexture);
             D.assert(devicePixelRatio > 0);
             D.assert(meshPool != null);
             this._devicePixelRatio = devicePixelRatio;
             this._meshPool = meshPool;
+            this._antiAliasing = antiAliasing;
         }
         
         public float getDevicePixelRatio() {
                             autoGenerateMips = false,
                         };
                 
-                        if (Window.instance.antiAliasing != 0) {
-                            desc.msaaSamples = Window.instance.antiAliasing;
+                        if (this._antiAliasing != 0) {
+                            desc.msaaSamples = this._antiAliasing;
                         }
                 
                         cmdBuf.GetTemporaryRT(subLayer.rtID, desc, subLayer.filterMode);
     public class CommandBufferCanvas : RecorderCanvas {
         readonly PictureFlusher _flusher;
         
-        public CommandBufferCanvas(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) 
+        public CommandBufferCanvas(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool, int antiAliasing = Window.DefaultAntiAliasing) 
-            this._flusher = new PictureFlusher(renderTexture, devicePixelRatio, meshPool);
+            this._flusher = new PictureFlusher(renderTexture, devicePixelRatio, antiAliasing, meshPool);
         }
 
         public override float getDevicePixelRatio() {

Runtime/ui/window.cs

 
         internal static Window _instance;
 
+        public const int DefaultAntiAliasing = 4;
+
         public float devicePixelRatio {
             get { return this._devicePixelRatio; }
         }
             get { return this._antiAliasing; }
         }
 
-        protected int _antiAliasing = 4;
+        protected int _antiAliasing = DefaultAntiAliasing;
 
         public Size physicalSize {
             get { return this._physicalSize; }

Tests/Editor/CanvasAndLayers.cs

 
         static Texture2D texture6;
 
+        int _antiAliasing = Window.DefaultAntiAliasing;
+
         CanvasAndLayers() {
             this._options = new Action[] {
                 this.drawPloygon4,
                     autoGenerateMips = false,
                 };
 
-                if (Window.instance.antiAliasing != 0) {
-                    desc.msaaSamples = Window.instance.antiAliasing;
+                if (this._antiAliasing != 0) {
+                    desc.msaaSamples = this._antiAliasing;
                 }
 
                 this._renderTexture = RenderTexture.GetTemporary(desc);

.DS_Store

-
Bud1 
d.batIl

 
@
�





 
@
�






 
@
�






 
@ 	build.batIlocblob;(������build.bat.metaIlocblob�(������build.shIlocblob
(������
build.sh.metaIlocblob
�(������CHANGELOG.mdIlocblob
�(������CHANGELOG.md.metaIlocblob;�������CONTRIBUTING.mdIlocblob��������CONTRIBUTING.md.metaIlocblob
�������Documentation~Ilocblob
��������EditorIlocblob
��������Editor.metaIlocblob;
������
-LICENSE.mdIlocblob�
������LICENSE.md.metaIlocblob

������package.jsonIlocblob
�
������package.json.metaIlocblob
�
������QAReport.mdIlocblob;
x������QAReport.md.metaIlocblob�
x������README-ZH.mdIlocblob
7
�������	README.mdIlocblob

x������README.md.metaIlocblob
�
x������RuntimeIlocblob
�
x������Runtime.metaIlocblob;
�������SamplesIlocblob�
�������Samples.metaIlocblob

�������scriptsIlocblob
�
�������scripts.metaIlocblob
�
�������TestsIlocblob;X������
-Tests.metaIlocblob�X������Third Party Notices.mdIlocblob
X������Third Party Notices.md.metaIlocblob
�X������!UIWidgetCleanupPlugin.DotSettingsIlocblob
�X������&UIWidgetCleanupPlugin.DotSettings.metaIlocblob;�������E
DSDB
 `
�





 
@
�






 
@
�






 
@lesIlocblob�
�������Samples.metaIlocblob

�������scriptsIlocblob
�
�������scripts.metaIlocblob
�
�������TestsIlocblob;X������
-Tests.metaIlocblob�X������Third Party Notices.mdIlocblob
X������Third Party Notices.md.metaIlocblob
�X������!UIWidgetCleanupPlugin.DotSettingsIlocblob
�X������&UIWidgetCleanupPlugin.DotSettings.metaIlocblob;�������