常連

### 実現したいこと
画面が点滅するのを防ぎたい

### 発生している問題・分からないこと
Directx12の魔導書という書籍で勉強中に、４章まで終わったのですが、実行すると出てくる画面がずっと点滅してしまっています　このスクリーンショットだと分かりにくいとは思うのですが青い四角形の外側が点滅しています
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-11-10/e4532835-1c05-4563-b5d4-520cb3561732.png)

### エラーメッセージ
```error
重大度レベル	コード	説明	プロジェクト	ファイル	行	抑制状態	詳細
警告	C6387	'_pipelinestate' は '0' である可能性があります: この動作は、関数 'ID3D12GraphicsCommandList::SetPipelineState' の指定に従っていません。	Project4	C:\Users\nao12\source\repos\Project4\main.cpp	416		
重大度レベル	コード	説明	プロジェクト	ファイル	行	抑制状態	詳細
警告	C6387	'event' は '0' である可能性があります: この動作は、関数 'WaitForSingleObject' の指定に従っていません。	Project4	C:\Users\nao12\source\repos\Project4\main.cpp	463		
重大度レベル	コード	説明	プロジェクト	ファイル	行	抑制状態	詳細
警告	C6387	'event' は '0' である可能性があります: この動作は、関数 'CloseHandle' の指定に従っていません。これが行われる可能性のある以前の行 463 を参照してください	Project4	C:\Users\nao12\source\repos\Project4\main.cpp	464		

```

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

```
特になし
```

### 試したこと・調べたこと
- [ ] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [x] その他

##### 上記の詳細・結果
著者のgithubにサンプルコードがあったため、その通りに変更していてもどうしても点滅してしまいます

### 補足
特になし

Directx12で画面が点滅する

シェーダーを勉強中です。
タイトルの通りですが、下記コードの★の部分で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の意味がリファレンスを見てもよくわからない。

### はじめに

現在、Unityでシェーダーに関して勉強中なのですが、Unityでシェーダーを記述する際に用いるシェーダー言語は
HLSL/CG/GLSLの三つがあり、主に使用されているのがHLSL/CGで、GLSLは扱えるものの向いていない（？）という認識です。



### 知りたい事

勉強を進めていく中で、CGは既に開発が終了しているという事を知りました。
また、UnityのUniversalRPの記事ではCGではなくHLSLで記述してあるという内容がありました。

本題ですが上記のことから、今後シェーダーを学び、作成していくならCGではなく、
HLSLを使って記述するべきなのかな？と思っているのですが、多くのお手本と出来そうなシェーダーはCGで記述されている為、勉強して実践する際に上手く置換できるか不安です。

----
**１、HLSLとCGはどの程度互換性があるのか？**

どちらの開発にもNVIDIAが携わっていると書いてあったので、互換性は高いのかなと思っているのですが、
GLSLとHLSLの違いについての記事は見つけたのですが、CGとHLSLの違いについてまとめてある記事は見つかりませんでした。

----
**2、CGでできて、HLSLでできないことはあるのか？（逆もしかり）**

私が見てきた記事では大抵CGとHLSLはひとくくりで紹介されていたのですが、両者の違いは何かしらあると思います。
私が調べた中ではCGはグラフィックスのためのC言語、HLSLはDirectX用、という程度の違いしか分かりませんでした。
そのため、機能的にCGではこんなことが出来るが、HLSLではできないない。（どちらかというと逆かもしれませんが）
という事はあるのでしょうか？

私の調べ不足があるかもしれませんが、この二点に関して教えていただけますでしょうか。

【Unity】【Shader】Shader言語について　HLSL/GLSL/CG

### 実現したいこと
モーションブラーの実装に使用する速度マップを作りたい。
速度マップが想定した通りに作れていないので、見直す部分や間違えているであろう箇所を教えてほしいです。

### 発生している問題・分からないこと
下の画像の左上に速度マップを表示させています。オブジェクトの動き関係なくRGで色がついてしまっています。動いていないなら黒になると思うのですが...
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-11-09/fdc73041-0446-4400-84f0-a46af01c6922.gif)



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

```HLSL
//各オブジェクトの頂点シェーダーです
void main(in VS_IN In, out PS_IN Out) {
	matrix wvp;
	wvp = mul(World, View);
	wvp = mul(wvp, Projection);

	Out.Position = mul(In.Position, wvp);
	Out.TexCoord = In.TexCoord;
	Out.Diffuse = In.Diffuse * Material.Diffuse;

	matrix prevmvp;
	prevmvp = mul(PrevWorld, PrevView);
	prevmvp = mul(prevmvp, PrevProjection);
	Out.PrevPosition = mul(In.Position, prevmvp);
}
```

