intial commit

.gitignore

+[Ll]ibrary/
+[Tt]emp/
+[Oo]bj/
+[Bb]uild/
+[Bb]uilds/
+Assets/AssetStoreTools*
+
+# Visual Studio cache directory
+.vs/
+
+# Autogenerated VS/MD/Consulo solution and project files
+ExportedObj/
+.consulo/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+*.pdb
+*.opendb
+
+# Unity3D generated meta files
+*.pidb.meta
+*.pdb.meta
+
+# Unity3D Generated File On Crash Reports
+sysinfo.txt
+
+# Builds
+*.apk
+*.unitypackage

README.md

+# UIWidgets

Assets/UIWidgets.meta

+fileFormatVersion: 2
+guid: 9f90b02b089a64284a0510a208167a74
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/UIWidgets/Resources.meta

+fileFormatVersion: 2
+guid: 95dc2df730ba4da9902c271af522b4c2
+timeCreated: 1533739106

Assets/UIWidgets/Resources/UIWidgets_ShadowMat.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: UIWidgets_ShadowMat
+  m_Shader: {fileID: 4800000, guid: 1f7a328e0f36042d89a5781d0a2b9cdf, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/UIWidgets/Resources/UIWidgets_ShadowMat.mat.meta

+fileFormatVersion: 2
+guid: 8fb13a939b26349648cac189e4b8b0c0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/UIWidgets/Resources/UIWidgets_ShadowShader.shader

+Shader "UIWidgets/ShadowShader"
+{
+    Properties {
+        _MainTex ("Texture", any) = "white" {}
+        _SrcBlend("SrcBlend", Int) = 5 // SrcAlpha
+        _DstBlend("DstBlend", Int) = 10 // OneMinusSrcAlpha
+    }
+
+    CGINCLUDE
+    #pragma vertex vert
+    #pragma fragment frag
+    #pragma target 2.5
+
+    #include "UnityCG.cginc"
+
+    struct appdata_t {
+        float4 vertex : POSITION;
+        fixed4 color : COLOR;
+        float2 texcoord : TEXCOORD0;
+    };
+
+    struct v2f {
+        float4 vertex : SV_POSITION;
+        fixed4 color : COLOR;
+        float2 texcoord : TEXCOORD0;
+        float2 clipUV : TEXCOORD1;
+        float4 pos : TEXCOORD2;
+    };
+
+    sampler2D _MainTex;
+    sampler2D _GUIClipTexture;
+    uniform bool _ManualTex2SRGB;
+    uniform int _SrcBlend;
+
+    uniform float4 _MainTex_ST;
+    uniform float4x4 unity_GUIClipTextureMatrix;
+    
+    uniform float _Rect[4];
+    uniform float _sigma;
+
+    // http://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+    float4 erf (float4 x) {
+        float4 s = sign(x);
+        float4 a = abs(x);
+        
+        x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+        x *= x;
+        return s - s / (x * x);
+    }
+    
+    float boxShadow1 (float2 lower, float2 upper, float2 pos, float sigma) {
+        float4 query = float4((lower - pos).xy, (upper - pos).xy);
+        float4 integral = erf(query * (sqrt(0.5) / sigma)) * 0.5 + 0.5;
+        return (integral.z - integral.x) * (integral.w - integral.y);
+    }
+
+    v2f vert (appdata_t v) {
+        float3 eyePos = UnityObjectToViewPos(v.vertex);
+        v2f o;
+        o.vertex = UnityObjectToClipPos(v.vertex);
+        o.color = v.color;
+        o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+        o.clipUV = mul(unity_GUIClipTextureMatrix, float4(eyePos.xy, 0, 1.0));
+        o.pos = v.vertex;
+        return o;
+    }
+
+    fixed4 frag (v2f i) : SV_Target {
+        half4 col = tex2D(_MainTex, i.texcoord);
+        if (_ManualTex2SRGB)
+            col.rgb = LinearToGammaSpace(col.rgb);
+        col *= i.color;
+
+        float2 p = i.pos.xy;
+
+        float clipAlpha = tex2D(_GUIClipTexture, i.clipUV).a;
+        col.a *= clipAlpha;
+        
+        float shadowAlpha = boxShadow1(
+            float2(_Rect[0] + 3 * _sigma, _Rect[1] + 3 * _sigma),
+            float2(_Rect[0] + _Rect[2] - 3 * _sigma, _Rect[1] + _Rect[3] - 3 * _sigma),
+            p, _sigma);
+        col.a *= shadowAlpha;
+        
+        // If the source blend is not SrcAlpha (default) we need to multiply the color by the rounded corner
+        // alpha factors for clipping, since it will not be done at the blending stage.
+        if (_SrcBlend != 5) { // 5 SrcAlpha
+            col.rgb *= clipAlpha;
+        }
+        return col;
+    }
+    ENDCG
+
+    SubShader {
+        Blend [_SrcBlend] [_DstBlend], One OneMinusSrcAlpha
+        Cull Off
+        ZWrite Off
+        ZTest Always
+
+        Pass {
+            CGPROGRAM
+            ENDCG
+        }
+    }
+
+    SubShader {
+        Blend [_SrcBlend] [_DstBlend]
+        Cull Off
+        ZWrite Off
+        ZTest Always
+
+        Pass {
+            CGPROGRAM
+            ENDCG
+        }
+    }
+
+    FallBack "Hidden/Internal-GUITextureClip"
+}

Assets/UIWidgets/Resources/UIWidgets_ShadowShader.shader.meta

+fileFormatVersion: 2
+guid: 1f7a328e0f36042d89a5781d0a2b9cdf
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/UIWidgets/foundation.meta

+fileFormatVersion: 2
+guid: 96d331edfa7445e2baacdfc047f76a58
+timeCreated: 1533448892

Assets/UIWidgets/foundation/callback.cs

+namespace UIWidgets.foundation {
+    public delegate void VoidCallback();
+}

Assets/UIWidgets/foundation/callback.cs.meta

+fileFormatVersion: 2
+guid: 9efb9d71d76943ca91fd129b3205b8bf
+timeCreated: 1533531286

Assets/UIWidgets/foundation/node.cs

+namespace UIWidgets.foundation {
+    public class AbstractNode {
+        public int depth {
+            get { return this._depth; }
+        }
+
+        public int _depth = 0;
+
+        public void redepthChild(AbstractNode child) {
+            if (child._depth <= this._depth) {
+                child._depth = this._depth + 1;
+                child.redepthChildren();
+            }
+        }
+
+        public void redepthChildren() {
+        }
+
+        public object owner {
+            get { return this._owner; }
+        }
+
+        public object _owner;
+
+        public bool attached {
+            get { return this._owner != null; }
+        }
+
+        public void attach(object owner) {
+            this._owner = owner;
+        }
+
+        public void detach() {
+            this._owner = null;
+        }
+
+        public AbstractNode parent {
+            get { return this._parent; }
+        }
+
+        public AbstractNode _parent;
+
+        public void adoptChild(AbstractNode child) {
+            child._parent = this;
+            if (this.attached) {
+                child.attach(this._owner);
+            }
+
+            this.redepthChild(child);
+        }
+
+        public void dropChild(AbstractNode child) {
+            child._parent = null;
+            if (this.attached) {
+                child.detach();
+            }
+        }
+    }
+}

Assets/UIWidgets/foundation/node.cs.meta

+fileFormatVersion: 2
+guid: 5ac7aaa3083440a0ae7a39ad6290bd68
+timeCreated: 1533448903

Assets/UIWidgets/painting.meta

+fileFormatVersion: 2
+guid: cffabf74937a4c1bbd701e107e4b0bc2
+timeCreated: 1533526750

Assets/UIWidgets/painting/binding.cs

+namespace UIWidgets.painting {
+    public abstract class PaintingBinding {
+        
+    }
+}

Assets/UIWidgets/painting/binding.cs.meta

+fileFormatVersion: 2
+guid: 0d2c5fd9228349db9c1aa84047816985
+timeCreated: 1533694574

Assets/UIWidgets/painting/border_radius.cs

+using System;
+
+namespace UIWidgets.painting {
+    public class BorderRadius : IEquatable<BorderRadius> {
+        private BorderRadius(
+            double topLeft,
+            double topRight,
+            double bottomRight,
+            double bottomLeft) {
+            this.topLeft = topLeft;
+            this.topRight = topRight;
+            this.bottomRight = bottomRight;
+            this.bottomLeft = bottomLeft;
+        }
+
+        public static BorderRadius all(double radius) {
+            return BorderRadius.only(radius, radius, radius, radius);
+        }
+
+        public static BorderRadius vertical(double top, double bottom) {
+            return BorderRadius.only(top, top, bottom, bottom);
+        }
+
+        public static BorderRadius horizontal(double left, double right) {
+            return BorderRadius.only(left, right, right, left);
+        }
+
+        public static BorderRadius only(
+            double topLeft = 0.0, double topRight = 0.0,
+            double bottomRight = 0.0, double bottomLeft = 0.0) {
+            return new BorderRadius(topLeft, topRight, bottomRight, bottomLeft);
+        }
+
+        public static readonly BorderRadius zero = BorderRadius.all(0);
+
+        public readonly double topLeft;
+        public readonly double topRight;
+        public readonly double bottomRight;
+        public readonly double bottomLeft;
+
+        public bool Equals(BorderRadius other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return this.topLeft.Equals(other.topLeft)
+                   && this.topRight.Equals(other.topRight)
+                   && this.bottomRight.Equals(other.bottomRight)
+                   && this.bottomLeft.Equals(other.bottomLeft);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((BorderRadius) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                var hashCode = this.topLeft.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.topRight.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.bottomRight.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.bottomLeft.GetHashCode();
+                return hashCode;
+            }
+        }
+    }
+
+    public class BorderWidth : IEquatable<BorderWidth> {
+        private BorderWidth(
+            double top,
+            double right,
+            double bottom,
+            double left) {
+            this.top = top;
+            this.right = right;
+            this.bottom = bottom;
+            this.left = left;
+        }
+
+        public static BorderWidth only(
+            double top = 0, double right = 0,
+            double bottom = 0, double left = 0) {
+            return new BorderWidth(top, right, bottom, left);
+        }
+
+        public static readonly BorderWidth zero = BorderWidth.only();
+
+        public readonly double top;
+        public readonly double right;
+        public readonly double bottom;
+        public readonly double left;
+
+        public bool Equals(BorderWidth other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return this.top.Equals(other.top)
+                   && this.right.Equals(other.right)
+                   && this.bottom.Equals(other.bottom)
+                   && this.left.Equals(other.left);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((BorderWidth) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                var hashCode = this.top.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.right.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.bottom.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.left.GetHashCode();
+                return hashCode;
+            }
+        }
+    }
+}

Assets/UIWidgets/painting/border_radius.cs.meta

+fileFormatVersion: 2
+guid: d6bd54c2d66c4df2ac2119c89654bd8a
+timeCreated: 1533696119

Assets/UIWidgets/painting/borders.cs

+namespace UIWidgets.painting {
+    public abstract class ShapeBorder {
+        public abstract EdgeInsetsGeometry dimensions { get; }
+    }
+}

Assets/UIWidgets/painting/borders.cs.meta

+fileFormatVersion: 2
+guid: 2ed98d909ff04c5380a039fa232bd8d3
+timeCreated: 1533696568

Assets/UIWidgets/painting/box_border.cs

