Add MRTK files

Assets/MRTK.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 14be2b90e69d75d4989646c4751e42ba
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 839b0c0b34efe2b499281cde5f00aab6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/ChannelPacker.shader

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+Shader "Hidden/ChannelPacker"
+{
+    Properties
+    {
+        _MetallicMap("Metallic Map", 2D) = "black" {}
+        _MetallicMapChannel("Metallic Map Channel", Int) = 0 // Red.
+        _MetallicUniform("Metallic Uniform", Float) = -0.01
+        _OcclusionMap("Occlusion Map", 2D) = "white" {}
+        _OcclusionMapChannel("Occlusion Map Channel", Int) = 1 // Green.
+        _OcclusionUniform("Occlusion Uniform", Float) = -0.01
+        _EmissionMap("Emission Map", 2D) = "black" {}
+        _EmissionMapChannel("Emission Map Channel", Int) = 4 // RGBAverage.
+        _EmissionUniform("Emission Uniform", Float) = -0.01
+        _SmoothnessMap("Smoothness Map", 2D) = "gray" {}
+        _SmoothnessMapChannel("Smoothness Map Channel", Int) = 3 // Alpha.
+        _SmoothnessUniform("Smoothness Uniform", Float) = -0.01
+    }
+    SubShader
+    {
+        Pass
+        {
+            CGPROGRAM
+
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "UnityCG.cginc"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 vertex : SV_POSITION;
+                float2 uv : TEXCOORD0;
+            };
+
+            sampler2D _MetallicMap;
+            int _MetallicMapChannel;
+            float _MetallicUniform;
+            sampler2D _OcclusionMap;
+            int _OcclusionMapChannel;
+            float _OcclusionUniform;
+            sampler2D _EmissionMap;
+            int _EmissionMapChannel;
+            float _EmissionUniform;
+            sampler2D _SmoothnessMap;
+            int _SmoothnessMapChannel;
+            float _SmoothnessUniform;
+
+            v2f vert(appdata v)
+            {
+                v2f o;
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.uv = v.uv;
+
+                return o;
+            }
+
+            fixed4 ToGrayScale(fixed4 color)
+            {
+                return color.r * 0.21 + color.g * 0.71 + color.b * 0.08;
+            }
+
+            fixed Sample(fixed4 color, int channel, float uniformValue)
+            {
+                if (uniformValue >= 0.0)
+                {
+                    return uniformValue;
+                }
+
+                if (channel == 4)
+                {
+                    return ToGrayScale(color);
+                }
+
+                return color[channel];
+            }
+
+            fixed4 frag(v2f i) : SV_Target
+            {
+                fixed4 output;
+
+                output.r = Sample(tex2D(_MetallicMap, i.uv), _MetallicMapChannel, _MetallicUniform);
+                output.g = Sample(tex2D(_OcclusionMap, i.uv), _OcclusionMapChannel, _OcclusionUniform);
+                output.b = Sample(tex2D(_EmissionMap, i.uv), _EmissionMapChannel, _EmissionUniform);
+                output.a = Sample(tex2D(_SmoothnessMap, i.uv), _SmoothnessMapChannel, _SmoothnessUniform);
+
+                return output;
+            }
+
+            ENDCG
+        }
+    }
+}

Assets/MRTK/Shaders/ChannelPacker.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 72ba6d7b37f51174bb3c7be2acc8fb0d
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/DepthBufferPostProcess.shader

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+Shader "Mixed Reality Toolkit/Depth Buffer Viewer"
+{
+    Properties
+    {
+        _DepthTex("Texture", 2D) = "black" {}
+        _MainTex("Base (RGB)", 2D) = "green" {}
+    }
+
+    SubShader
+    {
+        Pass
+        {
+        CGPROGRAM
+            #pragma vertex vert_img
+            #pragma fragment frag
+
+            #include "UnityCG.cginc"
+
+            uniform sampler2D _MainTex;
+            sampler2D _DepthTex;
+
+            float4 frag(v2f_img i) : COLOR
+            {
+                return Linear01Depth(SAMPLE_DEPTH_TEXTURE(_DepthTex, i.uv));
+            }
+        ENDCG
+        }
+    }
+}

