Unity - 记一次，使用 RenderDoc 调试 渲染 异常 的过程

news2025/1/11 14:30:26

文章目录

  • vertex shader - raw
  • fragment shader - raw
  • 调试RDC的shader准备选项 - remote - 不要选local
  • 先查看 texture, sampler, ubo 数据
  • 调试：输出原始的法线数据
  • 调试：输出原始法线0\~1=>-1\~1，并应用法线强度的法线
  • 调试：输出世界坐标下的法线
  • 调试：输出view
  • 调试：未知数值1
  • 调试： UNITY_ADRENO_ES3 宏分支
  • 调试：metallic, glossiness, ao
  • 调试：unity_SpecCube0
  • 调试：又回到 ao
  • 调试：又回到 glossiness
  • 调试：又回到 metallic + glossiness
  • 调试： albedo
  • 最终确定问题

2023.05.01 写的记录

先拿到 有问题的 vertex shader, fragment shader 分析

vertex shader - raw

#version 320 es

#define HLSLCC_ENABLE_UNIFORM_BUFFERS 1
#if HLSLCC_ENABLE_UNIFORM_BUFFERS
#define UNITY_UNIFORM
#else
#define UNITY_UNIFORM uniform
#endif
#define UNITY_SUPPORTS_UNIFORM_LOCATION 1
#if UNITY_SUPPORTS_UNIFORM_LOCATION
#define UNITY_LOCATION(x) layout(location = x)
#define UNITY_BINDING(x) layout(binding = x, std140)
#else
#define UNITY_LOCATION(x)
#define UNITY_BINDING(x) layout(std140)
#endif
uniform 	vec3 _WorldSpaceCameraPos;
uniform 	vec4 hlslcc_mtx4x4unity_ObjectToWorld[4];
uniform 	vec4 hlslcc_mtx4x4unity_WorldToObject[4];
uniform 	vec4 unity_WorldTransformParams;
uniform 	vec4 hlslcc_mtx4x4unity_MatrixVP[4];
uniform 	vec4 unity_FogParams;
uniform 	vec4 _MainTex_ST;
uniform 	vec4 _DetailAlbedoMap_ST;
uniform 	mediump float _UVSec;
uniform 	float _Curve_Depth;
uniform 	float _Depth_Divider;
uniform 	vec4 _Cam_Forward;
uniform 	float _Z_Dist_Offset;
in highp vec4 in_POSITION0;
in mediump vec3 in_NORMAL0;
in highp vec2 in_TEXCOORD0;
in highp vec2 in_TEXCOORD1;
in mediump vec4 in_TANGENT0;
out highp vec4 vs_TEXCOORD0;
out highp vec4 vs_TEXCOORD1;
out highp vec4 vs_TEXCOORD2;
out highp vec4 vs_TEXCOORD3;
out highp vec4 vs_TEXCOORD4;
out mediump vec4 vs_TEXCOORD5;
out highp vec4 vs_TEXCOORD7;
out highp vec3 vs_TEXCOORD8;
vec3 u_xlat0;
vec4 u_xlat1;
vec4 u_xlat2;
mediump vec3 u_xlat16_3;
float u_xlat12;
bool u_xlatb12;
void main()
{
    u_xlat0.xyz = in_POSITION0.yyy * hlslcc_mtx4x4unity_ObjectToWorld[1].xyz;
    u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[0].xyz * in_POSITION0.xxx + u_xlat0.xyz;
    u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[2].xyz * in_POSITION0.zzz + u_xlat0.xyz;
    u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[3].xyz * in_POSITION0.www + u_xlat0.xyz;
    u_xlat1.xyz = (-u_xlat0.xyz) + _WorldSpaceCameraPos.xyz;
    u_xlat12 = dot(u_xlat1.xyz, _Cam_Forward.xyz);
    u_xlat12 = u_xlat12 + (-_Z_Dist_Offset);
    u_xlat12 = max(u_xlat12, 0.0);
    u_xlat12 = u_xlat12 * u_xlat12;
    u_xlat1.x = _Depth_Divider * (-_Curve_Depth);
    u_xlat1.y = u_xlat12 * u_xlat1.x;
    u_xlat1.x = float(0.0);
    u_xlat1.z = float(0.0);
    u_xlat0.xyz = u_xlat0.xyz + u_xlat1.xyz;
    u_xlat1.xyz = u_xlat0.yyy * hlslcc_mtx4x4unity_WorldToObject[1].xyz;
    u_xlat1.xyz = hlslcc_mtx4x4unity_WorldToObject[0].xyz * u_xlat0.xxx + u_xlat1.xyz;
    u_xlat1.xyz = hlslcc_mtx4x4unity_WorldToObject[2].xyz * u_xlat0.zzz + u_xlat1.xyz;
    u_xlat1.xyz = u_xlat1.xyz + hlslcc_mtx4x4unity_WorldToObject[3].xyz;
    u_xlat2 = u_xlat1.yyyy * hlslcc_mtx4x4unity_ObjectToWorld[1];
    u_xlat2 = hlslcc_mtx4x4unity_ObjectToWorld[0] * u_xlat1.xxxx + u_xlat2;
    u_xlat1 = hlslcc_mtx4x4unity_ObjectToWorld[2] * u_xlat1.zzzz + u_xlat2;
    u_xlat1 = u_xlat1 + hlslcc_mtx4x4unity_ObjectToWorld[3];
    u_xlat2 = u_xlat1.yyyy * hlslcc_mtx4x4unity_MatrixVP[1];
    u_xlat2 = hlslcc_mtx4x4unity_MatrixVP[0] * u_xlat1.xxxx + u_xlat2;
    u_xlat2 = hlslcc_mtx4x4unity_MatrixVP[2] * u_xlat1.zzzz + u_xlat2;
    u_xlat1 = hlslcc_mtx4x4unity_MatrixVP[3] * u_xlat1.wwww + u_xlat2;
    gl_Position = u_xlat1;
    vs_TEXCOORD1.w = u_xlat1.z * unity_FogParams.z + unity_FogParams.w;
#ifdef UNITY_ADRENO_ES3
    u_xlatb12 = !!(_UVSec==0.0);
#else
    u_xlatb12 = _UVSec==0.0;
#endif
    u_xlat1.xy = (bool(u_xlatb12)) ? in_TEXCOORD0.xy : in_TEXCOORD1.xy;
    vs_TEXCOORD0.zw = u_xlat1.xy * _DetailAlbedoMap_ST.xy + _DetailAlbedoMap_ST.zw;
    vs_TEXCOORD0.xy = in_TEXCOORD0.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    vs_TEXCOORD1.xyz = u_xlat0.xyz + (-_WorldSpaceCameraPos.xyz);
    vs_TEXCOORD8.xyz = u_xlat0.xyz;
    u_xlat0.xyz = in_TANGENT0.yyy * hlslcc_mtx4x4unity_ObjectToWorld[1].xyz;
    u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[0].xyz * in_TANGENT0.xxx + u_xlat0.xyz;
    u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[2].xyz * in_TANGENT0.zzz + u_xlat0.xyz;
    u_xlat12 = dot(u_xlat0.xyz, u_xlat0.xyz);
    u_xlat12 = inversesqrt(u_xlat12);
    u_xlat0.xyz = vec3(u_xlat12) * u_xlat0.xyz;
    vs_TEXCOORD2.xyz = u_xlat0.xyz;
    vs_TEXCOORD2.w = 0.0;
    u_xlat1.x = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[0].xyz);
    u_xlat1.y = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[1].xyz);
    u_xlat1.z = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[2].xyz);
    u_xlat12 = dot(u_xlat1.xyz, u_xlat1.xyz);
    u_xlat12 = inversesqrt(u_xlat12);
    u_xlat1.xyz = vec3(u_xlat12) * u_xlat1.xyz;
    u_xlat16_3.xyz = u_xlat0.yzx * u_xlat1.zxy;
    u_xlat16_3.xyz = u_xlat1.yzx * u_xlat0.zxy + (-u_xlat16_3.xyz);
    vs_TEXCOORD4.xyz = u_xlat1.xyz;
    u_xlat0.x = in_TANGENT0.w * unity_WorldTransformParams.w;
    u_xlat16_3.xyz = u_xlat0.xxx * u_xlat16_3.xyz;
    vs_TEXCOORD3.xyz = u_xlat16_3.xyz;
    vs_TEXCOORD3.w = 0.0;
    vs_TEXCOORD4.w = 0.0;
    vs_TEXCOORD5 = vec4(0.0, 0.0, 0.0, 0.0);
    vs_TEXCOORD7 = vec4(0.0, 0.0, 0.0, 0.0);
    return;
}