+using System;
+using System.Runtime.CompilerServices;
+using UIWidgets.foundation;
+using UIWidgets.ui;
+using UnityEditor;
+
+namespace UIWidgets.painting {
+    public class BorderSide : IEquatable<BorderSide> {
+        public BorderSide(
+            Color color = null,
+            double width = 1.0
+        ) {
+            this.color = color ?? Color.fromARGB(255, 0, 0, 0);
+            this.width = width;
+        }
+
+        public readonly Color color;
+        public readonly double width;
+
+        public static readonly BorderSide none = new BorderSide(width: 0.0);
+
+        public bool Equals(BorderSide other) {
+            return this.color.Equals(other.color) && this.width.Equals(other.width);
+        }
+
+        public override bool Equals(object obj) {
+            if (ReferenceEquals(null, obj)) return false;
+            return obj is BorderSide && Equals((BorderSide) obj);
+        }
+
+
+        public override int GetHashCode() {
+            unchecked {
+                var hashCode = this.color.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.width.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(BorderSide lhs, BorderSide rhs) {
+            return lhs.Equals(rhs);
+        }
+
+        public static bool operator !=(BorderSide lhs, BorderSide rhs) {
+            return !(lhs == rhs);
+        }
+    }
+
+    public class Border : ShapeBorder {
+        public Border(
+            BorderSide top = null,
+            BorderSide right = null,
+            BorderSide bottom = null,
+            BorderSide left = null
+        ) {
+            this.top = top ?? BorderSide.none;
+            this.right = right ?? BorderSide.none;
+            this.bottom = bottom ?? BorderSide.none;
+            this.left = left ?? BorderSide.none;
+        }
+
+        public readonly BorderSide top;
+        public readonly BorderSide right;
+        public readonly BorderSide bottom;
+        public readonly BorderSide left;
+
+
+        public override EdgeInsetsGeometry dimensions {
+            get { return null; }
+        }
+
+        public bool isSameColor {
+            get {
+                Color topColor = this.top.color;
+                return this.right.color == topColor && this.bottom.color == topColor && this.left.color == topColor;
+            }
+        }
+
+        public void paint(Canvas canvas, Rect rect, BorderRadius borderRadius = null) {
+            var paint = new Paint();
+
+            if (this.isSameColor) {
+                paint.color = this.top.color;
+
+                canvas.drawRect(paint, rect,
+                    BorderWidth.only(this.top.width, this.right.width, this.bottom.width, this.left.width),
+                    borderRadius ?? BorderRadius.zero);
+
+                return;
+            }
+
+            if (this.top.width > 0) {
+                paint.color = this.top.color;
+                var points = new Offset[] {
+                    new Offset(rect.left, rect.top),
+                    new Offset(rect.right, rect.top),
+                    new Offset(rect.right - this.right.width, rect.top + this.top.width),
+                    new Offset(rect.left + this.right.width, rect.top + this.top.width),
+                };
+                canvas.drawPloygon4(paint, points);
+            }
+
+            if (this.right.width > 0) {
+                paint.color = this.right.color;
+                var points = new Offset[] {
+                    new Offset(rect.right, rect.top),
+                    new Offset(rect.right, rect.bottom),
+                    new Offset(rect.right - this.right.width, rect.bottom - this.bottom.width),
+                    new Offset(rect.right - this.right.width, rect.top + this.top.width),
+                };
+                canvas.drawPloygon4(paint, points);
+            }
+
+            if (this.bottom.width > 0) {
+                paint.color = this.bottom.color;
+                var points = new Offset[] {
+                    new Offset(rect.right, rect.bottom),
+                    new Offset(rect.left, rect.bottom),
+                    new Offset(rect.left + this.left.width, rect.bottom - this.bottom.width),
+                    new Offset(rect.right - this.right.width, rect.bottom - this.bottom.width),
+                };
+                canvas.drawPloygon4(paint, points);
+            }
+
+            if (this.left.width > 0) {
+                paint.color = this.left.color;
+                var points = new Offset[] {
+                    new Offset(rect.left, rect.bottom),
+                    new Offset(rect.left, rect.top),
+                    new Offset(rect.left + this.left.width, rect.top + this.top.width),
+                    new Offset(rect.left + this.left.width, rect.bottom - this.bottom.width),
+                };
+                canvas.drawPloygon4(paint, points);
+            }
+        }
+    }
+
+
+    public class ImageConfiguration {
+        public ImageConfiguration(Size size = null) {
+            this.size = size;
+        }
+
+        public readonly Size size;
+    }
+}

Assets/UIWidgets/painting/box_border.cs.meta

+fileFormatVersion: 2
+guid: 43cd4770379048f883ada8383c9c6c6f
+timeCreated: 1533526766

Assets/UIWidgets/painting/box_decoration.cs

+using System.Collections.Generic;
+using UIWidgets.foundation;
+using UIWidgets.ui;
+
+namespace UIWidgets.painting {
+    public class BoxDecoration : Decoration {
+        public BoxDecoration(
+            Color color = null,
+            DecorationImage image = null,
+            Border border = null,
+            BorderRadius borderRadius = null,
+            List<BoxShadow> boxShadow = null,
+            Gradient gradient = null
+        ) {
+            this.color = color;
+            this.image = image;
+            this.border = border;
+            this.borderRadius = borderRadius;
+            this.boxShadow = boxShadow;
+            this.gradient = gradient;
+        }
+
+        public readonly Color color;
+        public readonly DecorationImage image;
+        public readonly Border border;
+        public readonly BorderRadius borderRadius;
+        public readonly List<BoxShadow> boxShadow;
+        public readonly Gradient gradient;
+
+
+        public override EdgeInsetsGeometry padding {
+            get {
+                if (this.border != null) {
+                    return this.border.dimensions;
+                }
+
+                return base.padding;
+            }
+        }
+
+        public override BoxPainter createBoxPainter(VoidCallback onChanged = null) {
+            return new _BoxDecorationPainter(this, onChanged);
+        }
+    }
+
+
+    public class _BoxDecorationPainter : BoxPainter {
+        public _BoxDecorationPainter(BoxDecoration _decoration, VoidCallback onChanged) : base(onChanged) {
+            this._decoration = _decoration;
+        }
+
+        public readonly BoxDecoration _decoration;
+
+        public Paint _cachedBackgroundPaint;
+        public Rect _rectForCachedBackgroundPaint;
+
+        public Paint _getBackgroundPaint(Rect rect) {
+            if (this._cachedBackgroundPaint == null) {
+                this._cachedBackgroundPaint = new Paint();
+            }
+
+            return this._cachedBackgroundPaint;
+        }
+
+        public void _paintBox(Canvas canvas, Rect rect, Paint paint) {
+            if (this._decoration.borderRadius == null) {
+                //canvas.drawRect(rect, paint);
+            } else {
+                //canvas.drawRRect(_decoration.borderRadius.resolve().toRRect(rect), paint);
+            }
+        }
+
+        public void _paintShadows(Canvas canvas, Rect rect) {
+            if (this._decoration.boxShadow == null) {
+                return;
+            }
+
+            foreach (BoxShadow boxShadow in this._decoration.boxShadow) {
+                Rect bounds = rect.shift(boxShadow.offset).inflate(boxShadow.spreadRadius);
+
+                Paint paint = new Paint {
+                    color = boxShadow.color,
+                    blurSigma = boxShadow.blurRadius
+                };
+                canvas.drawRectShadow(paint, bounds);
+            }
+        }
+
+        public void _paintBackgroundColor(Canvas canvas, Rect rect) {
+            if (this._decoration.color != null || this._decoration.gradient != null) {
+                this._paintBox(canvas, rect, this._getBackgroundPaint(rect));
+            }
+        }
+
+        public void _paintBackgroundImage(Canvas canvas, Rect rect, ImageConfiguration configuration) {
+            if (this._decoration.image == null) {
+                return;
+            }
+
+//            _imagePainter ??= _decoration.image.createPainter(onChanged);
+//            Path clipPath;
+//            switch (_decoration.shape) {
+//                case BoxShape.circle:
+//                    clipPath = new Path()..addOval(rect);
+//                    break;
+//                case BoxShape.rectangle:
+//                    if (_decoration.borderRadius != null)
+//                        clipPath = new Path()..addRRect(_decoration.borderRadius.resolve(configuration.textDirection).toRRect(rect));
+//                    break;
+//            }
+//            _imagePainter.paint(canvas, rect, clipPath, configuration);
+        }
+
+
+        public void dispose() {
+            base.dispose();
+        }
+
+        public override void paint(Canvas canvas, Offset offset, ImageConfiguration configuration) {
+            Rect rect = offset & configuration.size;
+
+            this._paintShadows(canvas, rect);
+            this._paintBackgroundColor(canvas, rect);
+            this._paintBackgroundImage(canvas, rect, configuration);
+
+            if (this._decoration.border != null) {
+                this._decoration.border.paint(
+                    canvas,
+                    rect,
+                    borderRadius: (BorderRadius) this._decoration.borderRadius
+                );
+            }
+        }
+    }
+}

Assets/UIWidgets/painting/box_decoration.cs.meta

+fileFormatVersion: 2
+guid: 11e6de6b082a4c42ac97ff053bb22060
+timeCreated: 1533695679

Assets/UIWidgets/painting/box_shadow.cs

+using System;
+using UIWidgets.ui;
+
+namespace UIWidgets.painting {
+    public class BoxShadow : IEquatable<BoxShadow> {
+        public BoxShadow(
+            Color color = null,
+            Offset offset = null,
+            double blurRadius = 0.0,
+            double spreadRadius = 0.0
+        ) {
+            this.color = color ?? new Color(0xFF000000);
+            this.offset = offset ?? Offset.zero;
+            this.blurRadius = blurRadius;
+            this.spreadRadius = spreadRadius;
+        }
+
+        public readonly Color color;
+        public readonly Offset offset;
+        public readonly double blurRadius;
+        public readonly double spreadRadius;
+
+        public static double convertRadiusToSigma(double radius) {
+            return radius * 0.57735 + 0.5;
+        }
+
+        public double blurSigma {
+            get { return BoxShadow.convertRadiusToSigma(this.blurRadius); }
+        }
+
+        public bool Equals(BoxShadow other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return object.Equals(this.color, other.color)
+                   && object.Equals(this.offset, other.offset)
+                   && this.blurRadius.Equals(other.blurRadius)
+                   && this.spreadRadius.Equals(other.spreadRadius);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((BoxShadow) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                var hashCode = (this.color != null ? this.color.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ (this.offset != null ? this.offset.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ this.blurRadius.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.spreadRadius.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(BoxShadow a, BoxShadow b) {
+            return object.Equals(a, b);
+        }
+
+        public static bool operator !=(BoxShadow a, BoxShadow b) {
+            return !(a == b);
+        }
+    }
+}

Assets/UIWidgets/painting/box_shadow.cs.meta

+fileFormatVersion: 2
+guid: 2b949001cd474846a54bade4e071803a
+timeCreated: 1533696193

Assets/UIWidgets/painting/decoration.cs

+using UIWidgets.foundation;
+using UIWidgets.ui;
+
+namespace UIWidgets.painting {
+    public abstract class Decoration {
+        protected Decoration() {
+        }
+
+        public virtual EdgeInsetsGeometry padding {
+            get { return EdgeInsets.zero; }
+        }
+
+        public abstract BoxPainter createBoxPainter(VoidCallback onChanged = null);
+    }
+    
+    public abstract class BoxPainter {
+        protected BoxPainter(VoidCallback onChanged = null) {
+            this.onChanged = onChanged;
+        }
+
+        public readonly VoidCallback onChanged;
+
+        public abstract void paint(Canvas canvas, Offset offset, ImageConfiguration configuration);
+
+        public void dispose() {
+        }
+    }
+}

Assets/UIWidgets/painting/decoration.cs.meta

+fileFormatVersion: 2
+guid: f4f7c68e28ec49f7a8ec9170a3b27380
+timeCreated: 1533690931

Assets/UIWidgets/painting/decoration_image.cs

+
+
+namespace UIWidgets.painting {
+    public class DecorationImage {
+        
+    }
+}

Assets/UIWidgets/painting/decoration_image.cs.meta

+fileFormatVersion: 2
+guid: cf69a7cd054f488db9fd55e194935818
+timeCreated: 1533695992

Assets/UIWidgets/painting/edge_insets.cs

+namespace UIWidgets.painting {
+    public abstract class EdgeInsetsGeometry {
+        protected EdgeInsetsGeometry() {
+        }
+    }
+
+
+    public class EdgeInsets : EdgeInsetsGeometry {
+        private EdgeInsets() {
+        }
+
+        public static EdgeInsets only() {
+            return new EdgeInsets();
+        }
+
+        public static readonly EdgeInsets zero = EdgeInsets.only();
+    }
+}

Assets/UIWidgets/painting/edge_insets.cs.meta

+fileFormatVersion: 2
+guid: 931a04f54b20437b95bea24342d46fd5
+timeCreated: 1533691268

Assets/UIWidgets/painting/gradient.cs

+namespace UIWidgets.painting {
+    public abstract class Gradient {
+    }
+}

Assets/UIWidgets/painting/gradient.cs.meta

+fileFormatVersion: 2
+guid: 8c47e382f7a14e239605bbdfef3bbd35
+timeCreated: 1533696238

Assets/UIWidgets/rendering.meta

+fileFormatVersion: 2
+guid: 8b6981ba72c249fd9c112e7bdd7a2c0e
+timeCreated: 1533448846

Assets/UIWidgets/rendering/object.cs

+using UIWidgets.foundation;
+using UnityEngine;
+
+namespace UIWidgets.rendering {
+    public abstract class RenderObject : AbstractNode {
+        protected RenderObject() {
+        }
+
+        public void onGUI(GUIContext context) {
+        }
+    }
+
+    public class GUIContext {
+        public void paintChild(RenderObject child) {
+            child.onGUI(this);
+        }
+    }
+
+    public class RenderLabel {
+        public RenderLabel() {
+        }
+    }
+
+    public class TextSpan {
+        
+    }
+}

Assets/UIWidgets/rendering/object.cs.meta

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

Assets/UIWidgets/ui.meta

+fileFormatVersion: 2
+guid: 50dd13c5f55e412c929373d86cf70de1
+timeCreated: 1533536840

Assets/UIWidgets/ui/geometry.cs

+using System;
+
+namespace UIWidgets.ui {
+    public abstract class OffsetBase : IEquatable<OffsetBase> {
+        protected OffsetBase(double _dx, double _dy) {
+            this._dx = _dx;
+            this._dy = _dy;
+        }
+
+        public readonly double _dx;
+
+        public readonly double _dy;
+
+        public bool isInfinite {
+            get { return double.IsInfinity(this._dx) || double.IsInfinity(this._dy); }
+        }
+
+        public bool isFinite {
+            get { return !double.IsInfinity(this._dx) && !double.IsInfinity(this._dy); }
+        }
+
+        public static bool operator <(OffsetBase a, OffsetBase b) {
+            return a._dx < b._dx && a._dy < b._dy;
+        }
+
+        public static bool operator <=(OffsetBase a, OffsetBase b) {
+            return a._dx <= b._dx && a._dy <= b._dy;
+        }
+
+        public static bool operator >(OffsetBase a, OffsetBase b) {
+            return a._dx > b._dx && a._dy > b._dy;
+        }
+
+        public static bool operator >=(OffsetBase a, OffsetBase b) {
+            return a._dx >= b._dx && a._dy >= b._dy;
+        }
+
+        public static bool operator ==(OffsetBase a, OffsetBase b) {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(OffsetBase a, OffsetBase b) {
+            return !(a == b);
+        }
+
+        public bool Equals(OffsetBase other) {
+            return this._dx.Equals(other._dx) && this._dy.Equals(other._dy);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            return obj is OffsetBase && this.Equals((OffsetBase) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                return (this._dx.GetHashCode() * 397) ^ this._dy.GetHashCode();
+            }
+        }
+
+        public override string ToString() {
+            return this.GetType() + "(" + this._dx.ToString("0.0") + ", " + this._dy.ToString("0.0") + ")";
+        }
+    }
+
+    public class Offset : OffsetBase, IEquatable<Offset> {
+        public Offset(double dx, double dy) : base(dx, dy) {
+        }
+
+        public double dx {
+            get { return this._dx; }
+        }
+
+        public double dy {
+            get { return this._dy; }
+        }
+
+        public double distance {
+            get { return Math.Sqrt(this._dx * this._dx + this._dy * this._dy); }
+        }
+
+        public double distanceSquared {
+            get { return this._dx * this._dx + this._dy * this._dy; }
+        }
+
+        public static readonly Offset zero = new Offset(0.0, 0.0);
+        public static readonly Offset infinite = new Offset(double.PositiveInfinity, double.PositiveInfinity);
+
+        public Offset scale(double scaleX, double scaleY) {
+            return new Offset(this.dx * scaleX, this.dy * scaleY);
+        }
+
+        public Offset translate(double translateX, double translateY) {
+            return new Offset(this.dx + translateX, this.dy + translateY);
+        }
+
+        public static Rect operator &(Offset a, Size other) {
+            return Rect.fromLTWH(a.dx, a.dy, other.width, other.height);
+        }
+
+        public bool Equals(Offset other) {
+            return this._dx.Equals(other._dx) && this._dy.Equals(other._dy);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            return obj is Offset && this.Equals((Offset) obj);
+        }
+
+        public override int GetHashCode() {
+            return base.GetHashCode();
+        }
+
+        public override string ToString() {
+            return "Offset(" + this._dx.ToString("0.0") + ", " + this._dy.ToString("0.0") + ")";
+        }
+    }
+
+    public class Size : OffsetBase, IEquatable<Size> {
+        public Size(double width, double height) : base(width, height) {
+        }
+
+        public static Size copy(Size source) {
+            return new Size(source.width, source.height);
+        }
+
+        public static Size square(double dimension) {
+            return new Size(dimension, dimension);
+        }
+
+        public static Size fromWidth(double width) {
+            return new Size(width, double.PositiveInfinity);
+        }
+
+        public static Size fromHeight(double height) {
+            return new Size(double.PositiveInfinity, height);
+        }
+
+        public static Size fromRadius(double radius) {
+            return new Size(radius * 2, radius * 2);
+        }
+
+        public double width {
+            get { return this._dx; }
+        }
+
+        public double height {
+            get { return this._dy; }
+        }
+
+        public static readonly Size zero = new Size(0.0, 0.0);
+
+        public static readonly Size infinite = new Size(double.PositiveInfinity, double.PositiveInfinity);
+
+        public bool isEmpty {
+            get { return this.width <= 0.0 || this.height <= 0.0; }
+        }
+
+        public double shortestSide {
+            get { return Math.Min(Math.Abs(this.width), Math.Abs(this.height)); }
+        }
+
+        public double longestSide {
+            get { return Math.Max(Math.Abs(this.width), Math.Abs(this.height)); }
+        }
+
+        public bool Equals(Size other) {
+            return this._dx.Equals(other._dx) && this._dy.Equals(other._dy);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            return obj is Size && this.Equals((Size) obj);
+        }
+
+        public override int GetHashCode() {
+            return base.GetHashCode();
+        }
+
+        public override string ToString() {
+            return "Size(" + this._dx.ToString("0.0") + ", " + this._dy.ToString("0.0") + ")";
+        }
+    }
+
+    public class Radius : IEquatable<Radius> {
+        private Radius(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public readonly double x;
+
+        public readonly double y;
+
+        public static Radius circular(double radius) {
+            return new Radius(radius, radius);
+        }
+
+        public static Radius elliptical(double x, double y) {
+            return new Radius(x, y);
+        }
+
+        public static readonly Radius zero = Radius.circular(0);
+
+        public static Radius operator -(Radius a) {
+            return new Radius(-a.x, -a.y);
+        }
+
+        public static Radius operator -(Radius a, Radius b) {
+            return new Radius(a.x - b.x, a.y - b.y);
+        }
+
+        public static Radius operator +(Radius a, Radius b) {
+            return new Radius(a.x + b.x, a.y + b.y);
+        }
+
+        public static Radius operator *(Radius a, double operand) {
+            return new Radius(a.x * operand, a.y * operand);
+        }
+
+        public static Radius operator /(Radius a, double operand) {
+            return new Radius(a.x / operand, a.y / operand);
+        }
+
+        public static Radius operator %(Radius a, double operand) {
+            return new Radius(a.x % operand, a.y % operand);
+        }
+
+        public bool Equals(Radius other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return this.x.Equals(other.x) && this.y.Equals(other.y);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((Radius) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                return (this.x.GetHashCode() * 397) ^ this.y.GetHashCode();
+            }
+        }
+
+        public override String ToString() {
+            if (this.x == this.y) {
+                return "Radius.circular(" + this.x.ToString("0.0") + ")";
+            }
+
+            return "Radius.elliptical(" + this.x.ToString("0.0") + ", " + this.y.ToString("0.0") + ")";
+        }
+    }
+
+
+    public class Rect : IEquatable<Rect> {
+        private Rect(double left, double top, double right, double bottom) {
+            this.left = left;
+            this.top = top;
+            this.right = right;
+            this.bottom = bottom;
+        }
+
+        public static Rect fromLTRB(double left, double top, double right, double bottom) {
+            return new Rect(left, top, right, bottom);
+        }
+
+        public static Rect fromLTWH(double left, double top, double width, double height) {
+            return new Rect(left, top, left + width, top + height);
+        }
+
+        public static Rect fromCircle(Offset offset, double radius) {
+            return new Rect(offset.dx - radius, offset.dy - radius, offset.dx + radius, offset.dy + radius);
+        }
+
+        public static Rect fromPoints(Offset a, Offset b) {
+            return new Rect(
+                Math.Min(a.dx, b.dx),
+                Math.Min(a.dy, b.dy),
+                Math.Max(a.dx, b.dx),
+                Math.Max(a.dy, b.dy)
+            );
+        }
+
+
+        public readonly double left;
+        public readonly double top;
+        public readonly double right;
+        public readonly double bottom;
+
+        public double width {
+            get { return this.right - this.left; }
+        }
+
+        public double height {
+            get { return this.bottom - this.top; }
+        }
+
+        public Size size {
+            get { return new Size(this.width, this.height); }
+        }
+
+        public static readonly Rect zero = new Rect(0, 0, 0, 0);
+
+        public const double _giantScalar = 1.0E+9;
+
+        public static readonly Rect largest = Rect.fromLTRB(-_giantScalar, -_giantScalar, _giantScalar, _giantScalar);
+
+        public bool isInfinite {
+            get {
+                return double.IsInfinity(this.left)
+                       || double.IsInfinity(this.top)
+                       || double.IsInfinity(this.right)
+                       || double.IsInfinity(this.bottom);
+            }
+        }
+
+        public bool isFinite {
+            get { return !this.isInfinite; }
+        }
+
+        public bool isEmpty {
+            get { return this.left >= this.right || this.top >= this.bottom; }
+        }
+
+        public Rect shift(Offset offset) {
+            return Rect.fromLTRB(this.left + offset.dx, this.top + offset.dy, this.right + offset.dx,
+                this.bottom + offset.dy);
+        }
+
+        public Rect inflate(double delta) {
+            return Rect.fromLTRB(this.left - delta, this.top - delta, this.right + delta, this.bottom + delta);
+        }
+
+
+        public bool Equals(Rect other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return this.left.Equals(other.left) && this.top.Equals(other.top) && this.right.Equals(other.right) &&
+                   this.bottom.Equals(other.bottom);
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((Rect) obj);
+        }
+
+        public override int GetHashCode() {
+            unchecked {
+                var hashCode = this.left.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.top.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.right.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.bottom.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public override String ToString() {
+            return "Rect.fromLTRB(" + this.left.ToString("0.0") + ", " + this.top.ToString("0.0") + ", " +
+                   this.right.ToString("0.0") + ", " + this.bottom.ToString("0.0") + ")";
+        }
+    }
+}

Assets/UIWidgets/ui/geometry.cs.meta

+fileFormatVersion: 2
+guid: e4df4584171f4cdcaa9d0792878e6312
+timeCreated: 1533536856

Assets/UIWidgets/ui/painting.cs

+using System;
+using UIWidgets.painting;
+using UnityEditor;
+using UnityEngine;
+
+namespace UIWidgets.ui {
+    public class Color : IEquatable<Color> {
+        public Color(long value) {
+            this.value = value & 0xFFFFFFFF;
+        }
+
+        public static Color fromARGB(int a, int r, int g, int b) {
+            return new Color(
+                (((a & 0xff) << 24) |
+                 ((r & 0xff) << 16) |
+                 ((g & 0xff) << 8) |
+                 ((b & 0xff) << 0)) & 0xFFFFFFFF);
+        }
+
+        public static Color fromRGBO(int r, int g, int b, double opacity) {
+            return new Color(
+                ((((int) (opacity * 0xff) & 0xff) << 24) |
+                 ((r & 0xff) << 16) |
+                 ((g & 0xff) << 8) |
+                 ((b & 0xff) << 0)) & 0xFFFFFFFF);
+        }
+
+        public readonly long value;
+
+        public int alpha {
+            get { return (int) ((0xff000000 & this.value) >> 24); }
+        }
+
+        public double opacity {
+            get { return this.alpha / 255.0; }
+        }
+
+        public int red {
+            get { return (int) ((0x00ff0000 & this.value) >> 16); }
+        }
+
+        public int green {
+            get { return (int) ((0x0000ff00 & this.value) >> 8); }
+        }
+
+        public int blue {
+            get { return (int) ((0x000000ff & this.value) >> 0); }
+        }
+
+        public Color withAlpha(int a) {
+            return Color.fromARGB(a, this.red, this.green, this.blue);
+        }
+
+        public Color withOpacity(double opacity) {
+            return this.withAlpha((int) (opacity * 255));
+        }
+
+        public Color withRed(int r) {
+            return Color.fromARGB(this.alpha, r, this.green, this.blue);
+        }
+
+        public Color withGreen(int g) {
+            return Color.fromARGB(this.alpha, this.red, g, this.blue);
+        }
+
+        public Color withBlue(int b) {
+            return Color.fromARGB(this.alpha, this.red, this.green, b);
+        }
+
+        public bool Equals(Color other) {
+            if (object.ReferenceEquals(null, other)) return false;
+            if (object.ReferenceEquals(this, other)) return true;
+            return this.value == other.value;
+        }
+
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) return false;
+            if (object.ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return this.Equals((Color) obj);
+        }
+
+        public override int GetHashCode() {
+            return this.value.GetHashCode();
+        }
+
+        public static bool operator ==(Color a, Color b) {
+            return object.ReferenceEquals(a, null) ? object.ReferenceEquals(b, null) : a.Equals(b);
+        }
+
+        public static bool operator !=(Color a, Color b) {
+            return !(a == b);
+        }
+    }
+
+    public abstract class Canvas {
+        public abstract void drawPloygon4(Paint paint, params Offset[] points);
+
+        public abstract void drawRect(Paint paint, Rect rect, BorderWidth borderWidth, BorderRadius borderRadius);
+
+        public abstract void drawRectShadow(Paint paint, Rect rect);
+    }
+
+    public class Paint {
+        public Color color;
+        public double blurSigma;
+    }
+
+    public static class Conversions {
+        public static UnityEngine.Color toColor(this Color color) {
+            return new UnityEngine.Color(
+                color.red / 255f, color.green / 255f, color.blue / 255f, color.alpha / 255f);
+        }
+
+        public static Vector2 toVector(this Offset offset) {
+            return new Vector2((float) offset.dx, (float) offset.dy);
+        }
+
+        public static UnityEngine.Rect toRect(this Rect rect) {
+            return new UnityEngine.Rect((float) rect.left, (float) rect.top, (float) rect.width, (float) rect.height);
+        }
+
+        public static Vector4 toVector(this BorderWidth borderWidth) {
+            return new Vector4((float) borderWidth.left, (float) borderWidth.top, (float) borderWidth.right,
+                (float) borderWidth.bottom);
+        }
+
+        public static Vector4 toVector(this BorderRadius borderRadius) {
+            return new Vector4((float) borderRadius.topLeft, (float) borderRadius.topRight,
+                (float) borderRadius.bottomRight, (float) borderRadius.bottomLeft);
+        }
+    }
+
+    public class GUICanvas : Canvas {
+        static GUICanvas() {
+            GUICanvas.shadowMat = Resources.Load<Material>("UIWidgets_ShadowMat");
+            if (GUICanvas.shadowMat == null) {
+                throw new Exception("UIWidgets_ShadowShader not found");
+            }
+        }
+
+        public static readonly Material shadowMat;
+
+        public override void drawPloygon4(Paint paint, params Offset[] points) {
+            Vector3[] vectors = new Vector3 [points.Length];
+            for (int i = 0; i < points.Length; i++) {
+                vectors[i] = points[i].toVector();
+            }
+
+            Handles.DrawSolidRectangleWithOutline(vectors, paint.color.toColor(),
+                new UnityEngine.Color(0f, 0f, 0f, 0f));
+        }
+
+        public override void drawRect(Paint paint, Rect rect, BorderWidth borderWidth, BorderRadius borderRadius) {
+            GUI.DrawTexture(rect.toRect(), EditorGUIUtility.whiteTexture, ScaleMode.StretchToFill, true, 0,
+                paint.color.toColor(), borderWidth.toVector(), borderRadius.toVector());
+        }
+
+        public override void drawRectShadow(Paint paint, Rect rect) {
+            GUICanvas.shadowMat.SetFloatArray("_Rect", new float[] {
+                (float) rect.left, (float) rect.top, (float) rect.width, (float) rect.height,
+            });
+            GUICanvas.shadowMat.SetFloat("_sigma", (float) paint.blurSigma);
+
+            Graphics.DrawTexture(rect.toRect(), EditorGUIUtility.whiteTexture,
+                new UnityEngine.Rect(0.0f, 0.0f, 1f, 1f), 0, 0, 0, 0, paint.color.toColor(), GUICanvas.shadowMat);
+        }
+    }
+}

Assets/UIWidgets/ui/painting.cs.meta

+fileFormatVersion: 2
+guid: 33ba32b528aa470ab3b51236ab82a7d8
+timeCreated: 1533690847

Assets/UIWidgets/widgets.meta

+fileFormatVersion: 2
+guid: bd7bb99a5be7a4156ae6b0ffa0e85d5f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/UIWidgets/widgets/framework.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UIWidgets.foundation;
+using UIWidgets.rendering;
+using UnityEngine.Assertions;
+
+namespace UIWidgets.widgets {
+    public delegate void ElementVisitor(Element element);
+    public delegate bool ElementVisitorBool(Element element);
+
+
+
+    public abstract class Widget {
+        protected Widget(string key) {
+            this._key = key;
+        }
+
+        public readonly string _key;
+
+        public string key {
+            get { return this._key; }
+        }
+
+        public abstract Element createElement();
+
+        public static bool canUpdate(Widget oldWidget, Widget newWidget) {
+            return oldWidget.GetType() == newWidget.GetType() && oldWidget.key == newWidget.key;
+        }
+    }
+
+    public abstract class StatelessWidget : Widget {
+        protected StatelessWidget(string key) : base(key) {
+        }
+
+        public override Element createElement() {
+            return new StatelessElement(this);
+        }
+
+        public abstract Widget build(BuildContext context);
+    }
+
+    public abstract class RenderObjectWidget : Widget {
+        protected RenderObjectWidget(string key) : base(key) {
+        }
+
+        public abstract RenderObject createRenderObject(BuildContext context);
+
+        public virtual void updateRenderObject(BuildContext context, RenderObject renderObject) {
+        }
+
+        public virtual void didUnmountRenderObject(RenderObject renderObject) {
+        }
+    }
+
+    public abstract class Element : BuildContext {
+        protected Element(Widget widget) {
+            Assert.IsNotNull(widget);
+            this._widget = widget;
+        }
+
+        public Element _parent;
+
+        public override bool Equals(object obj) {
+            return object.ReferenceEquals(this, obj);
+        }
+
+        private static int _nextHashCode = 1;
+
+        private readonly int _cachedHash = Element._nextHashCode = (Element._nextHashCode + 1) % 0xffffff;
+
+        public override int GetHashCode() {
+            return this._cachedHash;
+        }
+
+        public object _slot;
+
+        public object slot {
+            get { return this._slot; }
+        }
+
+        public int _depth;
+
+        public int depth {
+            get { return this._depth; }
+        }
+
+        public static int _sort(Element a, Element b) {
+            if (a.depth < b.depth)
+                return -1;
+            if (b.depth < a.depth)
+                return 1;
+            if (b.dirty && !a.dirty)
+                return -1;
+            if (a.dirty && !b.dirty)
+                return 1;
+            return 0;
+        }
+
+        public Widget _widget;
+
+        public Widget widget {
+            get { return this._widget; }
+        }
+
+        public BuildOwner _owner;
+
+        public BuildOwner owner {
+            get { return this._owner; }
+        }
+
+        public bool _active = false;
+
+        public RenderObject renderObject {
+            get {
+                RenderObject result = null;
+
+                ElementVisitor visit = null;
+                visit = (element) => {
+                    Assert.IsNull(result);
+                    if (element is RenderObjectElement) {
+                        result = element.renderObject;
+                    } else {
+                        element.visitChildren(visit);
+                    }
+                };
+
+                visit(this);
+
+                return result;
+            }
+        }
+
+        public virtual void visitChildren(ElementVisitor visitor) {
+        }
+
+        public void visitChildElements(ElementVisitor visitor) {
+            this.visitChildren(visitor);
+        }
+
+        public Element updateChild(Element child, Widget newWidget, object newSlot) {
+            if (newWidget == null) {
+                if (child != null) {
+                    this.deactivateChild(child);
+                }
+
+                return null;
+            }
+
+            if (child != null) {
+                if (child.widget == newWidget) {
+                    if (child.slot != newSlot) {
+                        this.updateSlotForChild(child, newSlot);
+                    }
+
+                    return child;
+                }
+
+                if (Widget.canUpdate(child.widget, newWidget)) {
+                    if (child.slot != newSlot) {
+                        this.updateSlotForChild(child, newSlot);
+                    }
+
+                    child.update(newWidget);
+                    return child;
+                }
+
+                this.deactivateChild(child);
+            }
+
+            return inflateWidget(newWidget, newSlot);
+        }
+
+        public virtual void update(Widget newWidget) {
+            this._widget = newWidget;
+        }
+
+        public virtual void mount(Element parent, object newSlot) {
+            this._parent = parent;
+            this._slot = newSlot;
+            this._depth = parent != null ? parent.depth + 1 : 1;
+            this._active = true;
+            if (parent != null) {
+                this._owner = parent.owner;
+            }
+
+            // _updateInheritance();
+        }
+
+        void updateSlotForChild(Element child, object newSlot) {
+            ElementVisitor visit = null;
+            visit = (element) => {
+                element._updateSlot(newSlot);
+                if (element is RenderObjectElement) {
+                    element.visitChildren(visit);
+                }
+            };
+            visit(child);
+        }
+
+        void _updateSlot(object newSlot) {
+            this._slot = newSlot;
+        }
+
+        void _updateDepth(int parentDepth) {
+            int expectedDepth = parentDepth + 1;
+            if (this._depth < expectedDepth) {
+                this._depth = expectedDepth;
+                this.visitChildren(child => { child._updateDepth(expectedDepth); });
+            }
+        }
+
+
+        public void detachRenderObject() {
+            this.visitChildren(child => { child.detachRenderObject(); });
+            this._slot = null;
+        }
+
+        public void attachRenderObject(object newSlot) {
+            Assert.IsNull(_slot);
+            this.visitChildren(child => { child.attachRenderObject(newSlot); });
+            this._slot = newSlot;
+        }
+
+        public Element inflateWidget(Widget newWidget, object newSlot) {
+            Element newChild = newWidget.createElement();
+            newChild.mount(this, newSlot);
+            return newChild;
+        }
+
+        public void deactivateChild(Element child) {
+            child._parent = null;
+            child.detachRenderObject();
+            this.owner._inactiveElements.add(child);
+        }
+
+        public abstract void forgetChild(Element child);
+
+        public void activate() {
+            Assert.IsTrue(!this._active);
+            this._active = true;
+            if (this._dirty) {
+                this.owner.scheduleBuildFor(this);
+            }
+        }
+
+        public void deactivate() {
+            Assert.IsTrue(this._active);
+            this._active = false;
+        }
+
+        public void unmount() {
+        }
+
+        public RenderObject findRenderObject() {
+            return this.renderObject;
+        }
+
+        public void didChangeDependencies() {
+            this.markNeedsBuild();
+        }
+
+        public void visitAncestorElements(ElementVisitorBool visitor) {
+            Element ancestor = this._parent;
+            while (ancestor != null && visitor(ancestor)) {
+                ancestor = ancestor._parent;
+            }
+        }
+
+        public bool _dirty;
+
+        public bool dirty {
+            get { return this._dirty; }
+        }
+
+        public bool _inDirtyList = false;
+
+        public void markNeedsBuild() {
+            if (!this._active) {
+                return;
+            }
+
+            if (this.dirty) {
+                return;
+            }
+
+            this._dirty = true;
+            this.owner.scheduleBuildFor(this);
+        }
+
+        public void rebuild() {
+            if (!this._active || !this._dirty) {
+                return;
+            }
+
+            this.performRebuild();
+            Assert.IsTrue(!this._dirty);
+        }
+
+        public abstract void performRebuild();
+    }
+
+
+    public abstract class ComponentElement : Element {
+        protected ComponentElement(Widget widget) : base(widget) {
+        }
+
+        public Element _child;
+
+        public override void mount(Element parent, object newSlot) {
+            base.mount(parent, newSlot);
+
+            this._firstBuild();
+        }
+
+        public void _firstBuild() {
+            this.rebuild();
+        }
+
+        public override void performRebuild() {
+            Widget built;
+
+            try {
+                built = this.build();
+            }
+            catch (Exception e) {
+                built = null; // ErrorWidget.builder(_debugReportException('building $this', e, stack));
+            }
+            finally {
+                this._dirty = false;
+            }
+
+            try {
+                this._child = this.updateChild(this._child, built, this.slot);
+                Assert.IsNotNull(_child);
+            }
+            catch (Exception e) {
+                built = null; //ErrorWidget.builder(_debugReportException('building $this', e, stack));
+                this._child = this.updateChild(null, built, this.slot);
+            }
+        }
+
+        public abstract Widget build();
+
+        public override void visitChildren(ElementVisitor visitor) {
+            if (this._child != null) {
+                visitor(this._child);
+            }
+        }
+
+        public override void forgetChild(Element child) {
+            Assert.IsTrue(child == _child);
+            this._child = null;
+        }
+    }
+
+    public class StatelessElement : ComponentElement {
+        public StatelessElement(StatelessWidget widget) : base(widget) {
+        }
+
+        public new StatelessWidget widget {
+            get { return (StatelessWidget) base.widget; }
+        }
+
+        public override Widget build() {
+            return this.widget.build(this);
+        }
+
+        public override void update(Widget newWidget) {
+            base.update(newWidget);
+
+            this._dirty = true;
+            this.rebuild();
+        }
+    }
+
+    public abstract class RenderObjectElement : Element {
+        protected RenderObjectElement(RenderObjectWidget widget) : base(widget) {
+        }
+
+        public new RenderObjectWidget widget {
+            get { return (RenderObjectWidget) base.widget; }
+        }
+
+        public RenderObject _renderObject;
+
+        public RenderObject renderObject {
+            get { return this._renderObject; }
+        }
+
+        public RenderObjectElement _ancestorRenderObjectElement;
+
+        public override void mount(Element parent, object newSlot) {
+            this._renderObject = this.widget.createRenderObject(this);
+            this.attachRenderObject(newSlot);
+            this._dirty = false;
+        }
+
+        public override void update(Widget newWidget) {
+            base.update(newWidget);
+
+            this.widget.updateRenderObject(this, this.renderObject);
+            this._dirty = false;
+        }
+
+        public override void performRebuild() {
+            this.widget.updateRenderObject(this, this.renderObject);
+            this._dirty = false;
+        }
+
+        public List<Element> updateChildren(List<Element> oldChildren, List<Widget> newWidgets,
+            HashSet<Element> forgottenChildren) {
+            return null;
+        }
+    }
+
+    public interface BuildContext {
+        Widget widget { get; }
+    }
+
+    public class BuildOwner {
+        public VoidCallback onBuildScheduled;
+
+        public BuildOwner(VoidCallback onBuildScheduled) {
+            this.onBuildScheduled = onBuildScheduled;
+        }
+
+        public readonly _InactiveElements _inactiveElements = new _InactiveElements();
+        public readonly List<Element> _dirtyElements = new List<Element>();
+
+        public bool _scheduledFlushDirtyElements = false;
+        public bool _dirtyElementsNeedsResorting = false;
+
+        public void scheduleBuildFor(Element element) {
+            if (element._inDirtyList) {
+                this._dirtyElementsNeedsResorting = true;
+                return;
+            }
+
+            if (!this._scheduledFlushDirtyElements && this.onBuildScheduled != null) {
+                this._scheduledFlushDirtyElements = true;
+                this.onBuildScheduled();
+            }
+
+            this._dirtyElements.Add(element);
+            element._inDirtyList = true;
+        }
+
+        public void buildScope(Element context, VoidCallback callback = null) {
+            if (callback == null && this._dirtyElements.Count == 0) {
+                return;
+            }
+
+
+            try {
+                this._scheduledFlushDirtyElements = true;
+                if (callback != null) {
+                    this._dirtyElementsNeedsResorting = false;
+                    callback();
+                }
+
+                this._dirtyElements.Sort(Element._sort);
+                this._dirtyElementsNeedsResorting = false;
+
+                int dirtyCount = this._dirtyElements.Count;
+                int index = 0;
+
+                while (index < dirtyCount) {
+                    this._dirtyElements[index].rebuild();
+                    index++;
+
+                    if (dirtyCount < this._dirtyElements.Count || this._dirtyElementsNeedsResorting) {
+                        this._dirtyElements.Sort(Element._sort);
+                        this._dirtyElementsNeedsResorting = false;
+                        dirtyCount = this._dirtyElements.Count;
+                        while (index > 0 && this._dirtyElements[index - 1].dirty) {
+                            index -= 1;
+                        }
+                    }
+                }
+            }
+            finally {
+                foreach (Element element in this._dirtyElements) {
+                    Assert.IsTrue(element._inDirtyList);
+                    element._inDirtyList = false;
+                }
+
+                this._dirtyElements.Clear();
+                this._scheduledFlushDirtyElements = false;
+                this._dirtyElementsNeedsResorting = false;
+            }
+        }
+
+        public void finalizeTree() {
+            this._inactiveElements._unmountAll();
+        }
+    }
+
+    public class _InactiveElements {
+        public readonly HashSet<Element> _elements = new HashSet<Element>();
+
+        public void _unmount(Element element) {
+            element.visitChildren(child => {
+                Assert.IsTrue(child._parent.Equals(element));
+                this._unmount(child);
+            });
+            element.unmount();
+        }
+
+        public void _unmountAll() {
+            List<Element> elements = this._elements.ToList();
+            this._elements.Clear();
+
+            elements.Sort(Element._sort);
+            elements.Reverse();
+
+            elements.ForEach(this._unmount);
+        }
+
+        public void _deactivateRecursively(Element element) {
+            element.deactivate();
+            element.visitChildren(this._deactivateRecursively);
+        }
+
+        public void add(Element element) {
+            if (element._active) {
+                this._deactivateRecursively(element);
+            }
+
+            this._elements.Add(element);
+        }
+
+        public void remove(Element element) {
+            this._elements.Remove(element);
+        }
+    }
+}

Assets/UIWidgets/widgets/framework.cs.meta

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

Packages/manifest.json

+{
+  "dependencies": {
+    "com.unity.ads": "2.0.8",
+    "com.unity.analytics": "2.0.16",
+    "com.unity.package-manager-ui": "1.9.11",
+    "com.unity.purchasing": "2.0.3",
+    "com.unity.textmeshpro": "1.2.4",
+    "com.unity.modules.ai": "1.0.0",
+    "com.unity.modules.animation": "1.0.0",
+    "com.unity.modules.assetbundle": "1.0.0",
+    "com.unity.modules.audio": "1.0.0",
+    "com.unity.modules.cloth": "1.0.0",
+    "com.unity.modules.director": "1.0.0",
+    "com.unity.modules.imageconversion": "1.0.0",
+    "com.unity.modules.imgui": "1.0.0",
+    "com.unity.modules.jsonserialize": "1.0.0",
+    "com.unity.modules.particlesystem": "1.0.0",
+    "com.unity.modules.physics": "1.0.0",
+    "com.unity.modules.physics2d": "1.0.0",
+    "com.unity.modules.screencapture": "1.0.0",
+    "com.unity.modules.terrain": "1.0.0",
+    "com.unity.modules.terrainphysics": "1.0.0",
+    "com.unity.modules.tilemap": "1.0.0",
+    "com.unity.modules.ui": "1.0.0",
+    "com.unity.modules.uielements": "1.0.0",
+    "com.unity.modules.umbra": "1.0.0",
+    "com.unity.modules.unityanalytics": "1.0.0",
+    "com.unity.modules.unitywebrequest": "1.0.0",
+    "com.unity.modules.unitywebrequestassetbundle": "1.0.0",
+    "com.unity.modules.unitywebrequestaudio": "1.0.0",
+    "com.unity.modules.unitywebrequesttexture": "1.0.0",
+    "com.unity.modules.unitywebrequestwww": "1.0.0",
+    "com.unity.modules.vehicles": "1.0.0",
+    "com.unity.modules.video": "1.0.0",
+    "com.unity.modules.vr": "1.0.0",
+    "com.unity.modules.wind": "1.0.0",
+    "com.unity.modules.xr": "1.0.0"
+  }
+}

ProjectSettings/AudioManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!11 &1
+AudioManager:
+  m_ObjectHideFlags: 0
+  m_Volume: 1
+  Rolloff Scale: 1
+  Doppler Factor: 1
+  Default Speaker Mode: 2
+  m_SampleRate: 0
+  m_DSPBufferSize: 1024
+  m_VirtualVoiceCount: 512
+  m_RealVoiceCount: 32
+  m_SpatializerPlugin: 
+  m_AmbisonicDecoderPlugin: 
+  m_DisableAudio: 0
+  m_VirtualizeEffects: 1

ProjectSettings/ClusterInputManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!236 &1
+ClusterInputManager:
+  m_ObjectHideFlags: 0
+  m_Inputs: []

ProjectSettings/DynamicsManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!55 &1
+PhysicsManager:
+  m_ObjectHideFlags: 0
+  serializedVersion: 7
+  m_Gravity: {x: 0, y: -9.81, z: 0}
+  m_DefaultMaterial: {fileID: 0}
+  m_BounceThreshold: 2
+  m_SleepThreshold: 0.005
+  m_DefaultContactOffset: 0.01
+  m_DefaultSolverIterations: 6
+  m_DefaultSolverVelocityIterations: 1
+  m_QueriesHitBackfaces: 0
+  m_QueriesHitTriggers: 1
+  m_EnableAdaptiveForce: 0
+  m_ClothInterCollisionDistance: 0
+  m_ClothInterCollisionStiffness: 0
+  m_ContactsGeneration: 1
+  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  m_AutoSimulation: 1
+  m_AutoSyncTransforms: 1
+  m_ClothInterCollisionSettingsToggle: 0
+  m_ContactPairsMode: 0
+  m_BroadphaseType: 0
+  m_WorldBounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 250, y: 250, z: 250}
+  m_WorldSubdivisions: 8

ProjectSettings/EditorBuildSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1045 &1
+EditorBuildSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Scenes:
+  - enabled: 1
+    path: Assets/Scenes/SampleScene.unity
+    guid: 99c9720ab356a0642a771bea13969a05
+  m_configObjects: {}

ProjectSettings/EditorSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!159 &1
+EditorSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 7
+  m_ExternalVersionControlSupport: Visible Meta Files
+  m_SerializationMode: 2
+  m_LineEndingsForNewScripts: 2
+  m_DefaultBehaviorMode: 0
+  m_SpritePackerMode: 0
+  m_SpritePackerPaddingPower: 1
+  m_EtcTextureCompressorBehavior: 1
+  m_EtcTextureFastCompressor: 1
+  m_EtcTextureNormalCompressor: 2
+  m_EtcTextureBestCompressor: 4
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd
+  m_ProjectGenerationRootNamespace: 
+  m_UserGeneratedProjectSuffix: 
+  m_CollabEditorSettings:
+    inProgressEnabled: 1

ProjectSettings/GraphicsSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!30 &1
+GraphicsSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_Deferred:
+    m_Mode: 1
+    m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0}
+  m_DeferredReflections:
+    m_Mode: 1
+    m_Shader: {fileID: 74, guid: 0000000000000000f000000000000000, type: 0}
+  m_ScreenSpaceShadows:
+    m_Mode: 1
+    m_Shader: {fileID: 64, guid: 0000000000000000f000000000000000, type: 0}
+  m_LegacyDeferred:
+    m_Mode: 1
+    m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0}
+  m_DepthNormals:
+    m_Mode: 1
+    m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0}
+  m_MotionVectors:
+    m_Mode: 1
+    m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0}
+  m_LightHalo:
+    m_Mode: 1
+    m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0}
+  m_LensFlare:
+    m_Mode: 1
+    m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0}
+  m_AlwaysIncludedShaders:
+  - {fileID: 7, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 15104, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 15105, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 15106, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
+  m_PreloadedShaders: []
+  m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
+    type: 0}
+  m_CustomRenderPipeline: {fileID: 0}
+  m_TransparencySortMode: 0
+  m_TransparencySortAxis: {x: 0, y: 0, z: 1}
+  m_DefaultRenderingPath: 1
+  m_DefaultMobileRenderingPath: 1
+  m_TierSettings: []
+  m_LightmapStripping: 0
+  m_FogStripping: 0
+  m_InstancingStripping: 0
+  m_LightmapKeepPlain: 1
+  m_LightmapKeepDirCombined: 1
+  m_LightmapKeepDynamicPlain: 1
+  m_LightmapKeepDynamicDirCombined: 1
+  m_LightmapKeepShadowMask: 1
+  m_LightmapKeepSubtractive: 1
+  m_FogKeepLinear: 1
+  m_FogKeepExp: 1
+  m_FogKeepExp2: 1
+  m_AlbedoSwatchInfos: []
+  m_LightsUseLinearIntensity: 0
+  m_LightsUseColorTemperature: 0

ProjectSettings/InputManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!13 &1
+InputManager:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Axes:
+  - serializedVersion: 3
+    m_Name: Horizontal
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: left
+    positiveButton: right
+    altNegativeButton: a
+    altPositiveButton: d
+    gravity: 3
+    dead: 0.001
+    sensitivity: 3
+    snap: 1
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Vertical
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: down
+    positiveButton: up
+    altNegativeButton: s
+    altPositiveButton: w
+    gravity: 3
+    dead: 0.001
+    sensitivity: 3
+    snap: 1
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire1
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left ctrl
+    altNegativeButton: 
+    altPositiveButton: mouse 0
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire2
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left alt
+    altNegativeButton: 
+    altPositiveButton: mouse 1
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire3
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left shift
+    altNegativeButton: 
+    altPositiveButton: mouse 2
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Jump
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: space
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse X
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse Y
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 1
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse ScrollWheel
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 2
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Horizontal
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0.19
+    sensitivity: 1
+    snap: 0
+    invert: 0
+    type: 2
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Vertical
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0.19
+    sensitivity: 1
+    snap: 0
+    invert: 1
+    type: 2
+    axis: 1
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire1
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 0
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire2
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 1
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire3
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 2
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Jump
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 3
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Submit
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: return
+    altNegativeButton: 
+    altPositiveButton: joystick button 0
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Submit
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: enter
+    altNegativeButton: 
+    altPositiveButton: space
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Cancel
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: escape
+    altNegativeButton: 
+    altPositiveButton: joystick button 1
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0

ProjectSettings/NavMeshAreas.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!126 &1
+NavMeshProjectSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  areas:
+  - name: Walkable
+    cost: 1
+  - name: Not Walkable
+    cost: 1
+  - name: Jump
+    cost: 2
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  m_LastAgentTypeID: -887442657
+  m_Settings:
+  - serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.75
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_SettingNames:
+  - Humanoid

ProjectSettings/NetworkManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!149 &1
+NetworkManager:
+  m_ObjectHideFlags: 0
+  m_DebugLevel: 0
+  m_Sendrate: 15
+  m_AssetToPrefab: {}

ProjectSettings/Physics2DSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!19 &1
+Physics2DSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 3
+  m_Gravity: {x: 0, y: -9.81}
+  m_DefaultMaterial: {fileID: 0}
+  m_VelocityIterations: 8
+  m_PositionIterations: 3
+  m_VelocityThreshold: 1
+  m_MaxLinearCorrection: 0.2
+  m_MaxAngularCorrection: 8
+  m_MaxTranslationSpeed: 100
+  m_MaxRotationSpeed: 360
+  m_BaumgarteScale: 0.2
+  m_BaumgarteTimeOfImpactScale: 0.75
+  m_TimeToSleep: 0.5
+  m_LinearSleepTolerance: 0.01
+  m_AngularSleepTolerance: 2
+  m_DefaultContactOffset: 0.01
+  m_AutoSimulation: 1
+  m_QueriesHitTriggers: 1
+  m_QueriesStartInColliders: 1
+  m_ChangeStopsCallbacks: 0
+  m_CallbacksOnDisable: 1
+  m_AutoSyncTransforms: 1
+  m_AlwaysShowColliders: 0
+  m_ShowColliderSleep: 1
+  m_ShowColliderContacts: 0
+  m_ShowColliderAABB: 0
+  m_ContactArrowScale: 0.2
+  m_ColliderAwakeColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.7529412}
+  m_ColliderAsleepColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.36078432}
+  m_ColliderContactColor: {r: 1, g: 0, b: 1, a: 0.6862745}
+  m_ColliderAABBColor: {r: 1, g: 1, b: 0, a: 0.2509804}
+  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