Assets/MRTK/Shaders/DepthBufferPostProcess.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8e3074f33703cbb4186e9b6c2c958fda
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/InstancedColored.shader

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+Shader "Hidden/Instanced-Colored"
+{
+    Properties
+    {
+        _Color("Color", Color) = (1.0, 1.0, 1.0, 1.0)
+        _ZWrite("ZWrite", Int) = 1.0 // On
+        [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("ZTest", Int) = 4.0 // LEqual
+        [Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull", Int) = 0.0 // Off
+    }
+
+    SubShader
+    {
+        Pass
+        {
+            Name "Main"
+            Tags{ "RenderType" = "Opaque" }
+            ZWrite[_ZWrite]
+            ZTest[_ZTest]
+            Cull[_Cull]
+
+            CGPROGRAM
+
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #pragma multi_compile_instancing
+
+            #include "UnityCG.cginc"
+
+            struct appdata_t
+            {
+                fixed4 vertex : POSITION;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                fixed4 vertex : SV_POSITION;
+                fixed4 color : COLOR0;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            float4x4 _ParentLocalToWorldMatrix;
+
+            UNITY_INSTANCING_BUFFER_START(Props)
+            UNITY_DEFINE_INSTANCED_PROP(float4, _Color)
+            UNITY_INSTANCING_BUFFER_END(Props)
+
+            v2f vert(appdata_t v)
+            {
+                v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                o.vertex = mul(UNITY_MATRIX_VP, mul(_ParentLocalToWorldMatrix, mul(unity_ObjectToWorld, float4(v.vertex.xyz, 1.0))));
+                o.color = UNITY_ACCESS_INSTANCED_PROP(Props, _Color);
+
+                return o;
+            }
+
+            fixed4 frag(v2f i) : SV_Target
+            {
+                return i.color;
+            }
+
+            ENDCG
+        }
+    }
+}

Assets/MRTK/Shaders/InstancedColored.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d199a2ca60343bb49ad9a41ddb45a083
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/InvisibleShader.shader

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+Shader "Mixed Reality Toolkit/InvisibleShader" {
+
+	Subshader
+	{
+		Pass
+		{
+			GLSLPROGRAM
+			#ifdef VERTEX
+			void main() {}
+			#endif
+
+			#ifdef FRAGMENT
+			void main() {}
+			#endif
+			ENDGLSL
+		}
+	}
+
+	Subshader
+	{
+		Pass
+		{
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+
+            #include "UnityCG.cginc"
+
+			struct v2f 
+			{
+				fixed4 position : SV_POSITION;
+                UNITY_VERTEX_OUTPUT_STEREO
+			};
+
+			v2f vert(appdata_base v)
+			{
+				v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+				o.position = fixed4(0,0,0,0);
+				return o;
+			}
+
+			fixed4 frag() : COLOR
+			{
+				return fixed4(0,0,0,0);
+			}
+		ENDCG
+		}
+	}
+}

Assets/MRTK/Shaders/InvisibleShader.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 54ea9f30be414d86a7260eceb330c449
+timeCreated: 1510009044
+licenseType: Free
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MRTK.Shaders.sentinel

@@ -0,0 +1 @@
+ver: 2

Assets/MRTK/Shaders/MRTK.Shaders.sentinel.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 05852dd420bb9ec4cb7318bfa529d37c
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MRTK_Wireframe.shader

@@ -0,0 +1,145 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+///
+/// Basic wireframe shader that can be used for rendering spatial mapping meshes.
+///
+Shader "Mixed Reality Toolkit/Wireframe"
+{
+    Properties
+    {
+        // Advanced options.
+        [Enum(RenderingMode)] _Mode("Rendering Mode", Float) = 0                                     // "Opaque"
+        [Enum(CustomRenderingMode)] _CustomMode("Mode", Float) = 0                                   // "Opaque"
+        [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend("Source Blend", Float) = 1                 // "One"
+        [Enum(UnityEngine.Rendering.BlendMode)] _DstBlend("Destination Blend", Float) = 0            // "Zero"
+        [Enum(UnityEngine.Rendering.BlendOp)] _BlendOp("Blend Operation", Float) = 0                 // "Add"
+        [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("Depth Test", Float) = 4                // "LessEqual"
+        [Enum(DepthWrite)] _ZWrite("Depth Write", Float) = 1                                         // "On"
+        _ZOffsetFactor("Depth Offset Factor", Float) = 0                                             // "Zero"
+        _ZOffsetUnits("Depth Offset Units", Float) = 0                                               // "Zero"
+        [Enum(UnityEngine.Rendering.ColorWriteMask)] _ColorWriteMask("Color Write Mask", Float) = 15 // "All"
+        [Enum(UnityEngine.Rendering.CullMode)] _CullMode("Cull Mode", Float) = 2                     // "Back"
+        _RenderQueueOverride("Render Queue Override", Range(-1.0, 5000)) = -1
+
+        _BaseColor("Base color", Color) = (0.0, 0.0, 0.0, 1.0)
+        _WireColor("Wire color", Color) = (1.0, 1.0, 1.0, 1.0)
+        _WireThickness("Wire thickness", Range(0, 800)) = 100
+    }
+    SubShader
+    {
+        Tags { "RenderType" = "Opaque" }
+        Blend[_SrcBlend][_DstBlend]
+        BlendOp[_BlendOp]
+        ZTest[_ZTest]
+        ZWrite[_ZWrite]
+        Cull[_CullMode]
+        Offset[_ZOffsetFactor],[_ZOffsetUnits]
+        ColorMask[_ColorWriteMask]
+
+        Pass
+        {
+            Offset 50, 100
+
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma geometry geom
+            #pragma fragment frag
+
+            #if defined(SHADER_API_D3D11)
+            #pragma target 5.0
+            #endif
+
+            #include "UnityCG.cginc"
+
+            float4 _BaseColor;
+            float4 _WireColor;
+            float _WireThickness;
+
+            // Based on approach described in Shader-Based Wireframe Drawing (2008)
+            // http://orbit.dtu.dk/en/publications/id(13e2122d-bec7-48de-beca-03ce6ea1c3f1).html
+
+            struct v2g
+            {
+                float4 viewPos : SV_POSITION;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            v2g vert(appdata_base v)
+            {
+                UNITY_SETUP_INSTANCE_ID(v);
+                v2g o;
+                o.viewPos = UnityObjectToClipPos(v.vertex);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                return o;
+            }
+
+            // inverseW is to counteract the effect of perspective-correct interpolation so that the lines
+            // look the same thickness regardless of their depth in the scene.
+            struct g2f
+            {
+                float4 viewPos : SV_POSITION;
+                float inverseW : TEXCOORD0;
+                float3 dist : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            [maxvertexcount(3)]
+            void geom(triangle v2g i[3], inout TriangleStream<g2f> triStream)
+            {
+                // Calculate the vectors that define the triangle from the input points.
+                float2 point0 = i[0].viewPos.xy / i[0].viewPos.w;
+                float2 point1 = i[1].viewPos.xy / i[1].viewPos.w;
+                float2 point2 = i[2].viewPos.xy / i[2].viewPos.w;
+
+                // Calculate the area of the triangle.
+                float2 vector0 = point2 - point1;
+                float2 vector1 = point2 - point0;
+                float2 vector2 = point1 - point0;
+                float area = abs(vector1.x * vector2.y - vector1.y * vector2.x);
+
+                float3 distScale[3];
+                distScale[0] = float3(area / length(vector0), 0, 0);
+                distScale[1] = float3(0, area / length(vector1), 0);
+                distScale[2] = float3(0, 0, area / length(vector2));
+
+                float wireScale = 800 - _WireThickness;
+
+                // Output each original vertex with its distance to the opposing line defined
+                // by the other two vertices.
+                g2f o;
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+                [unroll]
+                for (uint idx = 0; idx < 3; ++idx)
+                {
+                   o.viewPos = i[idx].viewPos;
+                   o.inverseW = 1.0 / o.viewPos.w;
+                   o.dist = distScale[idx] * o.viewPos.w * wireScale;
+                   UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(i[idx], o);
+                   triStream.Append(o);
+                }
+            }
+
+            float4 frag(g2f i) : COLOR
+            {
+                // Calculate  minimum distance to one of the triangle lines, making sure to correct
+                // for perspective-correct interpolation.
+                float dist = min(i.dist[0], min(i.dist[1], i.dist[2])) * i.inverseW;
+
+                // Make the intensity of the line very bright along the triangle edges but fall-off very
+                // quickly.
+                float I = exp2(-2 * dist * dist);
+
+                return I * _WireColor + (1 - I) * _BaseColor;
+            }
+            ENDCG
+        }
+    }
+
+    FallBack "Mixed Reality Toolkit/Standard"
+    CustomEditor "Microsoft.MixedReality.Toolkit.Editor.MixedRealityWireframeShaderGUI"
+}

Assets/MRTK/Shaders/MRTK_Wireframe.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5c1653eb4e20b76499141de7bc57c063
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MixedRealityShaderUtils.cginc

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#ifndef MRTK_SHADER_UTILS
+#define MRTK_SHADER_UTILS
+
+#if defined(_CLIPPING_PLANE)
+inline float PointVsPlane(float3 worldPosition, float4 plane)
+{
+    float3 planePosition = plane.xyz * plane.w;
+    return dot(worldPosition - planePosition, plane.xyz);
+}
+#endif
+
+#if defined(_CLIPPING_SPHERE)
+inline float PointVsSphere(float3 worldPosition, float4x4 sphereInverseTransform)
+{
+    return length(mul(sphereInverseTransform, float4(worldPosition, 1.0)).xyz) - 0.5;
+}
+#endif
+
+#if defined(_CLIPPING_BOX)
+inline float PointVsBox(float3 worldPosition, float4x4 boxInverseTransform)
+{
+    float3 distance = abs(mul(boxInverseTransform, float4(worldPosition, 1.0))) - 0.5;
+    return length(max(distance, 0.0)) + min(max(distance.x, max(distance.y, distance.z)), 0.0);
+}
+#endif
+
+
+#endif

Assets/MRTK/Shaders/MixedRealityShaderUtils.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: dfab24eea71ce3745be340d7a24fe8eb
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MixedRealityStandard.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 5bdea20278144b11916d77503ba1467a
+timeCreated: 1519154700
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MixedRealityTextMeshPro.shader

@@ -0,0 +1,377 @@
+// TextMesh Pro copyright © 2021 Unity Technologies ApS
+// Licensed under the Unity Companion License for Unity-dependent projects--see http://www.unity3d.com/legal/licenses/Unity_Companion_License.
+// Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+// MRTK Additions
+// - Single Pass Instanced Stereo Rendering Support
+// - Support for Clipping Primitives (Plane, Sphere, Box)
+// - ZWrite Property
+
+Shader "Mixed Reality Toolkit/TextMeshPro" {
+
+Properties {
+    _FaceColor            ("Face Color", Color) = (1,1,1,1)
+    _FaceDilate            ("Face Dilate", Range(-1,1)) = 0
+
+    _OutlineColor        ("Outline Color", Color) = (0,0,0,1)
+    _OutlineWidth        ("Outline Thickness", Range(0,1)) = 0
+    _OutlineSoftness    ("Outline Softness", Range(0,1)) = 0
+
+    _UnderlayColor        ("Border Color", Color) = (0,0,0,.5)
+    _UnderlayOffsetX     ("Border OffsetX", Range(-1,1)) = 0
+    _UnderlayOffsetY     ("Border OffsetY", Range(-1,1)) = 0
+    _UnderlayDilate        ("Border Dilate", Range(-1,1)) = 0
+    _UnderlaySoftness     ("Border Softness", Range(0,1)) = 0
+
+    _WeightNormal        ("Weight Normal", float) = 0
+    _WeightBold            ("Weight Bold", float) = .5
+
+    _ShaderFlags        ("Flags", float) = 0
+    _ScaleRatioA        ("Scale RatioA", float) = 1
+    _ScaleRatioB        ("Scale RatioB", float) = 1
+    _ScaleRatioC        ("Scale RatioC", float) = 1
+
+    _MainTex            ("Font Atlas", 2D) = "white" {}
+    _TextureWidth        ("Texture Width", float) = 512
+    _TextureHeight        ("Texture Height", float) = 512
+    _GradientScale        ("Gradient Scale", float) = 5
+    _ScaleX                ("Scale X", float) = 1
+    _ScaleY                ("Scale Y", float) = 1
+    _PerspectiveFilter    ("Perspective Correction", Range(0, 1)) = 0.875
+    _Sharpness            ("Sharpness", Range(-1,1)) = 0
+
+    _VertexOffsetX        ("Vertex OffsetX", float) = 0
+    _VertexOffsetY        ("Vertex OffsetY", float) = 0
+
+    _ClipRect            ("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+    _MaskSoftnessX        ("Mask SoftnessX", float) = 0
+    _MaskSoftnessY        ("Mask SoftnessY", float) = 0
+    
+    _StencilComp        ("Stencil Comparison", Float) = 8
+    _Stencil            ("Stencil ID", Float) = 0
+    _StencilOp            ("Stencil Operation", Float) = 0
+    _StencilWriteMask    ("Stencil Write Mask", Float) = 255
+    _StencilReadMask    ("Stencil Read Mask", Float) = 255
+    
+    _ColorMask            ("Color Mask", Float) = 15
+    _ZWrite             ("Depth Write", Float) = 0
+}
+
+SubShader {
+    Tags 
+    {
+        "Queue"="Transparent"
+        "IgnoreProjector"="True"
+        "RenderType"="Transparent"
+    }
+
+
+    Stencil
+    {
+        Ref [_Stencil]
+        Comp [_StencilComp]
+        Pass [_StencilOp] 
+        ReadMask [_StencilReadMask]
+        WriteMask [_StencilWriteMask]
+    }
+
+    Cull [_CullMode]
+    ZWrite[_ZWrite]
+    Lighting Off
+    Fog { Mode Off }
+    ZTest [unity_GUIZTestMode]
+    Blend One OneMinusSrcAlpha
+    ColorMask [_ColorMask]
+
+    Pass {
+        CGPROGRAM
+        #pragma vertex VertShader
+        #pragma fragment PixShader
+        #pragma shader_feature __ OUTLINE_ON
+        #pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+        #pragma multi_compile __ UNITY_UI_CLIP_RECT
+        #pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+        #pragma multi_compile __ _CLIPPING_PLANE _CLIPPING_SPHERE _CLIPPING_BOX
+
+        #include "UnityCG.cginc"
+        #include "UnityUI.cginc"
+        #include "MixedRealityShaderUtils.cginc"
+
+#if defined(_CLIPPING_PLANE) || defined(_CLIPPING_SPHERE) || defined(_CLIPPING_BOX)
+        #define _CLIPPING_PRIMITIVE
+#else
+        #undef _CLIPPING_PRIMITIVE
+#endif
+
+        // Direct include for portability.
+        //#include "TMPro_Properties.cginc"
+        // UI Editable properties
+        uniform sampler2D    _FaceTex;                    // Alpha : Signed Distance
+        uniform float        _FaceUVSpeedX;
+        uniform float        _FaceUVSpeedY;
+        uniform fixed4        _FaceColor;                    // RGBA : Color + Opacity
+        uniform float        _FaceDilate;                // v[ 0, 1]
+        uniform float        _OutlineSoftness;            // v[ 0, 1]
+        
+        uniform sampler2D    _OutlineTex;                // RGBA : Color + Opacity
+        uniform float        _OutlineUVSpeedX;
+        uniform float        _OutlineUVSpeedY;
+        uniform fixed4        _OutlineColor;                // RGBA : Color + Opacity
+        uniform float        _OutlineWidth;                // v[ 0, 1]
+        
+        uniform float        _Bevel;                        // v[ 0, 1]
+        uniform float        _BevelOffset;                // v[-1, 1]
+        uniform float        _BevelWidth;                // v[-1, 1]
+        uniform float        _BevelClamp;                // v[ 0, 1]
+        uniform float        _BevelRoundness;            // v[ 0, 1]
+        
+        uniform sampler2D    _BumpMap;                    // Normal map
+        uniform float        _BumpOutline;                // v[ 0, 1]
+        uniform float        _BumpFace;                    // v[ 0, 1]
+        
+        uniform samplerCUBE    _Cube;                        // Cube / sphere map
+        uniform fixed4         _ReflectFaceColor;            // RGB intensity
+        uniform fixed4        _ReflectOutlineColor;
+        uniform float3      _EnvMatrixRotation;
+        uniform float4x4    _EnvMatrix;
+        
+        uniform fixed4        _SpecularColor;                // RGB intensity
+        uniform float        _LightAngle;                // v[ 0,Tau]
+        uniform float        _SpecularPower;                // v[ 0, 1]
+        uniform float        _Reflectivity;                // v[ 5, 15]
+        uniform float        _Diffuse;                    // v[ 0, 1]
+        uniform float        _Ambient;                    // v[ 0, 1]
+        
+        uniform fixed4        _UnderlayColor;                // RGBA : Color + Opacity
+        uniform float        _UnderlayOffsetX;            // v[-1, 1]
+        uniform float        _UnderlayOffsetY;            // v[-1, 1]
+        uniform float        _UnderlayDilate;            // v[-1, 1]
+        uniform float        _UnderlaySoftness;            // v[ 0, 1]
+        
+        uniform fixed4         _GlowColor;                    // RGBA : Color + Intensity
+        uniform float         _GlowOffset;                // v[-1, 1]
+        uniform float         _GlowOuter;                    // v[ 0, 1]
+        uniform float         _GlowInner;                    // v[ 0, 1]
+        uniform float         _GlowPower;                    // v[ 1, 1/(1+4*4)]
+        
+        // API Editable properties
+        uniform float         _ShaderFlags;
+        uniform float        _WeightNormal;
+        uniform float        _WeightBold;
+        
+        uniform float        _ScaleRatioA;
+        uniform float        _ScaleRatioB;
+        uniform float        _ScaleRatioC;
+        
+        uniform float        _VertexOffsetX;
+        uniform float        _VertexOffsetY;
+        
+        uniform float        _MaskID;
+        uniform sampler2D    _MaskTex;
+        uniform float4        _MaskCoord;
+        uniform float4        _ClipRect;    // bottom left(x,y) : top right(z,w)
+        
+        uniform float        _MaskSoftnessX;
+        uniform float        _MaskSoftnessY;
+        
+        // Font Atlas properties
+        uniform sampler2D    _MainTex;
+        uniform float        _TextureWidth;
+        uniform float        _TextureHeight;
+        uniform float         _GradientScale;
+        uniform float        _ScaleX;
+        uniform float        _ScaleY;
+        uniform float        _PerspectiveFilter;
+        uniform float        _Sharpness;
+
+#if defined(_CLIPPING_PLANE)
+        fixed _ClipPlaneSide;
+        float4 _ClipPlane;
+#endif
+
+#if defined(_CLIPPING_SPHERE)
+        fixed _ClipSphereSide;
+        float4x4 _ClipSphereInverseTransform;
+#endif
+
+#if defined(_CLIPPING_BOX)
+        fixed _ClipBoxSide;
+        float4x4 _ClipBoxInverseTransform;
+#endif
+
+        struct vertex_t {
+            UNITY_VERTEX_INPUT_INSTANCE_ID
+            float4    vertex            : POSITION;
+            float3    normal            : NORMAL;
+            fixed4    color            : COLOR;
+            float2    texcoord0        : TEXCOORD0;
+            float2    texcoord1        : TEXCOORD1;
+        };
+
+        struct pixel_t {
+            UNITY_VERTEX_INPUT_INSTANCE_ID
+            UNITY_VERTEX_OUTPUT_STEREO
+            float4    vertex            : SV_POSITION;
+            fixed4    faceColor        : COLOR;
+            fixed4    outlineColor    : COLOR1;
+            float4    texcoord0        : TEXCOORD0;            // Texture UV, Mask UV
+            half4    param            : TEXCOORD1;            // Scale(x), BiasIn(y), BiasOut(z), Bias(w)
+            half4    mask            : TEXCOORD2;            // Position in clip space(xy), Softness(zw)
+            #if (UNDERLAY_ON | UNDERLAY_INNER)
+            float4    texcoord1        : TEXCOORD3;            // Texture UV, alpha, reserved
+            half2    underlayParam    : TEXCOORD4;            // Scale(x), Bias(y)
+            #endif
+#if defined(_CLIPPING_PRIMITIVE)
+            float3 worldPosition    : TEXCOORD5;
+#endif
+        };
+
+
+        pixel_t VertShader(vertex_t input)
+        {
+            pixel_t output;
+
+            UNITY_INITIALIZE_OUTPUT(pixel_t, output);
+            UNITY_SETUP_INSTANCE_ID(input);
+            UNITY_TRANSFER_INSTANCE_ID(input, output);
+            UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+            
+            float bold = step(input.texcoord1.y, 0);
+
+            float4 vert = input.vertex;
+            vert.x += _VertexOffsetX;
+            vert.y += _VertexOffsetY;
+            float4 vPosition = UnityObjectToClipPos(vert);
+
+            float2 pixelSize = vPosition.w;
+            pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));
+            
+            float scale = rsqrt(dot(pixelSize, pixelSize));
+            scale *= abs(input.texcoord1.y) * _GradientScale * (_Sharpness + 1);
+            if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert)))));
+
+            float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0;
+            weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5;
+
+            float layerScale = scale;
+
+            scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale);
+            float bias = (0.5 - weight) * scale - 0.5;
+            float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale;
+
+            float opacity = input.color.a;
+            #if (UNDERLAY_ON | UNDERLAY_INNER)
+            opacity = 1.0;
+            #endif
+
+            fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor;
+            faceColor.rgb *= faceColor.a;
+
+            fixed4 outlineColor = _OutlineColor;
+            outlineColor.a *= opacity;
+            outlineColor.rgb *= outlineColor.a;
+            outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2))));
+
+            #if (UNDERLAY_ON | UNDERLAY_INNER)
+            layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale);
+            float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale);
+
+            float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth;
+            float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight;
+            float2 layerOffset = float2(x, y);
+            #endif
+
+            // Generate UV for the Masking Texture
+            float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+            float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
+
+            // Populate structure for pixel shader
+            output.vertex = vPosition;
+            output.faceColor = faceColor;
+            output.outlineColor = outlineColor;
+            output.texcoord0 = float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y);
+            output.param = half4(scale, bias - outline, bias + outline, bias);
+            output.mask = half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+            #if (UNDERLAY_ON || UNDERLAY_INNER)
+            output.texcoord1 = float4(input.texcoord0 + layerOffset, input.color.a, 0);
+            output.underlayParam = half2(layerScale, layerBias);
+            #endif
+#if defined(_CLIPPING_PRIMITIVE)
+            output.worldPosition = mul(unity_ObjectToWorld, vert).xyz;
+#endif
+
+            return output;
+        }
+
+
+        // PIXEL SHADER
+        fixed4 PixShader(pixel_t input) : SV_Target
+        {
+            UNITY_SETUP_INSTANCE_ID(input);
+            
+            half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x;
+            half4 c = input.faceColor * saturate(d - input.param.w);
+
+            #ifdef OUTLINE_ON
+            c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z));
+            c *= saturate(d - input.param.y);
+            #endif
+
+            #if UNDERLAY_ON
+            d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+            c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a);
+            #endif
+
+            #if UNDERLAY_INNER
+            half sd = saturate(d - input.param.z);
+            d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+            c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a);
+            #endif
+
+            // Alternative implementation to UnityGet2DClipping with support for softness.
+            #if UNITY_UI_CLIP_RECT
+            half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(input.mask.xy)) * input.mask.zw);
+            c *= m.x * m.y;
+            #endif
+
+            #if (UNDERLAY_ON | UNDERLAY_INNER)
+            c *= input.texcoord1.z;
+            #endif
+
+            // Primitive clipping.
+#if defined(_CLIPPING_PRIMITIVE)
+            float primitiveDistance = 1.0;
+#if defined(_CLIPPING_PLANE)
+            primitiveDistance = min(primitiveDistance, PointVsPlane(input.worldPosition, _ClipPlane) * _ClipPlaneSide);
+#endif
+#if defined(_CLIPPING_SPHERE)
+            primitiveDistance = min(primitiveDistance, PointVsSphere(input.worldPosition, _ClipSphereInverseTransform) * _ClipSphereSide);
+#endif
+#if defined(_CLIPPING_BOX)
+            primitiveDistance = min(primitiveDistance, PointVsBox(input.worldPosition, _ClipBoxInverseTransform) * _ClipBoxSide);
+#endif
+            c *= step(0.0, primitiveDistance);
+#endif
+
+            #if UNITY_UI_ALPHACLIP
+            clip(c.a - 0.001);
+            #endif
+
+            return c;
+        }
+        ENDCG
+    }
+}
+
+CustomEditor "Microsoft.MixedReality.Toolkit.Editor.MixedRealityTextMeshProShaderGUI"
+}

