常連

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

### 実現したいこと
コップのモデルをフェードアウトさせたい。

### 発生している問題・分からないこと
フェードアウトさせるためにStandardシェーダーのRendering Modeを「Fade」にするとモデルが透けて反対側が見えてしまいます。これを解消するにはどうしたら良いでしょうか？![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-03-26/7c424e0a-0570-49cf-9a58-05b1e62a5a1f.jpeg)



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

```
特になし
```

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

##### 上記の詳細・結果
検索すると2パスさせる方法があるようですが、コードに詳しくないのでわかりませんでした。
ディザリングの方法もあるようですが、滑らかにフェードアウトさせたいのでこれは違うようです。

### 補足
特になし

UnityのシェーダーをFadeにするとモデルが透けてしまう。

### はじめに

現在、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

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

DxLibによるシェーダーを実装する手順が知りたい。

何か解決したい問題があるわけではなくて、知識としての質問です。

例えば、以下のような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