```HLSL
//各オブジェクトのピクセルシェーダーです
//Out.Out2が速度マップのレンダーターゲットです
void main(in PS_IN In, out PS_OUT Out) {
	if(Material.TextureEnable) {
		Out.Out0 = g_Texture.Sample(g_SamplerState, In.TexCoord);
		Out.Out0 *= In.Diffuse;
	}
	else {
		Out.Out0 = In.Diffuse;
	}
	Out.Out0.a = In.Diffuse.a;
	
	Out.Out1 = In.Position.z;
	
	float2 velocity = (In.Position.xy / In.Position.w) - (In.PrevPosition.xy / In.PrevPosition.w);
	float2 velocityNormalized = clamp(velocity * 0.5f + 0.5f, 0.0f, 1.0f);
	Out.Out2 = velocityNormalized;
}
```

```CPP
//オブジェクトの描画です
//例としてPlayerを記載します
void Player::Draw(){
	//入力レイアウト設定
	Renderer::GetDeviceContext()->IASetInputLayout(_vertexlayout);

	//シェーダ設定
	Renderer::GetDeviceContext()->VSSetShader(_vertexshader, NULL, 0);
	Renderer::GetDeviceContext()->PSSetShader(_pixelshader, NULL, 0);

	//ワールドマトリクス設定
	XMMATRIX world, scale, rot, trans;
	scale = XMMatrixScaling(GetScale().x, GetScale().y, GetScale().z);
	//クォータニオンで回転
	rot = XMMatrixRotationQuaternion(XMLoadFloat4(&GetQuaternion()));
	trans = XMMatrixTranslation(GetPosition().x, GetPosition().y, GetPosition().z);
	world = scale * rot * trans;
	Renderer::SetWorldMatrix(world, _prevworld);

	for (auto c : _components) {
		c->Draw();
	}
}

void Camera::Draw(){
	//ビューマトリクス設定
	XMFLOAT3 up{ 0.0f, 1.0f, 0.0f };
	XMMATRIX viewmatrix = XMMatrixLookAtLH(XMLoadFloat3(&GetPosition()), XMLoadFloat3(&_target), XMLoadFloat3(&up));

	Renderer::SetViewMatrix(viewmatrix);

	XMStoreFloat4x4(&_viewmatrix, viewmatrix);

	//プロジェクションマトリクス設定
	XMMATRIX projectionMatrix;
	projectionMatrix = XMMatrixPerspectiveFovLH(1.0f, (float)SCREEN_WIDTH / SCREEN_HEIGHT, 1.0f, 1000.0f);

	Renderer::SetProjectionMatrix(projectionMatrix);

	Renderer::SetCameraPosition(GetPosition());
}
```

```CPP
void Renderer::SetWorldMatrix(XMMATRIX WorldMatrix, XMMATRIX& PrevWorld) {
	XMFLOAT4X4 worldf;

	XMStoreFloat4x4(&worldf, XMMatrixTranspose(PrevWorld));
	_devicecontext->UpdateSubresource(_prevworldbuffer, 0, NULL, &worldf, 0, 0);

	XMStoreFloat4x4(&worldf, XMMatrixTranspose(WorldMatrix));
	_devicecontext->UpdateSubresource(_worldbuffer, 0, NULL, &worldf, 0, 0);

	//前フレーム保存
	PrevWorld = WorldMatrix;
}

void Renderer::SetViewMatrix(XMMATRIX ViewMatrix) {
	XMFLOAT4X4 viewf;

	XMStoreFloat4x4(&viewf, XMMatrixTranspose(_prevview));
	_devicecontext->UpdateSubresource(_prevviewbuffer, 0, NULL, &viewf, 0, 0);
	
	XMStoreFloat4x4(&viewf, XMMatrixTranspose(ViewMatrix));
	_devicecontext->UpdateSubresource(_viewbuffer, 0, NULL, &viewf, 0, 0);

	//前フレーム保存
	_prevview = ViewMatrix;
}

void Renderer::SetProjectionMatrix(XMMATRIX ProjectionMatrix) {
	XMFLOAT4X4 projectionf;

	XMStoreFloat4x4(&projectionf, XMMatrixTranspose(_prevprojection));
	_devicecontext->UpdateSubresource(_prevprojectionbuffer, 0, NULL, &projectionf, 0, 0);

	XMStoreFloat4x4(&projectionf, XMMatrixTranspose(ProjectionMatrix));
	_devicecontext->UpdateSubresource(_projectionbuffer, 0, NULL, &projectionf, 0, 0);

	//前フレーム保存
	_prevprojection = ProjectionMatrix;
}
```

