#define IS_FX_FILE
#include "../../../Ext/xelib/Include/xelib/System/Draw/modeDef.h"

//#define USE_WATER_SHOWER

// パラメーター
cbuffer cbParam
{
	// カラー設定
	int g_bright_type;				// 明るさタイプ(0:なし,1:あり)
	float g_bright = 0.0f;					// 明るさ

	int g_contrast_type;			// コントラストタイプ(0:なし,1:あり)
	float g_contrast = 0.0f;				// コントラスト

	int g_hue_type;					// 色相タイプ(0:なし,1:あり)
	float g_hue;					// 色相

	int g_gammma_type;				// ガンマタイプ(0:なし,1:v1,2:v2)
	float g_gamma_offset;			// ガンマ
	float g_gamma_scale;
	float g_gamma_pow = 1.0f;
	float g_gamma_scale2;
	float g_gamma_offset2;

	// フォグ
	float4	fogColor;
	float	g_PE_fogNear;
	float	g_PE_fogFar;
	float	g_PE_one_div_fogFar_fogNear;

	bool	fogEnable;
	bool    debugLineDisp;
	float	fogMapScale;
	float4	fogMapOffset;

	float   fogMapColorOffset;
	float   fogMapColorGain;
	float   fogMapBlendRate;
	float4	g_PosEye;	// カメラ位置,zはファークリップ距離
	int		fogTestMode;

	// 指数フォグ
	float	fogDensity;
	float	camFar;
	float   fogRate;


}

float2 ofs00 = float2(  0.000f,  0.001f );
float2 ofs01 = float2(  0.000f, -0.001f );
float2 ofs02 = float2(  0.001f,  0.000f );
float2 ofs03 = float2( -0.001f,  0.000f );

float2 ofs04 = float2(  0.001f,  0.001f );
float2 ofs05 = float2(  0.001f, -0.001f );
float2 ofs06 = float2( -0.001f,  0.001f );
float2 ofs07 = float2( -0.001f, -0.001f );

float2 ofs08 = float2(  0.000f,  0.002f );
float2 ofs09 = float2(  0.000f, -0.002f );
float2 ofs10 = float2(  0.002f,  0.000f );
float2 ofs11 = float2( -0.002f,  0.000f );

float2 ofs12 = float2(  0.002f,  0.002f );
float2 ofs13 = float2(  0.002f, -0.002f );
float2 ofs14 = float2( -0.002f,  0.002f );
float2 ofs15 = float2( -0.002f, -0.002f );

Texture2D HeightFogTex;
Texture2D FogBlendTex;
Texture2D g_HighBeamTex;
//Texture2D g_PinpointBlurTex;

float g_PinpointBlurRate;

//---

Texture2D s0;
Texture2D s1;
Texture2D s2;
Texture2D s3;

Texture2D g_ToneMapLum;

Texture2D g_PosTex;
Texture2D DepthTex;

// トーンマップ
Texture2D AveLuminanceTex;
Texture2D MaxLuminanceTex;

// ブルーム
Texture2D BloomTex;
// グレア
Texture2D GlareTex;


bool	g_toneEnable;
float	g_fMiddleGray;       // The middle gray key value
float	g_param_tone_up_bright_irate;

///< 位相
float g_FP_raster_phaseX = 0.08f;
float g_FP_raster_phaseY = 0.06f;

float g_FP_raster_pitchX = 48.0f;
float g_FP_raster_scaleX = 0.001f;
float g_FP_raster_pitchY = 36.0f;
float g_FP_raster_scaleY = 0.01f;

float g_FP_water_line[2];
float g_FP_char_pos[2];

float g_PE_distortion_00_pos[2];
float g_PE_distortion_01_pos[2];
float g_PE_distortion_02_pos[2];

// ブラー
float g_PE_dash_blur_param;
float g_PE_motion_blur_param;
float g_PE_motion_blur_alpha;
float g_PE_dash_blur_length_param;

float3 g_PlayerPos;

// フェード
float4 g_PE_fade_color;

// 水滴
Texture2D g_PE_water_drop_normal;

// 浴びせられた水
Texture2D g_PE_water_shower_normal;

// モーションブラー
Texture2D g_PE_motion_blur;

//static const float  MIDDLE_GRAY = 0.72f;
//float  LUM_WHITE = 1.5f;
float  LUM_WHITE = 1.0f;

int g_WaterDropNum = 0;
int g_WaterShowerNum = 0;

//SSAO--------------------------------
Texture2D	g_texture_diffuse;
Texture2D	g_RandomNormalTexture;
Texture2D	g_NormalZTexture;
Texture2D	g_BlurTexture;

float g_totStrength;
float g_strength;
float g_offset;
float g_falloff;
float g_rad;


#define SAMPLES 8 // 10 is good
float invSamples = 1.0/8.0;
//static float2 ScreenSize = float2(1360.0f/2.0f,768.0f/2.0f);
static float2 ScreenSize = float2(1360.0f,768.0f);

#define BLUROFFSET_COUNT 4
static float2 BlurOffset16[BLUROFFSET_COUNT] = {
        float2(  1,  1 )
      , float2( -1,  1 )
      , float2( -1, -1 )
      , float2(  1, -1 )
      //, float2(  3,  1 )
      //, float2(  3,  3 )
      //, float2(  1,  3 )
      //, float2( -1,  3 )
      //, float2( -3,  3 )
      //, float2( -3,  1 )
      //, float2( -3, -1 )
      //, float2( -3, -3 )
      //, float2( -1, -3 )
      //, float2(  1, -3 )
      //, float2(  3, -3 )
      //, float2(  3, -1 )
};

