[RESOLVIDO] Ajuda em documentação de shader

Preciso documentar este shader, bem como indicar, caso haja, alternativas melhores e mais viáveis.

Código:

Shader "cods/cod4"
{
 Properties
 {
 _Sura ("sura", 2D) = "white" {}
 _l1("l1", Vector) = (1,1,1,1)
 _C("l2", Color) = (1,1,1,1)
 _shhhh("shhh", Range(1,64)) = 16
 }
 SubShader
 {
 Tags { "RenderType"="Opaque" }

 Pass
 {
 CGPROGRAM
 #pragma vertex ara
 #pragma fragment oro
 
 #include "UnityCG.cginc"

 struct a
 {
 float4 p : POSITION;
 float3 n : NORMAL;
 float2 u : TEXCOORD0;
 };

 struct b
 {
 float4 p : SV_POSITION;
 float3 n : NORMAL;
 float2 u : TEXCOORD0;
 float3 e : TEXCOORD1;
 float3 l : TEXCOORD2;
 };

 uniform sampler2D _Sura;
 uniform float3 _l1;
 uniform float4 _C;
 uniform float _shhhh;
 
 b ara (a i)
 {
 b o;
 o.p = UnityObjectToClipPos(i.p);
 o.u = i.u;
 o.n = normalize(mul(float4(i.n, 0.0), unity_WorldToObject).xyz);
 o.e = normalize(mul(UNITY_MATRIX_M, i.p).xyz - _WorldSpaceCameraPos);
 o.l = -normalize(_l1);
 return o;
 }
 
 float4 oro(b i) : COLOR
 {
 float3 l1 = i.l;
 float it = max(dot(i.n, l1), 0.0);
 float4 d = _C * it;
 float4 a = _C * 0.2;
 float4 s = float4(0,0,0,0);
 
 if (it > 0)
 {
 float3 h = normalize(l1 - i.e);

 s = pow(max(dot(i.n, h), 0.0), _shhhh) * tex2D(_Sura, i.u);
 }
 
 
 return max(d + s, a);
 }
 ENDCG
 }
 }
}


De momento estou na struct a

Não sei se seria isso, mas lá vai...
Algumas melhorias eu deixei nos comentários, outras depende da aplicação, por exemplo, se eu prezar por desempenho ao invés de qualidade, posso mover alguns cálculos pro vertex shader, como o especular.
Existem funcões nativas pra calcular e normalizar as normais, e você pode usar o Transform Tex ao invés de só passar a UV diretamente, isso lhe permitiria usar o offset e o tiling na textura.

Código:

Shader "cods/cod4"
{
   Properties
   {
      _Sura ("sura", 2D) = "white" {}
      _l1("l1", Vector) = (1,1,1,1)
      _C("l2", Color) = (1,1,1,1)
      _shhhh("shhh", Range(1,64)) = 16
   }

   SubShader
   {
      Tags { "RenderType"="Opaque" }

      Pass
      {
         CGPROGRAM
         #pragma vertex ara
         #pragma fragment oro
         #include "UnityCG.cginc"

         struct a //parametros da mesh que serão utilizados no vertex shader - Entrada
         {
            float4 p : POSITION; // Posicão da vertice
            float3 n : NORMAL; // Normal
            float2 u : TEXCOORD0; // UV0 - primeiro canal das UVS
         };

         struct b // parametros que estarão disponíveis no fragment shader;
         {
            float4 p : SV_POSITION; // Posicão da vertice
            float3 n : NORMAL; //Normal
            float2 u : TEXCOORD0; //UV0 - Primeira UV
            float3 e : TEXCOORD1; //UV1 - Utiliza o interpolador da UV1 para armazenar outro tipo de dado.
            float3 l : TEXCOORD2; //UV2 - Utiliza o interpolador da UV2 para armazenar outro tipo de dado.
         };

         uniform sampler2D _Sura; //sampler2D permite o uso de uma textura;
         uniform float3 _l1; //L1 provavelmente representa a direcao da luz;
         uniform float4 _C; //Cor definida no inspector
         uniform float _shhhh; //Intensidade Specular
         
         b ara (a i) //Vertex shader, recebe os parametros definidos em A
         {
            b o; //declaracao
            o.p = UnityObjectToClipPos(i.p); //posicao da vertice recebe a posicao original multiplicada pela matrix MPV(Model>View>Projection)
            o.u = i.u; //A UV0 é passada diretamente entre o vertex e o fragment, (Melhoria) poderia usar o metodo "TRANSFORM_TEX" para levar em conta o tiling e o offset;
            o.n = normalize(mul(float4(i.n, 0.0), unity_WorldToObject).xyz);//Normal recebe o valor normalizao // Existe um metodo nativo pra isso
            o.e = normalize(mul(UNITY_MATRIX_M, i.p).xyz - _WorldSpaceCameraPos); //UV1 recebe a posicao da vertice multiplicada pela matrix do modelo - a posicao da camera no espaço global;
            o.l = -normalize(_l1); //valor l1 é normalizado e invertido;
            return o;
         }

         float4 oro(b i) : COLOR //Fragment Shader -- recebe o resultado do vertex shader
         {
            float3 l1 = i.l; //l1 recebe o valor vindo do vertex shader normalizado e invertido
            float it = max(dot(i.n, l1), 0.0); //valor maximo entre 0 e dot/normal - calculo de lambert?
            float4 d = _C * it; //Cor d = Cor definida no inspector multiplicada pela iluminação lambert;
            float4 a = _C * 0.2; //A cor recebe 20% da intensidade anterior;
            float4 s = float4(0,0,0,0); //100 Preto;

            if (it > 0) //se a iluminação não for full preto
            {
               float3 h = normalize(l1 - i.e);
               s = pow(max(dot(i.n, h), 0.0), _shhhh) * tex2D(_Sura, i.u); //Calculo de specular? Especular recebe o Calculo de iluminação passando por um power e clampado a 0 com o max, o resltado recebe a aplicação da textura.
            }
            return max(d + s, a); //saida do fragment shader, valor que é desenhado na tela caso o fragment vire um pixel (passe no teste de depth, etc);
         }
         ENDCG
      }
   }
}

Para que serve isso? tipo, estou curioso

Isso é o código do material, tipo o standard, o mobile/diffuse, etc. Com isso você controla a mesh e a aparência do objeto.
No vertex shader eu poderia por exemplo fazer a mesh ondular pra simular água, e no fragment shader eu posso aplicar algum efeito na cor do objeto mesmo ele tendo uma textura.

@poyser

Complementando o que o Fagner disse acima, também temos o Shader Graph, que é basicamente uma versão visual da coisa, mais fácil de usar.

E mais uns exemplos:

Da pra fazer uns efeitos de dissolver, lasers, campo de força, hologramas, Toon 

E muitas coisas quero aprender isso.

Um canal que mostra como fazer umas coisas com Shader Graph

klr, também quero pow, deve ser muito bom, obg  @dutrabr100 e  @Fagner por me explicarem, agora irei aprender isso.

Olha, sei só um pouco sobre shader e já me salvou várias vezes, recomendo de verdade que estudem nem que seja o básico, principalmente se seu foco for mobile, já que os shaders que vem na Unity por padrão são bem limitados.

tenho mais shaders que fiz em aula guardados, se quiserem eu posso ceder para tirarem uso deles e estudarem, caso estejam interessados

Joana escreveu:tenho mais shaders que fiz em aula guardados, se quiserem eu posso ceder para tirarem uso deles e estudarem, caso estejam interessados

O que tu cursa ?

desenvolvimento de jogos