Unity Shader总结（五）——基础纹理

于 2021-06-24 14:53:53 发布
阅读量190 收藏
点赞数 1
分类专栏： Unity Shader入门 文章标签： unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/memory_MM_forever/article/details/113782959
版权

单张纹理

实践

Shader "Unity Shaders Book/Chapter 7/Single Texture" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		//white是内置纹理的名字
		_MainTex ("Main Tex", 2D) = "white" {}
		_Specular ("Specular", Color) = (1, 1, 1, 1)
		_Gloss ("Gloss", Range(8.0, 256)) = 20
	}
	SubShader {		
		Pass { 
			Tags { "LightMode"="ForwardBase" }
		
			CGPROGRAM
			
			#pragma vertex vert
			#pragma fragment frag

			#include "Lighting.cginc"
			
			fixed4 _Color;
			sampler2D _MainTex;
			//ST代表缩放和平移，_MainTex_ST.xy是缩放，_MainTex_ST.zw是平移
			float4 _MainTex_ST;
			fixed4 _Specular;
			float _Gloss;
			
			struct a2v {
				float4 vertex : POSITION;
				float3 normal : NORMAL;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				float3 worldNormal : TEXCOORD0;
				float3 worldPos : TEXCOORD1;
				float2 uv : TEXCOORD2;
			};
			
			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				
				o.worldNormal = UnityObjectToWorldNormal(v.normal);
				
				o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				//对顶点纹理坐标先缩放后平移，下面有内置宏可以替代
				o.uv = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
				// Or just call the built-in function
//				o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
				fixed3 worldNormal = normalize(i.worldNormal);
				fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
				
				// Use the texture to sample the diffuse color
				//对纹理采样，tex2D（需要被采样的纹理，float2类型的纹理坐标），然后乘上color就是反射率
				fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				
				fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(worldNormal, worldLightDir));
				
				fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
				fixed3 halfDir = normalize(worldLightDir + viewDir);
				fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
				
				return fixed4(ambient + diffuse + specular, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Specular"
}

属性

在这里插入图片描述
wrap mode:
1.repeat:纹理坐标超过1，舍整数，取小数，导致纹理不断重复；
2.clamp：大于1，就取1，小于0，就取0；

filter mode：当纹理被拉伸时采用哪种滤波模式
1.point：最近邻滤波，采样像素数目只有一个，导致图像有像素风格；
2.Bilinear:找4个邻近像素线性插值混合，导致图像看起来模糊；
3.Trilinear:不使用多级渐远纹理的话和Bilinear效果相同；

凹凸映射

高度纹理

高度图存储强度值，颜色越浅表示该位置的表面越向外凸起，好处时直观，缺点是计算复杂，表面法线是由像素的灰度值计算而得。

法线纹理

法线纹理直接存储表面法线。
法线存储有两种：模型空间和切线空间

    模型空间切线空间
优点1.实现简单，更加直观；
2.边角部分的突变更少；		1.自由度更高，可以应用到不同的模型上；
2.可进行uv动画;
3.可以重用法线纹理；
4.可压缩；
缺点记录的是绝对法线信息，应用到其他模型会发生错误边角有更多的缝合迹象

实践

两种方法：在切线空间中计算光照或在世界空间下计算

切线空间

Shader "Unity Shaders Book/Chapter 7/Normal Map In Tangent Space" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_MainTex ("Main Tex", 2D) = "white" {}
		//当没有提供任何法线纹理时，bump对应模型自带的法线信息
		_BumpMap ("Normal Map", 2D) = "bump" {}
		//控制凹凸程度，值为0时，该法线纹理不会对模型产生任何影响
		_BumpScale ("Bump Scale", Float) = 1.0
		_Specular ("Specular", Color) = (1, 1, 1, 1)
		_Gloss ("Gloss", Range(8.0, 256)) = 20
	}
	SubShader {
		Pass { 
			Tags { "LightMode"="ForwardBase" }
		
			CGPROGRAM
			
			#pragma vertex vert
			#pragma fragment frag
			
			#include "Lighting.cginc"
			
			fixed4 _Color;
			sampler2D _MainTex;
			float4 _MainTex_ST;
			sampler2D _BumpMap;
			float4 _BumpMap_ST;
			float _BumpScale;
			fixed4 _Specular;
			float _Gloss;
			
			struct a2v {
				float4 vertex : POSITION;
				float3 normal : NORMAL;
				//填充切线方向，float4是因为w分量存储副切线
				float4 tangent : TANGENT;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				//xy存_MainTex纹理坐标，zw存_BumpMap纹理坐标，通常都使用同一组
				float4 uv : TEXCOORD0;
				float3 lightDir: TEXCOORD1;
				float3 viewDir : TEXCOORD2;
			};

			// Unity doesn't support the 'inverse' function in native shader
			// so we write one by our own
			// Note: this function is just a demonstration, not too confident on the math or the speed
			// Reference: http://answers.unity3d.com/questions/218333/shader-inversefloat4x4-function.html
			float4x4 inverse(float4x4 input) {
				#define minor(a,b,c) determinant(float3x3(input.a, input.b, input.c))
				
				float4x4 cofactors = float4x4(
				     minor(_22_23_24, _32_33_34, _42_43_44), 
				    -minor(_21_23_24, _31_33_34, _41_43_44),
				     minor(_21_22_24, _31_32_34, _41_42_44),
				    -minor(_21_22_23, _31_32_33, _41_42_43),
				    
				    -minor(_12_13_14, _32_33_34, _42_43_44),
				     minor(_11_13_14, _31_33_34, _41_43_44),
				    -minor(_11_12_14, _31_32_34, _41_42_44),
				     minor(_11_12_13, _31_32_33, _41_42_43),
				    
				     minor(_12_13_14, _22_23_24, _42_43_44),
				    -minor(_11_13_14, _21_23_24, _41_43_44),
				     minor(_11_12_14, _21_22_24, _41_42_44),
				    -minor(_11_12_13, _21_22_23, _41_42_43),
				    
				    -minor(_12_13_14, _22_23_24, _32_33_34),
				     minor(_11_13_14, _21_23_24, _31_33_34),
				    -minor(_11_12_14, _21_22_24, _31_32_34),
				     minor(_11_12_13, _21_22_23, _31_32_33)
				);
				#undef minor
				return transpose(cofactors) / determinant(input);
			}

			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				
				o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
				o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;

				///
				/// Note that the code below can handle both uniform and non-uniform scales
				///

				// Construct a matrix that transforms a point/vector from tangent space to world space
				fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);  
				fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);  
				fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w; 

				/*
				float4x4 tangentToWorld = float4x4(worldTangent.x, worldBinormal.x, worldNormal.x, 0.0,
												   worldTangent.y, worldBinormal.y, worldNormal.y, 0.0,
												   worldTangent.z, worldBinormal.z, worldNormal.z, 0.0,
												   0.0, 0.0, 0.0, 1.0);
				// The matrix that transforms from world space to tangent space is inverse of tangentToWorld
				float3x3 worldToTangent = inverse(tangentToWorld);
				*/
				
				//wToT = the inverse of tToW = the transpose of tToW as long as tToW is an orthogonal matrix.
				float3x3 worldToTangent = float3x3(worldTangent, worldBinormal, worldNormal);

				// Transform the light and view dir from world space to tangent space
				o.lightDir = mul(worldToTangent, WorldSpaceLightDir(v.vertex));
				o.viewDir = mul(worldToTangent, WorldSpaceViewDir(v.vertex));

				///
				/// Note that the code below can only handle uniform scales, not including non-uniform scales
				/// 

				// Compute the binormal
