常連


指定したpixelの太さの線を描画するShaderそのものがネット上に探してもなかったため、下記サイトのShaderを改修して、指定したPixelの太さの線を描画するShaderを実装しようとしているのですが、当方Shaderど素人につき、行き詰まったため質問を投稿いたしました。
[【Unity】カメラからどれだけ離れても、最低1ピクセルは表示されるように保障する \- 神様は有休消化中です。](https://appleorbit.hatenablog.com/entry/2016/03/19/155623)

上記サイトのShaderを使ったMeshに対してズームすると、当然ながらそのObjectが大きく表示されます。
指定したpixelの太さの線を描画することが目的のため、ズームしても大きくならないようにする方法を自分なりに調べたところ、`UnityObjectToClipPos(v.vertex)`によってズーム後の頂点座標になってしまっているからだと考えているのですが、正しいでしょうか？

その場合、指定したpixelの太さにするために、ズーム後の頂点座標にしないようにするためにはどうすればよろしいでしょうか？

初歩的な質問となりますが、どうぞよろしくお願いいたします。

使用しているMesh生成のコード
```cs
    public static Mesh CreateLineMesh(Vector3 center, float length, float thickness)
    {
        var mesh = new Mesh();
        var triangles = new int[6];
        triangles[0] = 0;
        triangles[1] = 1;
        triangles[2] = 2;
        triangles[3] = 2;
        triangles[4] = 3;
        triangles[5] = 0;
        var vertices = new Vector3[4];

        var left = center.x - length / 2.0f;
        var right = center.x + length / 2.0f;
        var bottom = center.y - thickness / 2;
        var top = center.y + thickness / 2;

        vertices[0] = new Vector3(left, bottom, center.z);
        vertices[1] = new Vector3(left, top, center.z);
        vertices[2] = new Vector3(right, top, center.z);
        vertices[3] = new Vector3(right, bottom, center.z);

        var nornals = vertices.ToArray();

        mesh.SetVertices(vertices);
        mesh.SetTriangles(triangles, 0);
        mesh.SetNormals(nornals);

        mesh.RecalculateBounds();

        return mesh;
    }
```

指定したpixelの太さの線を描画するShader

シェーダーを勉強中です。
タイトルの通りですが、下記コードの★の部分でalpha = 0としているのですが、
期待では全透明になるはずが半透明になってしまいます。なぜでしょうか？

```HLSL
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "Sprites/TestShader"
{
    Properties
    {
        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
        _Color ("Tint", Color) = (1,1,1,1)
        [MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
        [HideInInspector] _RendererColor ("RendererColor", Color) = (1,1,1,1)
        [HideInInspector] _Flip ("Flip", Vector) = (1,1,1,1)
        [PerRendererData] _AlphaTex ("External Alpha", 2D) = "white" {}
        [PerRendererData] _EnableExternalAlpha ("Enable External Alpha", Float) = 0

        [Space]
        
    }

    SubShader
    {
        Tags
        {
            "Queue"="Transparent"
            "IgnoreProjector"="True"
            "RenderType"="Transparent"
            "PreviewType"="Plane"
            "CanUseSpriteAtlas"="True"
        }

        Cull Off
        Lighting Off
        ZWrite Off
        Blend One OneMinusSrcAlpha

        Pass
        {
        CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0
            #pragma multi_compile_instancing
            #pragma multi_compile _ PIXELSNAP_ON
            #pragma multi_compile _ ETC1_EXTERNAL_ALPHA
            #include "UnitySprites.cginc"

            struct v2fCustom
            {
                float4 vertex    : SV_POSITION;
                fixed4 color    : COLOR;
                float2 texcoord : TEXCOORD0;
                float2 position : TEXCOORD1;
                UNITY_VERTEX_OUTPUT_STEREO
            };

            v2fCustom vert(appdata_t IN)
            {
                v2fCustom OUT;

                UNITY_SETUP_INSTANCE_ID (IN);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);

                OUT.vertex = UnityFlipSprite(IN.vertex, _Flip);
                OUT.vertex = UnityObjectToClipPos(OUT.vertex);
                OUT.texcoord = IN.texcoord;
                OUT.color = IN.color * _Color * _RendererColor;
                OUT.position = IN.vertex.xy * 2;

                #ifdef PIXELSNAP_ON
                OUT.vertex = UnityPixelSnap (OUT.vertex);
                #endif

                return OUT;
            }

            fixed4 frag(v2fCustom IN) : SV_Target
            {
                fixed4 c = SampleSpriteTexture (IN.texcoord) * IN.color;

                float alpha = 0; // ★ 0にすると全透明になると期待するが半透明になってしまう
                c.a = alpha;

                return c;
            }
        ENDCG
        }
    }
}
```

Unityのシェーダーでアルファ値=0にしたはずが半透明になってしまう

提示コードはピクセルシェーダーです。提示コードのグローバル変数の
```hlsl
SamplerState g_DiffuseMapSampler : register( s0 ) ;		// ディフューズマップサンプラ
Texture2D    g_DiffuseMapTexture : register( t0 ) ;		// ディフューズマップテクスチャ
```
の意味が知りたいです。マイクロソフト公式リファレンスを英語と日本語に切替ながら見ましたがよくわかりません。テクスチャをサンプリングしているという感じの意味なのはわかりますがもう少し詳細が知りたいです。**main();**関数ににもコメントしてありますが**.Sample();**関数の意味も合わせて知りたいです。

参考サイト: https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-sampler

```hlsl
// ピクセルシェーダーの入力
struct PS_INPUT
{
	float4 dif         : COLOR0 ;		// ディフューズカラー
	float2 texCoords0  : TEXCOORD0 ;	// テクスチャ座標
} ;

// ピクセルシェーダーの出力
struct PS_OUTPUT
{
	float4 color0           : SV_TARGET0 ;	// 色
} ;


// 定数バッファピクセルシェーダー基本パラメータ
struct DX_D3D11_PS_CONST_BUFFER_BASE
{
	float4		FactorColor ;			// アルファ値等

	float		MulAlphaColor ;			// カラーにアルファ値を乗算するかどうか( 0.0f:乗算しない  1.0f:乗算する )
	float		AlphaTestRef ;			// アルファテストで使用する比較値
	float2		Padding1 ;

	int			AlphaTestCmpMode ;		// アルファテスト比較モード( DX_CMP_NEVER など )
	int3		Padding2 ;

	float4		IgnoreTextureColor ;	// テクスチャカラー無視処理用カラー
} ;

// 基本パラメータ
cbuffer cbD3D11_CONST_BUFFER_PS_BASE				: register( b1 )
{
	DX_D3D11_PS_CONST_BUFFER_BASE		g_Base ;
} ;


SamplerState g_DiffuseMapSampler            : register( s0 ) ;		// ディフューズマップサンプラ
Texture2D    g_DiffuseMapTexture            : register( t0 ) ;		// ディフューズマップテクスチャ



// main関数
//PS_OUTPUT main( PS_INPUT PSInput )
void main( PS_INPUT PSInput )
{
	PS_OUTPUT PSOutput ;
	//float4 TextureDiffuseColor ;

	// テクスチャカラーの読み込み
	//TextureDiffuseColor =  g_DiffuseMapTexture.Sample( g_DiffuseMapSampler, PSInput.texCoords0 ) ;

	// 出力カラー = テクスチャカラー * ディフューズカラー
	//PSOutput.color0 = TextureDiffuseColor * PSInput.dif;
	

	// 出力パラメータを返す
	//return PSOutput ;
}

```

hlslシェーダー言語のSamplerStateの意味がリファレンスを見てもよくわからない。

主にゲーム用のリアルタイムなアニメーション補間のために
0<=x<=1の範囲でf(0)=0,f(1)=1となり、斜め軸(y=1-x)で線対称になる式がほしいです

条件は
y=1-x上の通過点を1点指定し、
A(0,0)で傾き真上、(1,1)で傾き真右、の場合
B(0,0)で傾き真右、(1,1)で傾き真上、の場合
の2パターンの式がほしいです

画像を添付しておきます
また、計算速度に関する問題や妥協点などあれば教えていただけると助かります
(円の方程式に指数を与えるとかなり近いのですが、内側に変化させられないため断念しました)

C++での実装を想定しています

よろしくお願いいたします

![イメージ説明](3619293655cbf00e14379f178c3b3c14.png)

追記です
図では紫のグラフ(条件A)の点を掴んでいますが、これがy=xをまたぐ際に緑(条件B)の方に切り替えて使用します
またアニメーション用途のため、xは時間を表していて線形変化を緩急のある変化に変えるために使います
（例としてスケール初期値100%～終端200%として線形ではなくいきなり180％くらいまでデカくなったのちゆっくりに落ち着くといった動きなどを表現）
そのためyの範囲は0~1で収まるものを想定しています

S字型のカーブをさせるための情報は
http://marupeke296.com/TIPS_No19_interpolation.html
が参考になったのですが今回のお椀型？の仕様に合う情報が欲しいです




### 更に追記


下記コードにて出力した点をプロットしたものが下記画像となります
a=0.1(緑)
a=0.25(赤)
a=0.4(水)


これが傾きの要件をみたしているのかはわからないのですが、これを線形補間で使えばもう十分かな感はあります
ただ、ソースのコメントにあるように分割時の右半分のYを求める係数がわからないため中央付近が異常に荒くなっています


```ここに言語を入力
struct f2
{
	float m_x;
	float m_y;
};

f2 outf2[20];
int numout=0;

void saiki(int div, f2 v0, f2 v1, float a)
{
	if(div){
		float sax = v1.m_x - v0.m_x;//差x
		float say = v1.m_y - v0.m_y;//差y
		f2 center_vec;

		center_vec.m_x = v0.m_x + sax*0.5f;		//xは中間
		center_vec.m_y = v0.m_y + say*(1.f-a);	//yは1-aでブレンド

		saiki(div-1, v0, center_vec, a);//左半分の再帰呼び出し
		outf2[numout++] = center_vec;
		//motomu(div-1, center_vec, v1, a);//右側分割が上手く行かない
	}
	else{
		return;
	}
}

void func()
{
	float a = 0.25f;//掴んでいる点のx座標

	f2 v0 = {0.f, 0.f};//原点
	f2 v1 = {a, 1.f-a};//y=x上の点

	saiki(5, v0, v1, a);
	outf2[numout++] = v1;
	//ここで出したoutf2は半分だけなのであとは手作業で鏡面写し
}

```

![イメージ説明](c51d4802ecc4f6fa31d0a2da7ccf16db.png)

補間用の方程式で添付画像の調整が可能なものが欲しいです

何か解決したい問題があるわけではなくて、知識としての質問です。

例えば、以下のようなUnityのShaderファイルがあるとします。
```HLSL
Shader "Custom/Test"
{
	Properties
	{
		_MainTex ("Main Texture", 2D) = "white" {}
		_CopyTex ("Copy Texture", 2D) = "white" {}
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			
			#include "UnityCG.cginc"

			struct appdata
			{
				float4 vertex : POSITION;
				float2 uv : TEXCOORD0;
			};

			struct v2f
			{
				float4 vertex : SV_POSITION;
				float2 uv : TEXCOORD0;
			};

			sampler2D _MainTex;
			
			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 = tex2D(_MainTex, i.uv);

				//Tex2D(_CopyTex, i.uv) = col;

				return col;
			}
			ENDCG
		}
	}
}

```

上記のように、フラグメントシェーダーでtex2Dを利用すれば、uv座標に対応する色情報を取得できます。

ふとした疑問なのですが、例えば、uv座標に対応する色情報を、書き換えるということはできないのでしょうか？
以下のように、値を代入するイメージです。
```HLSL
tex2D(_CopyTex, i.uv) = col;
```
ちなみに、このコードを試したところ、Unityで以下のようなエラーが表示されました。
```
Shader error in 'Custom/Test': undeclared identifier '_CopyTex' at line 47 (on d3d11)

Compiling Vertex program
Platform defines: UNITY_NO_DXT5nm UNITY_ENABLE_REFLECTION_BUFFERS UNITY_NO_CUBEMAP_ARRAY UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION
```

恥ずかしながら、ShaderやGPUの仕組みがよくわかっていないので、質問いたしました。
「そんなことできないよ」ということであれば、できないとお答えいただけますと幸いです。

できるのだとすれば、フラグメントシェーダーから利用できる巨大なバッファのように扱えるかなと思いまして。

# 開発環境
- Unity 2017.3.0f3
- Windows 10
- DirectX 11.0

UnityのSubShader内でテクスチャの書き換えはできますか？



### 前提・実現したいこと

ポイントライトを実装してある球に対してブラー処理を実現したい

### 発生している問題・エラーメッセージ

```
エラーメッセージ
エラー	X3017	cannot implicitly convert from 'const float2' to 'float4'
```

### 該当のソースコード

```HLSL
ソースコード
struct PS_IN
{
	float4 pos : SV_POSITION;
	float2 uv : TEXCOORD0;
};

Texture2D tex : register(t0);
SamplerState samp : register(s0);

cbuffer Parameter : register(b0)
{
	float2 texSize;// サイズ
	float2 blurDir;// 方向
};

float4 main(PS_IN pin) : SV_TARGET
{
	float4 color = float4(0.0f, 0.0f, 0.0f, 1.0f);

	float2 movePixel = 1.0f / texSize;

	movePixel *= blurDir;

	// ぼかし処理をかける
	color = tex.Sample(samp, pin.uv);  // 自分自身のピクセル
	// 正方向(右、上)の隣のピクセル///ここでエラーが出る
	color += tex.Sample(samp, pin.uv)+ movePixel * 1.0f;
	color += tex.Sample(samp, pin.uv)+ movePixel * 2.0f;
	color += tex.Sample(samp, pin.uv)+ movePixel * 3.0f;
	color += tex.Sample(samp, pin.uv)+ movePixel * 4.0f;
	// 負方向(左、下)の隣のピクセル
	color += tex.Sample(samp, pin.uv)- movePixel * 1.0f;
	color += tex.Sample(samp, pin.uv)- movePixel * 2.0f;
	color += tex.Sample(samp, pin.uv)- movePixel * 3.0f;
	color += tex.Sample(samp, pin.uv)- movePixel * 4.0f;
	// 足し合わせたピクセルの平均を求める
	color / 9.0f;

	return color;
}
```

### 試したこと

color += tex.Sample(samp, pin.uv),+ movePixel * 1.0f;
//コンマを付けたら動きましたが色がついているポイントライトが白飛びしてしまいます。
//あと表示はされたのですがブラーがかかっていません。
// 動く方向に1,動かない方向に0を設定して掛け算すれば求められるはずなのですがどう式を
//立てたらよいか分かりません。

### 補足情報（FW/ツールのバージョンなど）

VisualStudio2017
Visualc++
SDKバージョン：10.0.17763.0


HLSLでブラー処理を適用したい

DirectX11でCreateVertexShader()がE_INVALIDARGを返してしまいます。
[このサイト](https://gamesgard.com/directx11_lesson03/)を参考に進めていましたが、手詰まりました。
何が原因でこのようになってしまうのでしょうか。
どなたか御教授願います。

とりあえず、関係ありそうなところを載せます。
```C++
    //変数
    //Direct3Dデバイス(ポリゴンとかテクスチャとかを作るやつ)
    ComPtr<ID3D11Device> m_device;
    //Direct3Dデバイスコンテキスト(描画関係)
    ComPtr<ID3D11DeviceContext> m_devicecontext;
    //スワップチェーン(BackBufferを切り替えるやつ)
    ComPtr<IDXGISwapChain>m_swapchain;
    //BackBufferにアクセスするためのhandle
    ComPtr<ID3D11RenderTargetView> m_backbufview;
    //2D描画用シェーダ
    ComPtr<ID3D11VertexShader> m_spriteVS;//頂点シェーダ
    ComPtr<ID3D11PixelShader> m_spritePS;//ピクセルシェーダ
    ComPtr<ID3D11InputLayout> m_spriteIL;//インプットレイアウト
//初期化関数
    //略

    //m_deviceの生成
    UINT creationFlags = 0;
#ifdef DirectX11Engine_Graphics_GiveMeD3DErrorInfo
    // (すごく重いが細かいエラーがわかる)
    creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
    D3D_FEATURE_LEVEL featurelevels[] = {//使いたい機能の優先順位(若いほど良いはず)
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1,
    };
    D3D_FEATURE_LEVEL featurelevel; //使うことになった機能
    //m_deviceとm_devicecontextの生成
    //https://docs.microsoft.com/en-us/windows/win32/api/d3d11/nf-d3d11-d3d11createdevice
    if (FAILED(D3D11CreateDevice(
        NULL,                        //デバイスの作成時に使用するビデオアダプタへのポインタ。NULLだとデフォルトのアダプタ
        //https://docs.microsoft.com/en-us/windows/win32/api/d3dcommon/ne-d3dcommon-d3d_driver_type
        D3D_DRIVER_TYPE_HARDWARE,    //作成するドライバの種類を表す。HARDWAREは一番一番最高のパフォがでる。詳しくは上のリンク見ろ。
        NULL,                        //ソフトウェアラスタライザーを実装するDLLへのハンドル。
        creationFlags,
        featurelevels,
        _countof(featurelevels),
        D3D11_SDK_VERSION,
        &m_device,
        &featurelevel,
        &m_devicecontext
    ))) {
        return false;
    }

    //略

    //シェーダーの読み込み
    //頂点シェーダの読み込みandコンパイル
    ComPtr<ID3DBlob>compiledVS;
    if (FAILED(D3DCompileFromFile(ShaderPath, nullptr, nullptr, "VS", "vs_5_0", 0, 0, &compiledVS, nullptr))) {
        return false;
    }
    //ピクセルシェーダーの以下同文
    ComPtr<ID3DBlob>compiledPS;
    if (FAILED(D3DCompileFromFile(ShaderPath, nullptr, nullptr, "PS", "ps_5_0", 0, 0, &compiledPS, nullptr))) {
        return false;
    }
    //頂点シェーダの作成
    //-----------------------------------------------------
    //ここがエラーになってしまうところ
    //-----------------------------------------------------
    HRESULT temp = m_device->CreateVertexShader(compiledVS->GetBufferPointer(), compiledVS->GetBufferSize(), nullptr, &m_spriteVS);
    if (FAILED(temp)) {
        return false;//こっちに行ってしまう
    }
//略
```
```HLSL
// 頂点シェーダーから出力するデータ
struct VSOutput
{
    float4 Pos : SV_Position;   // 頂点の座標(射影座標系)
};

//========================================
// 頂点シェーダー
//========================================
VSOutput VS(float4 pos : POSITION)
{
    VSOutput Out;
    // 頂点座標を、何も加工せずそのまま出力
    Out.Pos = pos;
    return Out;
}

//========================================
// ピクセルシェーダー
//========================================
float4 PS(VSOutput In) : SV_Target0
{
    // 緑色にする
    return float4(0, 1, 0, 1);
}

```
みたところ、シェーダのコンパイルは上手く行ってそうです。

DirectX11でCreateVertexShader()がE_INVALIDARGを返してしまう

モザイクシェーダーを導入したのですが、モザイクが正方形ブロックにならなくて困っています。
下図のように横に長いブロックになってしまいます。
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-28/cf6c3e58-dbae-49de-9557-209f5b56eca5.png)

シェーダーの出どころはこちらです(フリー素材)
https://booth.pm/ja/items/1703064

各インスペクターです。
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-28/05a0f0b9-8aa9-4f2a-a2be-d3be7904fc9a.png)

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-28/2f3bdb29-190d-49e8-b581-0fb189e6f725.png)


