Invisible Shadow Caster

2025-04-06 16:36 UTC o3-mini-high Open in ChatGPT ↗

You can achieve this by using a custom shader that “hides” the object from the camera by not writing any color data while still allowing it to write to the depth buffer so that its geometry is available for shadow mapping. In Unity’s built-in pipeline, this is often done by using the ColorMask 0 directive in your shader. This tells the GPU not to output any color (making the object invisible), yet the object still exists in the scene to cast shadows.

Steps to Implement

Create a Custom Shader:
- Write a shader that uses ColorMask 0 in its pass. This pass won’t output any visible pixels, but the object’s geometry will still be processed for shadow casting.
Assign the Material:
- Create a new material using your custom shader and assign it to the object you want to be invisible yet cast shadows.
Configure the Mesh Renderer:
- Make sure the object’s Mesh Renderer is set to cast shadows. You can leave its “Receive Shadows” setting on if you want other objects to receive shadows.

Sample Shader Code

Below is an example shader for the built-in render pipeline:

Shader "Custom/InvisibleShadowCaster" {
    Properties {
        // You can add properties if needed.
    }
    SubShader {
        Tags { "Queue"="Geometry" "RenderType"="Opaque" }

        // Main pass: does not write to the color buffer
        Pass {
            // Disable color writes so nothing is visible to the camera.
            ColorMask 0

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

            struct appdata {
                float4 vertex : POSITION;
            };

            struct v2f {
                float4 pos : SV_POSITION;
            };

            v2f vert (appdata v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target {
                // This return value is irrelevant because ColorMask 0 prevents any color output.
                return fixed4(0,0,0,0);
            }
            ENDCG
        }

        // (Optional) You can add an explicit ShadowCaster pass if needed.
    }
    FallBack "Diffuse"
}

Additional Considerations

Render Pipeline Variations:
If you are using URP or HDRP, the approach might differ slightly. In URP, for instance, you might create a custom shader graph or modify an Unlit shader to achieve a similar effect.
Performance:
Since the object still exists in the scene and participates in shadow mapping, it will affect performance similar to a normal object casting shadows.

By using this shader, your object will remain invisible in the camera’s view while still casting shadows on other objects in your scene.

In URP you can also use a custom shader to “hide” the object from the camera while still allowing it to cast shadows. The idea is similar to the built-in pipeline approach—disable color writes (using a ColorMask) in the main pass so nothing is rendered to the screen, yet still include a ShadowCaster pass for proper shadow mapping.

Below is an example of a custom URP shader written in HLSL that achieves this effect:

Shader "Custom/InvisibleShadowCasterURP"
{
    Properties
    {
        // No properties needed unless you want to expose additional options.
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "Queue"="Geometry" }

        // Main pass: renders nothing to the camera.
        Pass
        {
            // Disable writing to the color buffer.
            ColorMask 0

            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;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                // This output is never written to the screen.
                return half4(0, 0, 0, 0);
            }
            ENDHLSL
        }

        // Shadow caster pass: necessary for casting shadows.
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }

            HLSLPROGRAM
            #pragma vertex vertShadow
            #pragma fragment fragShadow
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
            };

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

            float fragShadow(Varyings IN) : SV_Target
            {
                // The actual shadow output is handled by URP internally.
                return 0;
            }
            ENDHLSL
        }
    }
    FallBack "Hidden/InternalErrorShader"
}

How It Works

Main Pass:
The main pass has ColorMask 0 which prevents any color output, so the object is not visible in the camera’s view. However, the geometry is still processed and contributes to depth and shadow maps.
ShadowCaster Pass:
This pass is explicitly tagged for shadow casting ("LightMode"="ShadowCaster"), ensuring that URP correctly includes this object when calculating shadows.

Using the Shader

Create a Material:
Save the shader into your project (e.g., as InvisibleShadowCasterURP.shader), then create a new material that uses this shader.
Assign to Your Object:
Apply the material to the object you want to be invisible but still cast shadows.

Alternatives with Shader Graph

If you prefer using Shader Graph in URP:

You can create an Unlit Shader Graph and then, in the “Graph Inspector,” look for options to override render state. Although Shader Graph doesn’t expose a direct “ColorMask” setting in all versions, you can add a Custom Function Node or modify the generated shader code to insert ColorMask 0 in the appropriate pass.
Alternatively, you can duplicate a basic unlit shader generated by Shader Graph and then manually add the ColorMask 0 directive in your favorite code editor.

Using this approach, your object will be invisible during normal rendering but will still interact with lights and cast shadows on other objects in your URP scene.

this throws error before the offset is applied. make it handle utc offsets robustly

    // Create a DateTime in UTC, then apply the user's UTC offset to get local time
    DateTime dateTime = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc).AddHours(utcOffset);

Using the built-in DateTime type and manually applying offsets can lead to issues—especially when the resulting value goes out of the valid range. A more robust solution is to work with the DateTimeOffset type, which is designed for handling UTC offsets.

Using DateTimeOffset for Robust UTC Offset Handling

The DateTimeOffset type represents a point in time relative to UTC and makes it easy to adjust for different offsets without running into range issues as easily. For example:

try
{
    // Create a DateTimeOffset in UTC using your date components.
    DateTimeOffset utcDateTime = new DateTimeOffset(year, month, day, hour, minute, second, TimeSpan.Zero);

    // Create a TimeSpan from the user's UTC offset (supports fractional hours).
    TimeSpan userOffset = TimeSpan.FromHours(utcOffset);

    // Adjust the DateTimeOffset to the desired offset.
    DateTimeOffset localDateTime = utcDateTime.ToOffset(userOffset);

    // If you need a DateTime, you can extract it from the DateTimeOffset.
    DateTime localTime = localDateTime.DateTime;

    Console.WriteLine("Local Time: " + localTime);
}
catch (ArgumentOutOfRangeException ex)
{
    // Handle cases where the input values or resulting date are out of range.
    Console.WriteLine("Error: " + ex.Message);
}

Explanation

DateTimeOffset Creation:
We initialize the DateTimeOffset with a zero offset (UTC) using your provided date and time components. This ensures that the starting point is unambiguously defined as UTC.
Offset Conversion:
Using TimeSpan.FromHours(utcOffset), you can handle both whole and fractional hour offsets. Then, calling utcDateTime.ToOffset(userOffset) adjusts the time to the desired offset robustly.
Error Handling:
Wrapping the code in a try-catch block helps capture any ArgumentOutOfRangeException that might be thrown if the input values or the resulting date fall outside of the allowed DateTime range.

This approach minimizes potential errors related to manual offset adjustments and makes your code more robust when dealing with UTC offsets.

your method simply handled errors, didnt solve the underlying issue. review the following fix:

    try
    {
        var actualDay   = day;
        var actualHour  = hour;
        var actualMonth = month;
        var actualYear  = year;

        if (hour > 24 || (hour == 24 && (minute > 0 || second > 0)) )
        {
            actualHour = hour - 24;
            actualDay++;
        }

        if (day > DateTime.DaysInMonth(2025, month))
        {
            actualMonth++;
            actualDay = day - DateTime.DaysInMonth(2025, month);
        }

        if (month > 12)
        {
            actualYear++;
            actualMonth = month - 12;
        }

        // Create a DateTimeOffset in UTC using your date components.
        DateTimeOffset utcDateTime = new DateTimeOffset(actualYear, actualMonth, actualDay, actualHour, minute, second, TimeSpan.Zero);

Your fix attempts to manually “normalize” the time components before constructing the DateTimeOffset. It works for some cases, but it has a few limitations and potential pitfalls:

Hardcoded Year for DaysInMonth:
Your check uses DateTime.DaysInMonth(2025, month) even though the year might change once you increment it. Instead, you should use the actual year value (or a temporary variable that represents the current year being normalized).
Single Rollover Only:
The if‑statements only adjust for one rollover (e.g., when the hour exceeds 24 by a small amount or when the day exceeds the number of days in that month by a little). If the provided hour, day, or month is far outside the normal range (say, hour = 50 or day is several days too high), your code won’t fully normalize the value.
Negative Offsets and Underflow:
Your fix handles positive overflow (e.g., hour > 24), but if you have a negative offset that would push the time into the previous day, similar underflow logic would be needed.

A more robust and less error‑prone approach is to leverage TimeSpan arithmetic. For example, you can create a “base date” from the year, month, and day with a zero time, then add a TimeSpan constructed from the hour, minute, and second. This way, any overflow or underflow will be automatically handled by DateTime’s arithmetic. Finally, you can adjust for the UTC offset. Here’s an alternative implementation:

try
{
    // Construct a TimeSpan from the provided hour, minute, and second.
    // TimeSpan automatically handles values outside the typical 0-23 range.
    TimeSpan timeOfDay = new TimeSpan(hour, minute, second);

    // Create a base DateTime in UTC for the given year, month, and day.
    DateTime baseDate = new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);

    // Add the TimeSpan to the base date. This automatically normalizes the date/time.
    DateTime normalizedUtc = baseDate.Add(timeOfDay);

    // Create a DateTimeOffset from the normalized UTC time.
    DateTimeOffset utcDateTime = new DateTimeOffset(normalizedUtc, TimeSpan.Zero);

    // Apply the user's UTC offset.
    DateTimeOffset localDateTime = utcDateTime.ToOffset(TimeSpan.FromHours(utcOffset));

    Console.WriteLine("Local DateTime: " + localDateTime);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine("Error: " + ex.Message);
}

