Tag: Part

Using GrabPass

GrabPass is a special type of pass – it captures the content of the screen where the object is about to be drawn in a texture. This texture can be used in the following passes to perform advanced image-based effects.

Just GrabPass {} captures the contents of the current screen in a texture. The texture is accessible in other passages by the name _GrabTexture. Note: this form of capture will do the long screen capture operation for each object that uses it.

GrabPass {"TextureName"} captures the contents of the current screen in a texture, but will only do this once per image for the first object that uses the given texture name. The texture can be viewed in other passages by the given texture name. This is a more efficient method when multiple objects use GrabPass in the scene

GrabPass{ "_GrabTexture" }

Initialize the position and enter the position in the shader:

    v2f vert(appdata_base v) {
        v2f o;
        // use UnityObjectToClipPos from UnityCG.cginc to calculate 
        // the clip-space of the vertex
        o.pos = UnityObjectToClipPos(v.vertex);
        // use ComputeGrabScreenPos function from UnityCG.cginc
        // to get the correct texture coordinate
        o.grabPos = ComputeGrabScreenPos(o.pos);
        return o;
    }

pixelation results:

    float _PixelSize;
    sampler2D _GrabTexture;

    float4 frag(v2f IN) : COLOR
    {
        float2 steppedUV = IN.grabPos.xy / IN.grabPos.w;
        steppedUV /= _PixelSize / _ScreenParams.xy;
        steppedUV = round(steppedUV);
        steppedUV *= _PixelSize / _ScreenParams.xy;
        //Sampling GrabTexture according to screen capture positon, tex2DProj is equivalent to tex2D (grabPos.xy / grabpos.w)
        return tex2D(_GrabTexture, steppedUV);
    }

here is our pixelated shader:

Shader "Custom/Pixelate"
{
    Properties
    {
        _PixelSize("Pixel Size", Float) = 10
    }

    SubShader
    {
        Tags{ "Queue" = "Transparent" "IgnoreProjector" = "True" }
        Blend Off
        Lighting Off
        Fog{ Mode Off }
        ZWrite Off
        LOD 200
        Cull Off

        GrabPass{ "_GrabTexture" }

        Pass
        {
            CGPROGRAM

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

            struct v2f
            {
                float4 pos : SV_POSITION;
                float4 grabPos  : TEXCOORD0;
            };


            v2f vert(appdata_base v) {
                v2f o;
                // use UnityObjectToClipPos from UnityCG.cginc to calculate 
                // the clip-space of the vertex
                o.pos = UnityObjectToClipPos(v.vertex);
                // use ComputeGrabScreenPos function from UnityCG.cginc
                // to get the correct texture coordinate
                o.grabPos = ComputeGrabScreenPos(o.pos);
                return o;
            }

            float _PixelSize;
            sampler2D _GrabTexture;

            float4 frag(v2f IN) : COLOR
            {
                float2 steppedUV = IN.grabPos.xy / IN.grabPos.w;
                steppedUV /= _PixelSize / _ScreenParams.xy;
                steppedUV = round(steppedUV);
                steppedUV *= _PixelSize / _ScreenParams.xy;
                //Sampling GrabTexture according to screen capture positon, tex2DProj is equivalent to tex2D (grabPos.xy / grabpos.w)
                return tex2D(_GrabTexture, steppedUV);
            }

            ENDCG
        }
    }
}

1. Make a secondary camera

2. On the second camera, in Clear Flags, set it to Don & # 39; t clear

Using the control pad

we know that the GPU can operate in parallel. But what about communication between CPU and GPU? Does the processor have to wait for the GPU to finish the job before it can receive new commands?

No! because this communication would create bottlenecks (for example, when the processor cannot deliver orders fast enough) and make parallel work impossible. or how much data can be processed at one time.

The solution is a list where commands can be added by the CPU and read by the GPU – independently of each other! This list is called: Command buffer.

The command buffers contain the list of rendering commands ("define the rendering target, draw the mesh, …"). They can be configured to run at different points during camera rendering (see Camera.AddCommandBuffer), light rendering (see Light.AddCommandBuffer) or run immediately (see Graphics.ExecuteCommandBuffer).

The command buffer allows the CPU and GPU to operate independently of each other. When the CPU wants something to be returned, it can push this command to the queue and when the GPU has free resources, it can remove the command from the list and execute it (but the list works like a FIFO – so the GPU can only take the oldest item from the list (which was added first / earlier than all the others) and work on it).

By the way: there are different possible commands. One example is a draw call, another would be to change the render state.

https://vulkan-tutorial.com/Drawing_a_triangle/Drawing/Command_buffers

https://developer.nvidia.com/engaging-voyage-vulkan

Let's start using the command buffer

Hiding part of the character with a sphere:

 Stencil
     {
         Ref 1
         Comp Always
         Pass Replace
     }

create an order:

var commandBuffer = new CommandBuffer();
commandBuffer.name = "pixelate";

Temporarily copy the rendering result to the rendering texture:

  int tempTextureIdentifier = Shader.PropertyToID("_PostEffect");
        commandBuffer.GetTemporaryRT(tempTextureIdentifier, -1, -1);
        commandBuffer.Blit(BuiltinRenderTextureType.CameraTarget, tempTextureIdentifier);

Apply the rendering result to the material to which you want to apply image effects:

commandBuffer.Blit(tempTextureIdentifier, BuiltinRenderTextureType.CameraTarget, material);

Release the temporary rendering texture:

commandBuffer.ReleaseTemporaryRT(tempTextureIdentifier);

Save where you want to add the command buffer
Below is a high-level overview of how cameras use the forward or delayed pipeline to render a scene in Unity.

• The black boxes represent an internal Unity process. The blue boxes represent
• a CameraEvent where you can add control buffers.

camera.AddCommandBuffer(CameraEvent.BeforeImageEffects, commandBuffer);

add image effects where Ref is equal to 1

   Stencil
    {
        Ref 1
        Comp Equal
    }

adding color to the pixelated area

More examples!

pixelation of specific objects

grayscale where this is not equal to Ref 1

Stencil
{
    Ref 1
    Comp NotEqual
}

The references:

Render Hell – Book I

【Unity】CommandBuffer とステンシルバッファで特定のモデルにモザイクをかけてみる