// Pixel Shader
// https://github.com/darknesswind/DxLib/blob/master/DxLibMake/Windows/DxShader_PS_D3D11.h
// https://github.com/darknesswind/DxLib/blob/master/DxLibMake/Shader/Windows/Direct3D11/PixelShader.h
struct PS_INPUT { // from Vertex Shader
float2 texCoords0 : TEXCOORD0; // through
float4 dif : COLOR0; // through
float4 spc : COLOR1; // through
float3 norm : NORMAL0; // through
float3 pos : POSITION0; // through
float4 ppos : SV_POSITION; // pos in projection
};
struct PS_OUTPUT {
float4 color0 : SV_TARGET0; // screen pixel color
};
#include <shader_common.hlsl>
struct DX_D3D11_PS_CONST_BUFFER_BASE {
float4 FactorColor; // alpha etc
float MulAlphaColor; // 0.0f: ignore 1.0f: mul alpha
float AlphaTestRef; // alpha test compare with it
float2 Padding1;
int AlphaTestCmpMode; // alpha test mode (DX_CMP_NEVER etc)
int NoLightAngleAttenuation; // 0: attenuation, 1: no attenuation
int UseHalfLambert; // half lambert mode (20240324 later)
int Padding2;
float4 IgnoreTextureColor; // color when ignore texture
float4 DrawAddColor; // add color
};
struct DX_D3D11_PS_CONST_SHADOWMAP {
float AdjustDepth;
float GradationParam;
float Enable_Light0;
float Enable_Light1;
float Enable_Light2;
float3 Padding;
};
struct DX_D3D11_PS_CONST_BUFFER_SHADOWMAP {
DX_D3D11_PS_CONST_SHADOWMAP Data[3];
};
cbuffer cbD3D11_CONST_BUFFER_COMMON : register(b0) {
DX_D3D11_CONST_BUFFER_COMMON g_Common;
};
cbuffer cbD3D11_CONST_BUFFER_PS_BASE : register(b1) {
DX_D3D11_PS_CONST_BUFFER_BASE g_Base;
};
cbuffer cbD3D11_CONST_BUFFER_PS_SHADOWMAP : register(b2) {
DX_D3D11_PS_CONST_BUFFER_SHADOWMAP g_ShadowMap;
};
// DX_D3D11_PS_CONST_FILTER_SIZE 1280
// cbuffer cbD3D11_CONST_BUFFER_PS_FILTER : register(b3) {
// DX_D3D11_PS_CONST_BUFFER_FILTER g_Filter;
// };
cbuffer cbD3D11_CONST_BUFFER_PS_FILTER : register(b3) {
float4 g_Filter[1280 / 4 / 4]; // length will be changed (dummy)
};
SamplerState g_DiffuseMapSampler : register(s0);
Texture2D g_DiffuseMapTexture : register(t0);
cbuffer cb_Test : register(b4) {
float4 g_Test = float4(2.2f, 4.4f, 6.6f, 8.8f);
float4 g_Arr[4] = {
float4(0.2f, 0.3f, 0.4f, 0.5f),
float4(0.4f, 0.5f, 0.6f, 0.7f),
float4(0.6f, 0.7f, 0.8f, 0.9f),
float4(0.8f, 0.9f, 1.0f, 1.1f)};
};
float4 g_Reg0 : register(c0);
float4 g_Reg1 : register(c1);
cbuffer cb_5 : register(b5) {
float4 cb_cam_pos4;
};
cbuffer cb_6 : register(b6) {
float4 cb_a;
float4 cb_b;
};
cbuffer cb_7 : register(b7) {
float4 cb_c;
};
struct CamLight {
float4 cam_pos4;
float4 cam_lat4;
float4 r[2]; // light ratio: (r[0].xyzw and r[1].xy), camera angle: r[1].w
};
cbuffer cb_CamLight : register(b8) { // max 14 slots
CamLight g_CL;
};
struct LIGHT {
float4 test;
float4 amb;
float4 spc;
float a;
float3 padding;
};
LIGHT proc_light(PS_INPUT psi, int lh)
{
float3 n = normalize(psi.norm.xyz);
float3 look_vec = g_CL.cam_lat4.xyz - g_CL.cam_pos4.xyz;
// float3 look_vec = float3(0.0f, 0.0f, 0.0f); // test
DX_D3D11_CONST_LIGHT light = g_Common.Light[lh];
float4 light_amb = light.Ambient;
float4 light_pos4;
light_pos4.xyz = light.Position;
light_pos4.w = 1.0f;
float4 light_vec4;
light_vec4.xyz = light.Direction;
light_vec4.w = light.RangePow2;
float4 test = light_vec4;
test.xyz = light.Specular;
test.w = 1.0f;
float3 light_dir = normalize(light_vec4.xyz);
// float3 light_dir = normalize(float3(1.0f, 1.0f, 1.0f)); // test
float3 r = -normalize(light_dir);
float3 v = -normalize(look_vec);
float2 p = float2(
max(0.0f, dot(r, n)), // not use camera angle
dot(v, normalize(dot(r, n) * n))); // both rev. (- * - = +) hide by culling
// max(0.0f, dot(v, n)) * max(0.0f, dot(r, n))
float q = g_CL.r[1].w;
float a = dot(float2(1.0f - q, q), p);
float4 spc = psi.spc * pow(a, light_vec4.w);
// float4 spc = psi.spc * pow(a, 1.0f);
LIGHT l = {test, light_amb, spc, a, float3(0.0f, 0.0f, 0.0f)};
return l;
}
LIGHT m_s(CamLight e, LIGHT l[6], int i) // mul struct r LIGHT
{
float r[8]; // not use loop in HLSL
r[0] = e.r[0].x;
r[1] = e.r[0].y;
r[2] = e.r[0].z;
r[3] = e.r[0].w;
r[4] = e.r[1].x;
r[5] = e.r[1].y;
r[6] = e.r[1].z;
r[7] = e.r[1].w;
LIGHT o = {
float4(0.0f, 0.0f, 0.0f, 0.0f),
max(0.0f, r[i] * l[i].amb),
max(0.0f, r[i] * l[i].spc),
max(0.0f, r[i] * l[i].a),
float3(0.0f, 0.0f, 0.0f)};
return o;
}
LIGHT a_s(LIGHT a, LIGHT b) // add struct LIGHT LIGHT
{
LIGHT o = {
a.test + b.test,
a.amb + b.amb,
a.spc + b.spc,
a.a + b.a,
a.padding + b.padding};
return o;
}
LIGHT c_s(float c, LIGHT a) // clip struct s LIGHT
{
LIGHT o = {
min(c, a.test),
min(c, a.amb),
min(c, a.spc),
min(c, a.a),
min(c, a.padding)};
return o;
}
LIGHT dot_s(float c, CamLight e, LIGHT l[6]) // dot and clip struct c r LIGHT
{
return c_s(c, a_s(a_s(a_s(a_s(a_s(
m_s(e, l, 0), m_s(e, l, 1)), m_s(e, l, 2)),
m_s(e, l, 3)), m_s(e, l, 4)), m_s(e, l, 5)));
}
PS_OUTPUT main(PS_INPUT psi)
{
PS_OUTPUT pso;
LIGHT l[6]; // not use loop in HLSL
l[0] = proc_light(psi, 0);
l[1] = proc_light(psi, 1);
l[2] = proc_light(psi, 2);
l[3] = proc_light(psi, 3);
l[4] = proc_light(psi, 4);
l[5] = proc_light(psi, 5);
LIGHT o = dot_s(1.0f, g_CL, l);
// texture diffused color
float4 dc = g_DiffuseMapTexture.Sample(g_DiffuseMapSampler, psi.texCoords0);
// pso.color0 = dc * psi.dif; // not use light spc
// pso.color0 = dc * psi.dif * l[0].a + l[0].spc + l[0].amb; // only light 0
// pso.color0 = dc * psi.dif * l[1].a + l[1].spc + l[1].amb; // only light 1
// pso.color0 = (dc * psi.dif * l[1].a + l[1].spc + l[1].amb)
// * l[0].a + l[0].spc + l[0].amb;
pso.color0 = dc * psi.dif * o.a + o.spc + o.amb;
// pso.color0 = l[0].test; // test by light 0 direction or specular
// pso.color0 = l[1].test; // test by light 1 direction or specular
// pso.color0 = g_CL.cam_pos4; // test by constant buffer
// pso.color0 = float4(r[0], r[1], r[2], r[3]); // test by constant buffer
return pso;
}