fragment shader - raw

#version 320 es
#ifdef GL_EXT_shader_texture_lod
#extension GL_EXT_shader_texture_lod : enable
#endif

precision highp float;
precision highp int;
#define HLSLCC_ENABLE_UNIFORM_BUFFERS 1
#if HLSLCC_ENABLE_UNIFORM_BUFFERS
#define UNITY_UNIFORM
#else
#define UNITY_UNIFORM uniform
#endif
#define UNITY_SUPPORTS_UNIFORM_LOCATION 1
#if UNITY_SUPPORTS_UNIFORM_LOCATION
#define UNITY_LOCATION(x) layout(location = x)
#define UNITY_BINDING(x) layout(binding = x, std140)
#else
#define UNITY_LOCATION(x)
#define UNITY_BINDING(x) layout(std140)
#endif
uniform 	vec3 _WorldSpaceCameraPos;
uniform 	vec4 _WorldSpaceLightPos0;
uniform 	vec4 hlslcc_mtx4x4unity_WorldToShadow[16];
uniform 	mediump vec4 _LightShadowData;
uniform 	vec4 unity_ShadowFadeCenterAndType;
uniform 	vec4 hlslcc_mtx4x4unity_MatrixV[4];
uniform 	mediump vec4 unity_FogColor;
uniform 	mediump vec4 unity_SpecCube0_HDR;
uniform 	mediump vec4 _LightColor0;
uniform 	mediump vec4 _Color;
uniform 	mediump float _BumpScale;
uniform 	mediump float _Metallic;
uniform 	float _Glossiness;
uniform 	mediump float _OcclusionStrength;
uniform 	float _MainTex_mipmapBias;
uniform 	float _BumpMap_mipmapBias;
UNITY_LOCATION(0) uniform mediump sampler2D _MRATTex;
UNITY_LOCATION(1) uniform mediump sampler2D _MainTex;
UNITY_LOCATION(2) uniform mediump sampler2D _BumpMap;
UNITY_LOCATION(3) uniform mediump samplerCube unity_SpecCube0;
UNITY_LOCATION(4) uniform highp sampler2D _ShadowMapTexture;
UNITY_LOCATION(5) uniform highp sampler2DShadow hlslcc_zcmp_ShadowMapTexture;
in highp vec4 vs_TEXCOORD0;
in highp vec4 vs_TEXCOORD1;
in highp vec4 vs_TEXCOORD2;
in highp vec4 vs_TEXCOORD3;
in highp vec4 vs_TEXCOORD4;
in highp vec3 vs_TEXCOORD8;
layout(location = 0) out mediump vec4 SV_Target0;
vec3 u_xlat0;
mediump vec3 u_xlat16_0;
mediump vec4 u_xlat16_1;
mediump vec4 u_xlat16_2;
vec4 u_xlat3;
mediump vec4 u_xlat16_3;
vec4 u_xlat4;
mediump vec4 u_xlat16_5;
mediump vec3 u_xlat16_6;
vec3 u_xlat7;
mediump float u_xlat16_9;
vec3 u_xlat10;
float u_xlat14;
mediump float u_xlat16_16;
float u_xlat17;
float u_xlat21;
mediump float u_xlat16_22;
float u_xlat25;
void main()
{
    u_xlat16_0.xyz = texture(_BumpMap, vs_TEXCOORD0.xy, _BumpMap_mipmapBias).xyz;
    u_xlat16_1.xyz = u_xlat16_0.xyz * vec3(2.0, 2.0, 2.0) + vec3(-1.0, -1.0, -1.0);
    u_xlat16_1.xy = u_xlat16_1.xy * vec2(_BumpScale);
    u_xlat16_2.xyz = u_xlat16_1.yyy * vs_TEXCOORD3.xyz;
    u_xlat16_1.xyw = vs_TEXCOORD2.xyz * u_xlat16_1.xxx + u_xlat16_2.xyz;
    u_xlat16_1.xyz = vs_TEXCOORD4.xyz * u_xlat16_1.zzz + u_xlat16_1.xyw;
    u_xlat0.x = dot(u_xlat16_1.xyz, u_xlat16_1.xyz);
    u_xlat0.x = inversesqrt(u_xlat0.x);
    u_xlat0.xyz = u_xlat0.xxx * u_xlat16_1.xyz;
    u_xlat21 = dot(vs_TEXCOORD1.xyz, vs_TEXCOORD1.xyz);
    u_xlat21 = inversesqrt(u_xlat21);
    u_xlat3.xyz = vec3(u_xlat21) * vs_TEXCOORD1.xyz;
    u_xlat4.xyz = (-vs_TEXCOORD1.xyz) * vec3(u_xlat21) + _WorldSpaceLightPos0.xyz;
    u_xlat16_1.x = dot(u_xlat3.xyz, u_xlat0.xyz);
    u_xlat16_1.x = u_xlat16_1.x + u_xlat16_1.x;
    u_xlat16_1.xyz = u_xlat0.xyz * (-u_xlat16_1.xxx) + u_xlat3.xyz;
    u_xlat21 = dot(u_xlat0.xyz, (-u_xlat3.xyz));
#ifdef UNITY_ADRENO_ES3
    u_xlat21 = min(max(u_xlat21, 0.0), 1.0);
#else
    u_xlat21 = clamp(u_xlat21, 0.0, 1.0);
#endif
    u_xlat16_22 = (-u_xlat21) + 1.0;
    u_xlat16_22 = u_xlat16_22 * u_xlat16_22;
    u_xlat16_22 = u_xlat16_22 * u_xlat16_22;
    u_xlat16_3.xyz = texture(_MRATTex, vs_TEXCOORD0.xy).xyz;
    u_xlat21 = (-_Glossiness) * u_xlat16_3.y + 1.0;
    u_xlat16_2.xy = (-vec2(u_xlat21)) * vec2(0.699999988, 0.0799999982) + vec2(1.70000005, 0.600000024);
    u_xlat16_2.x = u_xlat21 * u_xlat16_2.x;
    u_xlat16_2.x = u_xlat16_2.x * 6.0;
    u_xlat16_5 = textureLod(unity_SpecCube0, u_xlat16_1.xyz, u_xlat16_2.x);
    u_xlat16_1.x = u_xlat16_5.w + -1.0;
    u_xlat16_1.x = unity_SpecCube0_HDR.w * u_xlat16_1.x + 1.0;
    u_xlat16_1.x = log2(u_xlat16_1.x);
    u_xlat16_1.x = u_xlat16_1.x * unity_SpecCube0_HDR.y;
    u_xlat16_1.x = exp2(u_xlat16_1.x);
    u_xlat16_1.x = u_xlat16_1.x * unity_SpecCube0_HDR.x;
    u_xlat16_1.xyz = u_xlat16_5.xyz * u_xlat16_1.xxx;
    u_xlat16_2.x = u_xlat16_3.z + -1.0;
    u_xlat16_2.x = _OcclusionStrength * u_xlat16_2.x + 1.0;
    u_xlat16_1.xyz = u_xlat16_1.xyz * u_xlat16_2.xxx;
    u_xlat17 = u_xlat21 * u_xlat21;
    u_xlat16_2.x = u_xlat21 * u_xlat17;
    u_xlat21 = u_xlat21 * u_xlat21 + 0.5;
    u_xlat16_2.x = (-u_xlat16_2.x) * u_xlat16_2.y + 1.0;
    u_xlat16_1.xyz = u_xlat16_1.xyz * u_xlat16_2.xxx;
    u_xlat16_2.x = u_xlat16_3.x * _Metallic;
    u_xlat16_9 = (-u_xlat16_2.x) * 0.959999979 + 0.959999979;
    u_xlat16_16 = (-u_xlat16_9) + 1.0;
    u_xlat16_16 = _Glossiness * u_xlat16_3.y + u_xlat16_16;
#ifdef UNITY_ADRENO_ES3
    u_xlat16_16 = min(max(u_xlat16_16, 0.0), 1.0);
#else
    u_xlat16_16 = clamp(u_xlat16_16, 0.0, 1.0);
#endif
    u_xlat16_3.xyw = texture(_MainTex, vs_TEXCOORD0.xy, _MainTex_mipmapBias).xyz;
    u_xlat16_6.xyz = _Color.xyz * u_xlat16_3.xyw + vec3(-0.0399999991, -0.0399999991, -0.0399999991);
    u_xlat3.xyw = u_xlat16_3.xyw * _Color.xyz;
    u_xlat16_6.xyz = u_xlat16_2.xxx * u_xlat16_6.xyz + vec3(0.0399999991, 0.0399999991, 0.0399999991);
    u_xlat16_2.xzw = vec3(u_xlat16_16) + (-u_xlat16_6.xyz);
    u_xlat16_2.xzw = vec3(u_xlat16_22) * u_xlat16_2.xzw + u_xlat16_6.xyz;
    u_xlat16_1.xyz = u_xlat16_1.xyz * u_xlat16_2.xzw;
    u_xlat25 = dot(u_xlat4.xyz, u_xlat4.xyz);
    u_xlat25 = max(u_xlat25, 0.00100000005);
    u_xlat25 = inversesqrt(u_xlat25);
    u_xlat4.xyz = vec3(u_xlat25) * u_xlat4.xyz;
    u_xlat4.w = dot(_WorldSpaceLightPos0.xyz, u_xlat4.xyz);
#ifdef UNITY_ADRENO_ES3
    u_xlat4.w = min(max(u_xlat4.w, 0.0), 1.0);
#else
    u_xlat4.w = clamp(u_xlat4.w, 0.0, 1.0);
#endif
    u_xlat4.x = dot(u_xlat0.xyz, u_xlat4.xyz);
#ifdef UNITY_ADRENO_ES3
    u_xlat4.x = min(max(u_xlat4.x, 0.0), 1.0);
#else
    u_xlat4.x = clamp(u_xlat4.x, 0.0, 1.0);
#endif
    u_xlat0.x = dot(u_xlat0.xyz, _WorldSpaceLightPos0.xyz);
#ifdef UNITY_ADRENO_ES3
    u_xlat0.x = min(max(u_xlat0.x, 0.0), 1.0);
#else
    u_xlat0.x = clamp(u_xlat0.x, 0.0, 1.0);
#endif
    u_xlat7.xy = u_xlat4.xw * u_xlat4.xw;
    u_xlat14 = max(u_xlat7.y, 0.100000001);
    u_xlat14 = u_xlat21 * u_xlat14;
    u_xlat21 = u_xlat17 * u_xlat17 + -1.0;
    u_xlat17 = u_xlat17 * u_xlat17;
    u_xlat7.x = u_xlat7.x * u_xlat21 + 1.00001001;
    u_xlat7.x = u_xlat7.x * u_xlat7.x;
    u_xlat7.x = u_xlat7.x * u_xlat14;
    u_xlat7.x = u_xlat7.x * 4.0;
    u_xlat7.x = u_xlat17 / u_xlat7.x;
    u_xlat7.x = u_xlat7.x + -9.99999975e-05;
    u_xlat7.x = max(u_xlat7.x, 0.0);
    u_xlat7.x = min(u_xlat7.x, 100.0);
    u_xlat7.xyz = u_xlat16_6.xyz * u_xlat7.xxx;
    u_xlat7.xyz = u_xlat3.xyw * vec3(u_xlat16_9) + u_xlat7.xyz;
    u_xlat3.xyz = vs_TEXCOORD8.xyz + (-unity_ShadowFadeCenterAndType.xyz);
    u_xlat3.x = dot(u_xlat3.xyz, u_xlat3.xyz);
    u_xlat3.x = sqrt(u_xlat3.x);
    u_xlat10.xyz = (-vs_TEXCOORD8.xyz) + _WorldSpaceCameraPos.xyz;
    u_xlat4.x = hlslcc_mtx4x4unity_MatrixV[0].z;
    u_xlat4.y = hlslcc_mtx4x4unity_MatrixV[1].z;
    u_xlat4.z = hlslcc_mtx4x4unity_MatrixV[2].z;
    u_xlat10.x = dot(u_xlat10.xyz, u_xlat4.xyz);
    u_xlat3.x = (-u_xlat10.x) + u_xlat3.x;
    u_xlat3.x = unity_ShadowFadeCenterAndType.w * u_xlat3.x + u_xlat10.x;
    u_xlat3.x = u_xlat3.x * _LightShadowData.z + _LightShadowData.w;
#ifdef UNITY_ADRENO_ES3
    u_xlat3.x = min(max(u_xlat3.x, 0.0), 1.0);
#else
    u_xlat3.x = clamp(u_xlat3.x, 0.0, 1.0);
#endif
    u_xlat10.xyz = vs_TEXCOORD8.yyy * hlslcc_mtx4x4unity_WorldToShadow[1].xyz;
    u_xlat10.xyz = hlslcc_mtx4x4unity_WorldToShadow[0].xyz * vs_TEXCOORD8.xxx + u_xlat10.xyz;
    u_xlat10.xyz = hlslcc_mtx4x4unity_WorldToShadow[2].xyz * vs_TEXCOORD8.zzz + u_xlat10.xyz;
    u_xlat10.xyz = u_xlat10.xyz + hlslcc_mtx4x4unity_WorldToShadow[3].xyz;
    vec3 txVec0 = vec3(u_xlat10.xy,u_xlat10.z);
    u_xlat10.x = textureLod(hlslcc_zcmp_ShadowMapTexture, txVec0, 0.0);
    u_xlat16_22 = (-_LightShadowData.x) + 1.0;
    u_xlat16_22 = u_xlat10.x * u_xlat16_22 + _LightShadowData.x;
    u_xlat16_2.x = (-u_xlat16_22) + 1.0;
    u_xlat16_22 = u_xlat3.x * u_xlat16_2.x + u_xlat16_22;
    u_xlat16_2.xyz = vec3(u_xlat16_22) * _LightColor0.xyz;
    u_xlat7.xyz = u_xlat7.xyz * u_xlat16_2.xyz;
    u_xlat0.xyz = u_xlat7.xyz * u_xlat0.xxx + u_xlat16_1.xyz;
    u_xlat0.xyz = u_xlat0.xyz + (-unity_FogColor.xyz);
    u_xlat21 = vs_TEXCOORD1.w;
#ifdef UNITY_ADRENO_ES3
    u_xlat21 = min(max(u_xlat21, 0.0), 1.0);
#else
    u_xlat21 = clamp(u_xlat21, 0.0, 1.0);
#endif
    u_xlat0.xyz = vec3(u_xlat21) * u_xlat0.xyz + unity_FogColor.xyz;
    SV_Target0.xyz = u_xlat0.xyz;
    SV_Target0.w = 1.0;
    return;
}

调试RDC的shader准备选项 - remote - 不要选local

选择：remote 还是 local是关键，因为 会影响 shader 指令的结果

当你打开 rdc 文件的时候， render doc 会提示使用

  • remote 当前连接的目标设备作为解释执行的主体
  • local 本地电脑来做为执行主体

如果你的抓帧数据是 移动真机设备，那么你保存下来的 rdc 再后续重新加载到 render doc 时，可以真机联调

你要确保：rdc 和 当时抓帧时的 真机上是同一个： 数据 和 设备

如果你的抓帧数据就是这台电脑 的 PC game，直接 local 就好

先查看 texture, sampler, ubo 数据

在这里插入图片描述

调试：输出原始的法线数据

在这里插入图片描述

在这里插入图片描述

调试：输出原始法线0~1=>-1~1，并应用法线强度的法线

在这里插入图片描述

在这里插入图片描述

调试：输出世界坐标下的法线

在这里插入图片描述

在这里插入图片描述

调试：输出view

首先在 vs 中 vs_TEXCOORD1 值的代码可以看得出来，xyz = view dir, w = fogFactor

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

调试：未知数值1

在这里插入图片描述

调试： UNITY_ADRENO_ES3 宏分支

在这里插入图片描述

调试：metallic, glossiness, ao

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

调试：unity_SpecCube0

本身是黑色的
在这里插入图片描述

采样出来结果必定 黑色的
在这里插入图片描述

从之前的 UBO 数据可以查看到：unity_SpecCube0_HDR : float4(1.0, 1.0, 0.0, 0.0)
正常来说，如果有正常的 cube 这个 hdr 解码数值不会是这个值
在这里插入图片描述
unity_SpecCube0 解码部分的代码，如果不了解算法原理，则可读性不高
我们可以从 unity builtin shader 中着手查看

  1. 先搜索： unity_SpecCube0_HDR，貌似只有传入到 probeHDR[0] 中，待后续使用
    在这里插入图片描述

  2. 那么再搜索 probeHDR，可以得知，只有 Unity_GlossyEnviroment 引用了
    在这里插入图片描述

  3. 那么再搜索 Unity_GlossyEnviroment 后续还有 DecodeHDR 的第二个参数
    在这里插入图片描述
    在这里插入图片描述

  4. 那么再搜索 DecodeHDR
    在这里插入图片描述

  5. 最终确定了 HDR 解码部分的内容
    在这里插入图片描述

输出一下
在这里插入图片描述

调试：又回到 ao

在这里插入图片描述

ao 应用在 spec cube 0 的采样后的遮蔽强度，ao 值越小，遮蔽越强
在这里插入图片描述

调试：又回到 glossiness

在这里插入图片描述

在这里插入图片描述

调试：又回到 metallic + glossiness

在这里插入图片描述
在这里插入图片描述

调试： albedo

在这里插入图片描述

这代码编译优化之后，可读性会看得让人头皮发麻
在这里插入图片描述

在这里插入图片描述

dot(L, H)
在这里插入图片描述

dot(N, H)
在这里插入图片描述

dot(N, L)
在这里插入图片描述

dot(N, H) 和 glossiness 的拟合应用
在这里插入图片描述
在这里插入图片描述

输出发现可能是有问题的
在这里插入图片描述

最终确定问题

hlslcc_zcmp_ShadowMapTexture shadow texture 怎么采样出来都是 全黑色

opengl textureLod 对应 API ：textureLod

shadow texture, vec3 重载的那个
在这里插入图片描述

结果全是黑色，明显是有问题的，但是 textureLod 采样出来为何会有这样的结果，明明 render doc 可以看到就是纯白色的，暂时没看懂
在这里插入图片描述

所以很有可能是因为做 shader 变体优化导致，那么我们可以另起一个 shader 变体文件，然后不需要： #define SHADOWS_SCREEN

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/676695.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

强化学习从基础到进阶-常见问题和面试必知必答[3]：表格型方法：Sarsa、Qlearning；蒙特卡洛策略、时序差分等以及Qlearning项目实战

