e4s/e4s-game
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

init

Browse source
This commit is contained in:
Vasily Petrov 2026-06-18 01:18:29 +03:00
commit 2fe6ca2f65
1473 changed files with 251771 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

51
gamedata/shaders/editor/accum_base.ps.hlsl Normal file
View file

@ -0,0 +1,51 @@
#include "common.hlsli"
#include "lmodel.hlsli"
//////////////////////////////////////////////////////////////////////////////////////////
// This is the basic primitive used by convex, volumetric lights
// for example spot-lights, one face of the omni lights, etc.
//////////////////////////////////////////////////////////////////////////////////////////
// following options are available to configure compilation:
// USE_LMAP
// USE_LMAPXFORM
// USE_SHADOW
//////////////////////////////////////////////////////////////////////////////////////////
uniform float4x4 m_shadow;
uniform sampler s_position;
uniform sampler s_normal;
uniform float4 Ldynamic_color;
uniform float4 Ldynamic_pos;
uniform float4 Ldynamic_dir;
float4 main(float4 tc : TEXCOORD0) : COLOR
{
float4 _P = tex2Dproj(s_position, tc);
if(_P.z < 0.001f)
return 0.0f;
float4 _C = tex2Dproj(s_base, tc);
float4 _N = tex2Dproj(s_normal, tc);
_N.xyz = normalize(_N.xyz);
// ----- light-model
float4 light = plight_local(_P.w, _P, _N, Ldynamic_pos, Ldynamic_pos.w);
// ----- shadow
float4 P4 = float4(_P.xyz, 1.0f);
float4 PS = mul(m_shadow, P4);
#ifdef USE_LMAP
light *= tex2Dlod(s_lmap, float4(PS.xy / PS.w, 0.0f, 0.0f));
#endif
float4 color = Ldynamic_color * light;
color.xyz = color.xyz * _C.xyz + color.w * _C.w;
return color;
}

8
gamedata/shaders/editor/accum_mask.vs.hlsl Normal file
View file

@ -0,0 +1,8 @@
#include "common.hlsli"
float4 main(float4 P : POSITION) : POSITION
{
return mul(m_WVP, P);
}

18
gamedata/shaders/editor/accum_volume.vs.hlsl Normal file
View file

@ -0,0 +1,18 @@
#include "common.hlsli"
struct v2p
{
float4 hpos : POSITION; // Clip-space position (for rasterization)
float4 tc : TEXCOORD0;
};
uniform float4x4 m_texgen;
// Vertex
v2p main(float4 P : POSITION)
{
v2p O;
O.hpos = mul(m_WVP, P);
O.tc = mul(m_texgen, P);
return O;
}

247
gamedata/shaders/editor/common.hlsli Normal file
View file

@ -0,0 +1,247 @@
#ifndef COMMON_H
#define COMMON_H
#include "shared\common.hlsli"
uniform float4 L_material; // per object, xyz=sun,w=hemi
uniform float4 L_dynamic_props; // per object, xyz=sun,w=hemi
uniform float4 L_dynamic_color; // dynamic light color (rgb1) - spot/point
uniform float4 L_dynamic_pos; // dynamic light pos+1/range(w) - spot/point
uniform float4x4 L_dynamic_xform;
uniform float4x4 m_plmap_xform;
uniform float4 m_plmap_clamp[2]; // 0.w = factor
uniform sampler s_material;
#define def_aref 0.5f
#define def_gloss 0.04f
#ifndef xmaterial
#define xmaterial 0.25f
#endif
uniform float4 is_lighting_enable;
float calc_fogging(float3 pos)
{
return saturate(length(pos - eye_position) * fog_params.w + fog_params.x);
}
float2 calc_detail(float3 w_pos)
{
float dtl = distance(w_pos, eye_position) * dt_params.w;
dtl = min(dtl * dtl, 1.0f);
float dt_mul = 1.0f - dtl; // dt* [1 .. 0 ]
float dt_add = 0.5f * dtl; // dt+ [0 .. 0.5]
return float2(dt_mul, dt_add);
}
float3 calc_reflection(float3 pos_w, float3 norm_w)
{
return reflect(normalize(pos_w - eye_position), norm_w);
}
float4 calc_spot(out float4 tc_lmap, out float2 tc_att, float4 w_pos, float3 w_norm)
{
float4 s_pos = mul(L_dynamic_xform, w_pos);
tc_lmap = s_pos.xyww; // projected in ps/ttf
tc_att = s_pos.z; // z=distance * (1/range)
float3 L_dir_n = normalize(w_pos - L_dynamic_pos.xyz);
float L_scale = dot(w_norm, -L_dir_n);
return L_dynamic_color * L_scale * saturate(calc_fogging(w_pos));
}
float4 calc_point(out float2 tc_att0, out float2 tc_att1, float4 w_pos, float3 w_norm)
{
float3 L_dir_n = normalize(w_pos - L_dynamic_pos.xyz);
float L_scale = dot(w_norm, -L_dir_n);
float3 L_tc = (w_pos - L_dynamic_pos.xyz) * L_dynamic_pos.w + .5f; // tc coords
tc_att0 = L_tc.xz;
tc_att1 = L_tc.xy;
return L_dynamic_color * L_scale * saturate(calc_fogging(w_pos));
}
float3 calc_sun(float3 norm_w)
{
return L_sun_color * max(dot((norm_w), -L_sun_dir_w), 0);
}
float3 calc_model_hemi(float3 norm_w)
{
return (norm_w.y * 0.5 + 0.5) * L_dynamic_props.w * L_hemi_color;
}
float3 calc_model_lq_lighting(float3 norm_w)
{
return calc_model_hemi(norm_w) + L_ambient + L_dynamic_props.xyz * calc_sun(norm_w);
}
float3 _calc_model_hemi(float3 norm_w)
{
return max(0, norm_w.y) * .2 * L_hemi_color;
}
float3 _calc_model_lq_lighting(float3 norm_w)
{
return calc_model_hemi(norm_w) + L_ambient + .5 * calc_sun(norm_w);
}
float4 calc_model_lmap(float3 pos_w)
{
float3 pos_wc = clamp(pos_w, m_plmap_clamp[0], m_plmap_clamp[1]); // clamp to BBox
float4 pos_w4c = float4(pos_wc, 1);
float4 plmap = mul(m_plmap_xform, pos_w4c); // calc plmap tc
return plmap.xyww;
}
struct v_lmap
{
float4 P : POSITION; // (float,float,float,1)
float4 N : NORMAL; // (nx,ny,nz,hemi occlusion)
float4 T : TANGENT;
float4 B : BINORMAL;
float2 uv0 : TEXCOORD0; // (base)
float2 uv1 : TEXCOORD1; // (lmap/compressed)
};
struct v_vert
{
float4 P : POSITION; // (float,float,float,1)
float4 N : NORMAL; // (nx,ny,nz,hemi occlusion)
float4 T : TANGENT;
float4 B : BINORMAL;
float4 color : COLOR0; // (r,g,b,dir-occlusion)
float2 uv : TEXCOORD0; // (u0,v0)
};
struct v_editor
{
float4 P : POSITION;
float2 tc : TEXCOORD0;
float3 N : NORMAL;
float4 color : COLOR0;
};
struct v_model
{
float4 P : POSITION; // (float,float,float,1)
float3 N : NORMAL; // (nx,ny,nz)
float3 T : TANGENT; // (nx,ny,nz)
float3 B : BINORMAL; // (nx,ny,nz)
float2 tc : TEXCOORD0; // (u,v)
};
struct v_detail
{
float4 pos : POSITION; // (float,float,float,1)
int4 misc : TEXCOORD0; // (u(Q),v(Q),frac,matrix-id)
};
struct vf_spot
{
float4 hpos : POSITION;
float2 tc0 : TEXCOORD0; // base
float4 tc1 : TEXCOORD1; // lmap, projected
float2 tc2 : TEXCOORD2; // att + clipper
float4 color : COLOR0;
};
struct vf_point
{
float4 hpos : POSITION;
float2 tc0 : TEXCOORD0; // base
float2 tc1 : TEXCOORD1; // att1 + clipper
float2 tc2 : TEXCOORD2; // att2 + clipper
float4 color : COLOR0;
};
struct p_bumped_new
{
float4 hpos : POSITION;
float4 tcdh : TEXCOORD0; // Texture coordinates, sun_occlusion || lm-hemi
float4 position : TEXCOORD1; // position + hemi
float3 M1 : TEXCOORD2; // nmap 2 eye - 1
float3 M2 : TEXCOORD3; // nmap 2 eye - 2
float3 M3 : TEXCOORD4; // nmap 2 eye - 3
};
uniform sampler2D s_base;
uniform samplerCUBE s_env;
uniform sampler2D s_lmap;
uniform sampler2D s_hemi;
uniform sampler2D s_att;
uniform sampler2D s_detail;
#define def_distort float(0.05f) // we get -0.5 .. 0.5 range, this is -512 .. 512 for 1024, so scale it
float3 v_hemi(float3 n)
{
return L_hemi_color /* *(.5f + .5f*n.y) */;
}
float3 v_hemi_wrap(float3 n, float w)
{
return L_hemi_color /* *(w + (1-w)*n.y) */;
}
float3 v_sun(float3 n)
{
return L_sun_color * max(0, dot(n, -L_sun_dir_w));
}
float3 v_sun_wrap(float3 n, float w)
{
return L_sun_color * (w + (1 - w) * dot(n, -L_sun_dir_w));
}
float3 p_hemi(float2 tc)
{
// float3 t_lmh = tex2D (s_hemi, tc);
// return dot (t_lmh,1.h/3.h);
float4 t_lmh = tex2D(s_hemi, tc);
return t_lmh.a;
}
struct f_editor_gbuffer
{
float4 Color : COLOR0;
#ifndef FORWARD_ONLY
float4 Albedo : COLOR1;
float4 Normal : COLOR2;
float4 PointZ : COLOR3;
#endif
};
void cotangent_frame(inout p_bumped_new O)
{
// Get edge vectors of the pixel triangle
float3 dp1 = ddx(O.position.xyz);
float3 dp2 = ddy(O.position.xyz);
float2 duv1 = ddx(O.tcdh.xy);
float2 duv2 = ddy(O.tcdh.xy);
float3 N = normalize(O.M1);
// Solve the linear system
float3 dp2perp = cross(dp2, N);
float3 dp1perp = cross(N, dp1);
float3 T = normalize(dp2perp * duv1.x + dp1perp * duv2.x);
float3 B = normalize(dp2perp * duv1.y + dp1perp * duv2.y);
float3x3 xform = float3x3(
T.x, B.x, N.x,
T.y, B.y, N.y,
T.z, B.z, N.z
);
O.M1 = xform[0];
O.M2 = xform[1];
O.M3 = xform[2];
}
#endif // COMMON_H

