Providing vertex data to vertex programs 向顶点程序提供顶点数据

For Cg/HLSL vertex programs, theMesh vertex data is passed as inputs to the vertexshader function. Each input needs to havesemantic speficied for it: for example, POSITION input is the vertex position, andNORMAL is the vertex normal.

对于cg/hlsl顶点程序，它们的顶点数据作为输入到vertex着色函数。每个输入都需要为它提供一个输入:例如，顶点位置是 POSITION， NORMAL是顶点法线。

Often, vertex data inputs are declared in a structure, instead oflisting them one by one. Several commonly used vertex structuresare defined inUnityCG.cginc include file,and in most cases it’s enough just to use those. The structures are:

通常，顶点数据输入是在一个结构中声明的，而不是一个一个地列出它们。一些常用的顶点结构在 “UnityCG.cginc”里面定义 ，在大多数情况下，仅使用这些文件就足够了。的结构是:

• appdata_base: position, normal and one texture coordinate.位置，法线和一个贴图坐标
  
• appdata_tan: position, tangent, normal and one texture coordinate.位置，切线空间坐标，法线和一个贴图坐标
• appdata_full: position, tangent, normal, four texture coordinates and color.位置，切线空间坐标，法线，四个贴图坐标和颜色。

Example: This shader colors the mesh based on its normals, and usesappdata_base as vertex program input:

示例：这个shader通过它自己的法线来定义面的颜色，同时使用 appdata_base作为顶点数据输入。

