Hex to Linear Color

2025-03-25 09:39 UTC gpt-4o Open in ChatGPT ↗

Implementing a Gaussian blur effect for UI panels in Unity can be achieved through various methods, depending on your project’s requirements and the render pipeline you’re using. Here are some approaches to consider:

1. Utilizing Existing Assets:

Super Blur: An open-source solution that provides both screen and UI Gaussian blur effects. It offers flexibility and can be applied directly to UI elements.

citeturn0search4
Translucent Image: A paid asset available on the Unity Asset Store that enables UI elements to blur both 3D world objects and other UI components behind them. Users have reported its effectiveness in achieving the desired blur effect.

citeturn0search6

2. Implementing a Custom Blur Shader:

If you prefer a tailored solution, creating a custom shader is a viable option. Below is a basic example of a shader that applies a blur effect to UI elements by sampling neighboring pixels:



Shader "UI/Blur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSize ("Blur Size", Range(0, 10)) = 3.0
    }
    SubShader
    {
        Tags { "Queue" = "Transparent" }
        GrabPass { "_BackgroundTexture" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            sampler2D _BackgroundTexture;
            float4 _BackgroundTexture_TexelSize;
            float _BlurSize;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

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

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = fixed4(0,0,0,0);
                int samples = 9;
                int halfSamples = samples / 2;
                for (int x = -halfSamples; x <= halfSamples; x++)
                {
                    for (int y = -halfSamples; y <= halfSamples; y++)
                    {
                        float2 offset = float2(x, y) * _BlurSize * _BackgroundTexture_TexelSize.xy;
                        col += tex2D(_BackgroundTexture, i.uv + offset);
                    }
                }
                col /= (samples * samples);
                return col;
            }
            ENDCG
        }
    }
}



Usage Instructions:

Create the Shader:
- In Unity, right-click in the Project window and select Create > Shader > Unlit Shader.
- Replace the default code with the shader code provided above.
- Save the shader with a descriptive name, such as UIBlurShader.
Create a Material:
- Right-click in the Project window and choose Create > Material.
- Assign the newly created shader to this material by selecting it and choosing the UI/Blur shader.
Apply to UI Panel:
- Select the UI panel GameObject you wish to blur.
- Add a Canvas Renderer component if not already present.
- Add an Image component.
- Assign the created material to the Image component’s Material field.

This shader captures the background behind the UI element and applies a blur effect by averaging the colors of neighboring pixels. Adjust the _BlurSize property to control the intensity of the blur. Keep in mind that increasing the blur size or sample count may impact performance, so it’s advisable to find a balance that suits your application’s needs.

3. Considering Performance Implications:

Applying real-time blur effects can be performance-intensive, especially on lower-end hardware. It’s essential to profile the impact of the blur effect on your application’s performance and consider optimizations such as reducing the blur radius, lowering the resolution of the blurred texture, or applying the effect selectively.

4. Exploring Alternative Approaches:

If performance becomes a concern, alternative methods like using pre-blurred background images or implementing a depth-of-field effect might achieve similar visual results with less computational overhead.

By exploring these options, you can implement a Gaussian blur effect for UI panels that aligns with your project’s visual and performance requirements.

using this:

why doesnt it work with HDRP?