ProjectSettings/PresetManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1386491679 &1
+PresetManager:
+  m_ObjectHideFlags: 0
+  m_DefaultList:
+  - type:
+      m_NativeTypeID: 108
+      m_ManagedTypePPtr: {fileID: 0}
+      m_ManagedTypeFallback: 
+    defaultPresets:
+    - m_Preset: {fileID: 2655988077585873504, guid: c1cf8506f04ef2c4a88b64b6c4202eea,
+        type: 2}
+  - type:
+      m_NativeTypeID: 1020
+      m_ManagedTypePPtr: {fileID: 0}
+      m_ManagedTypeFallback: 
+    defaultPresets:
+    - m_Preset: {fileID: 2655988077585873504, guid: 0cd792cc87e492d43b4e95b205fc5cc6,
+        type: 2}
+  - type:
+      m_NativeTypeID: 1006
+      m_ManagedTypePPtr: {fileID: 0}
+      m_ManagedTypeFallback: 
+    defaultPresets:
+    - m_Preset: {fileID: 2655988077585873504, guid: 7a99f8aa944efe94cb9bd74562b7d5f9,
+        type: 2}

ProjectSettings/ProjectSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!129 &1
+PlayerSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 15
+  productGUID: 185672378d37543aab87cc6227d7ec22
+  AndroidProfiler: 0
+  AndroidFilterTouchesWhenObscured: 0
+  AndroidEnableSustainedPerformanceMode: 0
+  defaultScreenOrientation: 4
+  targetDevice: 2
+  useOnDemandResources: 0
+  accelerometerFrequency: 60
+  companyName: DefaultCompany
+  productName: test
+  defaultCursor: {fileID: 0}
+  cursorHotspot: {x: 0, y: 0}
+  m_SplashScreenBackgroundColor: {r: 0.13725491, g: 0.12156863, b: 0.1254902, a: 1}
+  m_ShowUnitySplashScreen: 1
+  m_ShowUnitySplashLogo: 1
+  m_SplashScreenOverlayOpacity: 1
+  m_SplashScreenAnimation: 1
+  m_SplashScreenLogoStyle: 1
+  m_SplashScreenDrawMode: 0
+  m_SplashScreenBackgroundAnimationZoom: 1
+  m_SplashScreenLogoAnimationZoom: 1
+  m_SplashScreenBackgroundLandscapeAspect: 1
+  m_SplashScreenBackgroundPortraitAspect: 1
+  m_SplashScreenBackgroundLandscapeUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  m_SplashScreenBackgroundPortraitUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  m_SplashScreenLogos: []
+  m_VirtualRealitySplashScreen: {fileID: 0}
+  m_HolographicTrackingLossScreen: {fileID: 0}
+  defaultScreenWidth: 1024
+  defaultScreenHeight: 768
+  defaultScreenWidthWeb: 960
+  defaultScreenHeightWeb: 600
+  m_StereoRenderingPath: 0
+  m_ActiveColorSpace: 0
+  m_MTRendering: 1
+  m_StackTraceTypes: 010000000100000001000000010000000100000001000000
+  iosShowActivityIndicatorOnLoading: -1
+  androidShowActivityIndicatorOnLoading: -1
+  iosAppInBackgroundBehavior: 0
+  displayResolutionDialog: 1
+  iosAllowHTTPDownload: 1
+  allowedAutorotateToPortrait: 1
+  allowedAutorotateToPortraitUpsideDown: 1
+  allowedAutorotateToLandscapeRight: 1
+  allowedAutorotateToLandscapeLeft: 1
+  useOSAutorotation: 1
+  use32BitDisplayBuffer: 1
+  preserveFramebufferAlpha: 0
+  disableDepthAndStencilBuffers: 0
+  androidBlitType: 0
+  defaultIsNativeResolution: 1
+  macRetinaSupport: 1
+  runInBackground: 1
+  captureSingleScreen: 0
+  muteOtherAudioSources: 0
+  Prepare IOS For Recording: 0
+  Force IOS Speakers When Recording: 0
+  deferSystemGesturesMode: 0
+  hideHomeButton: 0
+  submitAnalytics: 1
+  usePlayerLog: 1
+  bakeCollisionMeshes: 0
+  forceSingleInstance: 0
+  resizableWindow: 0
+  useMacAppStoreValidation: 0
+  macAppStoreCategory: public.app-category.games
+  gpuSkinning: 1
+  graphicsJobs: 0
+  xboxPIXTextureCapture: 0
+  xboxEnableAvatar: 0
+  xboxEnableKinect: 0
+  xboxEnableKinectAutoTracking: 0
+  xboxEnableFitness: 0
+  visibleInBackground: 1
+  allowFullscreenSwitch: 1
+  graphicsJobMode: 0
+  fullscreenMode: 1
+  xboxSpeechDB: 0
+  xboxEnableHeadOrientation: 0
+  xboxEnableGuest: 0
+  xboxEnablePIXSampling: 0
+  metalFramebufferOnly: 0
+  n3dsDisableStereoscopicView: 0
+  n3dsEnableSharedListOpt: 1
+  n3dsEnableVSync: 0
+  xboxOneResolution: 0
+  xboxOneSResolution: 0
+  xboxOneXResolution: 3
+  xboxOneMonoLoggingLevel: 0
+  xboxOneLoggingLevel: 1
+  xboxOneDisableEsram: 0
+  xboxOnePresentImmediateThreshold: 0
+  switchQueueCommandMemory: 0
+  videoMemoryForVertexBuffers: 0
+  psp2PowerMode: 0
+  psp2AcquireBGM: 1
+  vulkanEnableSetSRGBWrite: 0
+  vulkanUseSWCommandBuffers: 0
+  m_SupportedAspectRatios:
+    4:3: 1
+    5:4: 1
+    16:10: 1
+    16:9: 1
+    Others: 1
+  bundleVersion: 0.1
+  preloadedAssets: []
+  metroInputSource: 0
+  wsaTransparentSwapchain: 0
+  m_HolographicPauseOnTrackingLoss: 1
+  xboxOneDisableKinectGpuReservation: 0
+  xboxOneEnable7thCore: 0
+  vrSettings:
+    cardboard:
+      depthFormat: 0
+      enableTransitionView: 0
+    daydream:
+      depthFormat: 0
+      useSustainedPerformanceMode: 0
+      enableVideoLayer: 0
+      useProtectedVideoMemory: 0
+      minimumSupportedHeadTracking: 0
+      maximumSupportedHeadTracking: 1
+    hololens:
+      depthFormat: 1
+      depthBufferSharingEnabled: 0
+    oculus:
+      sharedDepthBuffer: 0
+      dashSupport: 0
+    enable360StereoCapture: 0
+  protectGraphicsMemory: 0
+  useHDRDisplay: 0
+  m_ColorGamuts: 00000000
+  targetPixelDensity: 30
+  resolutionScalingMode: 0
+  androidSupportedAspectRatio: 1
+  androidMaxAspectRatio: 2.1
+  applicationIdentifier: {}
+  buildNumber: {}
+  AndroidBundleVersionCode: 1
+  AndroidMinSdkVersion: 16
+  AndroidTargetSdkVersion: 0
+  AndroidPreferredInstallLocation: 1
+  aotOptions: 
+  stripEngineCode: 1
+  iPhoneStrippingLevel: 0
+  iPhoneScriptCallOptimization: 0
+  ForceInternetPermission: 0
+  ForceSDCardPermission: 0
+  CreateWallpaper: 0
+  APKExpansionFiles: 0
+  keepLoadedShadersAlive: 0
+  StripUnusedMeshComponents: 1
+  VertexChannelCompressionMask: 4054
+  iPhoneSdkVersion: 988
+  iOSTargetOSVersionString: 8.0
+  tvOSSdkVersion: 0
+  tvOSRequireExtendedGameController: 0
+  tvOSTargetOSVersionString: 9.0
+  uIPrerenderedIcon: 0
+  uIRequiresPersistentWiFi: 0
+  uIRequiresFullScreen: 1
+  uIStatusBarHidden: 1
+  uIExitOnSuspend: 0
+  uIStatusBarStyle: 0
+  iPhoneSplashScreen: {fileID: 0}
+  iPhoneHighResSplashScreen: {fileID: 0}
+  iPhoneTallHighResSplashScreen: {fileID: 0}
+  iPhone47inSplashScreen: {fileID: 0}
+  iPhone55inPortraitSplashScreen: {fileID: 0}
+  iPhone55inLandscapeSplashScreen: {fileID: 0}
+  iPhone58inPortraitSplashScreen: {fileID: 0}
+  iPhone58inLandscapeSplashScreen: {fileID: 0}
+  iPadPortraitSplashScreen: {fileID: 0}
+  iPadHighResPortraitSplashScreen: {fileID: 0}
+  iPadLandscapeSplashScreen: {fileID: 0}
+  iPadHighResLandscapeSplashScreen: {fileID: 0}
+  appleTVSplashScreen: {fileID: 0}
+  appleTVSplashScreen2x: {fileID: 0}
+  tvOSSmallIconLayers: []
+  tvOSSmallIconLayers2x: []
+  tvOSLargeIconLayers: []
+  tvOSLargeIconLayers2x: []
+  tvOSTopShelfImageLayers: []
+  tvOSTopShelfImageLayers2x: []
+  tvOSTopShelfImageWideLayers: []
+  tvOSTopShelfImageWideLayers2x: []
+  iOSLaunchScreenType: 0
+  iOSLaunchScreenPortrait: {fileID: 0}
+  iOSLaunchScreenLandscape: {fileID: 0}
+  iOSLaunchScreenBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreenFillPct: 100
+  iOSLaunchScreenSize: 100
+  iOSLaunchScreenCustomXibPath: 
+  iOSLaunchScreeniPadType: 0
+  iOSLaunchScreeniPadImage: {fileID: 0}
+  iOSLaunchScreeniPadBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreeniPadFillPct: 100
+  iOSLaunchScreeniPadSize: 100
+  iOSLaunchScreeniPadCustomXibPath: 
+  iOSUseLaunchScreenStoryboard: 0
+  iOSLaunchScreenCustomStoryboardPath: 
+  iOSDeviceRequirements: []
+  iOSURLSchemes: []
+  iOSBackgroundModes: 0
+  iOSMetalForceHardShadows: 0
+  metalEditorSupport: 1
+  metalAPIValidation: 1
+  iOSRenderExtraFrameOnPause: 0
+  appleDeveloperTeamID: 
+  iOSManualSigningProvisioningProfileID: 
+  tvOSManualSigningProvisioningProfileID: 
+  iOSManualSigningProvisioningProfileType: 0
+  tvOSManualSigningProvisioningProfileType: 0
+  appleEnableAutomaticSigning: 0
+  iOSRequireARKit: 0
+  appleEnableProMotion: 0
+  vulkanEditorSupport: 0
+  clonedFromGUID: c0afd0d1d80e3634a9dac47e8a0426ea
+  templatePackageId: com.unity.3d@1.0.2
+  templateDefaultScene: Assets/Scenes/SampleScene.unity
+  AndroidTargetArchitectures: 5
+  AndroidSplashScreenScale: 0
+  androidSplashScreen: {fileID: 0}
+  AndroidKeystoreName: 
+  AndroidKeyaliasName: 
+  AndroidBuildApkPerCpuArchitecture: 0
+  AndroidTVCompatibility: 1
+  AndroidIsGame: 1
+  AndroidEnableTango: 0
+  androidEnableBanner: 1
+  androidUseLowAccuracyLocation: 0
+  m_AndroidBanners:
+  - width: 320
+    height: 180
+    banner: {fileID: 0}
+  androidGamepadSupportLevel: 0
+  resolutionDialogBanner: {fileID: 0}
+  m_BuildTargetIcons: []
+  m_BuildTargetPlatformIcons: []
+  m_BuildTargetBatching:
+  - m_BuildTarget: Standalone
+    m_StaticBatching: 1
+    m_DynamicBatching: 0
+  - m_BuildTarget: tvOS
+    m_StaticBatching: 1
+    m_DynamicBatching: 0
+  - m_BuildTarget: Android
+    m_StaticBatching: 1
+    m_DynamicBatching: 0
+  - m_BuildTarget: iPhone
+    m_StaticBatching: 1
+    m_DynamicBatching: 0
+  - m_BuildTarget: WebGL
+    m_StaticBatching: 0
+    m_DynamicBatching: 0
+  m_BuildTargetGraphicsAPIs:
+  - m_BuildTarget: AndroidPlayer
+    m_APIs: 0b00000015000000
+    m_Automatic: 1
+  - m_BuildTarget: iOSSupport
+    m_APIs: 10000000
+    m_Automatic: 1
+  - m_BuildTarget: AppleTVSupport
+    m_APIs: 10000000
+    m_Automatic: 0
+  - m_BuildTarget: WebGLSupport
+    m_APIs: 0b000000
+    m_Automatic: 1
+  m_BuildTargetVRSettings:
+  - m_BuildTarget: Standalone
+    m_Enabled: 0
+    m_Devices:
+    - Oculus
+    - OpenVR
+  m_BuildTargetEnableVuforiaSettings: []
+  openGLRequireES31: 0
+  openGLRequireES31AEP: 0
+  m_TemplateCustomTags: {}
+  mobileMTRendering:
+    Android: 1
+    iPhone: 1
+    tvOS: 1
+  m_BuildTargetGroupLightmapEncodingQuality: []
+  m_BuildTargetGroupLightmapSettings: []
+  playModeTestRunnerEnabled: 0
+  runPlayModeTestAsEditModeTest: 0
+  actionOnDotNetUnhandledException: 1
+  enableInternalProfiler: 0
+  logObjCUncaughtExceptions: 1
+  enableCrashReportAPI: 0
+  cameraUsageDescription: 
+  locationUsageDescription: 
+  microphoneUsageDescription: 
+  switchNetLibKey: 
+  switchSocketMemoryPoolSize: 6144
+  switchSocketAllocatorPoolSize: 128
+  switchSocketConcurrencyLimit: 14
+  switchScreenResolutionBehavior: 2
+  switchUseCPUProfiler: 0
+  switchApplicationID: 0x01004b9000490000
+  switchNSODependencies: 
+  switchTitleNames_0: 
+  switchTitleNames_1: 
+  switchTitleNames_2: 
+  switchTitleNames_3: 
+  switchTitleNames_4: 
+  switchTitleNames_5: 
+  switchTitleNames_6: 
+  switchTitleNames_7: 
+  switchTitleNames_8: 
+  switchTitleNames_9: 
+  switchTitleNames_10: 
+  switchTitleNames_11: 
+  switchTitleNames_12: 
+  switchTitleNames_13: 
+  switchTitleNames_14: 
+  switchPublisherNames_0: 
+  switchPublisherNames_1: 
+  switchPublisherNames_2: 
+  switchPublisherNames_3: 
+  switchPublisherNames_4: 
+  switchPublisherNames_5: 
+  switchPublisherNames_6: 
+  switchPublisherNames_7: 
+  switchPublisherNames_8: 
+  switchPublisherNames_9: 
+  switchPublisherNames_10: 
+  switchPublisherNames_11: 
+  switchPublisherNames_12: 
+  switchPublisherNames_13: 
+  switchPublisherNames_14: 
+  switchIcons_0: {fileID: 0}
+  switchIcons_1: {fileID: 0}
+  switchIcons_2: {fileID: 0}
+  switchIcons_3: {fileID: 0}
+  switchIcons_4: {fileID: 0}
+  switchIcons_5: {fileID: 0}
+  switchIcons_6: {fileID: 0}
+  switchIcons_7: {fileID: 0}
+  switchIcons_8: {fileID: 0}
+  switchIcons_9: {fileID: 0}
+  switchIcons_10: {fileID: 0}
+  switchIcons_11: {fileID: 0}
+  switchIcons_12: {fileID: 0}
+  switchIcons_13: {fileID: 0}
+  switchIcons_14: {fileID: 0}
+  switchSmallIcons_0: {fileID: 0}
+  switchSmallIcons_1: {fileID: 0}
+  switchSmallIcons_2: {fileID: 0}
+  switchSmallIcons_3: {fileID: 0}
+  switchSmallIcons_4: {fileID: 0}
+  switchSmallIcons_5: {fileID: 0}
+  switchSmallIcons_6: {fileID: 0}
+  switchSmallIcons_7: {fileID: 0}
+  switchSmallIcons_8: {fileID: 0}
+  switchSmallIcons_9: {fileID: 0}
+  switchSmallIcons_10: {fileID: 0}
+  switchSmallIcons_11: {fileID: 0}
+  switchSmallIcons_12: {fileID: 0}
+  switchSmallIcons_13: {fileID: 0}
+  switchSmallIcons_14: {fileID: 0}
+  switchManualHTML: 
+  switchAccessibleURLs: 
+  switchLegalInformation: 
+  switchMainThreadStackSize: 1048576
+  switchPresenceGroupId: 
+  switchLogoHandling: 0
+  switchReleaseVersion: 0
+  switchDisplayVersion: 1.0.0
+  switchStartupUserAccount: 0
+  switchTouchScreenUsage: 0
+  switchSupportedLanguagesMask: 0
+  switchLogoType: 0
+  switchApplicationErrorCodeCategory: 
+  switchUserAccountSaveDataSize: 0
+  switchUserAccountSaveDataJournalSize: 0
+  switchApplicationAttribute: 0
+  switchCardSpecSize: -1
+  switchCardSpecClock: -1
+  switchRatingsMask: 0
+  switchRatingsInt_0: 0
+  switchRatingsInt_1: 0
+  switchRatingsInt_2: 0
+  switchRatingsInt_3: 0
+  switchRatingsInt_4: 0
+  switchRatingsInt_5: 0
+  switchRatingsInt_6: 0
+  switchRatingsInt_7: 0
+  switchRatingsInt_8: 0
+  switchRatingsInt_9: 0
+  switchRatingsInt_10: 0
+  switchRatingsInt_11: 0
+  switchLocalCommunicationIds_0: 
+  switchLocalCommunicationIds_1: 
+  switchLocalCommunicationIds_2: 
+  switchLocalCommunicationIds_3: 
+  switchLocalCommunicationIds_4: 
+  switchLocalCommunicationIds_5: 
+  switchLocalCommunicationIds_6: 
+  switchLocalCommunicationIds_7: 
+  switchParentalControl: 0
+  switchAllowsScreenshot: 1
+  switchAllowsVideoCapturing: 1
+  switchAllowsRuntimeAddOnContentInstall: 0
+  switchDataLossConfirmation: 0
+  switchSupportedNpadStyles: 3
+  switchNativeFsCacheSize: 32
+  switchIsHoldTypeHorizontal: 0
+  switchSupportedNpadCount: 8
+  switchSocketConfigEnabled: 0
+  switchTcpInitialSendBufferSize: 32
+  switchTcpInitialReceiveBufferSize: 64
+  switchTcpAutoSendBufferSizeMax: 256
+  switchTcpAutoReceiveBufferSizeMax: 256
+  switchUdpSendBufferSize: 9
+  switchUdpReceiveBufferSize: 42
+  switchSocketBufferEfficiency: 4
+  switchSocketInitializeEnabled: 1
+  switchNetworkInterfaceManagerInitializeEnabled: 1
+  switchPlayerConnectionEnabled: 1
+  ps4NPAgeRating: 12
+  ps4NPTitleSecret: 
+  ps4NPTrophyPackPath: 
+  ps4ParentalLevel: 11
+  ps4ContentID: ED1633-NPXX51362_00-0000000000000000
+  ps4Category: 0
+  ps4MasterVersion: 01.00
+  ps4AppVersion: 01.00
+  ps4AppType: 0
+  ps4ParamSfxPath: 
+  ps4VideoOutPixelFormat: 0
+  ps4VideoOutInitialWidth: 1920
+  ps4VideoOutBaseModeInitialWidth: 1920
+  ps4VideoOutReprojectionRate: 60
+  ps4PronunciationXMLPath: 
+  ps4PronunciationSIGPath: 
+  ps4BackgroundImagePath: 
+  ps4StartupImagePath: 
+  ps4StartupImagesFolder: 
+  ps4IconImagesFolder: 
+  ps4SaveDataImagePath: 
+  ps4SdkOverride: 
+  ps4BGMPath: 
+  ps4ShareFilePath: 
+  ps4ShareOverlayImagePath: 
+  ps4PrivacyGuardImagePath: 
+  ps4NPtitleDatPath: 
+  ps4RemotePlayKeyAssignment: -1
+  ps4RemotePlayKeyMappingDir: 
+  ps4PlayTogetherPlayerCount: 0
+  ps4EnterButtonAssignment: 1
+  ps4ApplicationParam1: 0
+  ps4ApplicationParam2: 0
+  ps4ApplicationParam3: 0
+  ps4ApplicationParam4: 0
+  ps4DownloadDataSize: 0
+  ps4GarlicHeapSize: 2048
+  ps4ProGarlicHeapSize: 2560
+  ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ
+  ps4pnSessions: 1
+  ps4pnPresence: 1
+  ps4pnFriends: 1
+  ps4pnGameCustomData: 1
+  playerPrefsSupport: 0
+  enableApplicationExit: 0
+  restrictedAudioUsageRights: 0
+  ps4UseResolutionFallback: 0
+  ps4ReprojectionSupport: 0
+  ps4UseAudio3dBackend: 0
+  ps4SocialScreenEnabled: 0
+  ps4ScriptOptimizationLevel: 0
+  ps4Audio3dVirtualSpeakerCount: 14
+  ps4attribCpuUsage: 0
+  ps4PatchPkgPath: 
+  ps4PatchLatestPkgPath: 
+  ps4PatchChangeinfoPath: 
+  ps4PatchDayOne: 0
+  ps4attribUserManagement: 0
+  ps4attribMoveSupport: 0
+  ps4attrib3DSupport: 0
+  ps4attribShareSupport: 0
+  ps4attribExclusiveVR: 0
+  ps4disableAutoHideSplash: 0
+  ps4videoRecordingFeaturesUsed: 0
+  ps4contentSearchFeaturesUsed: 0
+  ps4attribEyeToEyeDistanceSettingVR: 0
+  ps4IncludedModules: []
+  monoEnv: 
+  psp2Splashimage: {fileID: 0}
+  psp2NPTrophyPackPath: 
+  psp2NPSupportGBMorGJP: 0
+  psp2NPAgeRating: 12
+  psp2NPTitleDatPath: 
+  psp2NPCommsID: 
+  psp2NPCommunicationsID: 
+  psp2NPCommsPassphrase: 
+  psp2NPCommsSig: 
+  psp2ParamSfxPath: 
+  psp2ManualPath: 
+  psp2LiveAreaGatePath: 
+  psp2LiveAreaBackroundPath: 
+  psp2LiveAreaPath: 
+  psp2LiveAreaTrialPath: 
+  psp2PatchChangeInfoPath: 
+  psp2PatchOriginalPackage: 
+  psp2PackagePassword: F69AzBlax3CF3EDNhm3soLBPh71Yexui
+  psp2KeystoneFile: 
+  psp2MemoryExpansionMode: 0
+  psp2DRMType: 0
+  psp2StorageType: 0
+  psp2MediaCapacity: 0
+  psp2DLCConfigPath: 
+  psp2ThumbnailPath: 
+  psp2BackgroundPath: 
+  psp2SoundPath: 
+  psp2TrophyCommId: 
+  psp2TrophyPackagePath: 
+  psp2PackagedResourcesPath: 
+  psp2SaveDataQuota: 10240
+  psp2ParentalLevel: 1
+  psp2ShortTitle: Not Set
+  psp2ContentID: IV0000-ABCD12345_00-0123456789ABCDEF
+  psp2Category: 0
+  psp2MasterVersion: 01.00
+  psp2AppVersion: 01.00
+  psp2TVBootMode: 0
+  psp2EnterButtonAssignment: 2
+  psp2TVDisableEmu: 0
+  psp2AllowTwitterDialog: 1
+  psp2Upgradable: 0
+  psp2HealthWarning: 0
+  psp2UseLibLocation: 0
+  psp2InfoBarOnStartup: 0
+  psp2InfoBarColor: 0
+  psp2ScriptOptimizationLevel: 0
+  splashScreenBackgroundSourceLandscape: {fileID: 0}
+  splashScreenBackgroundSourcePortrait: {fileID: 0}
+  spritePackerPolicy: 
+  webGLMemorySize: 256
+  webGLExceptionSupport: 1
+  webGLNameFilesAsHashes: 0
+  webGLDataCaching: 1
+  webGLDebugSymbols: 0
+  webGLEmscriptenArgs: 
+  webGLModulesDirectory: 
+  webGLTemplate: APPLICATION:Default
+  webGLAnalyzeBuildSize: 0
+  webGLUseEmbeddedResources: 0
+  webGLCompressionFormat: 1
+  webGLLinkerTarget: 1
+  scriptingDefineSymbols:
+    1: PowerUI
+  platformArchitecture: {}
+  scriptingBackend: {}
+  il2cppCompilerConfiguration: {}
+  incrementalIl2cppBuild: {}
+  allowUnsafeCode: 0
+  additionalIl2CppArgs: 
+  scriptingRuntimeVersion: 0
+  apiCompatibilityLevelPerPlatform: {}
+  m_RenderingPath: 1
+  m_MobileRenderingPath: 1
+  metroPackageName: Template_3D
+  metroPackageVersion: 
+  metroCertificatePath: 
+  metroCertificatePassword: 
+  metroCertificateSubject: 
+  metroCertificateIssuer: 
+  metroCertificateNotAfter: 0000000000000000
+  metroApplicationDescription: Template_3D
+  wsaImages: {}
+  metroTileShortName: 
+  metroTileShowName: 0
+  metroMediumTileShowName: 0
+  metroLargeTileShowName: 0
+  metroWideTileShowName: 0
+  metroDefaultTileSize: 1
+  metroTileForegroundText: 2
+  metroTileBackgroundColor: {r: 0.13333334, g: 0.17254902, b: 0.21568628, a: 0}
+  metroSplashScreenBackgroundColor: {r: 0.12941177, g: 0.17254902, b: 0.21568628,
+    a: 1}
+  metroSplashScreenUseBackgroundColor: 0
+  platformCapabilities: {}
+  metroFTAName: 
+  metroFTAFileTypes: []
+  metroProtocolName: 
+  metroCompilationOverrides: 1
+  n3dsUseExtSaveData: 0
+  n3dsCompressStaticMem: 1
+  n3dsExtSaveDataNumber: 0x12345
+  n3dsStackSize: 131072
+  n3dsTargetPlatform: 2
+  n3dsRegion: 7
+  n3dsMediaSize: 0
+  n3dsLogoStyle: 3
+  n3dsTitle: GameName
+  n3dsProductCode: 
+  n3dsApplicationId: 0xFF3FF
+  XboxOneProductId: 
+  XboxOneUpdateKey: 
+  XboxOneSandboxId: 
+  XboxOneContentId: 
+  XboxOneTitleId: 
+  XboxOneSCId: 
+  XboxOneGameOsOverridePath: 
+  XboxOnePackagingOverridePath: 
+  XboxOneAppManifestOverridePath: 
+  XboxOneVersion: 1.0.0.0
+  XboxOnePackageEncryption: 0
+  XboxOnePackageUpdateGranularity: 2
+  XboxOneDescription: 
+  XboxOneLanguage:
+  - enus
+  XboxOneCapability: []
+  XboxOneGameRating: {}
+  XboxOneIsContentPackage: 0
+  XboxOneEnableGPUVariability: 0
+  XboxOneSockets: {}
+  XboxOneSplashScreen: {fileID: 0}
+  XboxOneAllowedProductIds: []
+  XboxOnePersistentLocalStorageSize: 0
+  XboxOneXTitleMemory: 8
+  xboxOneScriptCompiler: 0
+  vrEditorSettings:
+    daydream:
+      daydreamIconForeground: {fileID: 0}
+      daydreamIconBackground: {fileID: 0}
+  cloudServicesEnabled:
+    UNet: 1
+  facebookSdkVersion: 7.9.4
+  apiCompatibilityLevel: 2
+  cloudProjectId: 
+  projectName: 
+  organizationId: 
+  cloudEnabled: 0
+  enableNativePlatformBackendsForNewInputSystem: 0
+  disableOldInputManagerSupport: 0

