Graphics.Blit in Unity

2025-09-22 13:59 UTC gpt-5-thinking Open in ChatGPT ↗

You

in unity can i Graphics.Blit from a texture 2D to a render texture of same size and properties? Because I am trying and it remains black. Also worth saying that i have already created the render texture and it’s not created procedurally

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Short answer: yes—Graphics.Blit(Texture2D, RenderTexture) works fine when both are the same size. If you’re getting a black RT, it’s almost always one of these gotchas:

The usual culprits (and quick fixes)

1. The RenderTexture isn’t actually created yet
   Even if it’s an asset in your Project (not made in code), it might not be created at runtime when you blit.

if (targetRT && !targetRT.IsCreated())
    targetRT.Create();
Graphics.Blit(sourceTex2D, targetRT);

2. Wrong RT format (depth-only / None) Make sure the RT is a color format (e.g. ARGB32, Default, or a color GraphicsFormat). A depth-only RT will show up black.

3. You’re looking at the wrong texture / timing conflict

• Verify the UI/mesh is showing that RenderTexture (easy to point at a different asset by mistake).
• If the same RT is bound to a camera (camera.targetTexture = targetRT), the camera may overwrite your blit later in the frame. Blit after the camera (or use another RT).

4. URP/HDRP + OnRenderImage confusion
   OnRenderImage doesn’t run in URP/HDRP. If your blit lives there, it won’t execute. Do the blit from Update/LateUpdate, a custom render pass, or a command buffer.

5. SRGB / Linear mismatch (looks very dark) If the result is “basically black,” check the RT’s sRGB (Color Texture) toggle vs Project color space. It won’t usually go fully black—but it can look much darker than expected.

---

Minimal working example

Drop this on any GameObject and assign sourceTex2D (imported Texture2D asset) and targetRT (RenderTexture asset with a color format):

using UnityEngine;

public class BlitTest : MonoBehaviour
{
    [SerializeField] Texture2D sourceTex2D;
    [SerializeField] RenderTexture targetRT;

    void Start()
    {
        if (!sourceTex2D || !targetRT)
        {
            Debug.LogError("Assign sourceTex2D and targetRT in the inspector.");
            return;
        }

        // 1) Ensure RT exists on GPU
        if (!targetRT.IsCreated())
            targetRT.Create();

        // 2) Sanity-check format (must be color, not depth-only)
        if (targetRT.format == RenderTextureFormat.Depth)
            Debug.LogWarning("targetRT is Depth format; use a color format like ARGB32.");

        // 3) Do the blit
        Graphics.Blit(sourceTex2D, targetRT);
    }
}

Quick diagnostic: is the display path correct?

Before blaming the blit, paint the RT a solid color and see if you can see it (e.g., in a RawImage):

var prev = RenderTexture.active;
RenderTexture.active = targetRT;
GL.Clear(true, true, Color.magenta);
RenderTexture.active = prev;

• If you see magenta, your display path is fine and the blit (or source) is the issue.
• If you still see black, you’re either looking at a different texture, the RT isn’t created, or it’s an unsupported format.

If you’re creating the RT in code (reference)

var rt = new RenderTexture(sourceTex2D.width, sourceTex2D.height, 0, RenderTextureFormat.ARGB32);
rt.useMipMap = false;
rt.Create();
Graphics.Blit(sourceTex2D, rt);

Common edge cases to avoid

• Trying to blit into a 3D or volume texture (Blit is 2D).
• Doing the blit in edit-time editor code without ensuring the RT is created first.
• Expecting Read/Write Enabled on the Texture2D import—not required for GPU blits (that’s only for CPU reads).

If you share a couple of lines showing where you call Graphics.Blit and how you’re viewing the RT (RawImage? Mesh material? Camera target?), I can pinpoint the exact issue.

You

using System.Collections; using System.Collections.Generic; using UnityEngine; using System; using Sirenix.OdinInspector; using Unity.Mathematics; using UnityEditor; using UnityEngine.Serialization;