64
gamedata/shaders/editor/deffer_base.ps.hlsl Normal file
View file

@ -0,0 +1,64 @@
#include "common.hlsli"
#include "sload.hlsli"
#include "lmodel.hlsli"
#include "hmodel.hlsli"
void main(p_bumped_new I, out f_editor_gbuffer O)
{
if(is_lighting_enable.x < 0.5f) {
O.Color = tex2D(s_base, I.tcdh.xy);
#ifdef USE_AREF
clip(O.Color.w - def_aref);
#endif
#ifndef FORWARD_ONLY
O.Normal = float4(I.M1.xyz, def_gloss);
O.Albedo = float4(O.Color.xyz, def_gloss);
O.PointZ = float4(I.position.xyz, xmaterial);
#endif
return;
}
cotangent_frame(I);
XrayMaterial M;
M.Sun = I.tcdh.w;
M.Hemi = I.tcdh.z;
M.Point = I.position.xyz;
SloadNew(I, M);
#ifdef USE_AREF
clip(M.Color.w - def_aref);
#endif
M.Normal = mul(float3x3(I.M1, I.M2, I.M3), M.Normal);
M.Normal = normalize(M.Normal);
M.Sun = saturate(M.Sun * 2.0f);
M.Color.xyz = saturate(M.Color.xyz);
float MaterialID = xmaterial;
float Gloss = 1.0f - M.Roughness;
#ifndef FORWARD_ONLY
O.Albedo = float4(M.Color.xyz, Gloss);
O.Normal = float4(M.Normal.xyz, Gloss);
O.PointZ = float4(M.Point.xyz, MaterialID);
#endif
float4 Light = float4(L_sun_color, 1.0f) * M.Sun * plight_infinity(MaterialID, M.Point, M.Normal, L_sun_dir_e);
float3 Diffuse, Specular;
hmodel(Diffuse, Specular, MaterialID, M.Hemi, Gloss, M.Point, M.Normal);
O.Color = float4(Diffuse + Light.xyz, M.Color.w);
O.Color.xyz *= M.Color.xyz;
O.Color.xyz += Light.w * Gloss + Specular;
float fog = saturate(length(M.Point) * fog_params.w + fog_params.x);
O.Color = lerp(O.Color, fog_color, fog);
}

25
gamedata/shaders/editor/deffer_base.vs.hlsl Normal file
View file

@ -0,0 +1,25 @@
#ifndef SKIN_NONE
#include "deffer_model.vs.hlsl"
#else
#include "common.hlsli"
void main(in v_editor I, out p_bumped_new O)
{
float3 Pe = mul(m_WV, I.P);
O.tcdh = float4(I.tc.xy, 0.7f, 0.5f);
O.position = float4(Pe, 1.0f);
float3 N = normalize(mul(m_W, I.N));
O.tcdh.z = N.y * 0.3f + 0.5f;
N = normalize(mul(m_V, N));
O.M1 = N;
O.M2 = N;
O.M3 = N;
O.hpos = mul(m_WVP, I.P);
}
#endif

63
gamedata/shaders/editor/deffer_detail.vs.hlsl Normal file
View file

@ -0,0 +1,63 @@
#include "common.hlsli"
uniform float4 consts;
uniform float4 wave;
uniform float4 dir2D;
uniform float2x4 array[50];
float3x3 setMatrix (float3 hpb)
{
float _ch, _cp, _cb, _sh, _sp, _sb, _cc, _cs, _sc, _ss;
sincos(hpb.x, _sh, _ch);
sincos(hpb.y, _sp, _cp);
sincos(hpb.z, _sb, _cb);
_cc = _ch*_cb; _cs = _ch*_sb; _sc = _sh*_cb; _ss = _sh*_sb;
return float3x3(_cc-_sp*_ss, _sp*_sc+_cs, -_cp*_sh,
-_cp*_sb, _cp*_cb, _sp,
_sp*_cs+_sc, _ss-_sp*_cc, _cp*_ch);
};
void main(in v_detail I, out p_bumped_new O)
{
int i = I.misc.w;
float2x4 mm = array[i];
float3x3 mmhpb = setMatrix(mm[0].xyz);
float3 posi = float3(mm[1].xyz);
float scale = mm[0].w;
float4 m0 = float4(mmhpb[0]*scale, posi.x);
float4 m1 = float4(mmhpb[1]*scale, posi.y);
float4 m2 = float4(mmhpb[2]*scale, posi.z);
float4 pos;
pos.x = dot(m0, I.pos);
pos.y = dot(m1, I.pos);
pos.z = dot(m2, I.pos);
pos.w = 1.0f;
float3 Pe = mul(m_WV, pos);
float2 tc = I.misc.xy * consts.xy;
float3 N;
N.x = pos.x - m0.w;
N.y = pos.y - m1.w + 0.75f;
N.z = pos.z - m2.w;
O.tcdh = float4(tc.xy, 0.7, 0.5);
O.position = float4(Pe, 1.0f);
N = normalize(mul(m_WV, N));
O.M1 = N;
O.M2 = N;
O.M3 = N;
O.hpos = mul(m_WVP, pos);
}

142
gamedata/shaders/editor/deffer_impl.ps.hlsl Normal file
View file