ProjectSettings/ProjectVersion.txt

+m_EditorVersion: 2018.2.0f2

ProjectSettings/QualitySettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!47 &1
+QualitySettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 5
+  m_CurrentQuality: 4
+  m_QualitySettings:
+  - serializedVersion: 2
+    name: Very Low
+    pixelLightCount: 0
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 15
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 1
+    textureQuality: 1
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 0
+    lodBias: 0.3
+    maximumLODLevel: 0
+    particleRaycastBudget: 4
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Low
+    pixelLightCount: 0
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 0
+    lodBias: 0.4
+    maximumLODLevel: 0
+    particleRaycastBudget: 16
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Medium
+    pixelLightCount: 1
+    shadows: 1
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 1
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 1
+    lodBias: 0.7
+    maximumLODLevel: 0
+    particleRaycastBudget: 64
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: High
+    pixelLightCount: 2
+    shadows: 2
+    shadowResolution: 1
+    shadowProjection: 1
+    shadowCascades: 2
+    shadowDistance: 40
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 1
+    antiAliasing: 2
+    softParticles: 0
+    softVegetation: 1
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    vSyncCount: 1
+    lodBias: 1
+    maximumLODLevel: 0
+    particleRaycastBudget: 256
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Very High
+    pixelLightCount: 3
+    shadows: 2
+    shadowResolution: 2
+    shadowProjection: 1
+    shadowCascades: 2
+    shadowDistance: 40
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 4
+    textureQuality: 0
+    anisotropicTextures: 1
+    antiAliasing: 4
+    softParticles: 1
+    softVegetation: 1
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    vSyncCount: 1
+    lodBias: 1.5
+    maximumLODLevel: 0
+    particleRaycastBudget: 1024
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Ultra
+    pixelLightCount: 4
+    shadows: 2
+    shadowResolution: 2
+    shadowProjection: 1
+    shadowCascades: 4
+    shadowDistance: 150
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 4
+    textureQuality: 0
+    anisotropicTextures: 1
+    antiAliasing: 4
+    softParticles: 1
+    softVegetation: 1
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    vSyncCount: 1
+    lodBias: 2
+    maximumLODLevel: 0
+    particleRaycastBudget: 4096
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  m_PerPlatformDefaultQuality:
+    Android: 2
+    Nintendo 3DS: 5
+    Nintendo Switch: 5
+    PS4: 5
+    PSP2: 2
+    Standalone: 5
+    Tizen: 2
+    WebGL: 3
+    WiiU: 5
+    Windows Store Apps: 5
+    XboxOne: 5
+    iPhone: 2
+    tvOS: 2