//				float3 binormal = cross( normalize(v.normal), normalize(v.tangent.xyz) ) * v.tangent.w;
//				// Construct a matrix which transform vectors from object space to tangent space
//				float3x3 rotation = float3x3(v.tangent.xyz, binormal, v.normal);
				// Or just use the built-in macro
//				TANGENT_SPACE_ROTATION;
//				
//				// Transform the light direction from object space to tangent space
//				o.lightDir = mul(rotation, normalize(ObjSpaceLightDir(v.vertex))).xyz;
//				// Transform the view direction from object space to tangent space
//				o.viewDir = mul(rotation, normalize(ObjSpaceViewDir(v.vertex))).xyz;
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {				
				fixed3 tangentLightDir = normalize(i.lightDir);
				fixed3 tangentViewDir = normalize(i.viewDir);
				
				// Get the texel in the normal map
				fixed4 packedNormal = tex2D(_BumpMap, i.uv.zw);
				fixed3 tangentNormal;
				// If the texture is not marked as "Normal map"
//				tangentNormal.xy = (packedNormal.xy * 2 - 1) * _BumpScale;
//				tangentNormal.z = sqrt(1.0 - saturate(dot(tangentNormal.xy, tangentNormal.xy)));
				
				// Or mark the texture as "Normal map", and use the built-in funciton
				tangentNormal = UnpackNormal(packedNormal);
				tangentNormal.xy *= _BumpScale;
				tangentNormal.z = sqrt(1.0 - saturate(dot(tangentNormal.xy, tangentNormal.xy)));
				
				fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				
				fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(tangentNormal, tangentLightDir));

				fixed3 halfDir = normalize(tangentLightDir + tangentViewDir);
				fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(tangentNormal, halfDir)), _Gloss);
				
				return fixed4(ambient + diffuse + specular, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Specular"
}