```HLSL
cbuffer WorldBuffer : register(b0) {
	matrix World;
}
cbuffer ViewBuffer : register(b1) {
	matrix View;
}
cbuffer ProjectionBuffer : register(b2) {
	matrix Projection;
}
cbuffer WorldBuffer : register(b9) {
	matrix PrevWorld;
}
cbuffer ViewBuffer : register(b10) {
	matrix PrevView;
}
cbuffer ProjectionBuffer : register(b11) {
	matrix PrevProjection;
}
struct VS_IN {
	float4 Position			: POSITION0; //ポジションゼロ
	float4 Normal			: NORMAL0; //ノーマルゼロ
	float4 Diffuse			: COLOR0; //カラーゼロ
	float2 TexCoord			: TEXCOORD0; //テクスコードゼロ
	float4 Tangent			: TANGENT0; //タンジェントゼロ
};


struct PS_IN {
	float4 Position			: SV_POSITION; //ピクセルの座標
	float4 PrevPosition		: TEXCOORD1; //ピクセルの座標
	float4 WorldPosition		: POSITION0; //ピクセルの空間での座標
	float4 Normal			: NORMAL0; //ピクセルの法線
	float4 Diffuse			: COLOR0; //ピクセルの色
	float2 TexCoord			: TEXCOORD0; //ピクセルのテクスチャ座標
	float4 Tangent			: TANGENT0; //タンジェント
	float4 Binormal			: BINORMAL0; //バイノーマル
};
struct PS_OUT {
	float4 Out0			: SV_Target0;	//デフォルトのびょうが
	float Out1				: SV_Target1;	//深度マップ
	float2 Out2			: SV_Target2;	//速度マップ
};
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
モーションブラー実装の記事を見ながら作りました。
ChatGPTを使いました。

### 補足
Sharder Model 5.0
DirectX11
C++20

速度マップが想定した通りに作れない

主にゲーム用のリアルタイムなアニメーション補間のために
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)

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

### WARNING: Shader Unsupported: 'Hidden/Internal-MotionVectors' - Pass '' has no vertex shader を出ないようにしたいです。

Unity5.4.1p4
Xcode Version 8.0 (8A218a)
iPhone 7 iOS10.0.2(14A456)
でGame用shaderを作っています。  
使用しているシェーダをコンパイル時に実行中に以下のエラーメッセージが発生しました。

###発生している問題・エラーメッセージ

```
-------- -------- -------- -------- Xcode OutPut-------- -------- -------- -------- -------- 
-------- failed compiling:
fragment evaluation shader
WARNING: 0:4: extension 'GL_EXT_frag_depth' is not supported
ERROR: 0:38: Use of undeclared identifier 'gl_FragDepthEXT'