// 単位球内のランダムなベクトル
#if SAMPLES == 16
float3 pSphere[16] = {
	float3(0.53812504, 0.18565957, -0.43192),
	float3(0.13790712, 0.24864247, 0.44301823),
	float3(0.33715037, 0.56794053, -0.005789503),
	float3(-0.6999805, -0.04511441, -0.0019965635),
	float3(0.06896307, -0.15983082, -0.85477847),
	float3(0.056099437, 0.006954967, -0.1843352),
	float3(-0.014653638, 0.14027752, 0.0762037),
	float3(0.010019933, -0.1924225, -0.034443386),
	float3(-0.35775623, -0.5301969, -0.43581226),
	float3(-0.3169221, 0.106360726, 0.015860917),
	float3(0.010350345, -0.58698344, 0.0046293875),
	float3(-0.08972908, -0.49408212, 0.3287904),
	float3(0.7119986, -0.0154690035, -0.09183723),
	float3(-0.053382345, 0.059675813, -0.5411899),
	float3(0.035267662, -0.063188605, 0.54602677),
	float3(-0.47761092, 0.2847911, -0.0271716)
};
#elif SAMPLES == 8
const float3 pSphere[8] = {
	float3(0.24710192, 0.6445882, 0.033550154),
	float3(0.00991752, -0.21947019, 0.7196721),
	float3(0.25109035, -0.1787317, -0.011580509),
	float3(-0.08781511, 0.44514698, 0.56647956),
	float3(-0.011737816, -0.0643377, 0.16030222),
	float3(0.035941467, 0.04990871, -0.46533614),
	float3(-0.058801126, 0.7347013, -0.25399926),
	float3(-0.24799341, -0.022052078, -0.13399573)
};
#elif SAMPLES == 12
const float3 pSphere[12] = {
	float3(-0.13657719, 0.30651027, 0.16118456),
	float3(-0.14714938, 0.33245975, -0.113095455),
	float3(0.030659059, 0.27887347, -0.7332209),
	float3(0.009913514, -0.89884496, 0.07381549),
	float3(0.040318526, 0.40091, 0.6847858),
	float3(0.22311053, -0.3039437, -0.19340435),
	float3(0.36235332, 0.21894878, -0.05407306),
	float3(-0.15198798, -0.38409665, -0.46785462),
	float3(-0.013492276, -0.5345803, 0.11307949),
	float3(-0.4972847, 0.037064247, -0.4381323),
	float3(-0.024175806, -0.008928787, 0.17719103),
	float3(0.694014, -0.122672155, 0.33098832)
};
#else
const float3 pSphere[10] = {
	float3(-0.010735935, 0.01647018, 0.0062425877),
	float3(-0.06533369, 0.3647007, -0.13746321),
	float3(-0.6539235, -0.016726388, -0.53000957),
	float3(0.40958285, 0.0052428036, -0.5591124),
	float3(-0.1465366, 0.09899267, 0.15571679),
	float3(-0.44122112, -0.5458797, 0.04912532),
	float3(0.03755566, -0.10961345, -0.33040273),
	float3(0.019100213, 0.29652783, 0.066237666),
	float3(0.8765323, 0.011236004, 0.28265962),
	float3(0.29264435, -0.40794238, 0.15964167)
};
#endif


// サンプルステート
SamplerState samDepth
{
	Filter = MIN_MAG_MIP_LINEAR;
	AddressU = Clamp;
	AddressV = Clamp;
};

SamplerState samLinear
{
	Filter = MIN_MAG_MIP_LINEAR;
	AddressU = Wrap;
	AddressV = Wrap;
};
SamplerState samPoint
{
	Filter = MIN_MAG_MIP_POINT;
	AddressU = Wrap;
	AddressV = Wrap;
};

//------------------------------------


SamplerState PointSampler
{
    Filter = MIN_MAG_MIP_POINT;
    //AddressU = Clamp;
    //AddressV = Clamp;
    AddressU = BORDER;
    AddressV = BORDER;
    BORDERCOLOR = float4(0,0,0,0);
};

SamplerState LinearSampler
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Clamp;
    AddressV = Clamp;
};

SamplerState LinearSamplerWrap
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

SamplerState LinearSamplerMirror
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = CLAMP;
    AddressV = CLAMP;
};

SamplerState PointSamplerMirror
{
    Filter = MIN_MAG_MIP_POINT;
    AddressU = Mirror;
    AddressV = Mirror;
};

SamplerState BlurSampler
{
    Filter = ANISOTROPIC;
    AddressU = CLAMP;
    AddressV = CLAMP;
};

#define postEffectSampler	(LinearSamplerMirror)


DepthStencilState DisableDepth
{
    DepthEnable = FALSE;
    DepthWriteMask = ZERO;
};

BlendState NoBlend
{
	BlendEnable[0] = FALSE;
	BlendEnable[1] = FALSE;
	BlendEnable[2] = FALSE;
	BlendEnable[3] = FALSE;
	BlendEnable[4] = FALSE;
	BlendEnable[5] = FALSE;
	BlendEnable[6] = FALSE;
	BlendEnable[7] = FALSE;
};