@ -0,0 +1,142 @@
#include "common.hlsli"
#include "sload.hlsli"
#include "lmodel.hlsli"
#include "hmodel.hlsli"
// void main(p_bumped_new I, out f_editor_gbuffer O)
// {
// cotangent_frame(I);
// XrayMaterial M;
// M.Sun = I.tcdh.w;
// M.Hemi = I.tcdh.z;
// M.Point = I.position.xyz;
// SloadNew(I, M);
// #ifdef USE_AREF
// clip(M.Color.w - def_aref);
// #endif
// M.Normal = mul(float3x3(I.M1, I.M2, I.M3), M.Normal);
// M.Normal = normalize(M.Normal);
// M.Sun = saturate(M.Sun * 2.0f);
// M.Color.xyz = saturate(M.Color.xyz);
// float MaterialID = 0.25f;
// float Gloss = 1.0f - M.Roughness;
// #ifndef FORWARD_ONLY
// O.Albedo = float4(M.Color.xyz, Gloss);
// O.Normal = float4(M.Normal.xyz, Gloss);
// O.PointZ = float4(M.Point.xyz, MaterialID);
// #endif
// float4 Light = float4(L_sun_color, 1.0f) * M.Sun * plight_infinity(MaterialID, M.Point, M.Normal, L_sun_dir_e);
// float3 Diffuse, Specular;
// hmodel(Diffuse, Specular, MaterialID, M.Hemi, Gloss, M.Point, M.Normal);
// O.Color = float4(Diffuse + Light.xyz, M.Color.w);
// O.Color.xyz *= M.Color.xyz;
// O.Color.xyz += Light.w * Gloss + Specular;
// float fog = saturate(length(M.Point) * fog_params.w + fog_params.x);
// O.Color = lerp(O.Color, fog_color, fog);
// }
uniform sampler2D s_mask;
uniform sampler2D s_dt_r;
uniform sampler2D s_dt_g;
uniform sampler2D s_dt_b;
uniform sampler2D s_dt_a;
uniform sampler2D s_dn_r;
uniform sampler2D s_dn_g;
uniform sampler2D s_dn_b;
uniform sampler2D s_dn_a;
void main(p_bumped_new I, out f_editor_gbuffer O)
{
if(is_lighting_enable.x < 0.5f) {
O.Color = tex2D(s_base, I.tcdh.xy);
float2 tcdbump = I.tcdh.xy * dt_params.xy;
float4 Detail = tex2D(s_detail, tcdbump);
O.Color.xyz *= Detail.xyz * 2.0f;
#ifndef FORWARD_ONLY
O.Normal = float4(I.M1.xyz, def_gloss);
O.Albedo = float4(O.Color.xyz, def_gloss);
O.PointZ = float4(I.position.xyz, xmaterial);
#endif
return;
}
cotangent_frame(I);
XrayMaterial M;
M.Sun = I.tcdh.w;
M.Hemi = I.tcdh.z;
M.Point = I.position.xyz;
M.Color = tex2D(s_base, I.tcdh.xy);
float4 Mask = tex2D(s_mask, I.tcdh.xy);
Mask /= dot(Mask, 1.0f);
float2 tcdbump = I.tcdh.xy * dt_params.xy;
float3 Detail_R = tex2D(s_dt_r, tcdbump).xyz * Mask.x;
float3 Detail_G = tex2D(s_dt_g, tcdbump).xyz * Mask.y;
float3 Detail_B = tex2D(s_dt_b, tcdbump).xyz * Mask.z;
float3 Detail_A = tex2D(s_dt_a, tcdbump).xyz * Mask.w;
float3 Detail = Detail_R + Detail_G + Detail_B + Detail_A;
float4 Normal_R = tex2D(s_dn_r, tcdbump) * Mask.x;
float4 Normal_G = tex2D(s_dn_g, tcdbump) * Mask.y;
float4 Normal_B = tex2D(s_dn_b, tcdbump) * Mask.z;
float4 Normal_A = tex2D(s_dn_a, tcdbump) * Mask.w;
float3 Normal = Normal_R.wzy + Normal_G.wzy + Normal_B.wzy + Normal_A.wzy - 0.5;
Normal.z *= 0.5f;
M.Roughness = saturate(1.0f - Normal_R.x + Normal_G.x + Normal_B.x + Normal_A.x);
M.Color.xyz *= Detail * 2.0f;
M.Metalness = 0.0f;
M.SSS = 0.0f;
M.AO = 1.0f;
M.Normal = mul(float3x3(I.M1, I.M2, I.M3), Normal);
M.Normal = normalize(M.Normal);
M.Sun = saturate(M.Sun * 2.0f);
M.Color.xyz = saturate(M.Color.xyz);
float MaterialID = 0.25f;
float Gloss = 1.0f - M.Roughness;
#ifndef FORWARD_ONLY
O.Albedo = float4(M.Color.xyz, Gloss);
O.Normal = float4(M.Normal.xyz, Gloss);
O.PointZ = float4(M.Point.xyz, MaterialID);
#endif
float4 Light = float4(L_sun_color, 1.0f) * M.Sun * plight_infinity(MaterialID, M.Point, M.Normal, L_sun_dir_e);
float3 Diffuse, Specular;
hmodel(Diffuse, Specular, MaterialID, M.Hemi, Gloss, M.Point, M.Normal);
O.Color = float4(Diffuse + Light.xyz, M.Color.w);
O.Color.xyz *= M.Color.xyz;
O.Color.xyz += Light.w * Gloss + Specular;
float fog = saturate(length(M.Point) * fog_params.w + fog_params.x);
O.Color = lerp(O.Color, fog_color, fog);
}

50
gamedata/shaders/editor/deffer_model.vs.hlsl Normal file
View file

@ -0,0 +1,50 @@
#include "common.hlsli"
#include "skin.hlsli"
void skinned_main(in v_model I, out p_bumped_new O)
{
float3 Nw = normalize(mul((float3x3)m_W, (float3)I.N));
float hemi_val = Nw.y * 0.3f + 0.5f;
float3 Pe = mul(m_WV, I.P);
O.tcdh = float4(I.tc.xy, hemi_val, 0.5f);
O.position = float4(Pe, 1.0f);
O.M1 = mul(m_WV, I.N.xyz * 2.0f);
O.M2 = mul(m_WV, I.T.xyz * 2.0f);
O.M3 = mul(m_WV, I.B.xyz * 2.0f);
O.hpos = mul(m_WVP, I.P);
}
#if defined(SKIN_0)
void main(in v_model_skinned_0 I, out p_bumped_new O)
{
skinned_main(skinning_0(I), O);
}
#elif defined(SKIN_1)
void main(in v_model_skinned_1 I, out p_bumped_new O)
{
skinned_main(skinning_1(I), O);
}
#elif defined(SKIN_2)
void main(in v_model_skinned_2 I, out p_bumped_new O)
{
skinned_main(skinning_2(I), O);
}
#elif defined(SKIN_3)
void main(in v_model_skinned_3 I, out p_bumped_new O)
{
skinned_main(skinning_3(I), O);
}
#elif defined(SKIN_4)
void main(in v_model_skinned_4 I, out p_bumped_new O)
{
skinned_main(skinning_4(I), O);
}
#else
void main(in v_model I, out p_bumped_new O)
{
skinned_main(I, O);
}
#endif

7
gamedata/shaders/editor/dumb.ps.hlsl Normal file
View file

@ -0,0 +1,7 @@
#include "common.hlsli"
// Pixel
float4 main() : COLOR
{
return 0;
}

32
gamedata/shaders/editor/effects_water.lua Normal file
View file

@ -0,0 +1,32 @@
local tex_base = "water\\water_water"
local tex_nmap = "water\\water_normal"
local tex_dist = "water\\water_dudv"
local tex_caustic = "water\\water_caustic"
local tex_env0 = "$user$sky0"
local tex_env1 = "$user$sky1"
local tex_env = "sky\\sky_8_cube"
function normal(shader, t_base, t_second, t_detail)
shader:begin("water", "water")
:sorting(2, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
:zb(true, false)
:fog(true)
shader:sampler("s_base"):texture(tex_base)
shader:sampler("s_nmap"):texture(tex_nmap)
shader:sampler("s_env0"):texture(tex_env0)
shader:sampler("s_env1"):texture(tex_env1)
shader:sampler("env_s0"):texture("$user$env_s0")
shader:sampler("env_s1"):texture("$user$env_s1")
shader:sampler("s_image"):texture("$user$rt_color")
shader:sampler("s_caustic"):texture(tex_caustic)
shader:sampler("s_env"):texture(tex_env)
end

18
gamedata/shaders/editor/font2.ps.hlsl Normal file
View file

@ -0,0 +1,18 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
};
// Pixel
float4 main(v2p I) : COLOR
{
float4 r = tex2D(s_base, I.tc0);
// r.x = 1 - r.x;
// r.y = 1 - r.y;
// r.z = 1 - r.z;
r.w = 1 - r.w;
return r;
// return /*(float4(1,1,1,1) - */ tex2D (s_base,I.tc0);
}

48
gamedata/shaders/editor/forward_base.ps.hlsl Normal file
View file

@ -0,0 +1,48 @@
#include "common.hlsli"
#include "sload.hlsli"
#include "lmodel.hlsli"
#include "hmodel.hlsli"
void main(p_bumped_new I, out float4 Color : COLOR0)
{
XrayMaterial M;
M.Sun = I.tcdh.w;
M.Hemi = I.tcdh.z;
M.Point = I.position.xyz;
SloadNew(I, M);
#ifdef USE_AREF
clip(M.Color.w - def_aref);
#endif
M.Normal = mul(float3x3(I.M1, I.M2, I.M3), M.Normal);
M.Normal = normalize(M.Normal);
#ifdef USE_LM_HEMI
float4 lm = tex2D(s_hemi, I.tcdh.zw);
M.Sun = get_sun(lm);
M.Hemi = get_hemi(lm);
#endif
M.Sun = saturate(M.Sun * 2.0f);
M.Color.xyz = saturate(M.Color.xyz);
float MaterialID = 0.5f;
float Gloss = 1.0f - M.Roughness;
float4 Light = float4(L_sun_color, 1.0f) * M.Sun * plight_infinity(MaterialID, M.Point, M.Normal, L_sun_dir_e);
float3 Diffuse, Specular;
hmodel(Diffuse, Specular, MaterialID, M.Hemi, Gloss, M.Point, M.Normal);
Color = float4(Diffuse + Light.xyz, M.Color.w);
Color.xyz *= M.Color.xyz;
Color.xyz += Light.w * Gloss + Specular;
float fog = saturate(length(M.Point) * fog_params.w + fog_params.x);
Color.xyz = M.Normal * 0.5f + 0.5f; //lerp(Color, fog_color, fog);
}

48
gamedata/shaders/editor/hmodel.hlsli Normal file
View file

@ -0,0 +1,48 @@
#ifndef HMODEL_H
#define HMODEL_H
#include "common.hlsli"
uniform samplerCUBE env_s0;
uniform samplerCUBE env_s1;
uniform samplerCUBE sky_s0;
uniform samplerCUBE sky_s1;
void hmodel(out float3 hdiffuse, out float3 hspecular,
float m, float h, float s, float3 Pnt, float3 normal)
{
// hscale - something like diffuse reflection
float3 nw = mul(m_invV, normal);
float hscale = h;
#ifdef USE_GAMMA_22
hscale = (hscale * hscale); // make it more linear
#endif
// reflection vector
float3 v2PntL = normalize(Pnt);
float3 v2Pnt = mul(m_invV, v2PntL);
float3 vreflect = reflect(v2Pnt, nw);
float hspec = .5h + .5h * dot(vreflect, v2Pnt);
// material
float4 light = tex3D(s_material, float3(hscale, hspec, m));
// diffuse color
float3 e0d = texCUBElod(env_s0, float4(nw, 0.0f));
float3 e1d = texCUBElod(env_s1, float4(nw, 0.0f));
float3 env_d = L_hemi_color.xyz * lerp(e0d, e1d, L_hemi_color.w);
env_d *= env_d; // contrast
hdiffuse = env_d * light.xyz + L_ambient.rgb;
// specular color
vreflect.y = vreflect.y * 2 - 1;
float3 e0s = texCUBElod(env_s0, float4(vreflect, 0.0f));
float3 e1s = texCUBElod(env_s1, float4(vreflect, 0.0f));
float3 env_s = L_hemi_color.xyz * lerp(e0s, e1s, L_hemi_color.w);
env_s *= env_s;
hspecular = env_s * light.w * s;
}
#endif