Assets/MRTK/Shaders/MixedRealityTextMeshPro.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1c504b73bf66872479cd1215fb5ce0fe
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/MixedRealityTextMeshProSprite.shader

@@ -0,0 +1,184 @@
+// TextMesh Pro copyright © 2021 Unity Technologies ApS
+// Licensed under the Unity Companion License for Unity-dependent projects--see http://www.unity3d.com/legal/licenses/Unity_Companion_License.
+// Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+// Text Mesh Pro Sprite shader with MRTK Additions
+
+// MRTK Additions
+// - Single Pass Instanced Stereo Rendering Support
+// - Support for Clipping Primitives (Plane, Sphere, Box)
+// - Added to MRTK namespace
+
+Shader "Mixed Reality Toolkit/TextMeshProSprite" {
+
+Properties {
+    _MainTex ("Sprite Texture", 2D) = "white" {}
+    _Color ("Tint", Color) = (1,1,1,1)
+		
+    _StencilComp ("Stencil Comparison", Float) = 8
+    _Stencil ("Stencil ID", Float) = 0
+    _StencilOp ("Stencil Operation", Float) = 0
+    _StencilWriteMask ("Stencil Write Mask", Float) = 255
+    _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+    _CullMode ("Cull Mode", Float) = 0
+	_ColorMask ("Color Mask", Float) = 15
+    _ClipRect ("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+
+    [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+}
+
+SubShader {
+    Tags
+    { 
+        "Queue"="Transparent" 
+        "IgnoreProjector"="True" 
+        "RenderType"="Transparent" 
+        "PreviewType"="Plane"
+        "CanUseSpriteAtlas"="True"
+    }
+		
+    Stencil {
+        Ref [_Stencil]
+        Comp [_StencilComp]
+        Pass [_StencilOp] 
+        ReadMask [_StencilReadMask]
+        WriteMask [_StencilWriteMask]
+    }
+
+    Cull [_CullMode]
+    Lighting Off
+    ZWrite Off
+    ZTest [unity_GUIZTestMode]
+    Blend SrcAlpha OneMinusSrcAlpha
+    ColorMask [_ColorMask]
+
+    Pass {
+        CGPROGRAM
+        #pragma vertex vert
+        #pragma fragment frag
+
+        #pragma multi_compile __ UNITY_UI_CLIP_RECT
+        #pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+        #pragma multi_compile __ _CLIPPING_PLANE _CLIPPING_SPHERE _CLIPPING_BOX
+
+        #include "UnityCG.cginc"
+        #include "UnityUI.cginc"
+        #include "MixedRealityShaderUtils.cginc"
+
+#if defined(_CLIPPING_PLANE) || defined(_CLIPPING_SPHERE) || defined(_CLIPPING_BOX)
+        #define _CLIPPING_PRIMITIVE
+#else
+        #undef _CLIPPING_PRIMITIVE
+#endif
+
+#if defined(_CLIPPING_PLANE)
+        fixed _ClipPlaneSide;
+        float4 _ClipPlane;
+#endif
+
+#if defined(_CLIPPING_SPHERE)
+        fixed _ClipSphereSide;
+        float4x4 _ClipSphereInverseTransform;
+#endif
+
+#if defined(_CLIPPING_BOX)
+        fixed _ClipBoxSide;
+        float4x4 _ClipBoxInverseTransform;
+#endif
+
+        uniform float        _VertexOffsetX;
+        uniform float        _VertexOffsetY;
+
+        struct appdata_t {
+
+        float4 vertex   : POSITION;
+        float4 color    : COLOR;
+        float2 texcoord : TEXCOORD0;
+        UNITY_VERTEX_INPUT_INSTANCE_ID
+        };
+
+        struct v2f {
+
+        float4 vertex   : SV_POSITION;
+        fixed4 color    : COLOR;
+        half2 texcoord  : TEXCOORD0;				
+        float3 worldPosition : TEXCOORD1;
+
+        UNITY_VERTEX_INPUT_INSTANCE_ID
+        UNITY_VERTEX_OUTPUT_STEREO     
+        };
+
+        fixed4 _Color;
+        fixed4 _TextureSampleAdd;
+        float4 _ClipRect;
+
+        v2f vert(appdata_t IN)
+        {
+            v2f OUT;
+
+            UNITY_SETUP_INSTANCE_ID(IN);
+            UNITY_TRANSFER_INSTANCE_ID(IN, OUT);
+            UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+
+            OUT.worldPosition = IN.vertex;
+            OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+
+            OUT.texcoord = IN.texcoord;
+
+            float4 vertin = IN.vertex;
+            vertin.x += _VertexOffsetX;
+            vertin.y += _VertexOffsetY;
+            float4 vPosition = UnityObjectToClipPos(vertin);
+
+#ifdef UNITY_HALF_TEXEL_OFFSET
+            OUT.vertex.xy += (_ScreenParams.zw-1.0)*float2(-1,1);
+#endif
+
+            OUT.color = IN.color * _Color;
+#if defined(_CLIPPING_PRIMITIVE)
+            OUT.worldPosition = mul(unity_ObjectToWorld, vertin).xyz;
+#endif
+
+            return OUT;
+        }
+
+        sampler2D _MainTex; 
+
+        fixed4 frag(v2f IN) : SV_Target
+        {
+            half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+				
+#if UNITY_UI_CLIP_RECT
+            color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+#endif
+
+    // Primitive clipping.
+#if defined(_CLIPPING_PRIMITIVE)
+            float primitiveDistance = 1.0;
+#if defined(_CLIPPING_PLANE)
+            primitiveDistance = min(primitiveDistance, PointVsPlane(IN.worldPosition, _ClipPlane) * _ClipPlaneSide);
+#endif
+#if defined(_CLIPPING_SPHERE)
+            primitiveDistance = min(primitiveDistance, PointVsSphere(IN.worldPosition, _ClipSphereInverseTransform) * _ClipSphereSide);
+#endif
+#if defined(_CLIPPING_BOX)
+            primitiveDistance = min(primitiveDistance, PointVsBox(IN.worldPosition, _ClipBoxInverseTransform) * _ClipBoxSide);
+#endif
+            color *= step(0.0, primitiveDistance);
+#endif
+
+#ifdef UNITY_UI_ALPHACLIP
+            clip (color.a - 0.001);
+#endif
+
+            return color;
+        }
+		ENDCG
+		}
+	}
+}

Assets/MRTK/Shaders/MixedRealityTextMeshProSprite.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: f11fd341db238f342a8b36d23162d67a
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTK/Shaders/Text3DShader.shader

@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// NOTE: MRTK Shaders are versioned via the MRTK.Shaders.sentinel file.
+// When making changes to any shader's source file, the value in the sentinel _must_ be incremented.
+
+///
+/// Basic 3D TextMesh shader with proper z-sorting and culling options.
+///
+Shader "Mixed Reality Toolkit/Text3DShader"
+{
+    Properties
+    {
+        _MainTex("Alpha (A)", 2D) = "white" {}
+        [Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull", Float) = 0
+
+        [HideInInspector] _Color("Main Color", Color) = (1,1,1,1)
+        [HideInInspector] _StencilComp("Stencil Comparison", Float) = 8
+        [HideInInspector] _Stencil("Stencil ID", Float) = 0
+        [HideInInspector] _StencilOp("Stencil Operation", Float) = 0
+        [HideInInspector] _StencilWriteMask("Stencil Write Mask", Float) = 255
+        [HideInInspector] _StencilReadMask("Stencil Read Mask", Float) = 255
+        [HideInInspector] _ColorMask("Color Mask", Float) = 15
+    }
+
+    SubShader
+    {
+        LOD 200
+
+        Tags
+        {
+            "Queue" = "Transparent"
+            "IgnoreProjector" = "True"
+            "RenderType" = "Transparent"
+            "PreviewType" = "Plane"
+        }
+
+        Stencil
+        {
+            Ref[_Stencil]
+            Comp[_StencilComp]
+            Pass[_StencilOp]
+            ReadMask[_StencilReadMask]
+            WriteMask[_StencilWriteMask]
+        }
+
+        Cull[_Cull]
+        Lighting Off
+        ZWrite On
+        ZTest[unity_GUIZTestMode]
+        Offset -1, -1
+        Fog { Mode Off }
+        Blend SrcAlpha OneMinusSrcAlpha
+        ColorMask[_ColorMask]
+
+        Pass
+        {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+                
+            #pragma multi_compile_instancing
+
+            #pragma multi_compile __ _CLIPPING_PLANE _CLIPPING_SPHERE _CLIPPING_BOX                
+
+            #if defined(_CLIPPING_PLANE) || defined(_CLIPPING_SPHERE) || defined(_CLIPPING_BOX)
+                #define _CLIPPING_PRIMITIVE
+            #else
+                #undef _CLIPPING_PRIMITIVE
+            #endif
+
+            #include "UnityCG.cginc"
+            #include "MixedRealityShaderUtils.cginc"
+
+            struct appdata_t
+            {
+                float4 vertex : POSITION;
+                half4 color : COLOR;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                float4 vertex : POSITION;
+                half4 color : COLOR;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+                UNITY_VERTEX_OUTPUT_STEREO
+
+            #if defined(_CLIPPING_PRIMITIVE)
+                float3 worldPosition    : TEXCOORD5;
+            #endif
+            };
+
+
+            sampler2D _MainTex;
+            float4 _MainTex_ST;
+
+            UNITY_INSTANCING_BUFFER_START(Props)
+            UNITY_DEFINE_INSTANCED_PROP(fixed4, _Color)
+        
+        #if defined(_CLIPPING_PLANE)
+            UNITY_DEFINE_INSTANCED_PROP(fixed, _ClipPlaneSide)
+            UNITY_DEFINE_INSTANCED_PROP(float4, _ClipPlane)
+        #endif
+
+        #if defined(_CLIPPING_SPHERE)
+            UNITY_DEFINE_INSTANCED_PROP(fixed, _ClipSphereSide)
+            UNITY_DEFINE_INSTANCED_PROP(float4x4, _ClipSphereInverseTransform)
+        #endif
+
+        #if defined(_CLIPPING_BOX)
+            UNITY_DEFINE_INSTANCED_PROP(fixed, _ClipBoxSide)
+            UNITY_DEFINE_INSTANCED_PROP(float4x4, _ClipBoxInverseTransform)
+        #endif
+
+            UNITY_INSTANCING_BUFFER_END(Props)
+
+            v2f vert(appdata_t v)
+            {
+                v2f o;
+                    
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_TRANSFER_INSTANCE_ID(v, o);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                    
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
+                o.color = v.color;
+
+            #ifdef UNITY_HALF_TEXEL_OFFSET
+                o.vertex.xy += (_ScreenParams.zw - 1.0)*float2(-1,1);
+            #endif
+
+            #if defined(_CLIPPING_PRIMITIVE)
+                o.worldPosition = mul(unity_ObjectToWorld, v.vertex).xyz;
+            #endif
+
+                return o;
+            }
+
+            half4 frag(v2f i) : COLOR
+            {
+                UNITY_SETUP_INSTANCE_ID(i);
+
+                half4 col = i.color;
+                col.a *= tex2D(_MainTex, i.texcoord).a;
+                col = col * UNITY_ACCESS_INSTANCED_PROP(Props, _Color);
+                    
+                // Primitive clipping.
+        #if defined(_CLIPPING_PRIMITIVE)
+                float primitiveDistance = 1.0;
+        #if defined(_CLIPPING_PLANE)
+                fixed clipPlaneSide = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipPlaneSide);
+                float4 clipPlane = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipPlane);
+                primitiveDistance = min(primitiveDistance, PointVsPlane(i.worldPosition.xyz, clipPlane) * clipPlaneSide);
+        #endif
+        #if defined(_CLIPPING_SPHERE)
+                fixed clipSphereSide = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipSphereSide);
+                float4x4 clipSphereInverseTransform = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipSphereInverseTransform);
+                primitiveDistance = min(primitiveDistance, PointVsSphere(i.worldPosition.xyz, clipSphereInverseTransform) * clipSphereSide);
+        #endif
+        #if defined(_CLIPPING_BOX)
+                fixed clipBoxSide = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipBoxSide);
+                float4x4 clipBoxInverseTransform = UNITY_ACCESS_INSTANCED_PROP(Props, _ClipBoxInverseTransform);
+                primitiveDistance = min(primitiveDistance, PointVsBox(i.worldPosition.xyz, clipBoxInverseTransform) * clipBoxSide);
+        #endif
+                col *= step(0.0, primitiveDistance);
+        #endif
+
+                clip(col.a - 0.01);
+                    
+                return col;
+            }
+            ENDCG
+        }
+    }
+    CustomEditor "Microsoft.MixedReality.Toolkit.Editor.Text3DShaderGUI"
+}

Assets/MRTK/Shaders/Text3DShader.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 80c006b91733f1a4991c49af89321ecd
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: