URP RimLit 移植示例（HLSL → GLSL ES 3.00）

three.js 会自动在最前面加入 `#version 300 es`，因此源文件本身不包含该指令。

// Browser port of RimLitUnlit.shader (Unity URP / HLSL) - vertex stage.
//
// URP                                  ->  GLSL ES 3.00
// TransformObjectToWorld(positionOS)   ->  (modelMatrix * vec4(position, 1.0)).xyz
// TransformWorldToHClip(positionWS)    ->  projectionMatrix * modelViewMatrix * vec4(position, 1.0)
// TransformObjectToWorldNormal(normal) ->  normalize(mat3(modelMatrix) * normal)
//
// NOTE: `#version 300 es` is injected by three.js (RawShaderMaterial + GLSL3).

precision highp float;

uniform mat4 modelMatrix;
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;

in vec3 position;   // Attributes.positionOS
in vec3 normal;     // Attributes.normalOS
in vec2 uv;         // Attributes.uv

out vec3 vPositionWS;   // Varyings.positionWS
out vec3 vNormalWS;     // Varyings.normalWS
out vec2 vUv;

void main() {
  vec4 worldPosition = modelMatrix * vec4(position, 1.0);
  vPositionWS = worldPosition.xyz;
  vNormalWS = normalize(mat3(modelMatrix) * normal);
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

// Browser port of RimLitUnlit.shader (Unity URP / HLSL) - fragment stage.
//
// Mapping summary (the full table lives in src/content/shaders/urp-rimlit-port.md):
//   GetMainLight().direction / .color  -> uLightDirection / uLightColor
//   mainLight.shadowAttenuation        -> uShadowAttenuation (exposed as a
//                                         constant: the browser preview has no
//                                         shadow map and no URP light data)
//   _Time.y                            -> uTime (pausable preview clock)
//   _WorldSpaceCameraPos               -> cameraPosition (provided by three.js)
//   half4 color : SV_Target            -> fragColor, plus an explicit
//                                         linear -> sRGB encode, because URP
//                                         relies on an sRGB framebuffer while
//                                         three.js adds no conversion for
//                                         RawShaderMaterial.
//
// NOTE: `#version 300 es` is injected by three.js (RawShaderMaterial + GLSL3).

precision highp float;

in vec3 vPositionWS;
in vec3 vNormalWS;
in vec2 vUv;

uniform vec3  cameraPosition;     // == _WorldSpaceCameraPos
uniform float uTime;              // == _Time.y
uniform vec3  uBaseColor;         // == _BaseColor.rgb      (linear)
uniform vec3  uRimColor;          // == _RimColor.rgb       (linear)
uniform vec3  uSpecularColor;     // == _SpecularColor.rgb  (linear)
uniform vec3  uAmbientColor;      // == _AmbientColor.rgb   (linear)
uniform vec3  uLightColor;        // == GetMainLight().color
uniform vec3  uLightDirection;    // == GetMainLight().direction
uniform float uShadowAttenuation; // == mainLight.shadowAttenuation
uniform float uRimPower;          // == _RimPower
uniform float uRimIntensity;      // == _RimIntensity
uniform float uRimPulse;          // == _RimPulse
uniform float uPulseSpeed;        // == _PulseSpeed
uniform float uSmoothness;        // == _Smoothness

out vec4 fragColor;

vec3 linearToSRGB(vec3 c) {
  vec3 lo = c * 12.92;
  vec3 hi = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
  return mix(lo, hi, step(vec3(0.0031308), c));
}

// half RimLitShininess(half smoothness)
float rimLitShininess(float smoothness) {
  return exp2(mix(3.0, 11.0, clamp(smoothness, 0.0, 1.0)));
}

// half RimLitFresnel(half3 N, half3 V, half rimPower)
float rimLitFresnel(vec3 N, vec3 V, float rimPower) {
  float cosTheta = clamp(dot(N, V), 0.0, 1.0);
  return pow(1.0 - cosTheta, max(rimPower, 0.0001));
}

void main() {
  vec3 N = normalize(vNormalWS);
  vec3 V = normalize(cameraPosition - vPositionWS);
  vec3 L = normalize(uLightDirection);
  float shadowAtten = clamp(uShadowAttenuation, 0.0, 1.0);

  // half ndotl = saturate(dot(N, L)) * shadowAtten;
  float ndotl = clamp(dot(N, L), 0.0, 1.0) * shadowAtten;
  vec3 diffuse = uBaseColor * uLightColor * ndotl;

  // Blinn-Phong specular.
  vec3 H = normalize(L + V);
  float shininess = rimLitShininess(uSmoothness);
  float ndoth = pow(clamp(dot(N, H), 0.0, 1.0), shininess);
  vec3 specular = uSpecularColor * uLightColor * ndoth * clamp(uSmoothness, 0.0, 1.0);

  // Fresnel rim, optionally pulsing with time.
  float fresnel = rimLitFresnel(N, V, uRimPower);
  float pulse = 1.0 + uRimPulse * sin(uTime * uPulseSpeed);
  vec3 rim = uRimColor * fresnel * uRimIntensity * pulse;

  vec3 ambient = uBaseColor * uAmbientColor;
  vec3 color = ambient + diffuse + specular + rim;

  fragColor = vec4(linearToSRGB(clamp(color, 0.0, 1.0)), 1.0);
}

// ---------------------------------------------------------------------------
// Portfolio/RimLitUnlit
//
// Unity URP forward-lit shader: Lambert diffuse + Blinn-Phong specular from the
// main light, plus a Fresnel rim term that can pulse over time.
//
// This is the ORIGINAL HLSL source. The browser cannot execute it; the GLSL ES
// 3.00 port used for the live preview is src/shaders/glsl/rimlit-port.vert and
// src/shaders/glsl/rimlit-port.frag, and the full mapping table plus the list
// of differences is in src/content/shaders/urp-rimlit-port.md.
//
// Verified with: static review only. See "verificationNotes" in the content
// entry - this repository has no Unity installation, so the shader has NOT
// been compiled or visually compared inside the Unity editor.
// ---------------------------------------------------------------------------
Shader "Portfolio/RimLitUnlit"
{
    Properties
    {
        [MainColor] _BaseColor("Base Color", Color) = (0.16, 0.42, 0.75, 1)
        [HDR] _RimColor("Rim Color", Color) = (0.35, 0.95, 1.00, 1)
        _RimPower("Rim Power", Range(0.25, 12)) = 3.0
        _RimIntensity("Rim Intensity", Range(0, 4)) = 1.2
        _RimPulse("Rim Pulse Amount", Range(0, 1)) = 0.0
        _PulseSpeed("Pulse Speed", Range(0, 6)) = 1.5
        _Smoothness("Smoothness", Range(0, 1)) = 0.6
        [HDR] _SpecularColor("Specular Color", Color) = (1, 1, 1, 1)
        _AmbientColor("Ambient Color", Color) = (0.06, 0.07, 0.09, 1)
    }

    SubShader
    {
        Tags
        {
            "RenderType" = "Opaque"
            "RenderPipeline" = "UniversalPipeline"
            "Queue" = "Geometry"
            "IgnoreProjector" = "True"
        }
        LOD 100

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }

            HLSLPROGRAM
            #pragma vertex rimlitVert
            #pragma fragment rimlitFrag
            #pragma target 3.5

            // URP shadow keywords. The browser port has no shadow map, so it
            // always behaves like shadowAttenuation == 1 (documented as a
            // limitation of the port).
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile_fragment _ _SHADOWS_SOFT

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "RimLitUnlitInput.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                float2 uv         : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float3 positionWS : TEXCOORD0;
                float3 normalWS   : TEXCOORD1;
            };

            Varyings rimlitVert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionWS = TransformObjectToWorld(IN.positionOS.xyz);
                OUT.positionCS = TransformWorldToHClip(OUT.positionWS);
                OUT.normalWS   = TransformObjectToWorldNormal(IN.normalOS);
                return OUT;
            }

            half4 rimlitFrag(Varyings IN) : SV_Target
            {
                float3 N = normalize(IN.normalWS);
                float3 V = normalize(_WorldSpaceCameraPos - IN.positionWS);

            #if defined(_MAIN_LIGHT_SHADOWS) || defined(_MAIN_LIGHT_SHADOWS_CASCADE)
                float4 shadowCoord = TransformWorldToShadowCoord(IN.positionWS);
                Light mainLight = GetMainLight(shadowCoord);
            #else
                Light mainLight = GetMainLight();
            #endif

                float3 L = normalize(mainLight.direction);
                half3  lightColor = mainLight.color;
                half   shadowAtten = mainLight.shadowAttenuation;

                // Lambert diffuse.
                half ndotl = saturate(dot(N, L)) * shadowAtten;
                half3 diffuse = _BaseColor.rgb * lightColor * ndotl;

                // Blinn-Phong specular.
                half3 H = normalize(L + V);
                half shininess = RimLitShininess(_Smoothness);
                half ndoth = pow(saturate(dot(N, H)), shininess);
                half3 specular = _SpecularColor.rgb * lightColor * ndoth * saturate(_Smoothness);

                // Fresnel rim, optionally pulsing with _Time.y.
                half fresnel = RimLitFresnel(N, V, _RimPower);
                half pulse = 1.0h + _RimPulse * sin(_Time.y * _PulseSpeed);
                half3 rim = _RimColor.rgb * fresnel * _RimIntensity * pulse;

                half3 ambient = _BaseColor.rgb * _AmbientColor.rgb;

                // In a linear-colour-space project Unity converts the sRGB
                // values from the colour picker to linear before they reach
                // this shader, and converts the result back to sRGB when
                // writing to the framebuffer. Neither conversion appears here.
                half3 color = ambient + diffuse + specular + rim;
                return half4(color, _BaseColor.a);
            }
            ENDHLSL
        }

        // ShadowCaster / DepthOnly / DepthNormalsOnly passes are intentionally
        // omitted from this reference implementation.
    }

    FallBack "Universal Render Pipeline/Unlit"
}

