GPT答：

7i24.cn

以下是一个使用CG语言编写的基本PBR着色器，包含漫反射、镜面反射、菲涅尔效应和能量守恒定律。该着色器使用顶点着色器+片元着色器的形式，并可以在Unity中运行。

顶点着色器：

```cg
#pragma vertex vert
#pragma fragment frag

struct appdata {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
};

struct v2f {
    float3 worldPos : TEXCOORD0;
    float3 worldNormal : TEXCOORD1;
};

v2f vert (appdata v) {
    v2f o;

    // Transform the position and normal to world space
    o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    o.worldNormal = normalize(mul(unity_ObjectToWorld, float4(v.normal, 0)).xyz);

   return o;
}
```

片元着色器：

```cg
v2f IN;

float _Metallic; // Metallic factor of the material (0-1)
float _Roughness; // Roughness factor of the material (0-1)
float3 _AlbedoColor; // Base color of the material

// Calculate Fresnel reflectance using Schlick's approximation
float SchlickFresnel(float u) {
  return lerp(pow(1.0 - u, 5.0), 1.0, max(u, 0.04));
}

// Calculate GGX distribution function for microfacet specular reflection 
float GGX_Distribution(float NdotH) {  
  	float a = pow(_Roughness + 1.00001 - NdotH * NdotH , 2.0);
    return a / (3.14159 * pow(_Roughness + 1.00001, 2.0) * pow(NdotH * NdotH - 1.00001 + _Roughness, 2.0));
}

// Calculate Smith's masking-shadowing function for microfacet specular reflection
float GGX_Smith(float NdotV, float NdotL) {
    float k = (_Roughness + 1) * (_Roughness + 1) / 8;
    float G_V = NdotV / (NdotV * (1 - k) + k);
    float G_L = NdotL / (NdotL * (1 - k) + k);
    return G_V * G_L;
}

// Calculate the color of the material at this fragment
fixed4 frag(v2f i): SV_Target {
  	float3 V = normalize(UnityWorldSpaceViewDir(i.worldPos)); // View vector in world space
  	float3 L = normalize(_WorldSpaceLightPos0.xyz - i.worldPos); // Light vector in world space
  	float3 H = normalize(V+L); // Halfway vector between view and light vectors

	// Calculate diffuse component using Lambertian reflectance model 
  	float NoL_Diffuse = max(dot(i.worldNormal,L),0);

	// Calculate specular component using Cook-Torrance BRDF 
  	float NoH_Specular= max(dot(i.worldNormal,H),0);
  
	// Apply Fresnel reflectance to specular component 
  	float F_Specular= SchlickFresnel(max(dot(H,V),0));

	// Calculate GGX distribution and Smith's masking-shadowing functions for specular component 
  	float D_GGX= GGX_Distribution(NoH_Specular);
    float S_GGX= GGX_Smith(max(dot(i.worldNormal,V),0), max(dot(i.worldNormal,L),0));

	// Calculate final specular component 
  	float3 F0 = lerp(float3(0.04, 0.04, 0.04), _AlbedoColor.rgb, _Metallic);
    float3 Specular = (D_GGX * S_GGX * F_Specular) / (4 * max(dot(i.worldNormal,L), 1e-5));
    Specular *= F_Specular;
    Specular *= lerp(1.00001 - _Roughness, 1.00001, _Metallic);

	// Apply energy conservation to the material color 
  	float3 Diffuse = (_AlbedoColor.rgb - F0) * (1 - _Metallic);
  	Diffuse *= (1 - pow(NoL_Diffuse,5));
  
	return fixed4(Diffuse + Specular + F0 , 1);
}
```

在Unity中使用该着色器，需要将其保存为一个.cginc文件，并在材质的Shader代码中引用它。例如：

```cg
Shader "Custom/PBR" {
    Properties {
        // Material properties
        _Albedo ("Base Color", Color) = (1, 1, 1)
        _Metallic ("Metallic", Range(0., 1.)) = .5
        _Roughness ("Smoothness", Range(0., 1.)) = .5

        // Light properties
        [PerRendererData]_MainTex("Texture",2D)="white"{}
        
        [UnityEngine.LightUsageAttribute(UnityEngine.LightUsage.MainLight)]
            [NoScaleOffset][HDR]_LightColor("Light Color",color)=(color.white)
            [NoScaleOffset]_WorldSpaceLightPos0("Light Position",Vector)=(0,1,0,1)
    }

    SubShader {
        Tags {"Queue"="Transparent"}

        Pass {
            CGPROGRAM
            #include "PBR.cginc"

            // Vertex shader
            #pragma vertex vert

            // Fragment shader
            #pragma fragment frag

			// Material properties
			float _Metallic;
			float _Roughness;
			float3 _AlbedoColor;

			// Light properties
        	float4 _MainTex_ST;
        	sampler2D _MainTex;

        	struct appdata {
            	float4 vertex : POSITION;
            	float3 normal : NORMAL;
				half2 uv : TEXCOORD0; 
        	};

	        struct v2f {
	            float3 worldPos : TEXCOORD0;
	            float3 worldNormal : TEXCOORD1; 
				half2 uv:TEXCOORD2;  
	        };

	        v2f vert (appdata v) {	
	            v2f o;

	            // Transform the position and normal to world space
	            o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				o.uv=v.uv.xy*_MainTex_ST.xy+_MainTex_ST.zw;//纹理坐标的变换，这里不是重点，就不详细讲解了。
	        	o.worldNormal = normalize(mul(unity_ObjectToWorld, float4(v.normal, 0)).xyz);

	           return o; 
	       }

	       fixed4 frag (v2f i) : SV_Target {	
	           fixed4 col= tex2D(_MainTex,i.uv); 

	           return col * frag(i);
	       }
           ENDCG		
       }
   }
   FallBack "Diffuse"
}
```

在上面的代码中，我们引用了PBR.cginc文件，并将着色器的顶点着色器和片元着色器分别设置为vert和frag。我们还定义了材质的属性（_Albedo、_Metallic和_Roughness），以及光源的属性（_MainTex、_LightColor和_WorldSpaceLightPos0）。在片元着色器中，我们首先获取纹理颜色，然后将其与PBR计算结果相乘并返回。

使用这个基本的PBR着色器可以让你在Unity中创建更真实的材质效果。当然，如果你想要更高级或更复杂的效果，你可能需要进一步修改这个代码来满足你特定的需求。