ProjectSettings/TagManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!78 &1
+TagManager:
+  serializedVersion: 2
+  tags: []
+  layers:
+  - Default
+  - TransparentFX
+  - Ignore Raycast
+  - 
+  - Water
+  - UI
+  - 
+  - 
+  - PostProcessing
+  - PowerUI
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  m_SortingLayers:
+  - name: Default
+    uniqueID: 0
+    locked: 0

ProjectSettings/TimeManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!5 &1
+TimeManager:
+  m_ObjectHideFlags: 0
+  Fixed Timestep: 0.02
+  Maximum Allowed Timestep: 0.1
+  m_TimeScale: 1
+  Maximum Particle Timestep: 0.03

ProjectSettings/UnityConnectSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!310 &1
+UnityConnectSettings:
+  m_ObjectHideFlags: 0
+  m_Enabled: 0
+  m_TestMode: 0
+  m_TestEventUrl: 
+  m_TestConfigUrl: 
+  m_TestInitMode: 0
+  CrashReportingSettings:
+    m_EventUrl: https://perf-events.cloud.unity3d.com/api/events/crashes
+    m_NativeEventUrl: https://perf-events.cloud.unity3d.com/symbolicate
+    m_Enabled: 0
+    m_CaptureEditorExceptions: 1
+  UnityPurchasingSettings:
+    m_Enabled: 0
+    m_TestMode: 0
+  UnityAnalyticsSettings:
+    m_Enabled: 1
+    m_InitializeOnStartup: 1
+    m_TestMode: 0
+    m_TestEventUrl: 
+    m_TestConfigUrl: 
+  UnityAdsSettings:
+    m_Enabled: 0
+    m_InitializeOnStartup: 1
+    m_TestMode: 0
+    m_IosGameId: 
+    m_AndroidGameId: 
+    m_GameIds: {}
+    m_GameId: 
+  PerformanceReportingSettings:
+    m_Enabled: 0