Note: Creation of internal variant of shader 'Hidden/Internal-MotionVectors' failed.
WARNING: Shader Unsupported: 'Hidden/Internal-MotionVectors' - Pass '' has no vertex shader
WARNING: Shader Unsupported: 'Hidden/Internal-MotionVectors' - Setting to default shader.
```

###該当のソースコード
```Internal-MotionVectors.shader
Shader "Hidden/Internal-MotionVectors"
{
	SubShader
	{
		CGINCLUDE
		#include "UnityCG.cginc"

		// Object rendering things
		float4x4 _NonJitteredVP;
		float4x4 _PreviousVP;
		float4x4 _PreviousM;
		bool _HasLastPositionData;
		float _MotionVectorDepthBias;

		struct MotionVectorData
		{
			float4 transferPos : TEXCOORD0;
			float4 transferPosOld : TEXCOORD1;
			float4 pos : SV_POSITION;
		};

		struct MotionVertexInput
		{
			float4 vertex : POSITION;
			float3 oldPos : NORMAL;
		};

		MotionVectorData VertMotionVectors(MotionVertexInput v)
		{
			MotionVectorData o;
			o.pos = UnityObjectToClipPos(v.vertex);

			// this works around an issue with dynamic batching
			// potentially remove in 5.4 when we use instancing
#if defined(UNITY_REVERSED_Z)
			o.pos.z -= _MotionVectorDepthBias * o.pos.w;
#else
			o.pos.z += _MotionVectorDepthBias * o.pos.w;
#endif
			o.transferPos = mul(_NonJitteredVP, mul(unity_ObjectToWorld, v.vertex));
			o.transferPosOld = mul(_PreviousVP, mul(_PreviousM, _HasLastPositionData ? float4(v.oldPos, 1) : v.vertex));
			return o;
		}

		half4 FragMotionVectors(MotionVectorData i) : SV_Target
		{
			float3 hPos = (i.transferPos.xyz / i.transferPos.w);
			float3 hPosOld = (i.transferPosOld.xyz / i.transferPosOld.w);

			// V is the viewport position at this pixel in the range 0 to 1.
			float2 vPos = (hPos.xy + 1.0f) / 2.0f;
			float2 vPosOld = (hPosOld.xy + 1.0f) / 2.0f;

#if UNITY_UV_STARTS_AT_TOP
			vPos.y = 1.0 - vPos.y;
			vPosOld.y = 1.0 - vPosOld.y;
#endif
			half2 uvDiff = vPos - vPosOld;
			return half4(uvDiff, 0, 1);
		}

		//Camera rendering things
		sampler2D_float _CameraDepthTexture;

		struct CamMotionVectors
		{
			float4 pos : SV_POSITION;
			float2 uv : TEXCOORD0;
			float3 ray : TEXCOORD1;
		};

		CamMotionVectors VertMotionVectorsCamera(float4 vertex : POSITION, float3 normal : NORMAL)
		{
			CamMotionVectors o;
			o.pos = UnityObjectToClipPos(vertex);

#ifdef UNITY_HALF_TEXEL_OFFSET
			o.pos.xy += (_ScreenParams.zw - 1.0) * float2(-1, 1) * o.pos.w;
#endif
			o.uv = ComputeScreenPos(o.pos);
			// we know we are rendering a quad,
			// and the normal passed from C++ is the raw ray.
			o.ray = normal;
			return o;
		}
		
		inline half2 CalculateMotion(float rawDepth, float2 inUV, float3 inRay)
		{
			float depth = Linear01Depth(rawDepth);
			float3 ray = inRay * (_ProjectionParams.z / inRay.z);
			float3 vPos = ray * depth;
			float4 worldPos = mul(unity_CameraToWorld, float4(vPos, 1.0));

			float4 prevClipPos = mul(_PreviousVP, worldPos);
			float2 prevHPos = prevClipPos.xy / prevClipPos.w;

			float4 curClipPos = mul(_NonJitteredVP, worldPos);
			float2 curHPos = curClipPos.xy / curClipPos.w;
			
			// V is the viewport position at this pixel in the range 0 to 1.
			float2 vPosPrev = (prevHPos.xy + 1.0f) / 2.0f;
			float2 vPosCur = (curHPos.xy + 1.0f) / 2.0f;
#if UNITY_UV_STARTS_AT_TOP
			vPosPrev.y = 1.0 - vPosPrev.y;
			vPosCur.y = 1.0 - vPosCur.y;
#endif
			return vPosCur - vPosPrev;
		}

		half4 FragMotionVectorsCamera(CamMotionVectors i) : SV_Target
		{
 			float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
			return half4(CalculateMotion(depth, i.uv, i.ray), 0, 1);
		}

		half4 FragMotionVectorsCameraWithDepth(CamMotionVectors i, out float outDepth : SV_Depth) : SV_Target
		{
			float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
			outDepth = depth;
			return half4(CalculateMotion(depth, i.uv, i.ray), 0, 1);
		}
		ENDCG

		// 0 - Motion vectors
		Pass
		{
			Tags{ "LightMode" = "MotionVectors" }
			
			ZTest LEqual
			Cull Back
			ZWrite Off

			CGPROGRAM
			#pragma vertex VertMotionVectors
			#pragma fragment FragMotionVectors
			ENDCG
		}

		// 1 - Camera motion vectors
		Pass
		{
			ZTest Always
			Cull Off
			ZWrite Off
			
			CGPROGRAM
			#pragma vertex VertMotionVectorsCamera
			#pragma fragment FragMotionVectorsCamera
			ENDCG
		}

		// 2 - Camera motion vectors (With depth (msaa / no render texture))
		Pass
		{
			ZTest Always
			Cull Off
			ZWrite On
			
			CGPROGRAM
			#pragma vertex VertMotionVectorsCamera
			#pragma fragment FragMotionVectorsCameraWithDepth
			ENDCG
		}
	}

	Fallback Off
}