13
gamedata/shaders/editor/hud3d.ps.hlsl Normal file
View file

@ -0,0 +1,13 @@
#include "common.hlsli"
struct ui_vert_out
{
float2 tc0 : TEXCOORD0;
float4 P : POSITION;
};
float4 main(ui_vert_out I) : COLOR
{
float4 r = tex2D(s_base, I.tc0);
return r;
}

25
gamedata/shaders/editor/hud3d.vs.hlsl Normal file
View file

@ -0,0 +1,25 @@
#include "common.hlsli"
struct ui_vert_in
{
float4 P : POSITION;
float4 color : COLOR0;
float2 uv : TEXCOORD0;
};
struct ui_vert_out
{
float2 tc0 : TEXCOORD0;
float4 P : POSITION;
};
ui_vert_out main(ui_vert_in v)
{
ui_vert_out O;
O.tc0 = v.uv;
O.P = v.P;
O.P.w = 1;
O.P = mul(m_WVP, O.P);
return O;
}

6
gamedata/shaders/editor/hud_crosshair.lua Normal file
View file

@ -0,0 +1,6 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("null", "simple_color")
:fog(false)
:zb(false, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
end

7
gamedata/shaders/editor/hud_font.lua Normal file
View file

@ -0,0 +1,7 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("null", "hud_font")
:fog(false)
:zb(false, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
shader:sampler("s_base"):texture(t_base)
end

15
gamedata/shaders/editor/hud_font.ps.hlsl Normal file
View file

@ -0,0 +1,15 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0;
float4 c0 : COLOR0;
};
float4 main(v2p I) : COLOR
{
float4 r = tex2D(s_base, I.tc0);
r.rgb = I.c0.rgb;
r.a *= I.c0.a;
return r;
}

7
gamedata/shaders/editor/hud_font2.lua Normal file
View file

@ -0,0 +1,7 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("null", "font2")
:fog(false)
:zb(false, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
shader:sampler("s_base"):texture(t_base)
end

7
gamedata/shaders/editor/hud_movie.lua Normal file
View file

@ -0,0 +1,7 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("null", "yuv2rgb")
:fog(false)
:zb(false, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
shader:sampler("s_base"):texture(t_base)
end

7
gamedata/shaders/editor/hud_p3d.lua Normal file
View file

@ -0,0 +1,7 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("hud3d", "hud3d")
:fog(false)
:zb(true, true)
:blend(true, blend.srcalpha, blend.invsrcalpha)
shader:sampler("s_base"):texture(t_base)
end

35
gamedata/shaders/editor/impl_dt.ps.hlsl Normal file
View file

@ -0,0 +1,35 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
float2 tc1 : TEXCOORD1; // lmap
float2 tc2 : TEXCOORD2; // detail
};
uniform sampler2D s_mask; //
uniform sampler2D s_dt_r; //
uniform sampler2D s_dt_g; //
uniform sampler2D s_dt_b; //
uniform sampler2D s_dt_a; //
// Pixel
float4 main(v2p I) : COLOR
{
float4 t_base = tex2D(s_base, I.tc0);
float4 mask = tex2D(s_mask, I.tc0);
float mag = dot(mask, 1);
mask = mask / mag;
float3 d_R = tex2D(s_dt_r, I.tc2) * mask.r;
float3 d_G = tex2D(s_dt_g, I.tc2) * mask.g;
float3 d_B = tex2D(s_dt_b, I.tc2) * mask.b;
float3 d_A = tex2D(s_dt_a, I.tc2) * mask.a;
float3 dt = d_R + d_G + d_B + d_A;
t_base.xyz *= 2.0f * dt;
// out
return float4(t_base.xyz, 1);
}

31
gamedata/shaders/editor/impl_dt.vs.hlsl Normal file
View file

@ -0,0 +1,31 @@
#include "common.hlsli"
struct vf
{
float4 hpos : POSITION;
float2 tc0 : TEXCOORD0;
float2 tc1 : TEXCOORD1;
float2 tc2 : TEXCOORD2;
float fog : FOG;
};
struct vv
{
float4 P : POSITION;
float2 tc : TEXCOORD0;
float3 N : NORMAL;
};
vf main(vv v)
{
vf o;
float3 N = unpack_normal(v.N);
o.hpos = mul(m_WVP, float4(v.P.xyz, 1)); // xform, input in world coords
o.tc0 = v.tc;
o.tc1 = o.tc0; // copy tc
o.tc2 = o.tc0 * dt_params; // dt tc
o.fog = calc_fogging(v.P); // fog, input in world coords
return o;
}

28
gamedata/shaders/editor/lmodel.hlsli Normal file
View file

@ -0,0 +1,28 @@
#ifndef LMODEL_H
#define LMODEL_H
#include "common.hlsli"
float4 plight_infinity(float m, float3 _point, float3 normal, float3 light_direction)
{
float3 N = normal; // normal
float3 V = -normalize(_point); // vector2eye
float3 L = -light_direction; // vector2light
float3 H = normalize(L + V); // float-angle-vector
return tex3D(s_material, float3(dot(L, N), dot(H, N), m)); // sample material
}
float4 plight_local(float m, float3 _point, float3 normal, float3 light_position, float light_range_rsq)
{
float3 N = normal; // normal
float3 L2P = _point - light_position; // light2point
float3 V = -normalize(_point); // vector2eye
float3 L = -normalize((float3)L2P); // vector2light
float3 H = normalize(L + V); // float-angle-vector
float rsqr = dot(L2P, L2P); // distance 2 light (squared)
float att = saturate(1 - rsqr * light_range_rsq); // q-linear attenuate
float4 light = tex3D(s_material, float3(dot(L, N), dot(H, N), m)); // sample material
return att * light;
}
#endif

12
gamedata/shaders/editor/model_def_hq.ps.hlsl Normal file
View file

@ -0,0 +1,12 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
};
// Pixel
float4 main_ps_1_1(v2p I) : COLOR
{
return tex2D(s_base, I.tc0);
}

23
gamedata/shaders/editor/model_def_hq.vs.hlsl Normal file
View file

@ -0,0 +1,23 @@
#include "common.hlsli"
#include "skin.hlsli"
// #define SKIN_2
struct vf
{
float4 hpos : POSITION;
float2 tc0 : TEXCOORD0; // base
float fog : FOG;
};
vf _main(v_model v)
{
vf o;
o.hpos = mul(m_WVP, v.pos); // xform, input in world coords
o.tc0 = v.tc.xy; // copy tc
o.fog = calc_fogging(v.pos);
return o;
}
#define SKIN_VF vf
#include "skin_main.hlsli"

23
gamedata/shaders/editor/model_env_hq.ps.hlsl Normal file
View file

@ -0,0 +1,23 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
float3 tc1 : TEXCOORD1; // environment
};
// Pixel
float4 main_ps_1_1(v2p I) : COLOR
{
float4 t_base = tex2D(s_base, I.tc0);
float4 t_env = texCUBE(s_env, I.tc1);
// lighting
// final-color
float3 base = lerp(t_env, t_base, t_base.a);
float3 final = base;
// out
return float4(final.r, final.g, final.b, t_base.a);
}

31
gamedata/shaders/editor/model_env_hq.vs.hlsl Normal file
View file

@ -0,0 +1,31 @@
#include "common.hlsli"
#include "skin.hlsli"
// #define SKIN_2
struct vf
{
float4 hpos : POSITION;
float2 tc0 : TEXCOORD0; // base
float3 tc1 : TEXCOORD1; // environment
float fog : FOG;
};
vf _main(v_model v)
{
vf o;
float4 pos = v.pos;
float3 pos_w = mul(m_W, pos);
float4 pos_w4 = float4(pos_w, 1);
float3 norm_w = normalize(mul(m_W, v.norm));
o.hpos = mul(m_WVP, pos); // xform, input in world coords
o.tc0 = v.tc.xy; // copy tc
o.tc1 = calc_reflection(pos_w, norm_w);
o.fog = calc_fogging(pos_w4); // fog, input in world coords
return o;
}
#define SKIN_VF vf
#include "skin_main.hlsli"

13
gamedata/shaders/editor/particle.ps.hlsl Normal file
View file

@ -0,0 +1,13 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
float4 c : COLOR0; // diffuse
};
// Pixel
float4 main(v2p I) : COLOR
{
return I.c * tex2D(s_base, I.tc0);
}

27
gamedata/shaders/editor/particle.vs.hlsl Normal file
View file