// ブレンドステート
BlendState SrcAlphaBlending
{
    AlphaToCoverageEnable = FALSE;
    BlendEnable[0] = TRUE;
    SrcBlend = SRC_ALPHA;
    DestBlend = INV_SRC_ALPHA;
    BlendOp = ADD;
    SrcBlendAlpha = ONE;
    DestBlendAlpha = INV_SRC_ALPHA;
    BlendOpAlpha = ADD;
    RenderTargetWriteMask[0] = 0x0F;
};

//===================================================================================================
// 共通
//===================================================================================================
struct QuadVS_Input
{
    float4 Pos : POSITION;
    float2 Tex : TEXCOORD0;
};

struct QuadVS_Output
{
    float4 Pos : SV_POSITION;              // Transformed position
    float2 Tex : TEXCOORD0;
};

QuadVS_Output QuadVS( QuadVS_Input Input )
{
    QuadVS_Output Output;
    Output.Pos = Input.Pos;
    Output.Tex = Input.Tex;
    return Output;
}

struct PS_OUTPUT
{
   float4 Col1 : SV_TARGET0;
   float4 Col2 : SV_TARGET1;
};

float	g_AspectRatio = 1360.0f/768.0f;
float	g_Pi		  = 3.141592f;
float	g_Pi_Quarter  = 3.141592f * 0.25f;

float	g_PE_Distortion_00_Radius = 0.0f;
float	g_PE_Distortion_01_Radius = 0.0f;
float	g_PE_Distortion_02_Radius = 0.0f;
float	g_PE_DistortionRate = 0.0f;



//===================================================================================================
// ファイナルパス
//===================================================================================================
PS_OUTPUT FinalPass( QuadVS_Output Input, uniform bool useBlur, uniform bool useGlare, uniform bool useToneMap, uniform bool useBloom )
{
	float4 vColor= float4(0,0,0,0);

	float2 ofset = float2( 0.0f, 0.0f );
	float power=0.0f;
	if ( Input.Tex.y > g_FP_water_line[1] )
	{
		ofset.x = sin( Input.Tex.y*g_FP_raster_pitchX + g_FP_raster_phaseX )*g_FP_raster_scaleX;
		ofset.y = cos( Input.Tex.y*g_FP_raster_pitchY + g_FP_raster_phaseY )*g_FP_raster_scaleY;

		//ofset.x = sin( g_FP_char_pos[0]*g_FP_raster_pitchX + g_FP_raster_phaseX )*g_FP_raster_scaleX;
		//ofset.y = cos( g_FP_char_pos[1]*g_FP_raster_pitchY + g_FP_raster_phaseY )*g_FP_raster_scaleY;

		///< 中心からの距離
		float2 dist = float2( Input.Tex.x-0.5f, Input.Tex.y-0.5f );
		power = max( 0.65f-length(dist), 0.0f );
	}

#if 0
	///< ディストーション
	float2 d_move = float2( 0.0f, 0.0f );
	{
		float2 p = float2( (g_PE_distortion_00_pos[0]-Input.Tex.x)*(g_AspectRatio), (g_PE_distortion_00_pos[1]-Input.Tex.y) );
		float l = length( p );
		if ( l <= max( (g_PE_Distortion_00_Radius - 0.06f), 0.0f ) ){
		}
		else
		if ( l <= g_PE_Distortion_00_Radius ) { 
			d_move = (-p)*0.10f;
			//d_move = p*0.30f;
		}
		//else 
		//if ( l <= g_PE_Distortion_01_Radius ) {
		//	d_move = (-p)*0.16f;
		//	//d_move = p*0.20f;
		//}
		//else 
		//if ( l <= g_PE_Distortion_02_Radius ) {
		//	d_move = p*0.10f;
		//}
		else ///< 外側は歪ませる
		{
			d_move = (-p) * max( 0.0f, ( g_PE_Distortion_00_Radius + 0.1f - l ) ) * 2.0f;
			//d_move = (p) * max( 0.0f, ( g_PE_Distortion_00_Radius + 0.1f - l ) ) * 2.0f;
		}
	}

	float2 texUV = Input.Tex+(ofset*power) - (d_move * g_PE_DistortionRate);
#endif

	float2 texUV = Input.Tex+(ofset*power);

	// グローバル座標
	//float4 gpos = g_PosTex.Sample( postEffectSampler, texUV );

///< 新型ブラーテスト
//float4 pbl = g_PinpointBlurTex.Sample( BlurSampler, texUV );
//pbl *= 10000.00f;
//vColor = s0.Sample( PointSamplerMirror, texUV );
//vColor += pbl;

	vColor = s0.Sample( PointSamplerMirror, texUV );
	if( vColor.a <= 0.0f ) discard;	// 背景2Dを消さないためのアルファテスト

#if (1)
	if( Input.Tex.y < g_FP_water_line[1] && (g_WaterDropNum > 0 || g_WaterShowerNum > 0))
	{
#ifdef USE_WATER_SHOWER
		// 浴びせられた水
		{
			float4 shower_offset = g_PE_water_shower_normal.Sample( postEffectSampler, texUV );
			shower_offset.rgb = ( shower_offset.rgb - 0.5f ) * 2.0f;
			shower_offset.r *= -1.0f;

			//滴の輪郭を取得する
			float p = 1.0f - dot( normalize( shower_offset.rgb ), float3( 0.0f, 0.0f, 1.0f ) );

			texUV += shower_offset.xy * 0.05f;
			vColor = s0.Sample( PointSamplerMirror, texUV ) + p;
		}
#endif

		// 水滴
		{
			float4 drop_offset = g_PE_water_drop_normal.Sample( postEffectSampler, texUV );
			if( drop_offset.a > 0.0f )
			{
				drop_offset.x -= 0.5f;
				drop_offset.y -= 0.5f;

				float fColorOffset = abs( drop_offset.x ) + abs( drop_offset.y );
				float4 vWaterDropColor = s0.Sample( PointSamplerMirror, texUV + drop_offset.xy );
				vWaterDropColor.xyz += fColorOffset;
				vColor = lerp( vColor, vWaterDropColor, drop_offset.a );
			}
		}
	}

#if 0
	///< ピンポイントブラー
	float4 pbl = g_PinpointBlurTex.Sample( BlurSampler, texUV );
	vColor += pbl*g_PinpointBlurRate;
#if 0
	if ( pbl.r > 0.0f )
	{
		vColor += s0.Sample( BlurSampler, texUV+ofs00 );
		vColor += s0.Sample( BlurSampler, texUV+ofs01 );
		vColor += s0.Sample( BlurSampler, texUV+ofs02 );
		vColor += s0.Sample( BlurSampler, texUV+ofs03 );

		vColor += s0.Sample( BlurSampler, texUV+ofs04 );
		vColor += s0.Sample( BlurSampler, texUV+ofs05 );
		vColor += s0.Sample( BlurSampler, texUV+ofs06 );
		vColor += s0.Sample( BlurSampler, texUV+ofs07 );

		vColor += s0.Sample( BlurSampler, texUV+ofs08 );
		vColor += s0.Sample( BlurSampler, texUV+ofs09 );
		vColor += s0.Sample( BlurSampler, texUV+ofs10 );
		vColor += s0.Sample( BlurSampler, texUV+ofs11 );

		vColor += s0.Sample( BlurSampler, texUV+ofs12 );
		vColor += s0.Sample( BlurSampler, texUV+ofs13 );
		vColor += s0.Sample( BlurSampler, texUV+ofs14 );
		vColor += s0.Sample( BlurSampler, texUV+ofs15 );

		vColor.rgb = vColor.rgb*0.0625f;
	}
#endif
#endif

#if 1
	float4 high = g_HighBeamTex.Sample( BlurSampler, texUV );
	if ( high.r > 0.0f )
	{
#if 0
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs00 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs01 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs02 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs03 ).r;

		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs04 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs05 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs06 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs07 ).r;