```

###試したこと
課題に対してアプローチしたことを記載してください
こちらのサイトに
http://answers.unity3d.com/questions/1112968/shader-unsupported-no-vertex-shader-breaking-graph.htm
Found the answer. The issue was actually in another custom shader, which contained the code "#pragma exclude_renderers gles flash". WebGL uses gles, and that line stopped the shader for compiling for it. 

とあったので#pragma exclude_renderers gles を追加してみました。

l
			CGPROGRAM
			#pragma exclude_renderers gles を追加してみました。


よく読むと"#pragma exclude_renderers gles flash"と書いた別のカスタムシェーダがわるさをしている
マニュアルによると#pragma exclude_renderers space separated names - 指定のレンダラーのみシェーダーをコンパイルしません。
OpenGLES2.0 しか指定していないのでglsl をコンパイルしないわけにいきません
その記述に関係なく動作しました。

###補足情報(言語/FW/ツール等のバージョンなど)
より詳細な情報
project setting は
OpenGLES2.0、まあまあ正常な中この WARNING: Shader Unsupported: 'Hidden/Internal-MotionVectors' - Pass '' has no vertex shader
OpenGLE3.0 3Dオブジェクトはピンク たぶんよくある シェーダーが見つかりませんよエラーです。
metal  3Dオブジェクトは真っ黒です。

Rendering Path はForward
です。

Unity5.4.1p4
Xcode Version 8.0 (8A218a)
iPhone 7 iOS10.0.2(14A456)

 WARNING: Shader Unsupported: 'Hidden/Internal-MotionVectors' - Pass '' has no vertex shader　を出ないように

シェーダーの実装コードの手順がDirectXの実装と異なるためわかりません。まずシェーダーバイナリを単純に読み込んでそこからシェーダーコードをいじろうと思っています。サイトが見つかりません

////コメント部の内部です。実装コードは正しいのでしょうか？if文で分岐していますが-1が返ってくるとexit(1);で強制終了するはずなので
終了しないつまり画面が閉じないということはしっかりシェーダーコードファイルが読み込まれているのでしょうか？

またDraw_Update();のfor文の下のDrawPolygonIndexed3DToShader();関数の使い方ですがリファレンスを見ると
シェーダーを使って２Ｄポリゴンを描画する(インデックスを使用)と書いてありますがこれを使って描画するのでしょうか？

参考サイト
https://yttm-work.jp/shader/shader_0001.html
https://dxlib.xsrv.jp/function/dxfunc_3d.html#R17N2
http://marupeke296.com/ProShader_main.html



![イメージ説明](0a6aa5ab59cfe32cc0032ec7579f560e.png)
```ここに言語を入力
#include "DxLib.h"

#include "Game.hpp"
#include "Input.hpp"
#include "Frame.hpp"
#include "Vector.hpp"

const char* filename = "Log.txt";
std::ofstream ofs(filename);


/*コンストラクタ　初期化*/
Game::Game()
{

	/*操作切替*/
	mc = ModeChange::rotate;

	/*ライト設定*/
	LightHandle = CreateDirLightHandle(VGet(0, -1, 0));
	if (LightHandle == -1)
	{
		exit(1);
	}

	SetLightEnable(false); //標準ライトを有効にするかどうか？	
	SetUseLighting(false);


	SetUseZBuffer3D(true);
	SetWriteZBuffer3D(true);
	handle = LoadGraph("assets/resource/texturePos.png");

	cameraPos.x = 0;
	cameraPos.y = 20;
	cameraPos.z = -40;

	targetV.x = 0;
	targetV.y = 0;
	targetV.z = 0;

	/*上　手前から右回りで　回ったら下で手前から右回り 省略*/
	//////////////////////////////////////////////////////////上の面の頂点
	Vertex[0].pos = VGet(targetV.x - RANGE, targetV.y + RANGE, targetV.z - RANGE);
	Vertex[0].norm = VGet(0.0f, 0.0f, -1.0f);
	Vertex[0].dif = color_dif;
	Vertex[0].spc = color_spc;
	Vertex[0].u = 0.0f;
	Vertex[0].v = 0.0f;

	/*地面　ポリゴン*/
	Ground_Vertex[0].pos = VGet(-GROUND_X, GROUND_Y, GROUND_Z);
	Ground_Vertex[0].norm = VGet(0.0f, 0.0f, -1.0f);
	Ground_Vertex[0].dif = color_dif;
	Ground_Vertex[0].spc = color_spc;
	Ground_Vertex[0].u = 0.0f;
	Ground_Vertex[0].v = 0.0f;


	//////////////////////////////////////////////////////////////////////////
	/*Shader 設定*/
	sh_V_handle = LoadVertexShader("assets/source/VertexShader.vso");
	if (sh_V_handle == -1)
	{
		exit(1);
	}
	sh_V_handle = SetUseVertexShader(sh_V_handle);

	if (sh_V_handle == -1)
	{
		exit(1);
	}
	if (SetUseTextureToShader(0, handle) == -1)
	{
		exit(1);	
	}

	//////////////////////////////////////////////////////////////////////////
	Vertex_Norm();

}