@ -0,0 +1,27 @@
#include "common.hlsli"
struct vv
{
float4 P : POSITION;
float2 tc : TEXCOORD0;
float4 c : COLOR0;
};
struct vf
{
float4 hpos : POSITION;
float2 tc : TEXCOORD0;
float4 c : COLOR0;
float fog : FOG;
};
vf main(vv v)
{
vf o;
o.hpos = mul(m_WVP, v.P); // xform, input in world coords
o.tc = v.tc; // copy tc
o.c = v.c; // copy color
o.fog = calc_fogging(v.P); // fog, input in world coords
return o;
}

25
gamedata/shaders/editor/particle_distort.ps.hlsl Normal file
View file

@ -0,0 +1,25 @@
#include "common.hlsli"
struct v2p
{
float2 tc0 : TEXCOORD0; // base
float4 proj : TEXCOORD1; // base
float4 c : COLOR0; // diffuse
};
// Pixel
uniform sampler s_distort;
uniform sampler s_image;
float4 main(v2p I) : COLOR
{
float2 uv = I.proj.xy / I.proj.w * float2(0.5f, -0.5f) + 0.5f;
float4 distort = tex2D(s_distort, I.tc0);
float factor = distort.a * dot(I.c.xyz, 0.33f);
float2 offset = (distort.xy - (127.0f / 255.0f)) * factor;
float3 image = tex2D(s_image, uv + offset * 0.05f).xyz;
return float4(image.xyz, 1.0f);
}

30
gamedata/shaders/editor/particle_distort.vs.hlsl Normal file
View file

@ -0,0 +1,30 @@
#include "common.hlsli"
struct vv
{
float4 P : POSITION;
float2 tc : TEXCOORD0;
float4 c : COLOR0;
};
struct vf
{
float4 hpos : POSITION;
float2 tc : TEXCOORD0;
float4 proj : TEXCOORD1;
float4 c : COLOR0;
float fog : FOG;
};
vf main(vv v)
{
vf o;
o.hpos = mul(m_WVP, v.P); // xform, input in world coords
o.tc = v.tc; // copy tc
o.c = v.c; // copy color
o.fog = calc_fogging(v.P); // fog, input in world coords
o.proj = o.hpos;
return o;
}

10
gamedata/shaders/editor/particles_xdistort.lua Normal file
View file

@ -0,0 +1,10 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("particle_distort", "particle_distort")
:sorting(3, false)
:blend(true, blend.srcalpha, blend.invsrcalpha)
:zb(true, false)
:fog(false)
shader:sampler("s_base") : texture(t_base)
shader:sampler("s_distort") : texture(t_base)
shader:sampler("s_image") : texture("$user$rt_color") : mirror ()
end

7
gamedata/shaders/editor/portal.lua Normal file
View file

@ -0,0 +1,7 @@
function normal(shader, t_base, t_second, t_detail)
shader:begin("portal", "portal")
:fog(true)
:zb(true, false)
:sorting(3, true)
:blend(true, blend.srcalpha, blend.invsrcalpha)
end

8
gamedata/shaders/editor/portal.ps.hlsl Normal file
View file

@ -0,0 +1,8 @@
#include "common.hlsli"
float4 main(float4 color : COLOR0, float fog : FOG) : COLOR
{
float4 final = color;
final.xyz = lerp(fog_color.xyz, final.xyz, fog);
return final;
}

19
gamedata/shaders/editor/portal.vs.hlsl Normal file
View file

@ -0,0 +1,19 @@
#include "common.hlsli"
struct vf
{
float4 hpos : POSITION;
float4 c : COLOR0;
float fog : FOG;
};
vf main(v_vert v)
{
vf o;
o.hpos = mul(m_VP, v.P); // xform, input in world coords
o.c = v.color;
o.fog = calc_fogging(v.P); // fog, input in world coords
return o;
}

11
gamedata/shaders/editor/shared/cloudconfig.hlsli Normal file
View file

@ -0,0 +1,11 @@
#ifndef _CLOUDCONFIG_H
#define _CLOUDCONFIG_H
// note: timers has resolution (sec), where x=1, y=10, z=1/10,
#define CLOUD_TILE0 (0.7f)
#define CLOUD_SPEED0 (2 * 0.05) //(0.033f)
#define CLOUD_TILE1 (2.8) //(2.5f)
#define CLOUD_SPEED1 (2 * 0.025) //(0.033f)
#define CLOUD_FADE (0.5)
#endif

65
gamedata/shaders/editor/shared/common.hlsli Normal file
View file

@ -0,0 +1,65 @@
#ifndef SHARED_COMMON_H
#define SHARED_COMMON_H
uniform float3x4 m_W;
uniform float3x4 m_V;
uniform float3x4 m_invV;
uniform float4x4 m_P;
uniform float3x4 m_WV;
uniform float4x4 m_VP;
uniform float4x4 m_WVP;
uniform float4 timers;
uniform float4 fog_plane;
uniform float4 fog_params; // x=near*(1/(far-near)), ?,?, w = -1/(far-near)
uniform float4 fog_color;
uniform float4 L_sky_color;
uniform float3 L_sun_color;
uniform float3 L_sun_dir_w;
uniform float3 L_sun_dir_e;
uniform float4 L_hemi_color;
uniform float4 L_ambient; // L_ambient.w = skynbox-lerp-factor
uniform float3 eye_position;
uniform float3 eye_direction;
uniform float3 eye_normal;
uniform float4 dt_params;
float3 unpack_normal(float3 v)
{
return 2 * v - 1;
}
float3 unpack_bx2(float3 v)
{
return 2 * v - 1;
}
float3 unpack_bx4(float3 v)
{
return 4 * v - 2;
}
float2 unpack_tc_base(float2 tc, float du, float dv)
{
return (tc.xy + float2(du, dv)) * (32.f / 32768.f);
}
float2 unpack_tc_lmap(float2 tc)
{
return tc * (1.f / 32768.f);
} // [-1 .. +1 ]
float calc_cyclic(float x)
{
float phase = 1 / (2 * 3.141592653589f);
float sqrt2 = 1.4142136f;
float sqrt2m2 = 2.8284271f;
float f = sqrt2m2 * frac(x) - sqrt2; // [-sqrt2 .. +sqrt2]
return f * f - 1.f; // [-1 .. +1]
}
float2 calc_xz_wave(float2 dir2D, float frac)
{
// Beizer
float2 ctrl_A = float2(0.f, 0.f);
float2 ctrl_B = float2(dir2D.x, dir2D.y);
return lerp(ctrl_A, ctrl_B, frac);
}
#endif

55
gamedata/shaders/editor/shared/waterconfig.hlsli Normal file
View file

@ -0,0 +1,55 @@
#ifndef _WATERCONFIG_H
#define _WATERCONFIG_H
// íàñòðîéêè äëÿ: (1)
// waterdistortion
// waterdistortion2
#define W_POSITION_SHIFT_HEIGHT (1.f / 60.f) //(1.f/100.f) //amplitude /50 - small, /10 - large
#define W_POSITION_SHIFT_SPEED (25.f) //(25.0f)
#define W_DISTORT_BASE_TILE_0 (1.0f) //(1.0f)
#define W_DISTORT_BASE_TILE_1 (1.1f) //(1.1f)
#define W_DISTORT_AMP_0 (+0.15f) //(+0.15f)
#define W_DISTORT_AMP_1 (+0.55f) //(-0.30f)
#define W_DISTORT_POWER (1.0f) //(1.0f)
#endif
/*
////////////////////////////////////////////////////////////////////////////////
-- waters clear
////////////////////////////////////////////////////////////////////////////////
íàñòðîéêè äëÿ:
waterdistortion
waterdistortion2
////////////////////////////////////////////////////////////////////////////////
#define W_POSITION_SHIFT_HEIGHT (1.f/50.f) //(1.f/100.f) //amplitude /50 - small, /10 - large
#define W_POSITION_SHIFT_SPEED (15.f) //(25.0f)
#define W_DISTORT_BASE_TILE_0 (1.3f) //(1.6f)
#define W_DISTORT_BASE_TILE_1 (2.3f) //(1.1f)
#define W_DISTORT_AMP_0 (+0.35f) //(+0.15f)
#define W_DISTORT_AMP_1 (-1.75f) //(-0.30f)
#define W_DISTORT_POWER (1.0f) //(1.0f)
////////////////////////////////////////////////////////////////////////////////
íàñòðîéêè äëÿ:
waterdistortion
waterdistortion
////////////////////////////////////////////////////////////////////////////////
#define W_POSITION_SHIFT_HEIGHT (1.f/80.f) //(1.f/100.f) //amplitude /50 - small, /10 - large
#define W_POSITION_SHIFT_SPEED (20.f) //(25.0f)
#define W_DISTORT_BASE_TILE_0 (1.6f) //(1.6f)
#define W_DISTORT_BASE_TILE_1 (1.1f) //(1.1f)
#define W_DISTORT_AMP_0 (+0.15f) //(+0.15f)
#define W_DISTORT_AMP_1 (-0.30f) //(-0.30f)
#define W_DISTORT_POWER (6.0f) //(6.0f)
////////////////////////////////////////////////////////////////////////////////
-- waters mulyaka
////////////////////////////////////////////////////////////////////////////////
#define W_POSITION_SHIFT_HEIGHT (1.f/50.f) // amplitude /50 - small, /10 - large
#define W_POSITION_SHIFT_SPEED (25.f)
#define W_DISTORT_BASE_TILE (0.1f) //(1.0f)
#define W_DISTORT_AMP_0 (+0.58f) //(-0.08f)
#define W_DISTORT_AMP_1 (+0.38f) //(+0.18f)
#define W_DISTORT_POWER (3.0f) //(2.0f)
////////////////////////////////////////////////////////////////////////////////
*/