Explanation

TimeSpan Arithmetic:
By constructing a TimeSpan from the given hour, minute, and second, any values outside the typical range (e.g., hour > 23) are normalized when added to the base date. For example, if hour is 25, the resulting time becomes 1:00 on the next day automatically.
Base Date Construction:
We create the base date using only the year, month, and day. This avoids the risk of constructing an invalid DateTime if the time components are out of range.
Automatic Normalization:
Adding the TimeSpan to the base date leverages DateTime’s built-in arithmetic to handle day/month/year overflows correctly, even across month and year boundaries.
UTC Offset Application:
Finally, using ToOffset with a TimeSpan from the user’s offset applies the desired UTC offset without manual adjustments.

This approach is generally more robust and reduces the risk of introducing subtle bugs from manually adjusting each component.

Assuming you have an altitude (or elevation) angle and an azimuth angle and you want to convert these spherical coordinates into Cartesian XYZ coordinates (with y as the up axis as is common in Unity), you can use the following formulas:

x = r * cos(altitude) * cos(azimuth)
y = r * sin(altitude)
z = r * cos(altitude) * sin(azimuth)

Here, r is the distance (or radius) from the origin. If you don’t have a specific radius, you can set r = 1 for a unit vector.

Note:
Make sure your angles are in radians. In Unity you can convert degrees to radians using Mathf.Deg2Rad.

Example Code in C#

using UnityEngine;

public class SphericalToCartesian : MonoBehaviour
{
    // Angles in degrees.
    public float altitudeDegrees = 30f;
    public float azimuthDegrees = 45f;
    public float radius = 1f;

    void Start()
    {
        // Convert degrees to radians.
        float altitude = altitudeDegrees * Mathf.Deg2Rad;
        float azimuth = azimuthDegrees * Mathf.Deg2Rad;

        // Compute Cartesian coordinates.
        float x = radius * Mathf.Cos(altitude) * Mathf.Cos(azimuth);
        float y = radius * Mathf.Sin(altitude);
        float z = radius * Mathf.Cos(altitude) * Mathf.Sin(azimuth);

        Vector3 cartesianCoords = new Vector3(x, y, z);
        Debug.Log("Cartesian Coordinates: " + cartesianCoords);
    }
}

Explanation

Altitude Conversion:
Mathf.Sin(altitude) gives the y-component (vertical) of the position.
Azimuth Conversion:
Mathf.Cos(azimuth) and Mathf.Sin(azimuth) determine the horizontal (x and z) components.
Normalization:
Using a radius of 1 produces a unit vector pointing in the direction specified by the altitude and azimuth. Adjust r if you need a different distance.

This approach correctly converts your spherical coordinates (using altitude and azimuth) into a Cartesian vector that you can use in your Unity project.