#endif

#if 1
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs08 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs09 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs10 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs11 ).r;

		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs12 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs13 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs14 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs15 ).r;

		high = max( 1.0f, (0.5f+((high)*0.0625f))*1.8f );
		vColor.rgb *= high;
#endif
		//vColor.rgb *= hight;
	}
#endif

	// ブラー
	if(useBlur && 0.0f < g_PE_dash_blur_param)
	{
		// 画面中心からの距離に応じて引き延ばす。
//		float2 screenVel = float2( Input.Tex.x - 0.5f, Input.Tex.y - 0.5f );
		float2 screenVel = float2( Input.Tex.x - g_PlayerPos.x, Input.Tex.y - g_PlayerPos.y );
		screenVel.y *= 0.7f;
		//中心（現状はプレイヤー位置）からある程度ゆるめにかけて中心付近はあまりブラーがかからないようにしたい
		float sp = step(g_PE_dash_blur_length_param,length(screenVel));
		float sm = smoothstep(g_PE_dash_blur_length_param,1.0f,length(screenVel));
		screenVel.x *= abs( screenVel.x )*sp*sm;
		screenVel.y *= abs( screenVel.y )*sp*sm;



		const int sampleNum = 15;

		float2 uv = Input.Tex + ofset;

		for(int i=0; i<sampleNum; i++, uv -= screenVel * ((g_PE_dash_blur_param*1.5f)/sampleNum))
		{
			float4 color = s0.Sample( postEffectSampler, uv );

			vColor += color;
		}
		vColor /= sampleNum;
	}
#endif

#if(1)
	// モーションブラー
	float4 vMotionBlurColor = float4(0,0,0,0);
	if( 0.0f < g_PE_motion_blur_param )
	{
		vMotionBlurColor = lerp( g_PE_motion_blur.Sample( PointSampler, texUV ), vColor, g_PE_motion_blur_alpha );	
	}
#endif

	// ここでフォグ
	{

		// フォグ
		float len = length ( g_PosEye.xyz - g_PosTex.Sample( postEffectSampler, texUV ).xyz);
//		float depth = DepthTex.Sample( PointSampler, texUV ).r;
		if(fogEnable){
			// 線型フォグ
//float rate = saturate( (len - g_PE_fogNear)/(g_PE_fogFar - g_PE_fogNear) );
float rate = saturate( (len - g_PE_fogNear)*(g_PE_one_div_fogFar_fogNear) );
//			// 指数フォグ(１次)
//			float satuDist = len/camFar;
//			if(gpos.w == 0) satuDist = 1;	// 天空は距離最大 暫定

//			float rate = 1.0f - 1.0/exp( (satuDist) * fogDensity );

			// 指数フォグ（２次）
			//float satuDist = (len/camFar) * fogDensity;
			//float satuDist = (depth) * fogDensity;
			//float rate = 1.0 - (1.0/exp( satuDist * satuDist ));



			//return float4(depth, depth, depth, 1);


			rate *= fogRate;	// 最後に少し小さく補正して真っ白になるのを防ぐ

			vColor = lerp( vColor, fogColor, rate);
		}

		// 距離パラメータに線を引く
		//if(debugLineDisp){

		//	// ファークリップ距離
		//	float rate = abs(len - g_PosEye.w) / g_PosEye.w * 100;
		//	rate = saturate(1.0 - rate);
		//	vColor = lerp( vColor, float4(0,0,1,1), rate);

		//	if(fogEnable){
		//		// フォグニア
		//		float rate1 = abs(len - g_PE_fogNear) / g_PE_fogNear * 100;
		//		rate1 = saturate(1.0 - rate1);
		//		vColor = lerp( vColor, float4(1,0,0,1), rate1);

		//		// フォグファー
		//		float rate2 = abs(len - g_PE_fogFar) / g_PE_fogFar * 100;
		//		rate2 = saturate(1.0 - rate2);
		//		vColor = lerp( vColor, float4(0,1,0,1), rate2);
		//	}
		//}
	}



	// 高さフォグ