![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-28/1ed60b3d-31ce-4cc2-b5b5-475e3d31c1b3.png)

※Canvasのサイズは120x90、Gameタブの解像度も120x90です。

元画像はこちらです(120x90)
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-28/3a2c4098-0f50-4072-a85d-4ac00144e3ea.png)

使用しているのはモザイク1なので
以下のHLSLでは恐らく★1～3の3行をどうにか修正すればいいのではないかと推測しますが、分からなくて困っています。

```ここに言語を入力
Shader "Pya/mosaic" {
    Properties {
		[Enum(UnityEngine.Rendering.CullMode)]
        _Cull("Cull", Float) = 0
		[KeywordEnum(mosaic1_normal, mosaic2_average, blur1_normal, blur2_gauss)] _Mode("Type", Float) = 0
		[Header(Mosaic)]
        _Pixelation ("Pixelation Size", Range(1, 1000)) = 70
		[Space (7)]
		[Header(Blur)]
		_BlockSize ("Block Size", Range(1, 1000)) = 10
		_SD ("SD(blur2 only)", Range(1,100)) = 10
    }

    SubShader {
		Tags { 
			"Queue" = "Transparent"
			"RenderType"="Transparent"
		}
		ZWrite Off
		Cull [_Cull]

		//GrabPassでレンダリング結果を取得
		GrabPass {}

		//X方向へのぼかし処理
        Pass {

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
			#pragma multi_compile _MODE_MOSAIC1_NORMAL _MODE_MOSAIC2_AVERAGE _MODE_BLUR1_NORMAL _MODE_BLUR2_GAUSS
            #include "UnityCG.cginc"

			struct appdata {
				float4 vertex : POSITION;
			};

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

			sampler2D _GrabTexture;
            float4 _GrabTexture_ST;
			float4	_GrabTexture_TexelSize;
            float _Pixelation;
			float _BlockSize;
			float _SD;

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

            fixed4 frag(v2f i) : SV_Target {
				fixed4 col;
				float2 uv = i.grabPos.xy / i.grabPos.w; //0～1に変換 // ★1
				float2 uv_pixel = floor(uv * _Pixelation) /_Pixelation; //ピクセル化  // ★2

				//-----モザイク1     先頭ピクセルで範囲を塗りつぶす  --------//
				#ifdef _MODE_MOSAIC1_NORMAL
					col = tex2D(_GrabTexture, uv_pixel);  // ★3


				//-----モザイク2     平均化した色で範囲を塗りつぶす  --------//
				#elif _MODE_MOSAIC2_AVERAGE
					float count=0;
					//X方向にピクセルをずらして色を加算する
					for(int j = 0; j <= floor(1/(_GrabTexture_TexelSize.x * _Pixelation)); j++) {
						col = col + tex2D(_GrabTexture, uv_pixel + float2(j * _GrabTexture_TexelSize.x, 0));
						count++;
					}
					//平均
					col = col / count;

				//-----ぼかし1     周辺ピクセルの色を平均化    -------------//
				#elif _MODE_BLUR1_NORMAL
					float count=0;
					float size=floor(_BlockSize)*0.1;
					for(int j = -size; j <= size; j++) {
						//X方向にピクセルをずらして色を加算する
						col = col + tex2D(_GrabTexture, uv + float2(j * _GrabTexture_TexelSize.x,0));
						count++;
					}
					//平均
					col = col / count;

				//-----ぼかし2      ガウス関数での重み付け    --------------//
				#elif _MODE_BLUR2_GAUSS
					float size=floor(_BlockSize)*0.1;
					float weight_total;
					float var = pow(_SD, 2) * 0.001; //分散

					for(int j = -size; j <= size; j++) {
						float distance = j / size;
						//重み y = -exp(-0.5*x^2/σ^2)
						float weight = exp(-0.5 * pow(distance, 2) / var);
						weight_total = weight_total + weight;
						//X方向にピクセルをずらして重み付けした色を加算する
						col = col + tex2D(_GrabTexture, uv + float2(j * _GrabTexture_TexelSize.x,0)) * weight;
					}
					//正規化
					col = col / weight_total;

				#endif

                return col;
            }

            ENDCG
        }

		//GrabPassで1つ目のPassのレンダリング結果を取得
        GrabPass {}

		//Y方向へのぼかし処理
        Pass {

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
			#pragma multi_compile _MODE_MOSAIC1_NORMAL _MODE_MOSAIC2_AVERAGE _MODE_BLUR1_NORMAL _MODE_BLUR2_GAUSS
            #include "UnityCG.cginc"

			struct appdata {
				float4 vertex : POSITION;
			};

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

			sampler2D _GrabTexture;
            float4 _GrabTexture_ST;
			float4	_GrabTexture_TexelSize;
			float _BlockSize;
			float _SD;

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

            fixed4 frag(v2f i) : SV_Target {
				fixed4 col;
				float2 uv = i.grabPos.xy / i.grabPos.w; //0～1に変換
				

				#ifdef _MODE_MOSAIC1_NORMAL
					//何もしない
					col = tex2D(_GrabTexture, uv);
				#elif _MODE_MOSAIC2_AVERAGE
					//何もしない
					col = tex2D(_GrabTexture, uv);
				#elif _MODE_BLUR1_NORMAL
					float count=0;
					float size=floor(_BlockSize)*0.1;
					for(int j = -size; j <= size; j++) {
						//Y方向にピクセルをずらして色を加算する
						col = col + tex2D(_GrabTexture, uv + float2(0,j * abs(_GrabTexture_TexelSize.y)));
						count++;
					}
					col = col / count;
				#elif _MODE_BLUR2_GAUSS
					float size=floor(_BlockSize)*0.1;
					float weight_total;
					float var = pow(_SD, 2) * 0.001;

					for(int j = -size; j <= size; j++) {
						float distance = j / size;
						float weight = exp(-0.5 * pow(distance, 2) / var);
						weight_total = weight_total + weight;
						//Y方向にピクセルをずらして色を加算する
						col = col + tex2D(_GrabTexture, uv + float2(0,j * abs(_GrabTexture_TexelSize.y))) * weight;
					}
					col = col / weight_total;
				#endif
                return col;
            }

            ENDCG
        }
    }

}
```
◆環境
Unity2020.3.11f1
Windows10