强化学习从基础到进阶-常见问题和面试必知必答[3]：表格型方法：Sarsa、Qlearning；蒙特卡洛策略、时序差分等以及Qlearning项目实战

【强化学习原理项目专栏】必看系列：单智能体、多智能体算法原理项目实战、相关技巧（调参、画图等、趣味项目实现、学术应用项目实现 专栏详细介绍：【强化学习原理项目专栏】必看系列：单智能体、多智能体算法原理项目实战、相关技巧…
阅读更多...
一文了解RabbitMQ安装使用

一文了解RabbitMQ安装使用

什么是RabbitMQ? 官网：Messaging that just works — RabbitMQ RabbitMQ是一种开源的消息中间件软件，用于构建可扩展的分布式应用程序。它实现了高级消息队列协议（AMQP），这是一种网络协议，用于在应用程序之…
阅读更多...
RIS 系列：TransVG: End-to-End Visual Grounding with Transformers 论文阅读笔记

RIS 系列：TransVG: End-to-End Visual Grounding with Transformers 论文阅读笔记

RIS 系列：TransVG: End-to-End Visual Grounding with Transformers 论文阅读笔记 一、Abstract二、引言三、相关工作3.1 视觉定位两阶段方法单阶段方法 3.2 Transformer视觉任务中的 Transformer视觉-语言任务中的 Transformer 四、视觉定位中的 Transformer4.1 基…
阅读更多...
【网络协议详解】——IPv4（学习笔记）