#ifndef RIMLIT_UNLIT_INPUT_INCLUDED
#define RIMLIT_UNLIT_INPUT_INCLUDED

// ---------------------------------------------------------------------------
// Portfolio/RimLitUnlit - material property declarations.
//
// Unity URP (HLSL). This file is the ORIGINAL source and is never compiled by
// the browser. The GLSL ES 3.00 port lives in src/shaders/glsl/rimlit-port.*.
//
// The whole material must sit inside one CBUFFER named UnityPerMaterial so the
// shader stays SRP-Batcher compatible.
// ---------------------------------------------------------------------------

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"

CBUFFER_START(UnityPerMaterial)
    half4 _BaseColor;
    half4 _RimColor;
    half4 _SpecularColor;
    half4 _AmbientColor;
    half  _RimPower;
    half  _RimIntensity;
    half  _RimPulse;
    half  _PulseSpeed;
    half  _Smoothness;
CBUFFER_END

// Perceptual smoothness -> Blinn-Phong exponent. Both sides of the port use
// this exact expression, which is what makes the specular highlight match.
half RimLitShininess(half smoothness)
{
    return exp2(lerp(3.0h, 11.0h, saturate(smoothness)));
}

// Schlick-style rim term: pow(1 - saturate(N dot V), power).
half RimLitFresnel(half3 N, half3 V, half rimPower)
{
    half cosTheta = saturate(dot(N, V));
    return pow(1.0h - cosTheta, max(rimPower, 0.0001h));
}

#endif // RIMLIT_UNLIT_INPUT_INCLUDED