Unity中Camera渲染Texture2D透明背景异常，寻求有效解决方法

问题描述 #

在Unity项目中，尝试将Camera画面渲染到Texture2D：通过RenderTexture捕获Camera输出再复制到Texture2D，但需要最终图像具备透明背景。目前设置Camera背景为透明时，仍需指定颜色，该颜色会在图像半透明区域显现（白色框内为RenderTexture得到的最终结果）。

尝试过清除RenderTexture后单帧渲染的方案，代码如下：

public void clearTexture(RenderTexture texture) {
    RenderTexture.active = texture;
    GL.Clear(true, true, Color.clear);
    RenderTexture.active = null;

    // texture.Release();  — 另一种选项
}

public Texture2D getTextureFromCamera(Camera camera) {
    RenderTexture rt = camera.targetTexture;
    clearTexture(rt);
    viewCamera.Render();
    
    Texture2D tex = new Texture2D(rt.width, rt.height, TextureFormat.RGBA32, false);
    RenderTexture.active = rt;
    tex.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
    tex.Apply();
    RenderTexture.active = null;

    return tex;
}

但结果仍不理想：黑色半透明阴影更暗，亮色出现暗晕，未达到预期的透明效果。想了解是否有其他可行思路，比如单独获取Alpha通道并烘焙纹理，但不知如何实现。

解决方案 #

方案1：分离RGB与Alpha通道渲染（通用管线适用） #

核心思路是让相机分别渲染RGB颜色和Alpha通道，再将二者合并，避免半透明像素与背景色混合：

1. 创建两个RenderTexture，分别存储RGB颜色和Alpha通道数据
2. 用自定义Shader让相机分两次渲染：一次输出RGB，一次输出Alpha
3. 合并两个RenderTexture的像素数据到最终Texture2D

代码实现

public Texture2D GetTransparentCameraTexture(Camera camera)
{
    // 创建临时RenderTexture，分别存储RGB和Alpha
    RenderTexture rgbRT = RenderTexture.GetTemporary(camera.pixelWidth, camera.pixelHeight, 24, RenderTextureFormat.ARGB32);
    RenderTexture alphaRT = RenderTexture.GetTemporary(camera.pixelWidth, camera.pixelHeight, 24, RenderTextureFormat.R8);

    // 保存相机原目标Texture
    RenderTexture originalTarget = camera.targetTexture;

    // 渲染RGB通道（使用自定义Shader）
    camera.targetTexture = rgbRT;
    camera.RenderWithShader(Shader.Find("Custom/RGBOnly"), "");
    // 渲染Alpha通道（使用自定义Shader）
    camera.targetTexture = alphaRT;
    camera.RenderWithShader(Shader.Find("Custom/AlphaOnly"), "");

    // 合并纹理数据
    Texture2D resultTex = new Texture2D(rgbRT.width, rgbRT.height, TextureFormat.RGBA32, false);
    
    // 读取RGB数据
    RenderTexture.active = rgbRT;
    resultTex.ReadPixels(new Rect(0, 0, rgbRT.width, rgbRT.height), 0, 0);
    
    // 读取Alpha数据并替换
    RenderTexture.active = alphaRT;
    Texture2D alphaTex = new Texture2D(alphaRT.width, alphaRT.height, TextureFormat.R8, false);
    alphaTex.ReadPixels(new Rect(0, 0, alphaRT.width, alphaRT.height), 0, 0);
    alphaTex.Apply();

    Color[] finalPixels = resultTex.GetPixels();
    Color[] alphaPixels = alphaTex.GetPixels();
    for (int i = 0; i < finalPixels.Length; i++)
    {
        finalPixels[i].a = alphaPixels[i].r;
    }
    resultTex.SetPixels(finalPixels);
    resultTex.Apply();

    // 释放资源，恢复相机设置
    RenderTexture.active = null;
    camera.targetTexture = originalTarget;
    RenderTexture.ReleaseTemporary(rgbRT);
    RenderTexture.ReleaseTemporary(alphaRT);
    Destroy(alphaTex);

    return resultTex;
}

自定义Shader代码

RGBOnly.shader（仅输出RGB通道）

Shader "Custom/RGBOnly"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            ColorMask RGB // 只写入RGB通道
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;

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

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                return col;
            }
            ENDCG
        }
    }
}

AlphaOnly.shader（仅输出Alpha通道）

Shader "Custom/AlphaOnly"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            ColorMask R // 将Alpha值写入R通道
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;

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

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                return fixed4(col.a, 0, 0, 1); // 将Alpha值赋值给R通道
            }
            ENDCG
        }
    }
}

方案2：URP/HDRP原生透明设置（新管线适用） #

如果使用Universal Render Pipeline或High Definition Render Pipeline，可直接通过相机设置实现：

• 选中相机，在Inspector面板的Render Settings中，设置Background Type为Transparent
• 确保半透明物体的Shader使用正确的混合模式（如SrcAlpha OneMinusSrcAlpha）
• 渲染后的RenderTexture会直接包含正确的Alpha通道，无需额外处理，直接读取即可

方案3：后处理修正Alpha通道（快速修复） #

如果不想修改Shader或渲染管线，可在读取Texture2D后手动修正半透明区域的颜色偏移：
原理是还原半透明像素的原始颜色（默认混合下，当前RGB = 原始RGB * Alpha + 背景色*(1-Alpha)，背景为透明黑色时，原始RGB = 当前RGB / Alpha）

public Texture2D FixTransparentColorOffset(Texture2D sourceTex)
{
    Color[] pixels = sourceTex.GetPixels();
    for (int i = 0; i < pixels.Length; i++)
    {
        Color c = pixels[i];
        // 避免除以0
        if (c.a > 0.001f)
        {
            c.r /= c.a;
            c.g /= c.a;
            c.b /= c.a;
        }
        pixels[i] = c;
    }
    sourceTex.SetPixels(pixels);
    sourceTex.Apply();
    return sourceTex;
}

注意：该方法仅适用于背景为纯透明黑色的场景。

内容的提问来源于stack exchange，提问作者Falkeyn