metal tessellation not show correct for wireframe mode

What about this?the wireframe not change when add tessellation.

 

Unity staff is probably going to ask you do submit a bug-report, following the advice given in this document.

If you want to speed things up, it's probably a good idea to submit that bug-report already and post its case number here for UT to pick up.

 

Is tessellation already available...where can i get a tessellation shader ?

 

https://forum.unity.com/threads/unity-5-standart-shader-with-tesselation.318751/
This shader is not supported, it compiles to the folder Not Supported under metal.

 

Did you just not see errors, or did you actually see tessellation happening?

The melt shader works

 

And what asset store package did you test and worked well?
Interested to try some out

 

I’ve only been able to get UnityDistanceBasedTess to work and it doesn’t seem to be generating triangles very smoothly. Below screenshot should be one continuous surface using a height map.

 

Trying the builtin tessellation functions I got very spiky results. Then I tried this https://assetstore.unity.com/packages/vfx/shaders/directx-11/dx11-tessellation-displacement-37322
I used the functions from that to integrate them in my current custom shaders, worked perfectly!

 

anything to share?

 

Maybe someone know what is wrong with this shader. It works on DX11 but doesn't on Metal, and there are no errors and warnings. I was trying to copy constructions from compiled surface shader. For example have changed [domain("tri")] with [UNITY_domain("tri")] etc. But no success. Unfortunatelly I can't use surface shader. I'm trying to port this asset to IOS/OSX: https://assetstore.unity.com/packages/tools/physics/hair-tool-66094

Code (CSharp):

1. Shader "Unlit/TestTess"
2. {
3.     Properties
4.     {
5.         _Tess ("Tessellation", Range(1,32)) = 4
6.         _DiffuseColor ("Diffuse Color", color) = (0.5,0.5,0.5,0.5)
7.  
8.     }
9.     SubShader
10.     {
11.         Tags { "RenderType"="Opaque"  }
12.         LOD 200
13.        
14.         Pass
15.         {
16.             Name "FORWARD"
17.             Tags { "LightMode" = "ForwardBase" }
18.  
19.             CGPROGRAM
20.             #pragma vertex VS
21.             #pragma fragment FS
22. #ifdef UNITY_CAN_COMPILE_TESSELLATION
23.             #pragma hull HS
24.             #pragma domain DS
25. #endif          
26.  
27.             #pragma target 5.0
28.             #pragma multi_compile_fwdbase
29.  
30.             #include "UnityCG.cginc"
31.             #include "Tessellation.cginc"          
32.            
33.             float _Tess;
34.             float4 _DiffuseColor;
35.            
36.             struct APP_OUTPUT
37.             {
38.                 float4 vertex : POSITION;
39.                 float3 normal : NORMAL;
40.             };
41.  
42.             struct VS_OUTPUT
43.             {
44.                 float4 vertex : POSITION;
45.                 float3 normal : NORMAL;
46.             };
47.                        
48.             struct HS_OUTPUT
49.             {
50.                 float4 vertex : POSITION;
51.                 float3 normal : NORMAL;
52.             };
53.            
54.             struct DS_OUTPUT
55.             {
56.                 float4 vertex : POSITION;
57.                 float3 normal : NORMAL;
58.             };
59.            
60. #ifdef UNITY_CAN_COMPILE_TESSELLATION
61.             struct HS_CONSTANT_OUTPUT
62.             {
63.                 float edges[3] : SV_TessFactor;
64.                 float inside : SV_InsideTessFactor;
65.             };
66.            
67.             HS_CONSTANT_OUTPUT HSConst()
68.             {
69.                 HS_CONSTANT_OUTPUT o;
70.                
71.                 o.edges[0] = _Tess;
72.                 o.edges[1] = _Tess;
73.                 o.edges[2] = _Tess;
74.                 o.inside = _Tess;
75.                
76.                 return o;
77.             }
78. #endif
79.             VS_OUTPUT VS (APP_OUTPUT v)
80.             {
81.                 VS_OUTPUT o;
82.                 o.vertex = v.vertex;
83.                 o.normal = v.normal;
84.                 o.vertex = UnityObjectToClipPos(o.vertex);
85.                 return o;
86.             }
87.            
88. #ifdef UNITY_CAN_COMPILE_TESSELLATION
89.            
90.             [UNITY_domain("tri")]
91.             [UNITY_partitioning("fractional_odd")]
92.             [UNITY_outputtopology("triangle_cw")]
93.             [UNITY_outputcontrolpoints(3)]
94.             [UNITY_patchconstantfunc("HSConst")]
95.             HS_OUTPUT HS(InputPatch<VS_OUTPUT, 3> ip, uint id : SV_OutputControlPointID)
96.             {
97.                 HS_OUTPUT o;
98.                 o.vertex = ip[id].vertex;
99.                 o.normal = ip[id].normal;
100.                 return o;
101.             }
102.            
103.  
104.            
105.             [UNITY_domain("tri")]
106.             DS_OUTPUT DS(HS_CONSTANT_OUTPUT input, OutputPatch<HS_OUTPUT, 3> ip, float3 b : SV_DomainLocation)
107.             {
108.                 DS_OUTPUT o;
109.                 o.vertex = ip[0].vertex*b.x + ip[1].vertex*b.y + ip[2].vertex*b.z;
110.                 o.normal = ip[0].normal*b.x + ip[1].normal*b.y + ip[2].normal*b.z;
111.                 o.vertex = UnityObjectToClipPos(o.vertex);
112.  
113.                 return o;
114.             }
115.            
116. #endif
117.             fixed4 FS (DS_OUTPUT i) : SV_Target
118.             {
119.                 float4 col  = float4(1,1,1,1);  
120.  
121.                 return col;
122.             }
123.             ENDCG
124.         }
125.     }
126. }
127.  
128.  

 