【网络协议详解】——IPv4（学习笔记）

目录 🕒 1. IPv4地址概述🕒 2. 分类编址🕒 3. 划分子网🕘 3.1 概述🕘 3.2 如何实现🕘 3.3 无分类编址🕘 3.4 应用规划🕤 3.4.1 定长的子网掩码FLSM（Fixed Length Subnet …
阅读更多...
【排序算法】冒泡排序、选择排序、插入排序

【排序算法】冒泡排序、选择排序、插入排序

冒泡排序 依次比较相邻的两个元素，将比较小的数放在前面，比较大的数放在后面，直到所有元素排列完。 最容易理解的版本 对一个数组的n个整型数据进行n趟排序，每趟排序都尝试将较大值放到数组右侧。 每趟排序比较两个相邻的数据&…
阅读更多...
相机模型概述

相机模型概述

相机模型 如图:假设P是现实世界中的一个点,P是三维世界中的点 Pr(Xr,Yr,Zr) 光心O视作摄像头 Pc(Xc,Yc,Zc) 在相机平面中,Pc的坐标为(0,0,0) 在物理成像平面 Pp(Xp,Yp,0) 在像素平面 P(Xp,Yp,0) 但是!!! 到了像素平面,坐标就不一样了,像素平面坐标顶点(最左上角)才是…
阅读更多...
【Java系列】深入解析 Lambda表达式

【Java系列】深入解析 Lambda表达式

序言 你只管努力，其他交给时间，时间会证明一切。 文章标记颜色说明： 黄色：重要标题红色：用来标记结论绿色：用来标记一级论点蓝色：用来标记二级论点 希望这篇文章能让你不仅有一定的收获&#xf…
阅读更多...
揭秘ChatGPT背后的传奇崛起，探索其引爆引爆网络的隐藏故事

揭秘ChatGPT背后的传奇崛起，探索其引爆引爆网络的隐藏故事

文章目录 前言一、ChatGPT的诞生背景二、ChatGPT的技术原理三、ChatGPT的推广策略四、ChatGPT的未来展望五、橙子送书第3期 前言 ChatGPT是一款基于人工智能技术的聊天机器人，它的出现引起了广泛的关注和热议。在短短的时间内，ChatGPT就成为了全球范围内…
阅读更多...
TLS SSL

TLS SSL

HTTPS HTTPS，全称为 Hypertext Transfer Protocol Secure，是一种通过加密通道传输数据的安全协议。它是 HTTP 协议的安全版本，用于在 Web 浏览器和 Web 服务器之间进行安全的数据传输。HTTPS 在传输过程中使用了 SSL（Secure Sock…
阅读更多...
使用Compose开发一款桌面端APK逆向工具

使用Compose开发一款桌面端APK逆向工具