void Game::Update()
{
	change();


	/*カメラ回転*/
	if (Input::keyboard(KEY_INPUT_LEFT) > 0)
	{
		rotate(&cameraPos, ROTATE_SPEED, targetV, Vector(0, 1, 0));
	}
	else if (Input::keyboard(KEY_INPUT_RIGHT) > 0)
	{
		rotate(&cameraPos, ROTATE_SPEED, targetV, Vector(0, -1, 0));
	}
	else if (Input::keyboard(KEY_INPUT_UP) > 0)
	{
		rotate(&cameraPos, ROTATE_SPEED, targetV, get_axis(cameraPos, targetV, Vector(0, 1, 0)));
	}
	else if (Input::keyboard(KEY_INPUT_DOWN) > 0)
	{
		rotate(&cameraPos, ROTATE_SPEED, targetV, get_axis(cameraPos, targetV, Vector(0, -1, 0)));
	}

	/*編集*/
	switch (mc) {	
	}


	//	Vertex_Norm();
}

/*確認用 描画*/
void Game::Debug_Draw()
{
	DrawFormatString(0, 0, GetColor(255, 255, 255), "カメラ 座標　x: %.2f , y: %.2f , z:%.2f ", cameraPos.x, cameraPos.y, cameraPos.z);
	int t = GetValidShaderVersion() / 100;
	//DrawFormatString(0, 0, GetColor(255, 255, 255), "シェーダー: %d",t);

	DrawFormatString(0, 32 * 1, GetColor(255, 255, 255), "注視点 座標　x: %.2f , y: %.2f , z:%.2f ", targetV.x, targetV.y, targetV.z);

}

void Game::DrawUpdate()
{
	//	DrawFormatString(0, 32 * 3, GetColor(255, 255, 255), "chqnge();");

	SetCameraPositionAndTarget_UpVecY(VGet(cameraPos.x, cameraPos.y, cameraPos.z), VGet(targetV.x, targetV.y, targetV.z));

	/*キューブ描画*/
	for (int i = 0; i < 6; i++) {
		switch (i)
		{
			/*手前*/
		case 0:
		{
			Vertex[0].u = 0.0;
			Vertex[0].v = 0.0;

			Vertex[1].u = 1.0;
			Vertex[1].v = 0.0;

			Vertex[4].u = 0.0;
			Vertex[4].v = 1.0;

			Vertex[5].u = 1.0;
			Vertex[5].v = 1.0;
		}
		break;//同じようなコードのため省略

		//		DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, DX_NONE_GRAPH, false);	
		//		DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
		}
　　　//////////////////////////////////////////////////////////////////////////////////
		if (DrawPolygonIndexed3DToShader(Vertex, 8, Index[i], 2) == -1) { exit(1); }
     //////////////////////////////////////////////////////////////////////////////////
	}

	/*平面描画*/
	DrawPolygonIndexed3D(Ground_Vertex, 4, Ground_Index, 2, handle, false);

	/*ライト*/
//	SetLightEnableHandle(LightHandle,true);

	Debug_Draw();

}
```



シェーダーコード
```
float4x4 matWVP : WorldViewProjection;

struct vertexInput {
	float3 Position : POSITION;
};

struct vertexOutput {
	float3 HPosition : POSITION;
	float4 Diffuse : COLORD;
};

//vertexOutput VS_TransformDiffuse(vertexInput IN)
vertexOutput main(vertexInput IN)
{
	vertexOutput OUT;
//	OUT.HPosition = mul(float4(IN.Position.xyz, 1.0f), matWVP);
//	OUT.Diffuse = float4(1.0f, 1.0f, 1.0f, 1.0f);

	return OUT;
}

technique textured
{
	pass p0
	{
		VertexShader = compile vs_5_0 main();

	}
}
```