ShowState Enum Functionality

2025-03-19 14:12 UTC o3-mini-high Open in ChatGPT ↗

In the OVRHand script from the Oculus Integration package for Unity, the ShowState enum is essentially a setting that determines under what conditions the hand model should be visible in VR. Different values in the ShowState enum tell Unity whether to show or hide the hand model based on factors like whether the user is holding controllers or performing certain gestures.

For example, one commonly used value is ControllerNotInHand, which means:

The hand model will only be shown when the user is not holding a controller.
If the user picks up or is detected using a controller, the hand model is automatically hidden.

Depending on your Oculus Integration version, you might see slightly different enum entries (such as “AlwaysShow,” “HideWhenController,” etc.), but they all revolve around deciding when to draw the virtual hand versus when to hide it. This lets you seamlessly switch between controller-based input and hand-tracking input without manual toggles—Unity (through OVRHand) handles visibility for you.

change this shader so that it works with URP

/************************************************************************************

See SampleFramework license.txt for license terms. Unless required by applicable law or agreed to in writing, the sample code is provided “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the license for specific language governing permissions and limitations under the license.

************************************************************************************/

Shader “Oculus Sample/Alpha Hand Outline (SBB)” { Properties { _ColorPrimary (“Color Primary”, Color) = (0.396078, 0.725490, 1) _ColorTop (“Color Top”, Color) = (0.031896, 0.0343398, 0.0368894) _ColorBottom (“Color Bottom”, Color) = (0.0137021, 0.0144438, 0.0152085) _RimFactor (“Rim Factor”, Range(0.01, 1.0)) = 0.65 _FresnelPower (“Fresnel Power”, Range(0.01,1.0)) = 0.16

_HandAlpha ("Hand Alpha", Range(0, 1)) = 1.0
_MinVisibleAlpha ("Minimum Visible Alpha", Range(0,1)) = 0.15

} SubShader { Tags {“Queue” = “Transparent” “Render” = “Transparent” “IgnoreProjector” = “True”} LOD 100

// Write depth values so that you see topmost layer.
Pass
{
  ZWrite On
  ColorMask 0

  CGPROGRAM
  #pragma vertex vert
  #pragma fragment frag
  #include "UnityCG.cginc"

  float4 vert(float4 vertex : POSITION) : SV_POSITION
  {
    return UnityObjectToClipPos(vertex);
  }

  fixed4 frag() : SV_Target
  {
    return 0;
  }
  ENDCG
}

CGPROGRAM
#include "UnityCG.cginc"
// no deferred. support lightmaps and one light. use half vector instead of
// view vector (less accurate but faster)
#pragma surface surf BlinnPhong alpha:fade exclude_path:prepass noforwardadd halfasview nolightmap

sampler2D _MainTex;

struct Input {
  float2 uv_MainTex;
  float3 worldRefl;
  float3 viewDir;
  INTERNAL_DATA
};

#define ColorBlack half3(0, 0, 0)
#define EmissionFactor (0.95)

fixed3 _ColorPrimary;
fixed3 _ColorTop;
fixed3 _ColorBottom;
float _RimFactor;
float _FresnelPower;

float _HandAlpha;
float _MinVisibleAlpha;

float3 SafeNormalize(float3 normal) {
  float magSq = dot(normal, normal);
  if (magSq == 0) {
    return 0;
  }
  return normalize(normal);
}

void surf(Input IN, inout SurfaceOutput o) {
  float3 normalDirection = SafeNormalize(o.Normal);
  float3 viewDir = SafeNormalize(IN.viewDir);
  half viewDotNormal = saturate(dot(viewDir, normalDirection));
  // the higher the rim factor, the greater the effect overall. by default,
  // it's strongest near edges
  half rim = pow(1.0 - viewDotNormal, 0.5) * (1.0 - _RimFactor) + _RimFactor;
  rim = saturate(rim);

  half3 emission = lerp(ColorBlack, _ColorPrimary, rim);
  // brighten emission a bit, multiply by factor to reign it in
  emission += rim * 0.5;
  emission *= EmissionFactor;

  // effect gets stronger toward edges. note that lerp can extrapolate! saturate first
  // potentially could schlick approx, like specColor + (1-specColor)*nDotLight^5
  // except here we woulduse nDotView instead of nDotLight
  float fresnel = saturate(pow(1.0 - viewDotNormal, _FresnelPower));
  fixed3 color = lerp(_ColorTop, _ColorBottom, fresnel);

  fixed alphaValue = step(_MinVisibleAlpha, _HandAlpha) * _HandAlpha;

  o.Albedo = 0;
  o.Gloss = 0;
  o.Specular = 0;
  o.Alpha = alphaValue;
  o.Emission = color * emission;
}
ENDCG

} }

Below is an example of how you can rewrite the original Alpha Hand Outline shader to work under the Universal Render Pipeline (URP). URP does not support the old Surface Shader (BlinnPhong, #pragma surface surf ...) style; instead, you typically write vertex/fragment (HLSL) passes or use Shader Graph.

Important Notes

The example below uses two passes to mimic the original shader’s behavior:

DepthOnly pass (writes to depth, no color).

ForwardLit pass (calculates rim/fresnel effect and final color/alpha).

Since this is a transparent object, you may want ZWrite Off in the second pass for typical blending—but the original code writes depth, so we leave ZWrite On to replicate that behavior. Adjust as needed for your project.

This version is effectively unlit except for the custom rim/fresnel calculation. If you need full dynamic lighting, you must implement additional URP lighting calls or use a Shader Graph approach with custom nodes.

Shader "Oculus Sample/Alpha Hand Outline URP"
{
    Properties
    {
        _ColorPrimary ("Color Primary", Color) = (0.396078, 0.725490, 1, 1)
        _ColorTop ("Color Top", Color) = (0.031896, 0.0343398, 0.0368894, 1)
        _ColorBottom ("Color Bottom", Color) = (0.0137021, 0.0144438, 0.0152085, 1)
        _RimFactor ("Rim Factor", Range(0.01, 1.0)) = 0.65
        _FresnelPower ("Fresnel Power", Range(0.01,1.0)) = 0.16

        _HandAlpha ("Hand Alpha", Range(0, 1)) = 1.0
        _MinVisibleAlpha ("Minimum Visible Alpha", Range(0,1)) = 0.15
    }

    SubShader
    {
        // Matches original tags for transparency
        Tags
        {
            "Queue"="Transparent"
            "RenderType"="Transparent"
            "IgnoreProjector"="True"
        }

        // --- Pass 1: Depth-only (no color) ---
        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode" = "DepthOnly" }

            ZWrite On
            ColorMask 0 // Don’t write color, only depth

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

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

            struct Attributes
            {
                float4 positionOS : POSITION;
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
            };

            Varyings vert (Attributes IN)
            {
                Varyings OUT;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS);
                return OUT;
            }

            float4 frag (Varyings IN) : SV_Target
            {
                // We only care about writing depth, so color is unused.
                return float4(0, 0, 0, 0);
            }
            ENDHLSL
        }

        // --- Pass 2: Forward-lit pass with rim/fresnel effect ---
        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }

            // Typical blend for transparency
            Blend SrcAlpha OneMinusSrcAlpha

            // Matching original code that writes depth on transparent
            ZWrite On
            Cull Off

            HLSLPROGRAM
            #pragma prefer_hlslcc gles
            #pragma vertex vert
            #pragma fragment frag

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

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

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float3 normalWS    : TEXCOORD0;
                float3 viewDirWS   : TEXCOORD1;
            };

            UNITY_DECLARE_COLOR(_ColorPrimary);
            UNITY_DECLARE_COLOR(_ColorTop);
            UNITY_DECLARE_COLOR(_ColorBottom);

            float _RimFactor;
            float _FresnelPower;
            float _HandAlpha;
            float _MinVisibleAlpha;

            // ---------------------------------------------------
            // VERTEX: transform positions/normals to world space
            // ---------------------------------------------------
            Varyings vert (Attributes IN)
            {
                Varyings OUT;

                float3 worldPos = TransformObjectToWorld(IN.positionOS.xyz);
                OUT.positionHCS = TransformWorldToHClip(worldPos);

                OUT.normalWS = normalize(TransformObjectToWorldNormal(IN.normalOS));

                // Calculate view direction in world space
                float3 viewDirWS = GetCameraPositionWS() - worldPos;
                OUT.viewDirWS = normalize(viewDirWS);

                return OUT;
            }

            // ---------------------------------------------------
            // FRAGMENT: apply rim/fresnel effect & alpha
            // ---------------------------------------------------
            half4 frag (Varyings IN) : SV_Target
            {
                // Safe normalize
                float3 normalDirection = normalize(IN.normalWS);
                float3 viewDir = normalize(IN.viewDirWS);

                // Dot of view direction vs. normal
                float viewDotNormal = saturate(dot(viewDir, normalDirection));

                // Rim factor logic from original
                float rim = pow(1.0 - viewDotNormal, 0.5) * (1.0 - _RimFactor) + _RimFactor;
                rim = saturate(rim);

                // "Emission" color near edges
                float3 emission = lerp(float3(0,0,0), _ColorPrimary.rgb, rim);
                emission += rim * 0.5;    // brightens near edges
                emission *= 0.95;        // original "EmissionFactor"

                // Fresnel-based color fade from top to bottom
                float fresnel = saturate(pow(1.0 - viewDotNormal, _FresnelPower));
                float3 color = lerp(_ColorTop.rgb, _ColorBottom.rgb, fresnel);

                // Minimum alpha logic
                float alphaValue = step(_MinVisibleAlpha, _HandAlpha) * _HandAlpha;

                // Final unlit color = "color * emission"
                float3 finalColor = color * emission;

                return float4(finalColor, alphaValue);
            }
            ENDHLSL
        }
    }

    // No built-in fallback
    FallBack Off
}

How this URP shader differs from the original

No Surface Shader: URP does not support #pragma surface surf ...; instead, we do a custom vertex + fragment approach.
Two Passes:
- DepthOnly pass replicates the original “write to depth only, no color” pass.
- ForwardLit pass performs the rim/fresnel calculation and final RGBA output.
Custom Emission: We manually compute “emission” rather than using built-in Unity lighting calls. This makes it effectively unlit except for the custom rim logic.

You can tweak the Blend, ZWrite, or Cull settings in the second pass to fit your project’s needs (e.g., if you want typical alpha blending with no depth writes, use ZWrite Off). If you require actual dynamic lighting, you’d have to incorporate URP’s lighting functions or use Shader Graph with nodes that replicate your rim/fresnel logic.