#if(0)
	if(gpos.w != 0){
		// フォグ
		//float len = length ( g_PosEye.xyz - g_FPtexPos.Sample( PointSampler, texUV ).xyz);
		// 高さフォグ
		//float3 pos = g_FPtexPos.Sample( PointSampler, texUV ).xyz;
		float3 viewPos = gpos.xyz - g_PosEye.xyz;

		float height	= viewPos.y;
		float len	= length(viewPos);

		if(fogEnable){
			float rate = saturate( ((-height) - g_PE_fogNear)/(g_PE_fogFar - g_PE_fogNear));
			float3 uv1 = viewPos / fogMapScale;
			float3 uv2 = viewPos / fogMapScale * 0.73;

			//// 逆距離フォグ
			//float near = 200;
			//float far  = 300;
			//float rate2 = saturate((len - far)/(near-far));
			//rate *= rate2;

			float fogmap =	(HeightFogTex.Sample( LinearSamplerWrap, uv1.xz + fogMapOffset.xy + float2(uv1.y,uv1.y) )
							+ HeightFogTex.Sample( LinearSamplerWrap, uv2.xz + fogMapOffset.zw + float2(uv2.y,uv2.y) )) /2.0;

			float fogBlend = FogBlendTex.Sample( LinearSampler, texUV ).x;

			//float fogmap =	lerp(  HeightFogTex.Sample( LinearSamplerWrap, uv1.xz + fogMapOffset.xy + float2(uv1.y,uv1.y) )
			//	, HeightFogTex.Sample( LinearSamplerWrap, uv2.xz + fogMapOffset.zw + float2(uv2.y,uv2.y) )
			//	//, fogMapBlendRate );
			//	, fogBlend );
			
			//float fogmap = HeightFogTex.Sample( LinearSamplerWrap, uv2.xz + fogMapOffset.zw + float2(uv2.y,uv2.y)) * max(fogMapBlendRate, fogBlend);
			fogmap *= max(fogMapBlendRate, fogBlend);

			rate *= saturate(((fogmap * fogMapColorGain) + fogMapColorOffset));
			//rate = 1.0 - (1.0-rate)*fogmap;

			if(fogTestMode==0){
				vColor = lerp( vColor, fogColor, rate);
			}else{
				vColor += float4(fogBlend,0,0,1);
			}
		}
	}
#endif

	///< DX Tone Map
#if 0
	if ( 0 )
	{
		float4 vLum = g_ToneMapLum.Sample( PointSampler, float2(0,0) );
		float lumavr = vLum.r;
		vColor.rgb *= g_fMiddleGray / (lumavr + 0.001f );
#if 0
		//float4 vColor = s0.Sample( PointSampler, Input.Tex );
		float4 vLum = g_ToneMapLum.Sample( PointSampler, float2(0,0) );
		//float3 vBloom = s2.Sample( LinearSampler, Input.Tex );

		// Tone mapping

		float lumavr = vLum.r;///< ピーキーに反応しない
//		if( lumavr > 0.7f && lumavr <= 1.7f ) lumavr = 0.7f;
//		else if ( lumavr > 1.7f ) lumavr -= 1.0f;

		vColor.rgb *= g_fMiddleGray / (lumavr + 0.001f);	///< スケーリング
		vColor.rgb *= (1.0f + vColor/LUM_WHITE);			///< 白調整
		vColor.rgb /= (1.0f + vColor);						///< 圧縮
    
		//vColor.rgb += 0.6f * vBloom;
		//vColor.a = 1.0f;
#endif
	}
#endif
#if(0)
	const float3 RGB2Y   = float3( +0.29900f, +0.58700f, +0.11400f );
	const float3 RGB2Cb  = float3( -0.16874f, -0.33126f, +0.50000f );
	const float3 RGB2Cr  = float3( +0.50000f, -0.41869f, -0.08131f );
	const float3 YCbCr2R = float3( +1.00000f, +0.00000f, +1.40200f );
	const float3 YCbCr2G = float3( +1.00000f, -0.34414f, -0.71414f );
	const float3 YCbCr2B = float3( +1.00000f, +1.77200f, +0.00000f );
#endif

///	if(useBloom)
	{
		float3 bloom = BloomTex.Sample( LinearSampler, texUV ).rgb;
		vColor.rgb += 1.00f * bloom;
	}
///	if(useGlare)
	{
		float3 glare = GlareTex.Sample( LinearSampler, texUV ).rgb;
		vColor.rgb += 0.25f * glare;
	}

