Unity URPで選択的アウトラインをつける

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

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

public class OutlineRendererPass : ScriptableRenderPass {

    const string NAME = nameof(OutlineRendererPass);
    
    Material outlineMaterial = null;
    RenderTargetIdentifier renderTargetID = default;
    OutlineRenderer parentRendererFeature;
    
    public OutlineRendererPass(OutlineRenderer parentRendererFeature, Material outlineMaterial) {
        // ここでこのパスをどのタイミングで挿入するか決める
        renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing;
        this.parentRendererFeature = parentRendererFeature;
        this.outlineMaterial = outlineMaterial;
    }

    public void SetRenderTarget(RenderTargetIdentifier renderTargetID) {
        this.renderTargetID = renderTargetID;
    }
    
    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) {

        // 一見いらないように見えるが、SceneView切替時などでリセットされることがあり、ないと画面がマゼンダのアレになる
        if (parentRendererFeature.contentRenderers == null) return;

        CommandBuffer CB = CommandBufferPool.Get(NAME);
        CameraData camData = renderingData.cameraData;

        int texId = Shader.PropertyToID("_MainTex");
        int w = camData.camera.scaledPixelWidth;
        int h = camData.camera.scaledPixelHeight;
        int shaderPass = 0;

        CB.GetTemporaryRT(texId, w, h, 0, FilterMode.Point, RenderTextureFormat.Default);
        CB.SetRenderTarget(texId);
        CB.ClearRenderTarget(false, true, Color.clear);

        // アウトラインを着けたいオブジェクトを描画
        foreach (Renderer renderer in parentRendererFeature.contentRenderers) {
            if (renderer == null) continue; // Play終了時に、Listは破棄されずその参照先のみ破棄されるのでScene描画のために入れとかないと例のマゼンダ(ry
            // オブジェクトのマテリアルすべてでかつForwardパスで描画
            for (int i = 0; i < renderer.sharedMaterials.Length; i++) {
                CB.DrawRenderer(renderer, renderer.sharedMaterials[i], i, 0);
            }
        }

        CB.Blit(texId, renderTargetID, outlineMaterial, shaderPass);
        
        context.ExecuteCommandBuffer(CB);
        CommandBufferPool.Release(CB);
    }
}

public class OutlineRenderer : ScriptableRendererFeature {

    // インスペクターで設定する　アウトライン描画するマテリアル
    public Material outlineMaterial; 
    // アウトラインをつけたいオブジェクトのRendererのリスト
    public List<Renderer> contentRenderers;

    OutlineRendererPass outlineRenderPass = null;

    public override void Create() {
        if (outlineRenderPass == null) {
            outlineRenderPass = new OutlineRendererPass(this, outlineMaterial);
        }
    }

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

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

Shader "Unlit/outline" {
    Properties {
        _OutlineColor ("Outline Color", Color) = (1,1,1,1)
        _OutlineWidth ("Outline Width", Range(0, 10)) = 1
        _Cutoff ("Cutoff Level", Range(0, 1)) = 0
    }
    SubShader {
        Tags { "RenderType"="Overlay" "RenderPipeline"="UniversalRenderPipeline" }
        LOD 100
        ZWrite Off
        Blend SrcAlpha OneMinusSrcAlpha
        Cull Off
        ZTest Always

        Pass {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

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

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            half2 _MainTex_TexelSize;

            half4 _OutlineColor;
            half _OutlineWidth;

            half _Cutoff;

            struct Attributes {
                float4 positionOS : POSITION;
                float2 uv         : TEXCOORD0;
            };

            struct Varyings {
                float2 uv         : TEXCOORD0;
                float4 positionCS : SV_POSITION;
            };

            Varyings vert (Attributes input) {
                Varyings output;
                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
                output.positionCS = vertexInput.positionCS;
                output.uv = input.uv;
                return output;
            }

            half4 frag (Varyings i) : SV_Target {

                half2 uv = i.uv;
                half2 destUV = _MainTex_TexelSize * _OutlineWidth;
                half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);

                half sum = 0;

                [unroll(3)]
                for (int i = -1; i <= 1; i++) {
                    [unroll(3)]
                    for (int j = -1; j <= 1; j++) {
                        sum += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv + half2(destUV.x * i, destUV.y * j)).a;
                    }
                }

                sum = saturate(sum);
                clip(_Cutoff - col.a);

                half4 outline = sum * _OutlineColor;

                return outline;
            }
            ENDHLSL
        }
    }
}