-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathgodot4_splatmap_shader.gdshader
254 lines (232 loc) · 11.7 KB
/
godot4_splatmap_shader.gdshader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
shader_type spatial;
render_mode blend_mix, diffuse_toon, specular_toon;
uniform sampler2D splat_map;
uniform bool Roughness_switch = true;
uniform bool AO_switch = true;
uniform bool Metalic_switch = false;
uniform bool Normal_switch = false;
uniform vec3 uv_scale_base = vec3(10.00,10.00,1.00);
uniform sampler2D albedo_base: source_color;
uniform sampler2D roughness_base;
uniform sampler2D AO_base;
uniform sampler2D Metalic_base;
uniform sampler2D Normal_base :hint_normal;
uniform vec3 uv_scale_R = vec3(10.00,10.00,1.00);
uniform sampler2D albedo_r: source_color;
uniform sampler2D roughness_r;
uniform sampler2D AO_r;
uniform sampler2D Metalic_r;
uniform sampler2D Normal_r :hint_normal;
uniform vec3 uv_scale_G = vec3(10.00,10.00,1.00);
uniform sampler2D albedo_g: source_color;
uniform sampler2D roughness_g;
uniform sampler2D AO_g;
uniform sampler2D Metalic_g;
uniform sampler2D Normal_g :hint_normal;
uniform vec3 uv_scale_B = vec3(10.00,10.00,1.00);
uniform sampler2D albedo_b: source_color;
uniform sampler2D roughness_b;
uniform sampler2D AO_b;
uniform sampler2D Metalic_b;
uniform sampler2D Normal_b :hint_normal;
uniform vec3 uv_scale_alpha = vec3(10.00,10.00,1.00);
uniform sampler2D alpha_albedo: source_color;
uniform sampler2D alpha_roughness;
uniform sampler2D alpha_AO;
uniform sampler2D alpha_Metalic;
uniform sampler2D alpha_Normal :hint_normal;
vec4 hash4( vec2 p ) { return fract(sin(vec4( 1.0+dot(p,vec2(37.0,17.0)),
2.0+dot(p,vec2(11.0,47.0)),
3.0+dot(p,vec2(41.0,29.0)),
4.0+dot(p,vec2(23.0,31.0))))*103.0); }
vec4 textureNoTile( sampler2D samp, in vec2 uv )
{
vec2 iuv = floor( uv );
vec2 fuv = fract( uv );
// generate per-tile transform
vec4 ofa = hash4( iuv + vec2(0.0,0.0) );
vec4 ofb = hash4( iuv + vec2(1.0,0.0) );
vec4 ofc = hash4( iuv + vec2(0.0,1.0) );
vec4 ofd = hash4( iuv + vec2(1.0,1.0) );
vec2 ddx = dFdx( uv );
vec2 ddy = dFdy( uv );
// transform per-tile uvs
ofa.zw = sign(ofa.zw-0.5);
ofb.zw = sign(ofb.zw-0.5);
ofc.zw = sign(ofc.zw-0.5);
ofd.zw = sign(ofd.zw-0.5);
// uv's, and derivarives (for correct mipmapping)
vec2 uva = uv*ofa.zw + ofa.xy; vec2 ddxa = ddx*ofa.zw; vec2 ddya = ddy*ofa.zw;
vec2 uvb = uv*ofb.zw + ofb.xy; vec2 ddxb = ddx*ofb.zw; vec2 ddyb = ddy*ofb.zw;
vec2 uvc = uv*ofc.zw + ofc.xy; vec2 ddxc = ddx*ofc.zw; vec2 ddyc = ddy*ofc.zw;
vec2 uvd = uv*ofd.zw + ofd.xy; vec2 ddxd = ddx*ofd.zw; vec2 ddyd = ddy*ofd.zw;
// fetch and blend
vec2 b = smoothstep(0.25,0.75,fuv);
return mix( mix( textureGrad( samp, uva, ddxa, ddya ),
textureGrad( samp, uvb, ddxb, ddyb ), b.x ),
mix( textureGrad( samp, uvc, ddxc, ddyc ),
textureGrad( samp, uvd, ddxd, ddyd ), b.x), b.y );
}
void fragment() {
vec4 splat_map_output = texture(splat_map, UV);
///////////////////////////////////////////////////////////////////
///////////////////////////ONLY FOR ALBEDO ////////////////////////
//splatmap component
float x_component_albedo = splat_map_output.x;
float y_component_albedo = splat_map_output.y;
float z_component_albedo = splat_map_output.z;
float w_component_albedo = splat_map_output.w;
//albedo alpha
vec3 scaled_uv_albedo = vec3(UV, 0.0) * uv_scale_alpha;
vec4 alpha_output_albedo = textureNoTile(alpha_albedo, vec2(scaled_uv_albedo.xy));
//albedo base
vec3 scaled_uv_2_albedo = vec3(UV, 0.0) * uv_scale_base;
vec4 albedo_base_output = textureNoTile(albedo_base, vec2(scaled_uv_2_albedo.xy));
//albedo red
vec3 scaled_uv_3_albedo = vec3(UV, 0.0) * uv_scale_R;
vec4 albedo_r_output = textureNoTile(albedo_r, vec2(scaled_uv_3_albedo.xy));
//albedo green
vec3 scaled_uv_4_albedo = vec3(UV, 0.0) * uv_scale_G;
vec4 albedo_g_output = textureNoTile(albedo_g, vec2(scaled_uv_4_albedo.xy));
//albedo blue
vec3 scaled_uv_5_albedo = vec3(UV, 0.0) * uv_scale_B;
vec4 albedo_b_output = textureNoTile(albedo_b, vec2(scaled_uv_5_albedo.xy));
//mixing operation
vec3 mix_stage_one_albedo = mix(vec3(albedo_base_output.xyz), vec3(albedo_r_output.xyz), vec3(x_component_albedo));
vec3 mix_stage_two_albedo = mix(mix_stage_one_albedo, vec3(albedo_g_output.xyz), vec3(y_component_albedo));
vec3 mix_stage_three_albedo = mix(mix_stage_two_albedo, vec3(albedo_b_output.xyz), vec3(z_component_albedo));
vec3 final_albedo_mix = mix(vec3(alpha_output_albedo.xyz), mix_stage_three_albedo, vec3(w_component_albedo));
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////ONLY FOR ROUGHNESS////////////////////////
//splatmap component
float x_component_roughness = splat_map_output.x;
float y_component_roughness = splat_map_output.y;
float z_component_roughness = splat_map_output.z;
float w_component_roughness = splat_map_output.w;
//roughness alpha
vec3 scaled_uv_roughness = vec3(UV, 0.0) * uv_scale_alpha;
vec4 alpha_output_roughness = textureNoTile(alpha_roughness, vec2(scaled_uv_roughness.xy));
//roughness base
vec3 scaled_uv_2_roughness = vec3(UV, 0.0) * uv_scale_base;
vec4 roughness_base_output = textureNoTile(roughness_base, vec2(scaled_uv_2_roughness.xy));
//roughness red
vec3 scaled_uv_3_roughness = vec3(UV, 0.0) * uv_scale_R;
vec4 roughness_r_output = textureNoTile(roughness_r, vec2(scaled_uv_3_roughness.xy));
//roughness green
vec3 scaled_uv_4_roughness = vec3(UV, 0.0) * uv_scale_G;
vec4 roughness_g_output = textureNoTile(roughness_g, vec2(scaled_uv_4_roughness.xy));
//roughness blue
vec3 scaled_uv_5_roughness = vec3(UV, 0.0) * uv_scale_B;
vec4 roughness_b_output = textureNoTile(roughness_b, vec2(scaled_uv_5_roughness.xy));
//mixing operation
vec3 mix_stage_one_roughness = mix(vec3(roughness_base_output.xyz), vec3(roughness_r_output.xyz), vec3(x_component_roughness));
vec3 mix_stage_two_roughness = mix(mix_stage_one_roughness, vec3(roughness_g_output.xyz), vec3(y_component_roughness));
vec3 mix_stage_three_roughness = mix(mix_stage_two_roughness, vec3(roughness_b_output.xyz), vec3(z_component_roughness));
vec3 final_roughness_mix = mix(vec3(alpha_output_roughness.xyz), mix_stage_three_roughness, vec3(w_component_roughness));
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////ONLY FOR AO ////////////////////////
//splatmap component
float x_component_AO = splat_map_output.x;
float y_component_AO = splat_map_output.y;
float z_component_AO = splat_map_output.z;
float w_component_AO = splat_map_output.w;
//AO alpha
vec3 scaled_uv_AO = vec3(UV, 0.0) * uv_scale_alpha;
vec4 alpha_output_AO = textureNoTile(alpha_AO, vec2(scaled_uv_AO.xy));
//AO base
vec3 scaled_uv_2_AO = vec3(UV, 0.0) * uv_scale_base;
vec4 AO_base_output = textureNoTile(AO_base, vec2(scaled_uv_2_AO.xy));
//AO red
vec3 scaled_uv_3_AO = vec3(UV, 0.0) * uv_scale_R;
vec4 AO_r_output = textureNoTile(AO_r, vec2(scaled_uv_3_AO.xy));
//AO green
vec3 scaled_uv_4_AO = vec3(UV, 0.0) * uv_scale_G;
vec4 AO_g_output = textureNoTile(AO_g, vec2(scaled_uv_4_AO.xy));
//AO blue
vec3 scaled_uv_5_AO = vec3(UV, 0.0) * uv_scale_B;
vec4 AO_b_output = textureNoTile(AO_b, vec2(scaled_uv_5_AO.xy));
//mixing operation
vec3 mix_stage_one_AO = mix(vec3(AO_base_output.xyz), vec3(AO_r_output.xyz), vec3(x_component_AO));
vec3 mix_stage_two_AO = mix(mix_stage_one_AO, vec3(AO_g_output.xyz), vec3(y_component_AO));
vec3 mix_stage_three_AO = mix(mix_stage_two_AO, vec3(AO_b_output.xyz), vec3(z_component_AO));
vec3 final_AO_mix = mix(vec3(alpha_output_AO.xyz), mix_stage_three_AO, vec3(w_component_AO));
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////ONLY FOR Normal_map ////////////////////////
//splatmap component
float x_component_Metalic = splat_map_output.x;
float y_component_Metalic = splat_map_output.y;
float z_component_Metalic = splat_map_output.z;
float w_component_Metalic = splat_map_output.w;
//Metalic alpha
vec3 scaled_uv_Metalic = vec3(UV, 0.0) * uv_scale_alpha;
vec4 alpha_output_Metalic = textureNoTile(alpha_Metalic, vec2(scaled_uv_Metalic.xy));
//Metalic base
vec3 scaled_uv_2_Metalic = vec3(UV, 0.0) * uv_scale_base;
vec4 Metalic_base_output = textureNoTile(Metalic_base, vec2(scaled_uv_2_Metalic.xy));
//Metalic red
vec3 scaled_uv_3_Metalic = vec3(UV, 0.0) * uv_scale_R;
vec4 Metalic_r_output = textureNoTile(Metalic_r, vec2(scaled_uv_3_Metalic.xy));
//Metalic green
vec3 scaled_uv_4_Metalic = vec3(UV, 0.0) * uv_scale_G;
vec4 Metalic_g_output = textureNoTile(Metalic_g, vec2(scaled_uv_4_Metalic.xy));
//Metalic blue
vec3 scaled_uv_5_Metalic = vec3(UV, 0.0) * uv_scale_B;
vec4 Metalic_b_output = textureNoTile(Metalic_b, vec2(scaled_uv_5_Metalic.xy));
//mixing operation
vec3 mix_stage_one_Metalic = mix(vec3(Metalic_base_output.xyz), vec3(Metalic_r_output.xyz), vec3(x_component_Metalic));
vec3 mix_stage_two_Metalic = mix(mix_stage_one_Metalic, vec3(Metalic_g_output.xyz), vec3(y_component_Metalic));
vec3 mix_stage_three_Metalic = mix(mix_stage_two_Metalic, vec3(Metalic_b_output.xyz), vec3(z_component_Metalic));
vec3 final_Metalic_mix = mix(vec3(alpha_output_Metalic.xyz), mix_stage_three_Metalic, vec3(w_component_Metalic));
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////ONLY FOR Normal_map ////////////////////////
//splatmap component
float x_component_Normal = splat_map_output.x;
float y_component_Normal = splat_map_output.y;
float z_component_Normal = splat_map_output.z;
float w_component_Normal = splat_map_output.w;
//Normal alpha
vec3 scaled_uv_Normal = vec3(UV, 0.0) * uv_scale_alpha;
vec4 alpha_output_Normal = textureNoTile(alpha_Normal, vec2(scaled_uv_Normal.xy));
//Normal base
vec3 scaled_uv_2_Normal = vec3(UV, 0.0) * uv_scale_base;
vec4 Normal_base_output = textureNoTile(Normal_base, vec2(scaled_uv_2_Normal.xy));
//Normal red
vec3 scaled_uv_3_Normal = vec3(UV, 0.0) * uv_scale_R;
vec4 Normal_r_output = textureNoTile(Normal_r, vec2(scaled_uv_3_Normal.xy));
//Normal green
vec3 scaled_uv_4_Normal = vec3(UV, 0.0) * uv_scale_G;
vec4 Normal_g_output = textureNoTile(Normal_g, vec2(scaled_uv_4_Normal.xy));
//Normal blue
vec3 scaled_uv_5_Normal = vec3(UV, 0.0) * uv_scale_B;
vec4 Normal_b_output = textureNoTile(Normal_b, vec2(scaled_uv_5_Normal.xy));
//mixing operation
vec3 mix_stage_one_Normal = mix(vec3(Normal_base_output.xyz), vec3(Normal_r_output.xyz), vec3(x_component_Normal));
vec3 mix_stage_two_Normal = mix(mix_stage_one_Normal, vec3(Normal_g_output.xyz), vec3(y_component_Normal));
vec3 mix_stage_three_Normal = mix(mix_stage_two_Normal, vec3(Normal_b_output.xyz), vec3(z_component_Normal));
vec3 final_Normal_mix = mix(vec3(alpha_output_Normal.xyz), mix_stage_three_Normal, vec3(w_component_Normal));
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//final output ALBEDO
ALBEDO = final_albedo_mix;
if (Roughness_switch == true){
ROUGHNESS = final_roughness_mix.x; //alphachannel auto disabled
}
if (AO_switch == true){
AO = final_AO_mix.x;
}
if (Metalic_switch == true){
METALLIC = final_Metalic_mix.x;
}
if (Normal_switch == true){
NORMAL = final_Normal_mix;
NORMAL_MAP_DEPTH = 10.00;
}
}