应该在每个渲染通道中重新计算顶点位置吗？

huangapple
go评论90阅读模式
英文:

Should I recalculate vertex position for each pass?

问题

我目前正在学习HLSL和着色器语言，我在想是否应该为每个通道重新计算位置，还是是否有一种绕过的方法，因为我觉得这样做会有很多冗余计算。

下面是问题的示例，在这段代码中，我实例化了许多树形网格，并根据它们的实例ID计算每个树的随机位置。但我必须在前向通道和阴影投射通道中都计算它们的位置。非常感谢您的时间。 (+ 对代码的任何反馈将不胜感激)

  1. Shader "Tree Shader"
  2. {
  3.     CGINCLUDE
  4.     #include "UnityCG.cginc"
  5.     #include "UnityLightingCommon.cginc"
  6.     #pragma vertex vertex_shader
  7.     #pragma fragment fragment_shader
  8.     #pragma target 5.0
  9.     uniform float _Radius;
  10.     uniform float _WaveStartHeight;
  11.     uniform int _InstanceCount;
  12.     uniform sampler2D _MainTex;
  13.     uniform float waveAmount;
  14.     ENDCG
  16.     Properties
  17.     {
  18.         _MainTex("Texture", 2D) = "white" {}
  19.     }
  20.     
  21.     SubShader
  22.     {
  23.         Tags { "IgnoreProjector" = "False" "DisableBatching" = "True" }
  25.         // 前向渲染通道
  26.         Pass
  27.         {
  28.             Tags { "LightMode" = "ForwardBase" }
  29.             Cull Off
  30.             CGPROGRAM
  31.             #pragma multi_compile_fwdbase
  33.             struct APPDATA
  34.             {
  35.                 half4 vertex : POSITION;
  36.                 half2 uv : TEXCOORD0;
  37.                 uint instanceID : SV_InstanceID;
  38.                 half3 normal : NORMAL;
  39.             };
  41.             struct SHADERDATA
  42.             {
  43.                 half4 vertex : SV_POSITION;
  44.                 half2 uv : TEXCOORD0;
  45.                 fixed4 diff : COLOR0;
  46.             };
  48.             half4 ComputeScreenPos(half4 p)
  49.             {
  50.                 half4 o = p * 0.5;
  51.                 return half4(o.x + o.w, o.y * _ProjectionParams.x + o.w, p.zw);
  52.             }
  54.             half3 GenerateRandomPosition(fixed instanceID)
  55.             {
  56.                 half3 position;
  57.                 position.x = frac(sin(dot(half2(instanceID, 12.345), half2(12.345, 67.890))) * 123.456);
  58.                 position.y = frac(sin(dot(half2(instanceID, 98.765), half2(43.210, 9.876))) * 654.321);
  59.                 position.z = frac(sin(dot(half2(instanceID, 0.123), half2(0.987, 6.543))) * 987.654);
  60.                 return position * _Radius;
  61.             }
  63.             SHADERDATA vertex_shader(APPDATA data)
  64.             {
  65.                 SHADERDATA vs;
  66.                 half3 randomPosition = GenerateRandomPosition(data.instanceID);
  67.                 half waveAmount = 0.0;
  69.                 if (data.vertex.y >= _WaveStartHeight)
  70.                 {
  71.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  72.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  73.                     half fade = max(fadeX, fadeZ);
  74.                     fade = saturate(fade * 2.0 - 1.0);
  75.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  76.                 }
  77.                 vs.vertex = mul(UNITY_MATRIX_VP, half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  78.                 vs.uv = data.uv;
  79.                 half3 worldNormal = UnityObjectToWorldNormal(data.normal);
  80.                 half nl = max(0, dot(worldNormal, _WorldSpaceLightPos0.xyz));
  81.                 vs.diff = nl * _LightColor0;
  82.                 vs.diff.rgb += ShadeSH9(half4(worldNormal, 1));
  83.                 return vs;
  84.             }
  86.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  87.             {
  88.                 half4 color = tex2D(_MainTex, ps.uv);
  89.                 return color;
  90.             }
  91.             ENDCG
  92.         }
  93.         
  94.         // 阴影投射通道
  95.         Pass
  96.         {
  97.             Tags { "LightMode" = "ShadowCaster" }
  98.             Cull Off
  99.             ZWrite On
  100.             ZTest LEqual
  101.             Blend Zero One
  103.             CGPROGRAM
  104.             #pragma multi_compile_shadowcaster
  106.             struct APPDATA
  107.             {
  108.                 half4 vertex : POSITION;
  109.                 uint instanceID : SV_InstanceID;
  110.             };
  112.             struct SHADERDATA
  113.             {
  114.                 half4 vertex : SV_POSITION;
  115.             };
  117.             half3 GenerateRandomPosition(fixed instanceID)
  118.             {
  119.                 half3 position;
  120.                 position.x = frac(sin(dot(half2(instanceID, 12.345), half2(12.345, 67.890))) * 123.456);
  121.                 position.y = frac(sin(dot(half2(instanceID, 98.765), half2(43.210, 9.876))) * 654.321);
  122.                 position.z = frac(sin(dot(half2(instanceID, 0.123), half2(0.987, 6.543))) * 987.654);
  123.                 return position * _Radius;
  124.             }
  126.             SHADERDATA vertex_shader(APPDATA data)
  127.             {
  128.                 SHADERDATA vs;
  129.                 half3 randomPosition = GenerateRandomPosition(data.instanceID);
  130.                 half waveAmount = 0.0;
  131.                 if (data.vertex.y >= _WaveStartHeight)
  132.                 {
  133.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  134.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  135.                     half fade = max(fadeX, fadeZ);
  136.                     fade = saturate(fade * 2.0 - 1.0);
  137.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  138.                 }
  139.                 vs.vertex = UnityObjectToClipPos(half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  140.                 return vs;
  141.             }
  143.             half4 fragment_shader() : SV_Target
  144.             {
  145.                 return half4(0, 0, 0, 0);
  146.             }
  147.             ENDCG
  148.         }
  149.     }
  150. }
英文:

im currently learning HLSL and shader language in general, and I was wondering if I should recalculate position for each pass or if there was a way around because it seems to me like a lot of redundant calculation.

Bellow is an exemple of the problem, in this code I instantiate a lot of tree mesh and calculate a random position for each of them based on there instance ID. But I have to calculate there position both in the forward pass and in the shadow casting pass. Thank you in advance for your time. (+ Any feedback on the code would be highly appreciated)

  1. Shader "Tree Shader"
  2. {
  3.     CGINCLUDE
  4.     #include "UnityCG.cginc"
  5.     #include "UnityLightingCommon.cginc"
  6.     #pragma vertex vertex_shader
  7.     #pragma fragment fragment_shader
  8.     #pragma target 5.0
  9.     uniform float _Radius;
  10.     uniform float _WaveStartHeight;
  11.     uniform int _InstanceCount;
  12.     uniform sampler2D _MainTex;
  13.     uniform float waveAmount;
  14.     ENDCG
  16.         Properties
  17.     {
  18.         _MainTex("Texture", 2D) = "white" {}
  19.     }
  20.         SubShader
  21.     {
  22.         Tags { "IgnoreProjector" = "False" "DisableBatching" = "True" }
  24.         // Forward Rendering Pass
  25.         Pass
  26.         {
  27.             Tags { "LightMode" = "ForwardBase" }
  28.             Cull Off
  29.             CGPROGRAM
  30.             #pragma multi_compile_fwdbase
  32.             struct APPDATA
  33.             {
  34.                 half4 vertex : POSITION;
  35.                 half2 uv : TEXCOORD0;
  36.                 uint instanceID : SV_InstanceID;
  37.                 half3 normal : NORMAL;
  38.             };
  40.             struct SHADERDATA
  41.             {
  42.                 half4 vertex : SV_POSITION;
  43.                 half2 uv : TEXCOORD0;
  44.                 fixed4 diff : COLOR0;
  45.             };
  47.             half4 ComputeScreenPos(half4 p)
  48.             {
  49.                 half4 o = p * 0.5;
  50.                 return half4(o.x + o.w, o.y * _ProjectionParams.x + o.w, p.zw);
  51.             }
  53.             half3 GenerateRandomPosition(fixed instanceID)
  54.             {
  55.                 half3 position;
  56.                 position.x = frac(sin(dot(half2(instanceID, 12.345), half2(12.345, 67.890))) * 123.456);
  57.                 position.y = frac(sin(dot(half2(instanceID, 98.765), half2(43.210, 9.876))) * 654.321);
  58.                 position.z = frac(sin(dot(half2(instanceID, 0.123), half2(0.987, 6.543))) * 987.654);
  59.                 return position * _Radius;
  60.             }
  62.             SHADERDATA vertex_shader(APPDATA data)
  63.             {
  64.                 SHADERDATA vs;
  65.                 half3 randomPosition = GenerateRandomPosition(data.instanceID);
  66.                 half waveAmount = 0.0;
  68.                 if (data.vertex.y >= _WaveStartHeight)
  69.                 {
  70.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  71.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  72.                     half fade = max(fadeX, fadeZ);
  73.                     fade = saturate(fade * 2.0 - 1.0);
  74.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  75.                 }
  76.                 vs.vertex = mul(UNITY_MATRIX_VP, half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  77.                 vs.uv = data.uv;
  78.                 half3 worldNormal = UnityObjectToWorldNormal(data.normal);
  79.                 half nl = max(0, dot(worldNormal, _WorldSpaceLightPos0.xyz));
  80.                 vs.diff = nl * _LightColor0;
  81.                 vs.diff.rgb += ShadeSH9(half4(worldNormal, 1));
  82.                 return vs;
  83.             }
  85.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  86.             {
  87.                 half4 color = tex2D(_MainTex, ps.uv);
  88.                 return color;
  89.             }
  90.             ENDCG
  91.         }
  92.         Pass
  93.         {
  94.             Tags { "LightMode" = "ShadowCaster" }
  95.             Cull Off
  96.             ZWrite On
  97.             ZTest LEqual
  98.             Blend Zero One
  100.             CGPROGRAM
  101.             #pragma multi_compile_shadowcaster
  103.             struct APPDATA
  104.             {
  105.                 half4 vertex : POSITION;
  106.                 uint instanceID : SV_InstanceID;
  107.             };
  109.             struct SHADERDATA
  110.             {
  111.                 half4 vertex : SV_POSITION;
  112.             };
  114.             half3 GenerateRandomPosition(fixed instanceID)
  115.             {
  116.                 half3 position;
  117.                 position.x = frac(sin(dot(half2(instanceID, 12.345), half2(12.345, 67.890))) * 123.456);
  118.                 position.y = frac(sin(dot(half2(instanceID, 98.765), half2(43.210, 9.876))) * 654.321);
  119.                 position.z = frac(sin(dot(half2(instanceID, 0.123), half2(0.987, 6.543))) * 987.654);
  120.                 return position * _Radius;
  121.             }
  123.             SHADERDATA vertex_shader(APPDATA data)
  124.             {
  125.                 SHADERDATA vs;
  126.                 half3 randomPosition = GenerateRandomPosition(data.instanceID);
  127.                 half waveAmount = 0.0;
  128.                 if (data.vertex.y >= _WaveStartHeight)
  129.                 {
  130.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  131.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  132.                     half fade = max(fadeX, fadeZ);
  133.                     fade = saturate(fade * 2.0 - 1.0);
  134.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  135.                 }
  136.                 vs.vertex = UnityObjectToClipPos(half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  137.                 return vs;
  138.             }
  140.             half4 fragment_shader() : SV_Target
  141.             {
  142.                 return half4(0, 0, 0, 0);
  143.             }
  144.             ENDCG
  145.         }
  146.     }
  147. }

答案1

得分: 0

如果您想要正确的阴影效果，那么需要重新计算顶点位置。您可以将通用代码提取到SubShader中，并将其包装在CGINCLUDE/ENDCG内。

英文:

If you want correct shadows, then the vertex position recaculation is necessary. You can extract the common code into SubShader and wrap it inside CGINCLUDE/ENDCG.

答案2

得分: 0

我修复了你在评论中粘贴的代码中的错误。

  1. Shader "Tree Shader"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex("Texture", 2D) = "white" {}
  6.     }
  7.     SubShader
  8.     {   
  9.         Tags { "IgnoreProjector" = "False" "DisableBatching" = "True" }
  10.  
  12.         CGINCLUDE
  14.         #include "UnityCG.cginc"
  15.         #include "UnityLightingCommon.cginc"
  16.         struct APPDATA
  17.         {
  18.             half4 vertex : POSITION;
  19.             half2 uv : TEXCOORD0;
  20.             uint instanceID : SV_InstanceID;
  21.             half3 normal : NORMAL;
  22.         };
  23.  
  25.         struct SHADERDATA
  26.         {
  27.             half4 vertex : POSITION;
  28.             half2 uv : TEXCOORD0;
  29.             fixed4 diff : COLOR0;
  30.         };
  31.         
  32.         ENDCG
  34.         // Forward Rendering Pass
  35.         Pass
  36.         {
  37.             Tags { "LightMode" = "ForwardBase" }
  38.             Cull Off
  39.             CGPROGRAM
  40.             #pragma target 5.0
  41.             #pragma multi_compile_fwdbase
  42.             #pragma vertex vertex_shader
  43.             #pragma fragment fragment_shader
  45.             
  46.             uniform float _Radius;
  47.             uniform float _WaveStartHeight;
  48.             uniform int _InstanceCount;
  49.             uniform sampler2D _MainTex;
  50.             uniform float waveAmount;
  52.             SHADERDATA vertex_shader(APPDATA data)
  53.             {
  54.                 SHADERDATA vs;
  55.                 half waveAmount = 0.0;
  56.  
  57.                 half3 randomPosition = half3(
  58.                     frac(sin(dot(half2(data.instanceID, 12.345), half2(12.345, 67.890))) * 123.456),
  59.                     frac(sin(dot(half2(data.instanceID, 98.765), half2(43.210, 9.876))) * 654.321),
  60.                     frac(sin(dot(half2(data.instanceID, 0.123), half2(0.987, 6.543))) * 987.654)
  61.                 );
  62.             
  63.                 if (data.vertex.y >= _WaveStartHeight)
  64.                 {
  65.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  66.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  67.                     half fade = max(fadeX, fadeZ);
  68.                     fade = saturate(fade * 2.0 - 1.0);
  69.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  70.                 }
  71.                 vs.vertex = mul(UNITY_MATRIX_VP, half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  72.                 vs.uv = data.uv;
  73.                 half3 worldNormal = UnityObjectToWorldNormal(data.normal);
  74.                 half nl = max(0, dot(worldNormal, _WorldSpaceLightPos0.xyz));
  75.                 vs.diff = nl * _LightColor0;
  76.                 vs.diff.rgb += ShadeSH9(half4(worldNormal, 1));
  77.                 return vs;
  78.             }
  80.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  81.             {
  82.                 half4 color = tex2D(_MainTex, ps.uv);
  83.                 return color;
  84.             }
  85.             ENDCG
  86.         }
  87.         Pass
  88.         {
  89.             Tags { "LightMode" = "ShadowCaster" }
  90.             Cull Off
  91.             ZWrite On
  92.             ZTest LEqual
  93.             Blend Zero One
  94.  
  96.             CGPROGRAM
  97.             #pragma target 5.0
  98.             #pragma multi_compile_shadowcaster
  99.             #pragma vertex vertex_shader
  100.             #pragma fragment fragment_shader
  102.             uniform float _Radius;
  103.             uniform float _WaveStartHeight;
  104.             uniform int _InstanceCount;
  105.             uniform sampler2D _MainTex;
  106.             uniform float waveAmount;
  107.             SHADERDATA vertex_shader(APPDATA data)
  108.             {
  109.                 SHADERDATA vs = (SHADERDATA)0;
  110.                 half waveAmount = 0.0;
  111.                 if (data.vertex.y >= _WaveStartHeight)
  112.                 {
  113.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  114.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  115.                     half fade = max(fadeX, fadeZ);
  116.                     fade = saturate(fade * 2.0 - 1.0);
  117.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  118.                 }
  119.             
  120.                 half3 randomPosition = half3(
  121.                     frac(sin(dot(half2(data.instanceID, 12.345), half2(12.345, 67.890))) * 123.456),
  122.                     frac(sin(dot(half2(data.instanceID, 98.765), half2(43.210, 9.876))) * 654.321),
  123.                     frac(sin(dot(half2(data.instanceID, 0.123), half2(0.987, 6.543))) * 987.654)
  124.                 );
  125.                 vs.vertex = UnityObjectToClipPos(half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  126.                 return vs;
  127.             }
  129.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  130.             {
  131.                 return half4(0, 0, 0, 0);
  132.             }
  133.             ENDCG
  134.         }
  135.     }
  136. }
英文:

I fixed the errors in your code that you paste in the comment.

  1. Shader "Tree Shader"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex("Texture", 2D) = "white" {}
  6.     }
  7.     SubShader
  8.     {   
  9.         Tags { "IgnoreProjector" = "False" "DisableBatching" = "True" }
  10.  
  12.         CGINCLUDE
  14.         #include "UnityCG.cginc"
  15.         #include "UnityLightingCommon.cginc"
  16.         struct APPDATA
  17.         {
  18.             half4 vertex : POSITION;
  19.             half2 uv : TEXCOORD0;
  20.             uint instanceID : SV_InstanceID;
  21.             half3 normal : NORMAL;
  22.         };
  23.  
  25.         struct SHADERDATA
  26.         {
  27.             half4 vertex : POSITION;
  28.             half2 uv : TEXCOORD0;
  29.             fixed4 diff : COLOR0;
  30.         };
  31.         
  32.         ENDCG
  34.         // Forward Rendering Pass
  35.         Pass
  36.         {
  37.             Tags { "LightMode" = "ForwardBase" }
  38.             Cull Off
  39.             CGPROGRAM
  40.             #pragma target 5.0
  41.             #pragma multi_compile_fwdbase
  42.             #pragma vertex vertex_shader
  43.             #pragma fragment fragment_shader
  45.             
  46.             uniform float _Radius;
  47.             uniform float _WaveStartHeight;
  48.             uniform int _InstanceCount;
  49.             uniform sampler2D _MainTex;
  50.             uniform float waveAmount;
  52.             SHADERDATA vertex_shader(APPDATA data)
  53.             {
  54.                 SHADERDATA vs;
  55.                 half waveAmount = 0.0;
  56.  
  57.                 half3 randomPosition = half3(
  58.                     frac(sin(dot(half2(data.instanceID, 12.345), half2(12.345, 67.890))) * 123.456),
  59.                     frac(sin(dot(half2(data.instanceID, 98.765), half2(43.210, 9.876))) * 654.321),
  60.                     frac(sin(dot(half2(data.instanceID, 0.123), half2(0.987, 6.543))) * 987.654)
  61.                 );
  62.             
  63.                 if (data.vertex.y >= _WaveStartHeight)
  64.                 {
  65.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  66.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  67.                     half fade = max(fadeX, fadeZ);
  68.                     fade = saturate(fade * 2.0 - 1.0);
  69.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  70.                 }
  71.                 vs.vertex = mul(UNITY_MATRIX_VP, half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  72.                 vs.uv = data.uv;
  73.                 half3 worldNormal = UnityObjectToWorldNormal(data.normal);
  74.                 half nl = max(0, dot(worldNormal, _WorldSpaceLightPos0.xyz));
  75.                 vs.diff = nl * _LightColor0;
  76.                 vs.diff.rgb += ShadeSH9(half4(worldNormal, 1));
  77.                 return vs;
  78.             }
  79.  
  81.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  82.             {
  83.                 half4 color = tex2D(_MainTex, ps.uv);
  84.                 return color;
  85.             }
  86.             ENDCG
  87.         }
  88.         Pass
  89.         {
  90.             Tags { "LightMode" = "ShadowCaster" }
  91.             Cull Off
  92.             ZWrite On
  93.             ZTest LEqual
  94.             Blend Zero One
  95.  
  97.             CGPROGRAM
  98.             #pragma target 5.0
  99.             #pragma multi_compile_shadowcaster
  100.             #pragma vertex vertex_shader
  101.             #pragma fragment fragment_shader
  103.             uniform float _Radius;
  104.             uniform float _WaveStartHeight;
  105.             uniform int _InstanceCount;
  106.             uniform sampler2D _MainTex;
  107.             uniform float waveAmount;
  108.             SHADERDATA vertex_shader(APPDATA data)
  109.             {
  110.                 SHADERDATA vs = (SHADERDATA)0;
  111.                 half waveAmount = 0.0;
  112.                 if (data.vertex.y >= _WaveStartHeight)
  113.                 {
  114.                     half fadeX = 1.0 - abs(data.vertex.x) / (_Radius * 0.5);
  115.                     half fadeZ = 1.0 - abs(data.vertex.z) / (_Radius * 0.5);
  116.                     half fade = max(fadeX, fadeZ);
  117.                     fade = saturate(fade * 2.0 - 1.0);
  118.                     waveAmount = sin(data.instanceID * 0.1 + _Time.y * 2.0) * 0.1 * fade;
  119.                 }
  120.             
  121.                 half3 randomPosition = half3(
  122.                     frac(sin(dot(half2(data.instanceID, 12.345), half2(12.345, 67.890))) * 123.456),
  123.                     frac(sin(dot(half2(data.instanceID, 98.765), half2(43.210, 9.876))) * 654.321),
  124.                     frac(sin(dot(half2(data.instanceID, 0.123), half2(0.987, 6.543))) * 987.654)
  125.                 );
  126.                 vs.vertex = UnityObjectToClipPos(half4(randomPosition.x + waveAmount, 0, randomPosition.z + waveAmount, 0) + data.vertex);
  127.                 return vs;
  128.             }
  129.  
  131.             half4 fragment_shader(SHADERDATA ps) : SV_Target
  132.             {
  133.                 return half4(0, 0, 0, 0);
  134.             }
  135.             ENDCG
  136.         }
  137.     }
  138. }

huangapple
  • 本文由 发表于 2023年7月3日 04:11:51
  • 转载请务必保留本文链接：https://go.coder-hub.com/76600605.html
  • hlsl
  • shader
  • unity-game-engine
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定