世界空间

Shader "Unity Shaders Book/Chapter 7/Normal Map In World Space" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_MainTex ("Main Tex", 2D) = "white" {}
		_BumpMap ("Normal Map", 2D) = "bump" {}
		_BumpScale ("Bump Scale", Float) = 1.0
		_Specular ("Specular", Color) = (1, 1, 1, 1)
		_Gloss ("Gloss", Range(8.0, 256)) = 20
	}
	SubShader {
		Pass { 
			Tags { "LightMode"="ForwardBase" }
		
			CGPROGRAM
			
			#pragma vertex vert
			#pragma fragment frag
			
			#include "Lighting.cginc"
			
			fixed4 _Color;
			sampler2D _MainTex;
			float4 _MainTex_ST;
			sampler2D _BumpMap;
			float4 _BumpMap_ST;
			float _BumpScale;
			fixed4 _Specular;
			float _Gloss;
			
			struct a2v {
				float4 vertex : POSITION;
				float3 normal : NORMAL;
				float4 tangent : TANGENT;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				float4 uv : TEXCOORD0;
				//3*3矩阵的三行，w分量存世界空间下的顶点位置
				float4 TtoW0 : TEXCOORD1;  
				float4 TtoW1 : TEXCOORD2;  
				float4 TtoW2 : TEXCOORD3; 
			};
			
			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				
				o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
				o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
				
				float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;  
				fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);  
				fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);  
				fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w; 
				
				// Compute the matrix that transform directions from tangent space to world space
				// Put the world position in w component for optimization
				o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
				o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
				o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
				// Get the position in world space		
				float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
				// Compute the light and view dir in world space
				fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
				fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
				
				// Get the normal in tangent space
				fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
				bump.xy *= _BumpScale;
				bump.z = sqrt(1.0 - saturate(dot(bump.xy, bump.xy)));
				// Transform the narmal from tangent space to world space
				bump = normalize(half3(dot(i.TtoW0.xyz, bump), dot(i.TtoW1.xyz, bump), dot(i.TtoW2.xyz, bump)));
				
				fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				
				fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(bump, lightDir));

				fixed3 halfDir = normalize(lightDir + viewDir);
				fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(bump, halfDir)), _Gloss);
				
				return fixed4(ambient + diffuse + specular, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Specular"
}

渐变纹理