29
gamedata/shaders/editor/shared/watermove.hlsli Normal file
View file

@ -0,0 +1,29 @@
#ifndef _WATERMOVE_H
#define _WATERMOVE_H
float4 watermove(float4 P)
{
float3 wave1 = float3(0.11f, 0.13f, 0.07f) * W_POSITION_SHIFT_SPEED;
float dh = sin(timers.x + dot((float3)P, wave1));
P.y += dh * W_POSITION_SHIFT_HEIGHT;
return P;
}
float2 watermove_tc(float2 base, float2 P, float amp)
{
float2 wave1 = float2(0.2111f, 0.2333f) * amp;
float angle = timers.z + dot(P, wave1);
float du = sin(angle);
float dv = cos(angle);
return (base + amp * float2(du, dv));
}
float3 waterrefl(out float amount, float3 P, float3 N)
{
float3 v2point = normalize(P - eye_position);
float3 vreflect = reflect(v2point, N);
float fresnel = (.5f + .5f * dot(vreflect, v2point));
amount = 1 - fresnel * fresnel; // 0=full env, 1=no env
return vreflect;
}
#endif

23
gamedata/shaders/editor/shared/wmark.hlsli Normal file
View file

@ -0,0 +1,23 @@
#ifndef WMARK_H
#define WMARK_H
#include "common.hlsli"
#define NORMAL_SHIFT 0.007f
#define MIN_SHIFT 0.003f
#define MAX_SHIFT 0.011f
#define RANGE 100.f
float4 wmark_shift(float3 pos, float3 norm)
{
float3 P = pos;
float3 N = norm;
float3 sd = eye_position - P;
float d = length(sd);
float w = min(d / RANGE, 1.f);
float s = lerp(MIN_SHIFT, MAX_SHIFT, d);
P += N.xyz * NORMAL_SHIFT;
P -= normalize(eye_direction + normalize(P - eye_position)) * s;
return float4(P, 1.f);
}
#endif

6
gamedata/shaders/editor/simple_color.ps.hlsl Normal file
View file

@ -0,0 +1,6 @@
#include "common.hlsli"
float4 main(float4 C : COLOR0) : COLOR
{
return C;
}

19
gamedata/shaders/editor/simple_color.vs.hlsl Normal file
View file

@ -0,0 +1,19 @@
#include "common.hlsli"
struct vf
{
float4 hpos : POSITION;
float4 C : COLOR0;
};
uniform float4 tfactor;
vf main(float4 P : POSITION)
{
vf o;
o.hpos = mul(m_WVP, P); // xform, input in world coords
o.C = tfactor;
return o;
}

226
gamedata/shaders/editor/skin.hlsli Normal file
View file

@ -0,0 +1,226 @@
#ifndef SKIN_H
#define SKIN_H
#include "common.hlsli"
struct v_model_skinned_0
{
float4 P : POSITION; // (float,float,float,1) - quantized // short4
float3 N : NORMAL; // normal // DWORD
float3 T : TANGENT; // tangent // DWORD
float3 B : BINORMAL; // binormal // DWORD
float2 tc : TEXCOORD0; // (u,v) // short2
};
struct v_model_skinned_1 // 24 bytes
{
float4 P : POSITION; // (float,float,float,1) - quantized // short4
float4 N : NORMAL; // (nx,ny,nz,index) // DWORD
float3 T : TANGENT; // tangent // DWORD
float3 B : BINORMAL; // binormal // DWORD
float2 tc : TEXCOORD0; // (u,v) // short2
};
struct v_model_skinned_2 // 28 bytes
{
float4 P : POSITION; // (float,float,float,1) - quantized // short4
float4 N : NORMAL; // (nx,ny,nz,weight) // DWORD
float3 T : TANGENT; // tangent // DWORD
float3 B : BINORMAL; // binormal // DWORD
float4 tc : TEXCOORD0; // (u,v, w=m-index0, z=m-index1) // short4
};
struct v_model_skinned_3 // 28 bytes
{
float4 P : POSITION; // (float,float,float,1) - quantized // short4
float4 N : NORMAL; // (nx,ny,nz,weight0) // DWORD
float4 T : TANGENT; // (tx,ty,tz,weight1) // DWORD
float4 B : BINORMAL; // (bx,by,bz,m-index2) // DWORD
float4 tc : TEXCOORD0; // (u,v, w=m-index0, z=m-index1) // short4
};
struct v_model_skinned_4 // 28 bytes
{
float4 P : POSITION; // (float,float,float,1) - quantized // short4
float4 N : NORMAL; // (nx,ny,nz,weight0) // DWORD
float4 T : TANGENT; // (tx,ty,tz,weight1) // DWORD
float4 B : BINORMAL; // (bx,by,bz,weight2) // DWORD
float2 tc : TEXCOORD0; // (u,v) // short2
float4 ind : TEXCOORD1; // (x=m-index0, y=m-index1, z=m-index2, w=m-index3) // DWORD
};
//////////////////////////////////////////////////////////////////////////////////////////
float4 u_position(float4 v)
{
return float4(v.xyz, 1.f);
} // -12..+12
//////////////////////////////////////////////////////////////////////////////////////////
// uniform float4 sbones_array [256-22];
// Igor: Max number of bones per mesh - 64. 3 registers per bone.
uniform float4 sbones_array[230];
float3 skinning_dir(float3 dir, float3 m0, float3 m1, float3 m2)
{
float3 U = unpack_normal(dir);
return float3(
dot(m0, U),
dot(m1, U),
dot(m2, U));
}
float4 skinning_pos(float4 pos, float4 m0, float4 m1, float4 m2)
{
float4 P = u_position(pos); // -12..+12
return float4(
dot(m0, P),
dot(m1, P),
dot(m2, P),
1);
}
v_model skinning_0(v_model_skinned_0 v)
{
// skinning
v_model o;
o.P = u_position(v.P);
o.N = unpack_normal(v.N);
o.T = unpack_normal(v.T);
o.B = unpack_normal(v.B);
o.tc = v.tc; // -16..+16
return o;
}
v_model skinning_1(v_model_skinned_1 v)
{
// matrices
int mid = v.N.w * (int)255;
float4 m0 = sbones_array[mid + 0];
float4 m1 = sbones_array[mid + 1];
float4 m2 = sbones_array[mid + 2];
// skinning
v_model o;
o.P = skinning_pos(v.P, m0, m1, m2);
o.N = skinning_dir(v.N, m0, m1, m2);
o.T = skinning_dir(v.T, m0, m1, m2);
o.B = skinning_dir(v.B, m0, m1, m2);
o.tc = v.tc; // -16..+16
return o;
}
v_model skinning_2(v_model_skinned_2 v)
{
// matrices
int id_0 = v.tc.z;
float4 m0_0 = sbones_array[id_0 + 0];
float4 m1_0 = sbones_array[id_0 + 1];
float4 m2_0 = sbones_array[id_0 + 2];
int id_1 = v.tc.w;
float4 m0_1 = sbones_array[id_1 + 0];
float4 m1_1 = sbones_array[id_1 + 1];
float4 m2_1 = sbones_array[id_1 + 2];
// lerp
float w = v.N.w;
float4 m0 = lerp(m0_0, m0_1, w);
float4 m1 = lerp(m1_0, m1_1, w);
float4 m2 = lerp(m2_0, m2_1, w);
// skinning
v_model o;
o.P = skinning_pos(v.P, m0, m1, m2);
o.N = skinning_dir(v.N, m0, m1, m2);
o.T = skinning_dir(v.T, m0, m1, m2);
o.B = skinning_dir(v.B, m0, m1, m2);
o.tc = v.tc; // -16..+16
return o;
}
v_model skinning_3(v_model_skinned_3 v)
{
// matrices
int id_0 = v.tc.z;
float4 m0_0 = sbones_array[id_0 + 0];
float4 m1_0 = sbones_array[id_0 + 1];
float4 m2_0 = sbones_array[id_0 + 2];
int id_1 = v.tc.w;
float4 m0_1 = sbones_array[id_1 + 0];
float4 m1_1 = sbones_array[id_1 + 1];
float4 m2_1 = sbones_array[id_1 + 2];
int id_2 = v.B.w * 255 + 0.3;
float4 m0_2 = sbones_array[id_2 + 0];
float4 m1_2 = sbones_array[id_2 + 1];
float4 m2_2 = sbones_array[id_2 + 2];
// lerp
float w0 = v.N.w;
float w1 = v.T.w;
float w2 = 1 - w0 - w1;
float4 m0 = m0_0 * w0;
float4 m1 = m1_0 * w0;
float4 m2 = m2_0 * w0;
m0 += m0_1 * w1;
m1 += m1_1 * w1;
m2 += m2_1 * w1;
m0 += m0_2 * w2;
m1 += m1_2 * w2;
m2 += m2_2 * w2;
// skinning
v_model o;
o.P = skinning_pos(v.P, m0, m1, m2);
o.N = skinning_dir(v.N, m0, m1, m2);
o.T = skinning_dir(v.T, m0, m1, m2);
o.B = skinning_dir(v.B, m0, m1, m2);
o.tc = v.tc; // -16..+16
#ifdef SKIN_COLOR
o.rgb_tint = float3(2, 0, 0);
if (id_0 == id_1)
{
o.rgb_tint = float3(1, 2, 0);
}
#endif
return o;
}
v_model skinning_4(v_model_skinned_4 v)
{
// matrices
float id[4];
float4 m[4][3]; // [bone index][matrix row or column???]
for (int i = 0; i < 4; ++i)
{
id[i] = v.ind[i] * 255 + 0.3;
for (int j = 0; j < 3; ++j)
{
m[i][j] = sbones_array[id[i] + j];
}
}
// lerp
float w[4];
w[0] = v.N.w;
w[1] = v.T.w;
w[2] = v.B.w;
w[3] = 1 - w[0] - w[1] - w[2];
float4 m0 = m[0][0] * w[0];
float4 m1 = m[0][1] * w[0];
float4 m2 = m[0][2] * w[0];
for (int i = 1; i < 4; ++i)
{
m0 += m[i][0] * w[i];
m1 += m[i][1] * w[i];
m2 += m[i][2] * w[i];
}
// skinning
v_model o;
o.P = skinning_pos(v.P, m0, m1, m2);
o.N = skinning_dir(v.N, m0, m1, m2);
o.T = skinning_dir(v.T, m0, m1, m2);
o.B = skinning_dir(v.B, m0, m1, m2);
o.tc = v.tc; // -16..+16
return o;
}
#endif