#if 0
	// トーンマップ
	if(1){
		float coeff	= AveLuminanceTex.Load(int3(0,0,0)).r;
		float l_max	= MaxLuminanceTex.Load(int3(0,0,0)).r;

		{
			//DirectX Sample
			//vColor.rgb *= g_fMiddleGray/(fAdaptedLum + 0.001f);
			//vColor.rgb /= (1.0f+vColor);
		}

		{
			//vColor.rgb *= g_fMiddleGray / (fAdaptedLum + 0.001f); // トーンに合わせて補正
			//vColor.rgb *= (1.0f + vColor.rgb/(fMaxLum*fMaxLum)); // 引き伸ばし
			//vColor.rgb /= (1.0f + vColor.rgb); // 丸め込み
		}

		{
		// YCbCrに変換して輝度補正する
		float3 YCbCr;
		YCbCr.y = dot( RGB2Cb, vColor.rgb);
		YCbCr.z = dot( RGB2Cr, vColor.rgb);

//		float lum = g_fMiddleGray / (fAdaptedLum + 0.001f); // トーンに合わせて補正;
//		lum *= (1.0f + vColor.rgb/(fMaxLum*fMaxLum)); // 引き伸ばし
//		lum /= (1.0f + vColor.rgb); // 丸め込み
//		YCbCr.x = lum * dot( RGB2Y, vColor.rgb);

//		float lum = coeff * dot( RGB2Y,  vColor.rgb );
//		YCbCr.x = lum * (1.0f+lum/(l_max*l_max)) / (1.0f+lum);
		YCbCr.x = dot( RGB2Y,  vColor.rgb );

		// RGBに戻す
		vColor.r = dot( YCbCr2R,  YCbCr );
		vColor.g = dot( YCbCr2G,  YCbCr );
		vColor.b = dot( YCbCr2B,  YCbCr );
		}
	}
#endif

	//---
	// 色調補正

#if(1)
	// 明るさ
	vColor.rgb = vColor.rgb + (float3)g_bright;
	
	// コントラスト
	float f = ( vColor.r + vColor.g + vColor.b ) * 0.33333f; // グレースケール
	vColor.rgb = (float3)f + ( ( vColor.rgb - (float3)f ) * (float3)g_contrast );
	
	// ガンマ
	vColor.rgb = pow( abs(vColor.rgb), g_gamma_pow );
	//vColor.rgb = ( pow( abs( ( vColor.rgb + g_gamma_offset ) * g_gamma_scale ), g_gamma_pow ) * g_gamma_scale2 + g_gamma_offset2 );
#endif


#if(1)
	// フェード
	{
		vColor = lerp( vColor, float4( g_PE_fade_color.r, g_PE_fade_color.g, g_PE_fade_color.b, 1.0f ), g_PE_fade_color.a );	
	}
#endif

//    return float4( vColor.rgb, 1.0f );
 //   return vColor.rgba;
	
	PS_OUTPUT output;
	output.Col1 = lerp( vColor, vMotionBlurColor, g_PE_motion_blur_param );
	output.Col2 = vMotionBlurColor;

	return output;
}

//===================================================================================================
// ファイナルパス
//===================================================================================================
PS_OUTPUT FinalPass_SSAO( QuadVS_Output Input, uniform bool useBlur, uniform bool useGlare, uniform bool useToneMap, uniform bool useBloom )
{
	float4 vColor= float4(0,0,0,0);

	float2 ofset = float2( 0.0f, 0.0f );
	float power=0.0f;
	if ( Input.Tex.y > g_FP_water_line[1] )
	{
		ofset.x = sin( Input.Tex.y*g_FP_raster_pitchX + g_FP_raster_phaseX )*g_FP_raster_scaleX;
		ofset.y = cos( Input.Tex.y*g_FP_raster_pitchY + g_FP_raster_phaseY )*g_FP_raster_scaleY;

		///< 中心からの距離
		float2 dist = float2( Input.Tex.x-0.5f, Input.Tex.y-0.5f );
		power = max( 0.65f-length(dist), 0.0f );
	}


	float2 texUV = Input.Tex+(ofset*power);

	vColor = s0.Sample( PointSamplerMirror, texUV );
	if( vColor.a <= 0.0f ) discard;	// 背景2Dを消さないためのアルファテスト

#if (1)
	if( Input.Tex.y < g_FP_water_line[1] && (g_WaterDropNum > 0 || g_WaterShowerNum > 0))
	{
#ifdef USE_WATER_SHOWER

		// 浴びせられた水
		{
			float4 shower_offset = g_PE_water_shower_normal.Sample( postEffectSampler, texUV );
			shower_offset.rgb = ( shower_offset.rgb - 0.5f ) * 2.0f;
			shower_offset.r *= -1.0f;

			//滴の輪郭を取得する
			float p = 1.0f - dot( normalize( shower_offset.rgb ), float3( 0.0f, 0.0f, 1.0f ) );

			texUV += shower_offset.xy * 0.05f;
			vColor = s0.Sample( PointSamplerMirror, texUV ) + p;
		}
#endif
		// 水滴
		{
			float4 drop_offset = g_PE_water_drop_normal.Sample( postEffectSampler, texUV );
			if( drop_offset.a > 0.0f )
			{
				drop_offset.x -= 0.5f;
				drop_offset.y -= 0.5f;

				float fColorOffset = abs( drop_offset.x ) + abs( drop_offset.y );
				float4 vWaterDropColor = s0.Sample( PointSamplerMirror, texUV + drop_offset.xy );
				vWaterDropColor.xyz += fColorOffset;
				vColor = lerp( vColor, vWaterDropColor, drop_offset.a );
			}
		}
	}


#if 1
	float4 high = g_HighBeamTex.Sample( BlurSampler, texUV );
	if ( high.r > 0.0f )
	{

#if 1
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs08 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs09 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs10 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs11 ).r;

		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs12 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs13 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs14 ).r;
		high += g_HighBeamTex.Sample( BlurSampler, texUV+ofs15 ).r;

		high = max( 1.0f, (0.5f+((high)*0.0625f))*1.8f );
		vColor.rgb *= high;