目录 1.前言2.小感慨3.逆向工具简介3.1.ApkTool3.2.Jadx3.3.其他工具3.3.1.Dex文件反编译为Jar文件dex2jar 3.3.2.Jar文件反编译为Java文件JavaDecompilerProcyonFernflowerCFR 4.桌面端逆向APK应用的开发4.1.文件拖拽4.2.构造工程目录4.3.文件标签页4.4.关键字高亮4.5.本地图片…
阅读更多...
大模型没有壁垒吗？开源模型和chatgpt已经没有差距了吗？

大模型没有壁垒吗？开源模型和chatgpt已经没有差距了吗？

近期有很多工作比如Alpaca、Vicuna、Koala等论文宣称通过收集到的大量chatgpt output，在基于开源大模型如LLaMA上进行微调后的模型就接近甚至超过chatgpt效果。有些看热闹不嫌事大的媒体渲染诸如“复制chatgpt，仅需100美元“，”开源大模型超过…
阅读更多...
行为型模式--观察者模式

行为型模式--观察者模式

目录 概述 结构 案例实现 优缺点 优点： 缺点： 使用场景 概述 又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者 对象同时监听某一个主题对象。这个主题对象在…
阅读更多...
vscode c++ 环境配置(终极版)

vscode c++ 环境配置(终极版)

1. window系统 c 环境配置 1.1 配置MinGw编译器 （1）下载mingw64 mingw64 的按照包，我已经放在百度网盘上了，搭建可自行下载: 链接: https://pan.baidu.com/s/1NoPGAYFuP5ysXTf8wtvbEA?pwdwd6w 提取码: wd6w （2&…
阅读更多...
目标检测基础

目标检测基础

MTCNN 人脸检测 MTCNN，Multi-task convolutional neural network（多任务卷积神经网络），将人脸区域检测与人脸关键点检测放在了一起，它的主题框架类似于cascade。总体可分为P-Net、R-Net、和O-Net三层网络结构。这三个…
阅读更多...
IOS工程使用OpenCV库完整步聚

IOS工程使用OpenCV库完整步聚

1.打开Xcode15并点击Create New Project 2.引用编译好的opencv2.framework框架 选择添加其它库 选择Add Files ... 选择OpenCV源码编译生成输入的IOS平台的opencv2.framework库 opencv库要放在工程目录下,不然会找不到 成功添加opencv库的引用,现在可在工程中使用openc…
阅读更多...
《网络安全0-100》多级安全

《网络安全0-100》多级安全

1.多级安全 建立安全模型的方法： 信息流模型 访问控制模型 1.1 BLP模型 1.1模型构建 不能下写、不能上读，保持数据的机密性。 例子：军事、商务、外交的机密性强场景。下级可以给上级进行汇报，但下级不能读取上级的作战计划…
阅读更多...
【C++学习】C++入门 | 缺省参数 | 函数重载 | 探究C++为什么能够支持函数重载

【C++学习】C++入门 | 缺省参数 | 函数重载 | 探究C++为什么能够支持函数重载

写在前面： 上一篇文章我介绍了C该怎么学，什么是命名空间，以及C的输入输出， 这里是传送门：http://t.csdn.cn/Oi6V8 这篇文章我们继续来学习C的基础知识。 目录 写在前面： 1. 缺省参数 2. 函数重载 3…
阅读更多...
浅谈【AI、算力赋能】“大算力”时代的到来

浅谈【AI、算力赋能】“大算力”时代的到来

🔻一、【💣 话题引入：“AI算力最强龙头”，你怎么看？】 🙈 AI人工智能是否可以取代人类？    🙈 应不应该限制人工智能的发展？      🙈 AI研究及龙头行业迎…
阅读更多...
011-从零搭建微服务-接口文档（一）

011-从零搭建微服务-接口文档（一）

写在最前 如果这个项目让你有所收获，记得 Star 关注哦，这对我是非常不错的鼓励与支持。 源码地址（后端）：https://gitee.com/csps/mingyue 源码地址（前端）：https://gitee.com/csps…
阅读更多...
【P2】VMware 下 docker 快速搭建漏洞靶场 DVWA

【P2】VMware 下 docker 快速搭建漏洞靶场 DVWA

文章目录 一、docker 快速搭建漏洞靶场指南二、执行步骤三、为 kali 配置 docker 加速器四、访问 dockerhub 的 dvwa 镜像五、漏洞利用初探，修改 requests 请求参数远程执行命令六、vulhub 搭建漏洞复现 包括什么是 docker、docker 和虚拟机的的区别、docker 搭建 D…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023