Does the shader work on Metal with earlier versions of Unity? If that's the case, then you probably found a regression and it's helpful to submit a bug-report, following the advice from this document.

 

It doesn't, Tesselation on metal has been promiced from Unity 2018.

 

Thanks alot, already find that by investigating compiled surface shader. But actually I need isoline tesselation. Do you plan to support it? Unity just crashes when I use:

[domain("isoline")]
[partitioning("integer")]
[outputtopology("line")]
[outputcontrolpoints(3)]
[patchconstantfunc("HSConst")]
before HullShader

and
[domain("isoline")]
before domain

 

Ok

Ok, I'll report a bug. This is a shader:

Code (CSharp):

1. Shader "Unlit/TestTess"
2. {
3.     Properties
4.     {
5.         _Tess ("Tessellation", Range(1,32)) = 4
6.  
7.     }
8.     SubShader
9.     {
10.         Tags { "RenderType"="Opaque"  }
11.         LOD 200
12.        
13.         Pass
14.         {
15.             Name "FORWARD"
16.             Tags { "LightMode" = "ForwardBase" }
17.  
18.             CGPROGRAM
19.             #pragma vertex VS
20.             #pragma fragment FS
21.             #pragma hull HS
22.             #pragma domain DS
23.  
24.             #pragma target 5.0
25.             #pragma multi_compile_fwdbase
26.  
27.             #include "UnityCG.cginc"
28.             #include "Tessellation.cginc"          
29.            
30.             float _Tess;
31.            
32.             struct APP_OUTPUT
33.             {
34.                 float4 vertex : POSITION;
35.             };
36.  
37.             struct VS_OUTPUT
38.             {
39.                 float4 vertex : INTERNALTESSPOS;
40.             };
41.                        
42.             struct HS_OUTPUT
43.             {
44.                 float4 vertex : INTERNALTESSPOS;
45.             };
46.            
47.             struct DS_OUTPUT
48.             {
49.                 float4 pos : POSITION;
50.             };
51.            
52.             struct HS_CONSTANT_OUTPUT
53.             {
54.                 float edges[2] : SV_TessFactor;
55.             };
56.            
57.                        
58.             VS_OUTPUT VS (APP_OUTPUT v)
59.             {
60.                 VS_OUTPUT o;
61.                 o.vertex = v.vertex;
62.                 return o;
63.             }
64.            
65.             HS_CONSTANT_OUTPUT HSConst()
66.             {
67.                 HS_CONSTANT_OUTPUT o;
68.                
69.                 o.edges[0] = _Tess;
70.                 o.edges[1] = _Tess;
71.                
72.                 return o;
73.             }
74.  
75.             [domain("isoline")]
76.             [partitioning("integer")]
77.             [outputtopology("line")]
78.             [outputcontrolpoints(3)]
79.             [patchconstantfunc("HSConst")]
80.             HS_OUTPUT HS(InputPatch<VS_OUTPUT, 3> v, uint id : SV_OutputControlPointID)
81.             {
82.                 HS_OUTPUT o;
83.                 o.vertex = v[id].vertex;
84.                 return o;
85.             }
86.  
87.             [domain("isoline")]
88.             DS_OUTPUT DS(HS_CONSTANT_OUTPUT tessFactors, OutputPatch<HS_OUTPUT, 3> vi, float2 uv : SV_DomainLocation)
89.             {
90.                 float4 start = lerp(vi[0].vertex, vi[1].vertex, uv.x);
91.  
92.                 float4 vertex = lerp(start, vi[2].vertex, uv.y);
93.  
94.                 DS_OUTPUT o;
95.                 o.pos = UnityObjectToClipPos(vertex);
96.  
97.                 return o;
98.             }      
99.  
100.             fixed4 FS (DS_OUTPUT i) : SV_Target
101.             {
102.                 return fixed4(1,1,1,1);
103.             }
104.             ENDCG
105.         }
106.     }
107. }
108.  
109.