#endif
	}
#endif

	// ブラー
	if(useBlur && 0.0f < g_PE_dash_blur_param)
	{
		// 画面中心からの距離に応じて引き延ばす。
//		float2 screenVel = float2( Input.Tex.x - 0.5f, Input.Tex.y - 0.5f );
		float2 screenVel = float2( Input.Tex.x - g_PlayerPos.x, Input.Tex.y - g_PlayerPos.y );
		screenVel.y *= 0.7f;
		//中心（現状はプレイヤー位置）からある程度ゆるめにかけて中心付近はあまりブラーがかからないようにしたい
		float sp = step(g_PE_dash_blur_length_param,length(screenVel));
		float sm = smoothstep(g_PE_dash_blur_length_param,1.0f,length(screenVel));
		screenVel.x *= abs( screenVel.x )*sp*sm;
		screenVel.y *= abs( screenVel.y )*sp*sm;

		const int sampleNum = 15;

		float2 uv = Input.Tex + ofset;

		for(int i=0; i<sampleNum; i++, uv -= screenVel * (g_PE_dash_blur_param/sampleNum))
		{
			float4 color = s0.Sample( postEffectSampler, uv );

			vColor += color;
		}
		vColor /= sampleNum;
	}
#endif

#if(1)
	// モーションブラー
	float4 vMotionBlurColor = float4(0,0,0,0);
	if( 0.0f < g_PE_motion_blur_param )
	{
		vMotionBlurColor = lerp( g_PE_motion_blur.Sample( PointSampler, texUV ), vColor, g_PE_motion_blur_alpha );	
	}
#endif

	// ここでフォグ
	{

		// フォグ
		float len = length ( g_PosEye.xyz - g_PosTex.Sample( postEffectSampler, texUV ).xyz);
		if(fogEnable){
			float rate = saturate( (len - g_PE_fogNear)*(g_PE_one_div_fogFar_fogNear) );

			rate *= fogRate;	// 最後に少し小さく補正して真っ白になるのを防ぐ

			vColor = lerp( vColor, fogColor, rate);
		}
	}



	// 高さフォグ

	///< DX Tone Map


///	if(useBloom)
	{
		float3 bloom = BloomTex.Sample( LinearSampler, texUV ).rgb;
		vColor.rgb += 1.00f * bloom;
	}
///	if(useGlare)
	{
		float3 glare = GlareTex.Sample( LinearSampler, texUV ).rgb;
		vColor.rgb += 0.25f * glare;
	}


	//---
	// 色調補正

#if(1)
	// 明るさ
	vColor.rgb = vColor.rgb + (float3)g_bright;
	
	// コントラスト
	float f = ( vColor.r + vColor.g + vColor.b ) * 0.33333f; // グレースケール
	vColor.rgb = (float3)f + ( ( vColor.rgb - (float3)f ) * (float3)g_contrast );
	
	// ガンマ
	vColor.rgb = pow( abs(vColor.rgb), g_gamma_pow );
	//vColor.rgb = ( pow( abs( ( vColor.rgb + g_gamma_offset ) * g_gamma_scale ), g_gamma_pow ) * g_gamma_scale2 + g_gamma_offset2 );
#endif


#if(1)
	// フェード
	{
		vColor = lerp( vColor, float4( g_PE_fade_color.r, g_PE_fade_color.g, g_PE_fade_color.b, 1.0f ), g_PE_fade_color.a );	
	}
#endif


	PS_OUTPUT output;
	output.Col1 = lerp( vColor, vMotionBlurColor, g_PE_motion_blur_param );
	float4 ssaoTex = g_BlurTexture.Sample( samLinear, Input.Tex );
	ssaoTex.a = 0.0f;
	output.Col1 -= ssaoTex;
	output.Col2 = vMotionBlurColor;

	return output;
}