100
gamedata/shaders/editor/skin_main.hlsli Normal file
View file

@ -0,0 +1,100 @@
#ifndef SKIN_MAIN_INCLUDED
#define SKIN_MAIN_INCLUDED
//////////////////////////////////////////////////////
#ifdef SKIN_LQ
//////////////////////////////////////////////////////
#ifdef SKIN_NONE
SKIN_VF main(v_model v)
{
return _main(v);
}
#endif
#ifdef SKIN_0
SKIN_VF main(v_model_skinned_0 v)
{
return _main(skinning_0(v));
}
#endif
#ifdef SKIN_1
SKIN_VF main(v_model_skinned_1 v)
{
return _main(skinning_1(v));
}
#endif
#ifdef SKIN_2
SKIN_VF main(v_model_skinned_2 v)
{
return _main(skinning_2lq(v));
}
#endif
#ifdef SKIN_3
SKIN_VF main(v_model_skinned_3 v)
{
return _main(skinning_3lq(v));
}
#endif
#ifdef SKIN_4
SKIN_VF main(v_model_skinned_4 v)
{
return _main(skinning_4lq(v));
}
#endif
//////////////////////////////////////////////////////
#else // SKIN_LQ
//////////////////////////////////////////////////////
#ifdef SKIN_NONE
SKIN_VF main(v_model v)
{
return _main(v);
}
#endif
#ifdef SKIN_0
SKIN_VF main(v_model_skinned_0 v)
{
return _main(skinning_0(v));
}
#endif
#ifdef SKIN_1
SKIN_VF main(v_model_skinned_1 v)
{
return _main(skinning_1(v));
}
#endif
#ifdef SKIN_2
SKIN_VF main(v_model_skinned_2 v)
{
return _main(skinning_2(v));
}
#endif
#ifdef SKIN_3
SKIN_VF main(v_model_skinned_3 v)
{
return _main(skinning_3(v));
}
#endif
#ifdef SKIN_4
SKIN_VF main(v_model_skinned_4 v)
{
return _main(skinning_4(v));
}
#endif
//////////////////////////////////////////////////////
#endif // SKIN_LQ
//////////////////////////////////////////////////////
#endif // SKIN_MAIN_INCLUDED

22
gamedata/shaders/editor/sky.ps.hlsl Normal file
View file

@ -0,0 +1,22 @@
#include "common.hlsli"
struct v2p
{
float4 factor : COLOR0;
float3 tc0 : TEXCOORD0;
float3 tc1 : TEXCOORD1;
};
uniform samplerCUBE s_sky0 : register(s0);
uniform samplerCUBE s_sky1 : register(s1);
uniform float3 color;
// Pixel
float4 main(v2p I) : COLOR
{
float3 s0 = texCUBE(s_sky0, I.tc0);
float3 s1 = texCUBE(s_sky1, I.tc1);
float3 sky = I.factor * lerp(s0, s1, I.factor.w);
return float4(sky, 1);
}

31
gamedata/shaders/editor/sky.vs.hlsl Normal file
View file

@ -0,0 +1,31 @@
#include "common.hlsli"
struct vi
{
float4 p : POSITION;
float4 c : COLOR0;
float3 tc0 : TEXCOORD0;
float3 tc1 : TEXCOORD1;
};
struct vf
{
float4 hpos : POSITION;
float4 c : COLOR0;
float3 tc0 : TEXCOORD0;
float3 tc1 : TEXCOORD1;
};
vf main(vi v)
{
vf o;
float4 tpos = mul(1000, v.p);
o.hpos = mul(m_WVP, tpos); // xform, input in world coords, 1000 - magic number
o.hpos.z = o.hpos.w;
o.c = v.c; // copy color
o.tc0 = v.tc0; // copy tc
o.tc1 = v.tc1; // copy tc
return o;
}

23
gamedata/shaders/editor/sky2.ps Normal file
View file

@ -0,0 +1,23 @@
#include "common.h"
struct v2p
{
float4 factor: COLOR0;
float3 tc0: TEXCOORD0;
float3 tc1: TEXCOORD1;
};
uniform samplerCUBE s_sky0 : register(s0);
uniform samplerCUBE s_sky1 : register(s1);
uniform float3 color;
//////////////////////////////////////////////////////////////////////////////////////////
// Pixel
float4 main ( v2p I ) : COLOR
{
float3 s0 = texCUBE(s_sky0,I.tc0);
float3 s1 = texCUBE(s_sky1,I.tc1);
float3 sky = I.factor*lerp(s0,s1,I.factor.w);
return float4 (sky,1);
}

31
gamedata/shaders/editor/sky2.vs Normal file
View file

@ -0,0 +1,31 @@
#include "common.h"
struct vi
{
float4 p : POSITION;
float4 c : COLOR0;
float3 tc0 : TEXCOORD0;
float3 tc1 : TEXCOORD1;
};
struct vf
{
float4 hpos : POSITION;
float4 c : COLOR0;
float3 tc0 : TEXCOORD0;
float3 tc1 : TEXCOORD1;
};
vf main (vi v)
{
vf o;
float4 tpos = mul (1000, v.p);
o.hpos = mul (m_WVP, tpos); // xform, input in world coords, 1000 - magic number
o.hpos.z = o.hpos.w;
o.c = v.c; // copy color
o.tc0 = v.tc0; // copy tc
o.tc1 = v.tc1; // copy tc
return o;
}

82
gamedata/shaders/editor/sload.hlsli Normal file
View file

@ -0,0 +1,82 @@
#ifndef SLOAD_H
#define SLOAD_H
#include "common.hlsli"
static const float fParallaxStartFade = 8.0f;
static const float fParallaxStopFade = 12.0f;
uniform sampler s_detailBumpX;
uniform sampler s_detailBump;
uniform sampler s_bumpX;
uniform sampler s_bump;
struct XrayMaterial
{
float Metalness;
float Roughness;
float3 Normal;
float3 Point;
float4 Color;
float Hemi;
float Sun;
float SSS;
float AO;
};
void SloadNew(inout p_bumped_new I, inout XrayMaterial M)
{
M.Color = tex2D(s_base, I.tcdh.xy);
#ifdef USE_BUMP
float4 Bump = tex2D(s_bump, I.tcdh.xy);
float4 BumpX = tex2D(s_bumpX, I.tcdh.xy);
// #ifndef USE_PBR
M.Normal = Bump.wzy + BumpX.xyz - 1.0f;
M.Normal.z *= 0.5f;
M.Roughness = Bump.x * Bump.x;
M.Metalness = 0.0f;
M.SSS = 0.0;
M.AO = 1.0;
// #endif
#else
M.Normal = float3(0.0f, 0.0f, 1.0f);
M.Roughness = 0.04f;
M.Metalness = 0.0f;
M.SSS = 0.0f;
M.AO = 1.0f;
#endif
#ifdef USE_TDETAIL
float2 tcdbump = I.tcdh.xy * dt_params.xy;
float4 Detail = tex2D(s_detail, tcdbump);
#ifndef USE_PBR
M.Color.xyz *= Detail.xyz * 2.0f;
#ifdef USE_TDETAIL_BUMP
float4 DetailBump = tex2D(s_detailBump, tcdbump);
float4 DetailBumpX = tex2D(s_detailBumpX, tcdbump);
M.Normal += DetailBump.wzy + DetailBumpX.xyz - 1.0f;
M.Roughness *= DetailBump.x * 2.0f;
#else
M.Roughness *= Detail.w * 2.0f;
#endif
#endif
#endif
#ifndef USE_PBR
M.Metalness = M.Roughness * 0.1f;
M.Roughness = saturate(1.0f - M.Roughness);
#endif
}
#endif