Shader "VertexInputSimple" {    SubShader {        Pass {            CGPROGRAM            #pragma vertex vert            #pragma fragment frag            #include "UnityCG.cginc"                     struct v2f {                float4 pos : SV_POSITION;                fixed4 color : COLOR;            };                        v2f vert (appdata_base v)            {                v2f o;                o.pos = UnityObjectToClipPos(v.vertex);//顶点位置转换                o.color.xyz = v.normal * 0.5 + 0.5;//顶点颜色=顶点的法线*0.5+0.5                o.color.w = 1.0;//顶点的颜色W（alpha）设置为1 非透明状态                return o;返回o的值            }            fixed4 frag (v2f i) : SV_Target { return i.color; }//返回切线坐标作为颜色？            ENDCG        }    } }

To access different vertex data, you need to declare thevertex structure yourself, or add input parameters to thevertex shader. Vertex data is identified by Cg/HLSLsemantics, and must be from thefollowing list:

要访问不同的顶点数据，您需要自己声明顶点结构，或者向顶点着色器添加输入参数。顶点数据由cg/hlsl语义标识，必须来自以下列表:

• POSITION is the vertex position, typically afloat3 orfloat4. 是顶点的位置，一般是float3 或者 float4
  
• NORMAL is the vertex normal, typically afloat3. 是顶点的法线，一般是 float3
  
• TEXCOORD0 is the first UV coordinate, typicallyfloat2,float3 orfloat4. 是第一套UV信息，一般是 float2,float3,float4
  
• TEXCOORD1, TEXCOORD2 andTEXCOORD3 are the 2nd, 3rd and 4th UV coordinates, respectively.  是第二套，第三套，第四套UV信息
• TANGENT is the tangent vector (used for normal mapping), typically afloat4.   是切线向量（用作法线贴图）。
• COLOR is the per-vertex color, typically afloat4. 是逐顶点颜色 一般是 float4
  

When the mesh data contains fewer components than are needed by the vertexshader input, the rest are filled with zeroes, except for the.wcomponent which defaults to 1. For example, mesh texture coordinatesare often 2D vectors with just x and y components. If a vertexshader declares afloat4 input with TEXCOORD0 semantic, thevalue received by the vertex shader will contain (x,y,0,1).

当网格数据包含比vertex着色输入所需的组件更少的组件时，其余的部分将填充0，除非是。默认为1的wcomponent。例如，网格纹理坐标通常是二维向量，只有x和y分量。如果一个vertex着色器声明了带有TEXCOORD0语义的浮动4输入，顶点着色器接收的值将包含(x，y，0,1)。

Examples

Visualizing UVs

The following shader example uses the vertex position and the first texture coordinate as the vertex shader inputs (defined in the structureappdata). This shader is very useful for debugging the UV coordinates of the mesh.

Shader "Debug/UV 1" {SubShader {    Pass {        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, UV        struct appdata {            float4 vertex : POSITION;            float4 texcoord : TEXCOORD0;        };        struct v2f {            float4 pos : SV_POSITION;            float4 uv : TEXCOORD0;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            o.uv = float4( v.texcoord.xy, 0, 0 );            return o;        }                half4 frag( v2f i ) : SV_Target {            half4 c = frac( i.uv );            if (any(saturate(i.uv) - i.uv))                c.b = 0.5;            return c;        }        ENDCG    }}}

Here, UV coordinates are visualized as red and green colors, while an additional blue tint has been applied to coordinates outside of the 0 to 1 range:

Debug UV1 shader applied to a torus knot model

Similarly, this shader vizualizes the second UV set of the model:

Shader "Debug/UV 2" {SubShader {    Pass {        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, second UV        struct appdata {            float4 vertex : POSITION;            float4 texcoord1 : TEXCOORD1;        };        struct v2f {            float4 pos : SV_POSITION;            float4 uv : TEXCOORD0;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            o.uv = float4( v.texcoord1.xy, 0, 0 );            return o;        }                half4 frag( v2f i ) : SV_Target {            half4 c = frac( i.uv );            if (any(saturate(i.uv) - i.uv))                c.b = 0.5;            return c;        }        ENDCG    }}}

Visualizing vertex colors

The following shader uses the vertex position and the per-vertex colors as the vertex shader inputs (defined in structureappdata).

Shader "Debug/Vertex color" {SubShader {    Pass {        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, color        struct appdata {            float4 vertex : POSITION;            fixed4 color : COLOR;        };        struct v2f {            float4 pos : SV_POSITION;            fixed4 color : COLOR;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            o.color = v.color;            return o;        }                fixed4 frag (v2f i) : SV_Target { return i.color; }        ENDCG    }}}

Debug Colors shader applied to a torus knot model that has illumination baked into colors

Visualizing normals

The following shader uses the vertex position and the normal as the vertex shader inputs (defined in the structureappdata). The normal’s X,Y & Z components are visualized as RGB colors. Because the normal components are in the –1 to 1 range, we scale and bias them so that the output colors are displayable in the 0 to 1 range.

Shader "Debug/Normals" {SubShader {    Pass {        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, normal        struct appdata {            float4 vertex : POSITION;            float3 normal : NORMAL;        };        struct v2f {            float4 pos : SV_POSITION;            fixed4 color : COLOR;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            o.color.xyz = v.normal * 0.5 + 0.5;            o.color.w = 1.0;            return o;        }                fixed4 frag (v2f i) : SV_Target { return i.color; }        ENDCG    }}}

Debug Normals shader applied to a torus knot model. You can see that the model has hard shading edges.

Visualizing tangents and binormals

Tangent and binormal vectors are used for normal mapping. In Unity only the tangent vector is stored in vertices, and the binormal is derived from the normal and tangent values.

The following shader uses the vertex position and the tangent as vertex shader inputs (defined in structureappdata). Tangent’s x,y and z components are visualized as RGB colors. Because the normal components are in the –1 to 1 range, we scale and bias them so that the output colors are in a displayable 0 to 1 range.

Shader "Debug/Tangents" {SubShader {    Pass {        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, tangent        struct appdata {            float4 vertex : POSITION;            float4 tangent : TANGENT;        };        struct v2f {            float4 pos : SV_POSITION;            fixed4 color : COLOR;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            o.color = v.tangent * 0.5 + 0.5;            return o;        }                fixed4 frag (v2f i) : SV_Target { return i.color; }        ENDCG    }}}

Debug Tangents shader applied to a torus knot model.

The following shader visualizes bitangents. It uses the vertex position, normal and tangent values as vertex inputs. The bitangent (sometimes calledbinormal) is calculated from the normal and tangent values. It needs to be scaled and biased into a displayable 0 to 1 range.

Shader "Debug/Bitangents" {SubShader {    Pass {        Fog { Mode Off }        CGPROGRAM        #pragma vertex vert        #pragma fragment frag        #include "UnityCG.cginc"        // vertex input: position, normal, tangent        struct appdata {            float4 vertex : POSITION;            float3 normal : NORMAL;            float4 tangent : TANGENT;        };        struct v2f {            float4 pos : SV_POSITION;            float4 color : COLOR;        };                v2f vert (appdata v) {            v2f o;            o.pos = UnityObjectToClipPos(v.vertex );            // calculate bitangent            float3 bitangent = cross( v.normal, v.tangent.xyz ) * v.tangent.w;            o.color.xyz = bitangent * 0.5 + 0.5;            o.color.w = 1.0;            return o;        }                fixed4 frag (v2f i) : SV_Target { return i.color; }        ENDCG    }}}

Debug Bitangents shader applied to a torus knot model.