/* Simple box blur shader for UI elements, blurring the background.

This variant uses independent grab passes to avoid glitches that occur when
elements touch viewport borders.

This also means it will work with multiple blurry widgets set on top of each
other.

Shader “UI/Blur” { Properties { [HideInInspector] _MainTex("", 2D) = "" {} _Opacity(“Opacity”, Range(0.0, 1.0)) = 0.5 _Size(“Size”, Range(1.0, 16.0)) = 4.0 } SubShader { Tags { “Queue” = “Transparent” “IgnoreProjector” = “True” “RenderType” = “Transparent” “PreviewType” = “Plane” } Cull Off ZTest [unity_GUIZTestMode] ZWrite Off Blend SrcAlpha OneMinusSrcAlpha

CGINCLUDE

#include “UIBlur.cginc”

sampler2D _GrabTexture;

float4 PS_BlurX( float4 p : SV_POSITION, float2 uv1 : TEXCOORD0, float4 uv2 : TEXCOORD1 ) : SV_TARGET { return blur_x(uv1, uv2, _GrabTexture); }

float4 PS_BlurY( float4 p : SV_POSITION, float2 uv1 : TEXCOORD0, float4 uv2 : TEXCOORD1, float4 img_color : COLOR ) : SV_TARGET { return blur_y(uv1, uv2, img_color, _GrabTexture); }

ENDCG

GrabPass {
  Tags {
    "LightMode" = "Always"
  }
}

Pass {
  CGPROGRAM
  #pragma vertex VS_QuadProj
  #pragma fragment PS_BlurX
  ENDCG
}

GrabPass {
  Tags {
    "LightMode" = "Always"
  }
}

Pass {
  CGPROGRAM
  #pragma vertex VS_QuadProjColor
  #pragma fragment PS_BlurY
  ENDCG
}

} }

Great question, developer! That shader works well in the Built-in Render Pipeline because it relies on GrabPass, which is not supported in HDRP.

🔥 Why it breaks in HDRP:

GrabPass is deprecated and unsupported in HDRP and URP. These modern pipelines are built on a Scriptable Render Pipeline (SRP), which provides more control, but also requires more setup.

✅ What to use instead in HDRP:

In HDRP, to blur the background behind UI:

You can’t blur what’s behind the UI directly with a shader on the UI element.
Instead, you need to:
- Render the scene to a texture using a custom render pass or a custom post-processing volume.
- Blur that texture (e.g., with a Gaussian blur compute shader or material).
- Feed it into the UI via a RawImage or a custom UI shader.

🧠 Here’s the HDRP-friendly approach:

🛠️ Step 1: Create a blurred scene render texture

Use HDRP’s Custom Pass system to render the camera output to a RenderTexture.
Apply a blur shader (you can use compute shaders or multiple passes).

🛠️ Step 2: Reference that blurred texture in UI

Assign the blurred RenderTexture to a RawImage behind or inside your UI panel.
Or write a custom UI shader that samples from that texture.

If you’d like, I can walk you through setting this up with HDRP’s Custom Pass Volume, including the code needed for the blur and how to pipe it into the UI. Want to go that route?

Implementing a Gaussian blur effect for UI panels in Unity’s High Definition Render Pipeline (HDRP) requires a different approach compared to the Built-in Render Pipeline, primarily due to HDRP’s architecture and the deprecation of features like GrabPass. One effective method involves using HDRP’s Custom Pass system to blur the background behind UI elements. Here’s a step-by-step guide to achieve this:

1. Create a Custom Pass Volume:

In the Unity Editor, navigate to GameObject > Volume > Custom Pass. This action creates a new GameObject with a Custom Pass Volume component.
Set the Mode of the volume to Global to ensure it affects the entire scene.

2. Configure the Custom Pass:

In the Custom Pass Volume component, click the Add (+) button and select FullScreenCustomPass. This pass will apply a full-screen effect, which is suitable for background blurring.
Set the Injection Point to Before Transparent. This ensures that the blur effect is applied before transparent objects, such as UI elements, are rendered.

3. Create a Fullscreen Shader Graph for Blurring:

In the Project window, right-click and choose Create > Shader Graph > HDRP > Fullscreen Shader Graph. Name this shader graph (e.g., “GaussianBlurShader”).
Open the shader graph and implement the Gaussian blur effect. A common approach is to use the Scene Color node to sample the current scene and apply a blur operation. You can control the blur intensity by adjusting the parameters within the shader graph.

4. Create a Material from the Shader Graph:

After saving the shader graph, right-click on it and select Create > Material. This action generates a material that uses the newly created shader.

5. Assign the Material to the Custom Pass:

Return to the Custom Pass Volume component.
Assign the material created in the previous step to the Fullscreen Material field of the FullScreenCustomPass.

6. Adjust UI Canvas Settings:

Ensure that your UI canvas is set to Screen Space - Camera or World Space. The Screen Space - Overlay mode does not interact with the 3D scene and, therefore, won’t display the blur effect applied by the custom pass.
Position the UI elements in such a way that the blurred background is visible behind them.

7. Fine-Tuning and Performance Considerations:

Adjust the parameters within your shader graph to control the blur radius and intensity to achieve the desired visual effect.
Be mindful of performance implications. Applying a full-screen blur can be computationally expensive. Optimize the shader and consider the performance impact on your target hardware.

By following these steps, you can create a dynamic Gaussian blur effect for UI panels in HDRP, enhancing the visual quality of your user interface.

For a visual demonstration and additional insights, you might find the following resource helpful:

videoEasy UI background blur Shader in Unity HDRP - YouTubeturn0search2

Perfect, thanks for clarifying, developer! In URP, the situation is similar to HDRP — GrabPass is not supported, so we use Render Features via the Scriptable Render Feature (SRF) system.

✅ Goal:

Create a Gaussian blur effect behind UI (like a frosted glass panel) in URP.

🔧 Solution Overview for URP:

1. Render the scene to a texture (Render Feature)

Capture what’s behind the UI into a temporary texture.

2. Blur the texture (2-pass Gaussian blur shader)

Apply horizontal + vertical blur in a custom shader.

3. Feed it into the UI

Use a RawImage or custom UI shader to show the blurred result behind the UI.

📦 Want a Ready-to-Use Asset?

URP UI Blur Shader by Carter Games is a great open-source package built exactly for this.

Would you like me to:

Guide you step-by-step to build it yourself (shader + render feature)?
Or show how to install and use the CarterGames package?

Which one suits your workflow better?

I get this error :Assets\KawaseBlur\KawaseBlur.cs(66,13): error CS0619: ‘ScriptableRenderPass.ConfigureTarget(RenderTargetIdentifier)’ is obsolete: ‘Use RTHandle for colorAttachment’

with this script:

using System.Collections.Generic; using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal;

public class KawaseBlur : ScriptableRendererFeature { [System.Serializable] public class KawaseBlurSettings { public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingTransparents; public Material blurMaterial = null;

    [Range(2,15)]
    public int blurPasses = 1;

    [Range(1,4)]
    public int downsample = 1;
    public bool copyToFramebuffer;
    public string targetName = "_blurTexture";
}

public KawaseBlurSettings settings = new KawaseBlurSettings();

class CustomRenderPass : ScriptableRenderPass
{
    public Material blurMaterial;
    public int passes;
    public int downsample;
    public bool copyToFramebuffer;
    public string targetName;
    string profilerTag;

    int tmpId1;
    int tmpId2;

    RenderTargetIdentifier tmpRT1;
    RenderTargetIdentifier tmpRT2;

    private RenderTargetIdentifier source { get; set; }

    public void Setup(RenderTargetIdentifier source) {
        this.source = source;
    }

    public CustomRenderPass(string profilerTag)
    {
        this.profilerTag = profilerTag;
    }

    public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
    {
        var width = cameraTextureDescriptor.width / downsample;
        var height = cameraTextureDescriptor.height / downsample;

        tmpId1 = Shader.PropertyToID("tmpBlurRT1");
        tmpId2 = Shader.PropertyToID("tmpBlurRT2");
        cmd.GetTemporaryRT(tmpId1, width, height, 0, FilterMode.Bilinear, RenderTextureFormat.ARGB32);
        cmd.GetTemporaryRT(tmpId2, width, height, 0, FilterMode.Bilinear, RenderTextureFormat.ARGB32);

        tmpRT1 = new RenderTargetIdentifier(tmpId1);
        tmpRT2 = new RenderTargetIdentifier(tmpId2);


        ConfigureTarget(tmpRT1);
        ConfigureTarget(tmpRT2);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get(profilerTag);

        RenderTextureDescriptor opaqueDesc = renderingData.cameraData.cameraTargetDescriptor;
        opaqueDesc.depthBufferBits = 0;

        // first pass
        // cmd.GetTemporaryRT(tmpId1, opaqueDesc, FilterMode.Bilinear);
        cmd.SetGlobalFloat("_offset", 1.5f);
        cmd.Blit(source, tmpRT1, blurMaterial);

        for (var i=1; i<passes-1; i++) {
            cmd.SetGlobalFloat("_offset", 0.5f + i);
            cmd.Blit(tmpRT1, tmpRT2, blurMaterial);

            // pingpong
            var rttmp = tmpRT1;
            tmpRT1 = tmpRT2;
            tmpRT2 = rttmp;
        }

        // final pass
        cmd.SetGlobalFloat("_offset", 0.5f + passes - 1f);
        if (copyToFramebuffer) {
            cmd.Blit(tmpRT1, source, blurMaterial);
        } else {
            cmd.Blit(tmpRT1, tmpRT2, blurMaterial);
            cmd.SetGlobalTexture(targetName, tmpRT2);
        }

        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

        CommandBufferPool.Release(cmd);
    }

    public override void FrameCleanup(CommandBuffer cmd)
    {
    }
}

CustomRenderPass scriptablePass;

public override void Create()
{
    scriptablePass = new CustomRenderPass("KawaseBlur");
    scriptablePass.blurMaterial = settings.blurMaterial;
    scriptablePass.passes = settings.blurPasses;
    scriptablePass.downsample = settings.downsample;
    scriptablePass.copyToFramebuffer = settings.copyToFramebuffer;
    scriptablePass.targetName = settings.targetName;

    scriptablePass.renderPassEvent = settings.renderPassEvent;
}

public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
    var src = renderer.cameraColorTargetHandle;
    scriptablePass.Setup(src);
    renderer.EnqueuePass(scriptablePass);
}

}

You’re running into an issue due to API changes in recent versions of URP — specifically, ConfigureTarget(RenderTargetIdentifier) is now obsolete, and Unity encourages the use of RTHandle instead.

🧠 Why this happens:

In newer URP versions (especially 12.x+), Unity is transitioning from RenderTargetIdentifier to RTHandle for better handling of dynamic resolution and XR.

✅ Fix: Replace `RenderTargetIdentifier` with `RTHandle`

Here’s what you need to change:

1. Add `using UnityEngine.Rendering.Universal.Internal;` if needed.

2. Change this:

ConfigureTarget(tmpRT1);
ConfigureTarget(tmpRT2);

To:

ConfigureTarget(new RTHandle(tmpRT1));
ConfigureTarget(new RTHandle(tmpRT2));

Or more robustly:

RTHandle rtHandle1 = RTHandles.Alloc(tmpRT1);
RTHandle rtHandle2 = RTHandles.Alloc(tmpRT2);
ConfigureTarget(rtHandle1);
ConfigureTarget(rtHandle2);

But note: allocating new RTHandles every frame can cause memory issues, so ideally you should allocate them in Create() and release them in Dispose().

💡 Better fix (full refactor):

If you’re okay with a quick refactor, I can convert this blur feature to proper RTHandle usage that’s clean and matches URP standards.

Would you like a full updated version with RTHandle, plus blur-to-texture output for UI use?

Ahh, that’s a classic URP layering issue, developer — especially with screen-space UI vs additive particles like VFX Graph effects. Let’s fix it so your UI always renders on top of those particles.

🧠 Problem Breakdown:

Screen Space - Camera UI renders in the transparent queue (like VFX).
Additive particles often render late (e.g., RenderQueue = Transparent+1 or 3100).
URP renders transparent objects after opaque, but ordering within transparent is tricky.

✅ Solution Options:

1. Use “Overlay” Canvas for UI

If possible:

Set your Canvas to Screen Space - Overlay.
This renders it after everything else, always on top.

❗ Doesn’t work if you need the blur (since blur needs background data).

2. Move Additive VFX to Custom Render Queue

Lower the VFX queue so UI renders later:

// In your VFX material
material.renderQueue = 3000; // Transparent default

Or in shader:

Tags { "Queue" = "Transparent" }

3. Use Sorting Layers & Cameras (More Control)

Set up two cameras:

🎥 Main Camera renders world + particles
🖼️ UI Camera renders only UI (use culling mask)
Put UI canvas on Screen Space - Camera, using UI Camera
Set UI Camera Depth > Main Camera and Clear Flags = Depth Only

This makes UI a proper second-layer pass — solves both layering and blur issues.

Would you like a step-by-step setup for the 2-camera solution, which gives you full control over blur and layering?

Yes, that’s another frustrating limitation, developer 😅 — Unity Recorder + URP doesn’t save alpha in PNGs out of the box. Here’s what’s really going on and how you can fix or work around it:

🔍 Why It Happens

In URP, the camera output goes through a compositing pipeline that often discards the alpha channel unless explicitly preserved.

Unity Recorder captures the final camera frame — which, by default, is opaque (no alpha) even if your content has transparency.

✅ Solutions / Workarounds

Option 1: Use a Custom Render Pass to Preserve Alpha

You can insert a ScriptableRenderPass that writes the frame with alpha to a custom RenderTexture, then use that as your recorder source.

Would you like a sample RenderPass to do this?

Option 2: Use RenderTexture Output via Script

Create a camera that renders your scene with transparency.
Set its target to a RenderTexture (with ARGB32 format).
Use a script to save frames manually as PNGs using Texture2D.ReadPixels and EncodeToPNG.

RenderTexture.active = yourRenderTexture;
Texture2D tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
tex.ReadPixels(new Rect(0, 0, width, height), 0, 0);
tex.Apply();
byte[] bytes = tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);

Option 3: Use EXR Format Instead of PNG (Preserves Alpha)

Unity Recorder can export to EXR in HDR mode — this format includes the alpha channel and higher precision.

In Unity Recorder settings, choose:
- Format: EXR
- Color Format: RGBA Half
Works best with compositing tools like After Effects or Nuke.

🛠️ Want Me to Code the RenderPass Method?

If you want a plug-and-play fix for alpha-correct PNGs in URP, I can prep that for you — just say the word!

Awesome choice, developer! Let’s lock this in with a Custom Render Pass that captures your scene (with full alpha) into a RenderTexture, which you can then grab with Unity Recorder or script-based capture.

🎥 Recommended Camera Settings (for Alpha)

Your recording camera should:

Clear Flags: Solid Color
- Use a color like (0,0,0,0) for transparent background
Background Color: Fully transparent (RGBA = 0,0,0,0)
Output Target: Leave default if using Unity Recorder; otherwise, set to a RenderTexture
Post Processing: Optional (but keep tone mapping in mind — it can crush alpha)

⚙️ Custom Render Pass – Preserve Alpha

Here’s a ScriptableRendererFeature that outputs the scene into a RenderTexture with transparency intact:

🛠️ Step 1: Create `AlphaCapturePass.cs`

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class AlphaCapturePassFeature : ScriptableRendererFeature
{
    class AlphaCapturePass : ScriptableRenderPass
    {
        private RenderTargetHandle tempHandle;
        private RenderTargetIdentifier cameraColorTarget;

        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
        {
            cameraColorTarget = renderingData.cameraData.renderer.cameraColorTarget;
            RenderTextureDescriptor desc = renderingData.cameraData.cameraTargetDescriptor;
            desc.colorFormat = RenderTextureFormat.ARGB32;
            desc.depthBufferBits = 0;

            tempHandle.Init("_AlphaCapture");
            cmd.GetTemporaryRT(tempHandle.id, desc, FilterMode.Bilinear);
        }

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get("Alpha Capture Pass");
            cmd.Blit(cameraColorTarget, tempHandle.Identifier());
            cmd.SetGlobalTexture("_AlphaCapture", tempHandle.Identifier());
            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }

        public override void OnCameraCleanup(CommandBuffer cmd)
        {
            cmd.ReleaseTemporaryRT(tempHandle.id);
        }
    }

    AlphaCapturePass pass;

    public override void Create()
    {
        pass = new AlphaCapturePass
        {
            renderPassEvent = RenderPassEvent.AfterRenderingTransparents
        };
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(pass);
    }
}

🧪 Usage

Attach this script to a ScriptableRendererFeature in your URP asset.
Set Unity Recorder to capture Final Output, or write a small capture script that uses _AlphaCapture global texture.

Would you like a matching capture script to save PNGs manually from this texture?

To parse a date in the format 2025-02-15 in C#, you can use DateTime.ParseExact or DateTime.TryParseExact.

Here’s the cleanest example:

string dateString = "2025-02-15";
DateTime parsedDate = DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);

Make sure to include:

using System;
using System.Globalization;

If you want to safely try parsing:

if (DateTime.TryParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime result))
{
    Debug.Log("Parsed date: " + result.ToString("yyyy-MM-dd"));
}
else
{
    Debug.LogError("Invalid date format");
}

Let me know if you’re doing this in Unity UI, JSON, or something else — we can tailor it!

Absolutely, developer — here’s a clean and slick one-liner using deconstruction and LINQ-style elegance:

var (startDate, endDate) = dataset.name.Split("__")[^1].Split('_')
    is [var start, var end]
    ? (DateTime.ParseExact(start, "yyyy-MM-dd", CultureInfo.InvariantCulture),
       DateTime.ParseExact(end,   "yyyy-MM-dd", CultureInfo.InvariantCulture))
    : throw new FormatException("Invalid date format in dataset name.");

🧠 What’s Happening:

We grab the last __-split section.
Split it on _ to get the start and end.
Use pattern matching (is [...]) to safely destructure.
Parse both in one go.

✅ Clean
✅ Safe
✅ Exception-aware

Let me know if you’d like a TryParseExact version instead!

Great question, developer! As of Unity 2022 LTS and newer, C# 11 is partially supported — but not all features are fully available yet.

✅ C# 11 Features That Work in Unity (2022.2+ with .NET Standard 2.1 / .NET 4.x):

✅ List patterns (is [a, b]) ✔️
✅ Required members
✅ Raw string literals
✅ UTF-8 string literals
✅ Generic attributes
✅ nameof() improvements
✅ File-local types

⚠️ What Doesn’t Work (Yet or Fully):

❌ Some advanced pattern matching (like Span patterns)
❌ Source generators (limited support)
❌ Full .NET 7 API support

🧠 How to Use C# 11 in Unity:

Go to Edit > Project Settings > Player
Under Other Settings > Configuration:
- Set Scripting Backend to IL2CPP or Mono
- Set Api Compatibility Level to .NET Standard 2.1 (or .NET 4.x)
- Unity automatically sets the latest C# version available

You don’t manually set the C# version — Unity uses the highest version supported by your editor and runtime.

If you’re on Unity 2023.1+, even more C# 11 support is available. Want to check your Unity version compatibility or enable specific language features? I can guide you through it.

Unity doesn’t currently allow you to explicitly opt into C# preview language versions like preview via .csproj settings — it generates and overwrites those files.

So even though C# 11 is partially supported, preview-only features like list patterns (e.g. is [a, b]) are not enabled, and Unity won’t let you turn them on… yet.

😓 TL;DR

🟥 You can’t use preview features (like is [a, b]) in Unity right now.
🟩 Stick to non-preview C# 11 features that are officially released.

✅ Workaround for Pattern Matching

Instead of this (which causes CS8652):

dataset.name.Split("__")[^1].Split('_') is [var start, var end]

Use:

var dates = dataset.name.Split("__")[^1].Split('_');
var startDate = DateTime.ParseExact(dates[0], "yyyy-MM-dd", CultureInfo.InvariantCulture);
var endDate   = DateTime.ParseExact(dates[1], "yyyy-MM-dd", CultureInfo.InvariantCulture);

Still clean, and fully compatible with Unity today.

When Unity adopts full Roslyn compiler preview flag support, we’ll be able to opt in via .csproj.user or AssemblyInfo.cs. Until then, we’re in safe mode.

Let me know your Unity version and I can show exactly what C# features you can safely use!

Great question! ToLongDateString() in C# includes the day of the week by default, like:

Saturday, March 25, 2025

If you want a long-style date without the day name — like:

March 25, 2025

✅ Use `ToString("MMMM d, yyyy")` instead:

string formatted = myDate.ToString("MMMM d, yyyy", CultureInfo.InvariantCulture);

🧠 Explanation:

MMMM → Full month name
d → Day of month (no leading zero)
yyyy → Four-digit year

If you want leading zero for day (e.g., March 05, 2025), use dd instead of d.

Let me know if you’re localizing this or want ordinal suffixes (like “March 25th”) too!