136
gamedata/shaders/editor/water.ps.hlsl Normal file
View file

@ -0,0 +1,136 @@
#include "common.hlsli"
struct vf
{
float2 tbase : TEXCOORD0;
float2 tnorm0 : TEXCOORD1;
float2 tnorm1 : TEXCOORD2;
float3 M1 : TEXCOORD3;
float3 M2 : TEXCOORD4;
float3 M3 : TEXCOORD5;
float3 v2point : TEXCOORD6;
float4 tctexgen : TEXCOORD7;
float3 pos : TEXCOORD8;
float4 c0 : COLOR0;
};
uniform float3 water_intensity;
uniform sampler s_image;
uniform sampler s_nmap;
uniform sampler s_env0;
uniform sampler s_env1;
uniform sampler env_s0;
uniform sampler env_s1;
uniform sampler s_leaves;
uniform sampler s_caustic;
uniform float4 screen_res;
float3 SpecularPhong(float3 Point, float3 Normal, float3 Light)
{
float3 LightColor = max(0.0f, L_sun_color.xyz * 4.0f - 1.0f);
return LightColor * pow(dot(normalize(Point + Light), -Normal), 256.0);
}
float GetBorderAtten(float2 tc, float2 att)
{
att.x *= screen_res.y * screen_res.z;
float2 factors = saturate(min(1.0f - tc, tc) / att);
return factors.x * factors.y;
}
float4 ScreenSpaceLocalReflections(float3 vreflect) //Initial beam length
{
float3 refl_vec = mul((float3x3)m_V, vreflect);
float4 new_pos_proj = mul(m_P,float4(refl_vec,1));//переводим её в скрин спейс
new_pos_proj.xy /= new_pos_proj.w; //нормализуем
new_pos_proj.xy = new_pos_proj.xy * float2(0.5h, -0.5h) + 0.5h;
float2 reflPos = saturate(new_pos_proj); // We get the pixel position in Screen Space of the reflected geometry
float canrefl = smoothstep(0.0f, 0.05f, refl_vec.z);
float borderAtten = GetBorderAtten(reflPos, 0.125f); // Grease the edges of the reflections for a smoother transition
float3 color = tex2D(s_image, reflPos);
return float4(color, borderAtten * canrefl);
}
// Pixel
float4 main(vf I) : COLOR
{
float4 base = tex2D(s_base, I.tbase);
float3 n0 = tex2D(s_nmap, I.tnorm0);
float3 n1 = tex2D(s_nmap, I.tnorm1);
float3 Navg = n0 + n1 - 1.0f;
float3 Nw = normalize(mul(float3x3(I.M1, I.M2, I.M3), Navg).xyz);
float3 v2point = normalize(I.v2point);
float3 vreflect = reflect(v2point, Nw);
float fresnel = saturate(dot(vreflect, v2point));
float power = pow(fresnel, 5.0f);
float amount = 0.25f + 0.25f * power;
float3 reflection = vreflect;
float2 rotation = 0.0f;
sincos(L_sky_color.w, rotation.x, rotation.y);
vreflect.xz = float2(vreflect.x * rotation.y - vreflect.z * rotation.x, vreflect.x * rotation.x + vreflect.z * rotation.y);
// true remapping. Slow.
float3 vreflectabs = abs(vreflect);
float vreflectmax = max(vreflectabs.x, max(vreflectabs.y, vreflectabs.z));
vreflect /= vreflectmax;
vreflect.y = vreflect.y * 2.0f - 1.0f;
if(is_lighting_enable.x < 0.5f) {
float3 env = texCUBE(s_env, vreflect) * amount * 0.8f;
env = lerp(env.xyz, base.xyz, base.w);
return float4(env, 0.8f + 0.2f * base.w);
}
float3 envd0 = texCUBE(env_s0, Nw);
float3 envd1 = texCUBE(env_s1, Nw);
float3 envd = lerp(envd0, envd1, L_ambient.w) * L_hemi_color.xyz;
float3 color = I.c0.xyz + envd * envd * I.c0.w;
base.xyz *= color;
float3 env0 = texCUBE(s_env0, vreflect);
float3 env1 = texCUBE(s_env1, vreflect);
float3 env = lerp(env0, env1, L_ambient.w) * L_sky_color.xyz;
float4 sslr = ScreenSpaceLocalReflections(reflection);
env = lerp(env, sslr.xyz, sslr.w);
float3 final = lerp(env * amount * 0.8f, base.xyz, base.w);
float alpha = 0.25f + 0.65f * power;
alpha = lerp(alpha, 1.0f, base.w);
float waterDepth = 0.75f;
// water fog
float3 Fc = 0.1f * water_intensity.xxx * color;
final = lerp(Fc, final, alpha);
alpha = min(alpha, saturate(waterDepth));
alpha = max(1.0f - exp(-4.0f * waterDepth), alpha);
float4 Light = float4(L_sun_color.xyz * 0.66f, 1.0f);
Light *= 1.0f - base.w;
float2 CausticTexcoord = I.pos.xz * 0.45f + v2point.xz / (0.0001f + abs(v2point.y)) * 0.3f;
float3 Caustic = tex2D(s_caustic, CausticTexcoord).yyy;
final += SpecularPhong(v2point, Nw, L_sun_dir_w.xyz) * Light.w;
final += Caustic * Light.xyz * 0.25f;
return lerp(float4(final, alpha), fog_color, calc_fogging(I.pos));
}

83
gamedata/shaders/editor/water.vs.hlsl Normal file
View file

@ -0,0 +1,83 @@
#include "common.hlsli"
#include "shared\waterconfig.hlsli"
#include "shared\watermove.hlsli"
struct vv
{
float4 P : POSITION;
float2 tc : TEXCOORD0;
float3 N : NORMAL;
float4 C : COLOR0;
};
struct vf
{
float2 tbase : TEXCOORD0; // base
float2 tnorm0 : TEXCOORD1; // nm0
float2 tnorm1 : TEXCOORD2; // nm1
float3 M1 : TEXCOORD3;
float3 M2 : TEXCOORD4;
float3 M3 : TEXCOORD5;
float3 v2point : TEXCOORD6;
float4 tctexgen : TEXCOORD7;
float3 pos : TEXCOORD8;
float4 c0 : COLOR0;
float4 hpos : POSITION;
};
uniform float4x4 m_texgen;
void main(in vv v, out vf o)
{
// v.N = unpack_normal(v.N.xyz);
// world
float4 P = float4(mul(m_W, v.P), 1.0f);
P = watermove(P);
o.pos = P.xyz;
o.v2point = P - eye_position;
o.tbase = P.xz * 0.3; // unpack_tc_base(v.uv, v.T.w, v.B.w);
o.tnorm0 = watermove_tc(o.tbase * W_DISTORT_BASE_TILE_0, P.xz, W_DISTORT_AMP_0);
o.tnorm1 = watermove_tc(o.tbase * W_DISTORT_BASE_TILE_1, P.xz, W_DISTORT_AMP_1);
// Calculate the 3x3 transform from tangent space to eye-space
// TangentToEyeSpace = object2eye * tangent2object
// = object2eye * transpose(object2tangent) (since the inverse of a rotation is its transpose)
float3 N = normalize(v.N);
float3 T = float3(-1.0f, 0.0f, 0.0f);
T = normalize(T - dot(T, N) * N);
float3 B = cross(N, T);
float3x3 xform = mul((float3x3)m_W, float3x3(
T.x, B.x, N.x,
T.y, B.y, N.y,
T.z, B.z, N.z));
// The pixel shader operates on the bump-map in [0..1] range
// Remap this range in the matrix, anyway we are pixel-shader limited :)
// ...... [ 2 0 0 0]
// ...... [ 0 2 0 0]
// ...... [ 0 0 2 0]
// ...... [-1 -1 -1 1]
// issue: strange, but it's slower :(
// issue: interpolators? dp4? VS limited? black magic?
// Feed this transform to pixel shader
o.M1 = xform[0];
o.M2 = xform[1];
o.M3 = xform[2];
// xform, input in world coords
o.hpos = mul(m_VP, P);
o.c0 = v.C;
// Igor: for additional depth dest
o.tctexgen = mul(m_texgen, P);
o.tctexgen.z = mul(m_V, P).z;
}

25
gamedata/shaders/editor/yuv2rgb.ps.hlsl Normal file
View file

@ -0,0 +1,25 @@
#include "common.hlsli"
float4 main(float2 uv : TEXCOORD0) : COLOR
{
float3 YUV = tex2D(s_base, uv);
float Y = YUV.x;
float U = YUV.y;
float V = YUV.z;
/*
float _T = 1.16406f*Y;
float R1 = _T + 1.59765f*V - 0.86961f;
float G1 = _T - 0.390625f*U - 0.8125f*V + 0.53076f;
float B1 = _T + 2.01562f*U - 1.0786f;
*/
float c = 1.16406f;
float3 _Y = float3(c, c, c) * Y;
float3 _U = float3(0, -0.390625f, +2.01562f) * U;
float3 _V = float3(+1.59765f, -0.8125f, 0) * V;
float3 _S = float3(-0.86961f, +0.53076f, -1.0786f);
return float4(_Y + _U + _V + _S, 1);
}