public class GradientMapper_RT : MonoBehaviour { [Header(“Gradient map parameters”)] public string mapperName; public Vector2Int gradientMapDimensions = new Vector2Int(128, 32); [GradientUsage(true)] public Gradient gradient;

[Header("Material parameters")]
public Material mat;
public string texture_name;

//[HideInInspector]
public RenderTexture rt;
public Texture2D preview_texture;
int _propId;

private void Start()
{
    Debug.Log("-------------START-----------");
    _propId = Shader.PropertyToID(string.IsNullOrEmpty(texture_name) ? "_MainTex" : texture_name);
    GradientToRT();
    PushToMaterial();
}

private void OnValidate()
{
    //Debug.Log("-------------VALIDATE-----------");
    PreviewGradient();
    //RebuildGradientTexture();
}

[Button]
private void RebuildGradientTexture()
{

    _propId = Shader.PropertyToID(string.IsNullOrEmpty(texture_name) ? "_MainTex" : texture_name);
    GradientToRT();
    PushToMaterial();
    //GradientToTexture();
}

private void GradientToRT()
{
    if (rt == null || preview_texture == null) return;
    Debug.Log("------------BLIT ------------");
    Graphics.Blit(preview_texture,rt);
}


void PushToMaterial()
{
    if (mat == null || rt == null) return;
    if (mat.HasProperty(_propId)) mat.SetTexture(_propId, rt);

#if UNITY_EDITOR EditorUtility.SetDirty(mat); AssetDatabase.SaveAssets(); #endif }

private void PreviewGradient()
{
    if(texture_name == String.Empty)  return;


    if (preview_texture == null)
    {
        preview_texture = new Texture2D(gradientMapDimensions.x, gradientMapDimensions.y, TextureFormat.RGBAFloat, false)
        {
            name = $"{mat.name}_Gradient_PREVIEW",
            wrapMode = TextureWrapMode.Clamp,
            filterMode = FilterMode.Bilinear
        };


    }

    var w = gradientMapDimensions.x; var h = gradientMapDimensions.y;
    var pixels = new Color[w * h];

    gradient.colorSpace = ColorSpace.Linear;
    gradient.mode = GradientMode.PerceptualBlend;

    for (int x = 0; x < w; x++)
    {
       var c = gradient.Evaluate((float)x / (w - 1));
       for (int y = 0; y < h; y++) pixels[y * w + x] = c;
    }

    preview_texture.SetPixels(pixels);
    preview_texture.Apply();

    if (mat == null) return;
    if (mat.HasProperty(texture_name))
    {
        mat.SetTexture(texture_name, preview_texture);
    }
}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

You’re super close—the black RT is coming from two things in your script:

1. preview_texture often isn’t built at runtime, so your GradientToRT() exits early and nothing is ever blitted.

   • You only create/fill preview_texture in OnValidate(), and you even return early there when texture_name == String.Empty. In Play Mode that can mean preview_texture is null when Start() runs → GradientToRT() returns → RT stays black.

2. The RenderTexture may not be created on the GPU yet.

   • Even for pre-made RT assets, you should call rt.Create() (if not created) before writing into them.

Also, using TextureFormat.RGBAFloat for the preview is overkill and can cause sampling issues on some platforms. For a gradient, RGBA32 (or RGBAHalf if you truly need HDR) is simpler and more compatible.

---

Minimal fixes (drop-in)

• Build the gradient in Start() before the blit.
• Always build the preview texture (don’t gate it on texture_name).
• Ensure the RT is created.
• (Optional) Use RGBA32 for the preview.

using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif
using System;

public class GradientMapper_RT : MonoBehaviour
{
    [Header("Gradient map parameters")]
    public string mapperName;
    public Vector2Int gradientMapDimensions = new Vector2Int(128, 32);
    [GradientUsage(true)] public Gradient gradient;

    [Header("Material parameters")]
    public Material mat;
    public string texture_name;

    public RenderTexture rt;
    public Texture2D preview_texture;
    int _propId;

    void Start()
    {
        _propId = Shader.PropertyToID(string.IsNullOrEmpty(texture_name) ? "_MainTex" : texture_name);

        // 1) Build/refresh the preview texture (runtime too!)
        BuildPreviewTexture();   // <- was only in OnValidate before

        // 2) Make sure the RT actually exists on the GPU
        EnsureRTCreated();

        // 3) Blit the preview into the RT
        Graphics.Blit(preview_texture, rt);

        // 4) Push RT to the material
        PushToMaterial();
    }

    void OnValidate()
    {
        // Keep editor preview responsive
        BuildPreviewTexture();
        // If you want the material to show the RT in edit mode, you can also call PushToMaterial() here.
    }

    [ContextMenu("Rebuild Gradient Texture")]
    void RebuildGradientTexture()
    {
        _propId = Shader.PropertyToID(string.IsNullOrEmpty(texture_name) ? "_MainTex" : texture_name);
        BuildPreviewTexture();
        EnsureRTCreated();
        Graphics.Blit(preview_texture, rt);
        PushToMaterial();
    }

    void EnsureRTCreated()
    {
        if (!rt)
        {
            Debug.LogError("[GradientMapper_RT] Assign a RenderTexture.");
            return;
        }

        if (rt.format == RenderTextureFormat.Depth)
            Debug.LogError("[GradientMapper_RT] Target RT is depth-only; use a color format.");

        if (!rt.IsCreated()) rt.Create();
    }

    void BuildPreviewTexture()
    {
        // Always build the source texture; don't bail just because texture_name is empty.
        int w = Mathf.Max(1, gradientMapDimensions.x);
        int h = Mathf.Max(1, gradientMapDimensions.y);

        // Prefer RGBA32 unless you truly need HDR
        if (preview_texture == null || preview_texture.width != w || preview_texture.height != h)
        {
            if (preview_texture != null) DestroyImmediate(preview_texture);
            preview_texture = new Texture2D(w, h, TextureFormat.RGBA32, false, true) // linear
            {
                name = (mat ? $"{mat.name}_Gradient_PREVIEW" : "Gradient_PREVIEW"),
                wrapMode = TextureWrapMode.Clamp,
                filterMode = FilterMode.Bilinear,
            };
        }

        var pixels = new Color[w * h];

        // Optional: ensure linear evaluation
        gradient.colorSpace = ColorSpace.Linear;
        gradient.mode = GradientMode.PerceptualBlend;

        for (int x = 0; x < w; x++)
        {
            var c = gradient.Evaluate((float)x / (w - 1));
            for (int y = 0; y < h; y++) pixels[y * w + x] = c;
        }

        preview_texture.SetPixels(pixels);
        preview_texture.Apply();

        // If you want a live **editor** preview of the gradient (Texture2D) on the material slot:
        if (mat && !string.IsNullOrEmpty(texture_name) && mat.HasProperty(texture_name))
        {
            // This is just for edit-time preview; Start()/Rebuild will overwrite with the RT.
            mat.SetTexture(texture_name, preview_texture);
#if UNITY_EDITOR
            EditorUtility.SetDirty(mat);
#endif
        }
    }

    void PushToMaterial()
    {
        if (!mat || !rt) return;
        if (mat.HasProperty(_propId)) mat.SetTexture(_propId, rt);
#if UNITY_EDITOR
        EditorUtility.SetDirty(mat);
        AssetDatabase.SaveAssets();
#endif
    }
}

Quick sanity check

Before the blit, try:

var prev = RenderTexture.active;
RenderTexture.active = rt;
GL.Clear(true, true, Color.magenta);
RenderTexture.active = prev;

If you now see magenta where the texture is used, the display path is fine; the issue was just that nothing had been written to the RT yet.

TL;DR

• Build the gradient in play (not only OnValidate).
• Don’t early-return from the preview path when texture_name is empty.
• rt.Create() if needed.
• Prefer RGBA32 for the source texture unless you truly need HDR.

You

when i create rt it needs some data though right? like colorspace etc

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Short version: you mostly choose size + format. “Color space” isn’t a separate knob on runtime RTs—it’s implied by the graphics format you pick (sRGB vs UNorm vs Float). Here’s the practical checklist and a drop-in creator:

What you should set

• Width/Height: match your source.
• Graphics format (most important):
  • LDR color you’ll sample as color: R8G8B8A8_SRGB
  • LDR data (no gamma transforms): R8G8B8A8_UNorm
  • HDR color/data: R16G16B16A16_SFloat (aka RGBAHalf)
• Depth: 0 unless you actually need a depth buffer.
• MSAA: 1 unless you’re rendering geometry into it.
• Mipmaps: usually false for a blitted lookup/gradient.
• Sampler: filterMode, wrapMode like any texture.
• enableRandomWrite: only if a compute shader writes to it.

If you’re using a RenderTexture asset in the Project, the “sRGB (Color Texture)” checkbox in the Inspector is the same idea: sRGB vs linear. At runtime, picking an _SRGB graphics format is the equivalent.

Helper: create a sane RT

using UnityEngine;
using UnityEngine.Experimental.Rendering; // GraphicsFormatUtility in older Unity

public static class RTUtil
{
    public static RenderTexture CreateColorRTLike(Texture source, bool treatAsColor = true, bool hdr = false, string name = "RT")
    {
        int w = source.width, h = source.height;

        var wanted = hdr
            ? GraphicsFormat.R16G16B16A16_SFloat
            : (treatAsColor ? GraphicsFormat.R8G8B8A8_SRGB : GraphicsFormat.R8G8B8A8_UNorm);

        // Make sure the format is supported for rendering on this GPU:
        var gfmt = SystemInfo.GetCompatibleFormat(wanted, FormatUsage.Render);

        var desc = new RenderTextureDescriptor(w, h)
        {
            graphicsFormat   = gfmt,          // sRGB vs linear is implied by this
            depthBufferBits  = 0,
            msaaSamples      = 1,
            mipCount         = 1,
            useMipMap        = false,
            autoGenerateMips = false,
            dimension        = UnityEngine.Rendering.TextureDimension.Tex2D
        };

        var rt = new RenderTexture(desc)
        {
            name       = name,
            filterMode = FilterMode.Bilinear,
            wrapMode   = TextureWrapMode.Clamp
        };

        rt.Create(); // allocate on GPU
        return rt;
    }
}

How to use in your script

// Build the preview first (you already do this)
BuildPreviewTexture();

// Create RT if missing or wrong size/format:
if (rt == null || rt.width != preview_texture.width || rt.height != preview_texture.height)
{
    if (rt != null) rt.Release();
    // For a color gradient you’ll sample: treatAsColor = true, hdr = false (or true if >1.0)
    rt = RTUtil.CreateColorRTLike(preview_texture, treatAsColor: true, hdr: false, name: "GradientRT");
}

// Ensure it exists (important if using a Project asset):
if (!rt.IsCreated()) rt.Create();

// Now blit
Graphics.Blit(preview_texture, rt);

Rules of thumb

• Treat gradient as color? Use sRGB (*_SRGB).
  Sampling in shaders will auto linearize under Linear color space.
• Treat gradient as data/lookup math? Use UNorm (*_UNorm) to avoid any gamma conversions.
• Need HDR values (>1 or <0)? Use R16G16B16A16_SFloat (linear by definition).

That’s it—pick the right graphicsFormat, make sure the RT is Created(), and you’re good.