Unity Shader Notes

Shader.md

There are two types of variables in Cg: single values and packed arrays. The latter can be identified because their type ends with a number such as float3 or int4. As their names suggest, these types of variables are similar to structs, which means they each contain several single values. Cg calls them packed arrays, though they are not exactly arrays in the traditional sense.

The elements of a packed array can be accessed as a normal struct. They are typically called x, y, z and w. However, Cg also provides you with another alias for them, that is, r, g, b, and a.

---

swizzling

o.Albedo = _Color.rgb;

Albedo is fixed3, which means that it contains three values of the fixed type.
_Color is defined as a fixed4 type.

---

smearing

a single value is assigned a packed array, it is copied to all of fieds:

o.Albedo = 0;  // Black = (0, 0, 0)
o.Albedo = 1;  // white = (1, 1, 1)

---

masking

allowing only certain components of a packed array to be overwritten:

o.Albedo.rg = _Color.rg;

Packed Matrices

Cg allows types such as float4x4, which represents a maxtrix of floats with four rows and for columns. You can access a single element of the matrix using the _mRC notation, where R is the row and C is the column:

float4x4 matrix;
float first = matrix._m00;
float last = matrix._m33;

float4 firstRow = matrix[0];
// Equivalent to
float4 firstRow = matrix._m00_m01_m02_m03;

float4 diagonal = matrix._m00_m11_m22_m33;

Each vertex on the model can store data that shaders can access and use to determine what to dray. One of the most important pieces of information that are stored in vertices is the UV data. It consists of two coordinates, U and V, ranging from 0 to 1.

fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;

tex2D function takes a texture and UV and returns the color of the pixel at that position, and the returned color is tinted by _Color

_Time: This built-in variable return a variable of the float4 type, meaning that each component of this variable contians different values of time as it pertains to game time.

Unity - Manual: Built-in shader variables

Tags are used to add infomation about how the object is going to be rendered. Unity has provided us with some default render queues, each with a unique value that directs Unity when to draw the object to the screen.
This are built-in render queues:

Render queue	Desc	value
Background	This render queue is rendered first. It is used for skyboxes and so on.	1000
Geometry	This is the default render queue. This is used for most objects. Opaque geometry use this queue.	2000
AlphaTest	'Alpha-tested geometry uses this queue. It's different from the Geometry queue as it's more efficient to render alpha-tested objects after all the solid objects are drawn.	2450
Transparent	This render queue is rendered after Geometry and AlphaTest queues in back-to-front order. Anything alpha-blended (that is, shaders that don't write to the depth buffer) should go here, for example, glass and particle effects.	3000
Overlay	This render queue is meant for overlay effects. Anything rendered last should go here, for example, lens flares.	4000

#prama surface surf Lambert aplha:fade nolighting

• Lambert: Use Lambertian Reflectance lighting model
• nolighting: disable any lighting
• alpha:face: signal to Cg that this is a Transparent Shader

Holographic Effect:

float4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color; 
o.Albedo = c.rgb; 
float border = 1 - (abs(dot(IN.viewDir, IN.worldNormal))); 
float alpha = (border * (1 - _DotProduct) + _DotProduct); 
// viewDir 是平面的 nomal direction
// dot: 0      border: 1     alpha:  向量正
//                           _DotProduct: 0.25      alpha: 1
//                           _DotProduct: 0.75      alpha: 1
// dot: 0.5    border: 0.5   alpha:
//                           _DotProduct: 0.25      alpha: 0.625
//                           _DotProduct: 0.75      alpha: 0.875
// dot: 1      border: 0     alpha:   向量平行
//                           _DotProduct: 0.25      alpha: 0.25
//                           _DotProduct: 0.75      alpha: 0.75
o.Alpha = c.a * alpha; 

Blending textures:

float4 aTexData = tex2D(_ATexture, IN.uv_ATexture); 
float4 bTexData = tex2D(_GTexture, IN.uv_BTexture); 
float4 blendData = tex2D(_BlendTex, IN.uv_BlendTex); 

float4 finalColor = lerp(aTexData, bTexData, blendData.g); 

sampler2D myTex;
float4          myTex_ST;  // 附带的一个变量

// ...

float2 tiling = myTex_ST.xy; // 放大缩小的倍数 
float2 offset = myTex_ST.zw;  // 位移

float4 o = tex2D(myTex, i.uv * tiling + offset)
return o

图片变灰：由于视觉感光对 R,G, B 的敏感度不一样，所以取不同的权重。

float4 grayScale(float4 v) {
    float g = v.r * 0.299 + v.g * 0.578 + v.b * 0.114;
    return float4(g, g, g, v.a);
}

if (w < 0) w = 0;
if (w > 1) w = 1;
// 等于
w = clamp(w, 0, 1);