Shader "Unity Shaders Book/Chapter 7/Ramp Texture" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_RampTex ("Ramp Tex", 2D) = "white" {}
		_Specular ("Specular", Color) = (1, 1, 1, 1)
		_Gloss ("Gloss", Range(8.0, 256)) = 20
	}
	SubShader {
		Pass { 
			Tags { "LightMode"="ForwardBase" }
		
			CGPROGRAM
			
			#pragma vertex vert
			#pragma fragment frag

			#include "Lighting.cginc"
			
			fixed4 _Color;
			sampler2D _RampTex;
			float4 _RampTex_ST;
			fixed4 _Specular;
			float _Gloss;
			
			struct a2v {
				float4 vertex : POSITION;
				float3 normal : NORMAL;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				float3 worldNormal : TEXCOORD0;
				float3 worldPos : TEXCOORD1;
				float2 uv : TEXCOORD2;
			};
			
			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				
				o.worldNormal = UnityObjectToWorldNormal(v.normal);
				
				o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				
				o.uv = TRANSFORM_TEX(v.texcoord, _RampTex);
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
				fixed3 worldNormal = normalize(i.worldNormal);
				fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
				
				// Use the texture to sample the diffuse color
				fixed halfLambert  = 0.5 * dot(worldNormal, worldLightDir) + 0.5;
				fixed3 diffuseColor = tex2D(_RampTex, fixed2(halfLambert, halfLambert)).rgb * _Color.rgb;
				
				fixed3 diffuse = _LightColor0.rgb * diffuseColor;
				
				fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
				fixed3 halfDir = normalize(worldLightDir + viewDir);
				fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
				
				return fixed4(ambient + diffuse + specular, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Specular"
}

遮罩纹理

一般r通道为高光反射强度，g为边缘光照强度，b为高光反射的指数部分，a为做发光强度；

Shader "Unity Shaders Book/Chapter 7/Mask Texture" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_MainTex ("Main Tex", 2D) = "white" {}
		_BumpMap ("Normal Map", 2D) = "bump" {}
		_BumpScale("Bump Scale", Float) = 1.0
		//高光反射遮罩纹理
		_SpecularMask ("Specular Mask", 2D) = "white" {}
		//控制遮罩影响度
		_SpecularScale ("Specular Scale", Float) = 1.0
		_Specular ("Specular", Color) = (1, 1, 1, 1)
		_Gloss ("Gloss", Range(8.0, 256)) = 20
	}
	SubShader {
		Pass { 
			Tags { "LightMode"="ForwardBase" }
		
			CGPROGRAM
			
			#pragma vertex vert
			#pragma fragment frag
			
			#include "Lighting.cginc"
			
			fixed4 _Color;
			sampler2D _MainTex;
			float4 _MainTex_ST;
			sampler2D _BumpMap;
			float _BumpScale;
			sampler2D _SpecularMask;
			float _SpecularScale;
			fixed4 _Specular;
			float _Gloss;
			
			struct a2v {
				float4 vertex : POSITION;
				float3 normal : NORMAL;
				float4 tangent : TANGENT;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				float2 uv : TEXCOORD0;
				float3 lightDir: TEXCOORD1;
				float3 viewDir : TEXCOORD2;
			};
			
			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				
				o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
				
				TANGENT_SPACE_ROTATION;
				o.lightDir = mul(rotation, ObjSpaceLightDir(v.vertex)).xyz;
				o.viewDir = mul(rotation, ObjSpaceViewDir(v.vertex)).xyz;
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
			 	fixed3 tangentLightDir = normalize(i.lightDir);
				fixed3 tangentViewDir = normalize(i.viewDir);

				fixed3 tangentNormal = UnpackNormal(tex2D(_BumpMap, i.uv));
				tangentNormal.xy *= _BumpScale;
				tangentNormal.z = sqrt(1.0 - saturate(dot(tangentNormal.xy, tangentNormal.xy)));

				fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				
				fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(tangentNormal, tangentLightDir));
				
			 	fixed3 halfDir = normalize(tangentLightDir + tangentViewDir);
			 	// Get the mask value
			 	fixed specularMask = tex2D(_SpecularMask, i.uv).r * _SpecularScale;
			 	// Compute specular term with the specular mask
			 	fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(tangentNormal, halfDir)), _Gloss) * specularMask;
			
				return fixed4(ambient + diffuse + specular, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Specular"
}
Lingo_work
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Shader开发的Unity碎屏特效
03-01
首先，我们需要了解Shader语言——Unity支持的主要是Cg/HLSL，这是基于DirectX HLSL的简化版本。Shader程序由两个主要部分组成：顶点着色器（Vertex Shader）和片段着色器（Fragment Shader）。顶点着色器处理图形的...
Unity Shader 基础纹理
九本才的博客
02-09 964
纹理最初的目的就是使用一张图片来控制模型的外观。使用纹理映射技术，我们可以把一张图片黏在模型表面，逐纹素地控制模型的颜色。 这里简单的总结一下单张纹理，凹凸映射，渐变纹理，遮罩纹理。 单张纹理 Properties { _Color ("Color Tint", Color) = (1, 1, 1, 1) _MainTex ("Main Tex", 2D) = "white" {} _Specular ("Specular", Color) = (1, 1, 1, 1) _Gl
Unity Shader（一）基础知识和语法
YYYJ_BOY的博客
10-25 1221
Unity Shader（一）语法1.Shader程序的基本架构1.文件声明2.简单的UV理解3.属性声明语法（properties）4.子着色器代码语法 1.Shader程序的基本架构 1.文件声明 下面展示一些 内联代码片。 /*首行声明了一个Shader，命名为MyFirstShader，存放在路径Study2下（这个路径在哪里不是重点，它归类在自定义中）*/ Shader "Study2/MyFirstShader" 2.简单的UV理解 /* UV纹理。简单来说：A是一张图片（称A为纹理）
Unity Shader内置属性 _MainTexture_TexelSize
virus2014的专栏
02-10 9921
_MainTexture_TexelSize，一个容易忘记的属性 {TextureName}_TexelSize - a float4 property contains texture size information: - x contains 1.0/width - y contains 1.0/height - z contains width - w contains heig...
Unity Shader 使用选定纹理或选定颜色进行渲染
Fanstasic的博客
01-05 531
Shader "SimpleShaderTest"{ Properties { _MainTexture ("MainTexture", 2D) = "white" {} _MainColor ("MainColor", Color) = (1,1,1,1) } SubShader{ pass//设置渲染状态和标签 { CGPROGRAM #pragma vertex vert.
《Unity Shader入门精要》自学笔记（四）第七章 基础纹理
就一笔记本儿
11-15 505
如果不确定一个变量需要在哪个着色器计算，可以判断一下它是否需要一个纹理值，需要的话就要在片元着色器中计算（因为需要进行fragment单位的纹理采样），不需要的话可以随意 需要顶点着色器处理的一般是一些对于模型顶点属性的计算（废话？？？），比如顶点坐标、顶点法线、顶点切线、顶点uv（总之就是语义里面不同于平平无奇的TEXCOORD的那一类） ...
unity_shaders_book_chapter_4_unityshader_SHADER_unity_
10-03
《Unity Shader编程进阶——第四章：Unity Shader与Shader基础知识》 在Unity引擎中，Shader是一种强大的工具，用于控制游戏中的图形渲染效果。本章主要围绕Unity Shader的基础知识展开，涵盖了在Shader编程过程中...
Unity 超强 Shader 源码
09-22
2. **Unity Shader语言**：Unity支持两种主要的Shader语言——CG和HLSL。CG是由NVIDIA开发的，被Unity广泛用于其内置Shader；HLSL（High-Level Shader Language）则更通用，常用于DirectX平台，Unity也通过其...
UnityShader 用Plane实现旗帜飘扬效果
05-02
Unity支持基于GLSL的着色语言——Surface Shader，它简化了复杂的着色器编写过程。我们将在Shader中添加时间（Time）变量，以根据时间改变顶点位置，模拟风吹的效果。 1. **创建Shader** 在Unity编辑器中，创建一...
《Unity Shader入门精要》源代码.rar
最新发布
05-20
同时，这也有助于理解和适应Unity引擎的Shader语言——Surface Shader和CG HLSL，这两种语言是Unity Shader开发的核心。 在学习过程中，读者应注重理论与实践相结合，理解Shader背后的数学原理，如向量运算、矩阵...
【深度之眼】Pytorch框架班第五期-模型容器之nn.ModuleDict代码调试
Zero_run的博客
09-08 914
模型容器(Containers) nn.ModuleDict nn.ModuleDict 是nn.module的容器，用于包装一组网络层，以索引方式调用网络层。 主要方法： clear(): 清空ModuleDict items(): 返回可迭代的键值对(key-value pairs) keys(): 返回字典的键（key） values(): 返回字典的值(value) pop(): 返回一对键值，并从字典中删除 class ModuleDict(nn.Module): def __ini
HLSL固有函数
熊小屁的专栏
02-17 1378
Intrinsic Functions (DirectX HLSL) The following table lists the intrinsic functions available in HLSL. Each function has a brief description, and a link to a reference page that has more detail abou
Unity Shader 详细自学（一）
Sevol_Y
02-27 1104
Shader 首先我也是自学shader，以下所有的代码和过程，都是我亲自做过，杜绝复制粘贴。shader分很多种类，我目前只研究了unity中的standard surface shader(表面着色器)，理解错误的，请大家指出学习。 在unity中新建一个shader,然后在vs中打开,代码结构如下: 代码解释 所有shader代码必须由Shader “shader路径” { } 包括在里面. Properties{…} 指的是本shader定义的属性,类似于C#中的定义int,string等
Unity Shader 高级纹理 立方体纹理 天空盒子
songhuanfei2017的博客
09-18 389
shader 是unity自带的Skybox/6 Sided 纹理的Wrap Mode 设置为Clamp,防止在接缝处出现不匹配的现象。 参考 我买的 unity shader 入门精要
Unity Shader 属性及标签
Edgar的博客
05-24 2166
一、渲染流水线应用阶段、几何阶段、光栅化阶段 1、应用阶段（cpu实现） （1）把数据加载到显存中 例如：顶点的位置信息、法线方向、顶点颜色、纹理坐标 （2）设置渲染状态 （3）调用DrawCall 2、几何阶段（gpu实现） （1）顶点着色器：实现顶点的空间变换、顶点着色等 <完全可编程> （2）曲面着色器：可选着色器，用于细分图元 （3）几何着色器：可选着色器，被用于执行图
（十五）unity shader基础之——————基础纹理：中篇（凹凸映射、法线纹理、高度纹理）
cgy56191948的博客
10-18 1427
纹理的另一种常见的应用就是凹凸映射。凹凸映射的目的是使用一张纹理来修改模型表面的法线，以便为模型提供更多的细节。这种方法不会真的改变模型的顶点位置，只是让模型看起来好像是“凹凸不平”的，但可以从模型的轮廓看出“破绽”。 有两种主要的方法可以用来进行凹凸映射：一种方法是使用一张高度纹理（height map）来模拟表面位移，然后得到一个修改后的法线值，这种方法又被称为高度映射；另一种方法则是使用一...
unity 一个物体边界的控制（Mathf.Clamp）
热门推荐
weixin_42116703的博客
02-15 1万+
首先创建一个边界类 [Serializable] public class Boundary { public float MaxX; public float MinX; public float MaxY; public float MinY; } 解释 Mathf.Clamp 限制 static function Clamp (value : float, ...
Unity Shader 从未入门到已放弃（十八）--高级 亮度、饱和度、对比度
leileilei的专栏
07-02 327
调整亮度、饱和度和对比度 屏幕后处理效果：指在渲染完整个场景得到屏幕图像后，再对这个图像进行一系列的操作，实现各种屏幕特效。 因此首先需要得到渲染后的屏幕图像，Unity提供了一个方便的接口——OnRenderImage。但在进行屏幕后处理之前，我们需要检测一切条件是否满足，例如当前平台是否支持渲染纹理和屏幕特效，是否支持当前使用的UnityShader等。 因此先创建一个基类用于检测条件：...
unityshader基础
09-12
在Unity中，Shader是用来定义物体表面的着色和渲染效果的一种程序。在Unity5.2及以上的版本中，Unity提供了四种Shader模板供我们选择。其中，Standard Surface Shader会产生一个包含了标准光照模型的表面着色器模板；Unity Shader会产生一个不包含光照（但包含雾效）的基本顶点/片元着色器；Image Effect Shader为我们实现各种屏幕后处理效果提供一个基本模板；Computer Shader则产生一种特殊的Shader文件，用于进行一些与常规渲染流水线无关的计算。一个单独的Unity Shader不能单独发挥作用，必须要和材质结合起来使用。 每一个Unity Shader文件可以包含多个SubShader语义块，但最少要有一个。当Unity需要加载一个Unity Shader时，会扫描所有的SubShader语义块，然后选择第一个能够在目标平台上运行的SubShader。如果都不支持的话，Unity会使用Fallback语义指定的Unity Shader。这是因为不同的显卡具有不同的能力，一些旧的显卡仅能支持一定数目的操作指令，而一些更高级的显卡可以支持更多的指令数。因此，我们希望在旧的显卡上使用计算复杂度较低的着色器，而在高级的显卡上使用计算复杂度较高的着色器，以提供更出色的画面效果。 SubShader的标签是一个键值对，它的键和值都是字符串类型。这些键值对是SubShader和渲染引擎之间的沟通桥梁，用来告诉Unity的渲染引擎应该以怎样的方式和何时渲染这个对象。具体情况可以查看相关的表格。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值