PS_OUTPUT RenderSSAO_PS(QuadVS_Output input)
{

	float2 tuv = input.Tex;
	tuv.xy *= g_offset;//ランダム性を出すため

	float4 tnorm = g_RandomNormalTexture.Sample( samPoint, tuv);
	float3 fres = normalize((tnorm.xyz*2.0)-1.0f);


	float4 currentPixelSample = g_NormalZTexture.Sample( samPoint,input.Tex);
	float currentPixelDepth = currentPixelSample.a;//aにいれたデプス値取得

	//法線取得
	float3 norm = currentPixelSample.xyz * 2.0f - 1.0f;

	float bl = 0.0;
	// サンプリング半径
	float radD = g_rad / currentPixelDepth;

	float3 ray;
	float3 occNorm;
	float2 se;
	float occluderDepth, depthDifference, normDiff;

	for(int i=0; i<SAMPLES;++i)
	{
		// radDは深度値の偏りの補正
		ray = radD * reflect(pSphere[i], fres);
		// 光線が半球の外なら反転
		se = input.Tex + (sign(dot(ray,norm)) * ray.xy * float2(1.0f, -1.0f)).xy;
		//画面端の黒モヤ防止　他にいい方法あれば
		se.x = clamp(se.x,0.001f,0.999f);
		se.y = clamp(se.y,0.001f,0.999f);

		//遮蔽するフラグメントを取得
		float4 occluderFragment = g_NormalZTexture.Sample(samPoint,se.xy);

		//遮蔽するフラグメントの法線
		occNorm = occluderFragment.xyz * 2.0f - 1.0f;

		//現在のフラグメントより前か奥かで遮蔽を判断
		depthDifference = currentPixelDepth - occluderFragment.a;

		//遮蔽フラグメントと現在のフラグメントでの法線の角度の差を計算
		//角度が大きければ遮蔽
		normDiff = (1.0 - dot(normalize(occNorm), normalize(norm)));

		bl += step(g_falloff, depthDifference) * normDiff * (1.0 - smoothstep(g_falloff, g_strength, depthDifference));
	}

	// AO項の計算。遮蔽されているほどblが大きいので、暗くなる。
	float ao = 1.0f - g_totStrength * bl * invSamples;
	float4 Outf = float4(ao, ao, ao,1.0f);
//	float4 Outf = float4(1.0f, 1.0f, 1.0f, ao);
	PS_OUTPUT Output = (PS_OUTPUT)0;
	Output.Col1 = Outf;


	return Output;
}

PS_OUTPUT PS_Blur( QuadVS_Output input )
{
   float4 Out = float4(0,0,0,0);
   
   for( uint i=0; i<BLUROFFSET_COUNT; i++ )
   {
      Out += g_texture_diffuse.Sample( samPoint, (input.Tex + BlurOffset16[i].xy / ScreenSize)*2.0f );
   }
   Out = Out / (float)BLUROFFSET_COUNT;
   
   PS_OUTPUT Output = (PS_OUTPUT)0;
   
   Output.Col1 = 1.0f-Out;

   return Output;
}
PS_OUTPUT NORMAL_PS(QuadVS_Output input )
{
	// 出力
	PS_OUTPUT output = (PS_OUTPUT)0;
	output.Col1 = g_BlurTexture.Sample( samLinear, input.Tex );
	output.Col1 = 1.0f - output.Col1;
	output.Col1.a = 1.0f;

	//output.Col1 = g_NormalZTexture.Sample( samPoint,input.Tex);
	//output.Col1.r = output.Col1.a;
	//output.Col1.g = output.Col1.a;
	//output.Col1.b = output.Col1.a;
	//output.Col1.a = 1.0f;


	return output;
}
int mode;

PixelShader ps[] = {
	CompileShader( ps_4_0, FinalPass( false, false, false, false) ),
	CompileShader( ps_4_0, FinalPass( false, false, false, true) ),
	CompileShader( ps_4_0, FinalPass( false, false, true, false) ),
	CompileShader( ps_4_0, FinalPass( false, false, true, true) ),
	CompileShader( ps_4_0, FinalPass( false, true, false, false) ),
	CompileShader( ps_4_0, FinalPass( false, true, false, true) ),
	CompileShader( ps_4_0, FinalPass( false, true, true, false) ),
	CompileShader( ps_4_0, FinalPass( false, true, true, true) ),
	CompileShader( ps_4_0, FinalPass( true, false, false, false) ),
	CompileShader( ps_4_0, FinalPass( true, false, false, true) ),
	CompileShader( ps_4_0, FinalPass( true, false, true, false) ),
	CompileShader( ps_4_0, FinalPass( true, false, true, true) ),
	CompileShader( ps_4_0, FinalPass( true, true, false, false) ),
	CompileShader( ps_4_0, FinalPass( true, true, false, true) ),
	CompileShader( ps_4_0, FinalPass( true, true, true, false) ),
	CompileShader( ps_4_0, FinalPass( true, true, true, true) ),
};
PixelShader ps_ex[] = {
	CompileShader( ps_4_0, FinalPass_SSAO( false, false, false, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, false, false, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, false, true, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, false, true, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, true, false, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, true, false, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, true, true, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( false, true, true, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, false, false, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, false, false, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, false, true, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, false, true, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, true, false, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, true, false, true) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, true, true, false) ),
	CompileShader( ps_4_0, FinalPass_SSAO( true, true, true, true) ),
};
technique10 FinalPass_FP
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, QuadVS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( ps[mode] );
		// 道はカメラブラー        
        SetDepthStencilState( DisableDepth, 0 );
//		SetBlendState( NoBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 		SetBlendState( SrcAlphaBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
    }
	pass p1
	{
        SetVertexShader( CompileShader( vs_4_0, QuadVS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, RenderSSAO_PS() ) );
	}
	pass p2
	{
        SetVertexShader( CompileShader( vs_4_0, QuadVS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_Blur() ) );
	}
	pass p3
	{
        SetVertexShader( CompileShader( vs_4_0, QuadVS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, NORMAL_PS() ) );
	}
	pass p4
	{
        SetVertexShader( CompileShader( vs_4_0, QuadVS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( ps_ex[mode] );
		// 道はカメラブラー        
        SetDepthStencilState( DisableDepth, 0 );
//		SetBlendState( NoBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 		SetBlendState( SrcAlphaBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );

	}
}