ProjectArcade

1
/*
2
   Hyllian's xBR-lv2 Shader Accuracy (tweak by guest.r)
3

4
   Copyright (C) 2011-2015 Hyllian - sergiogdb@gmail.com
5

6
   Permission is hereby granted, free of charge, to any person obtaining a copy
7
   of this software and associated documentation files (the "Software"), to deal
8
   in the Software without restriction, including without limitation the rights
9
   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
   copies of the Software, and to permit persons to whom the Software is
11
   furnished to do so, subject to the following conditions:
12

13
   The above copyright notice and this permission notice shall be included in
14
   all copies or substantial portions of the Software.
15

16
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
   THE SOFTWARE.
23

24
   Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
25
*/
26

27
#ifdef GL_ES
28
precision mediump float;
29
precision mediump int;
30
#endif
31

32
#define CornerA      0     	//ON:1/OFF:0 / A, B, C, D are just different variants of corner rounding
33
#define CornerB      0     	//ON:1/OFF:0 / activate only one
34
#define CornerD      0     	//ON:1/OFF:0
35
//	CornerC                 //used as default if none of the above is defined
36

37
const float XBR_SCALE = 3.0;
38
const float lv2_cf    = 2.0;
39

40
const float coef          = 2.0;
41
const vec3  rgbw          = vec3(14.352, 28.176, 5.472);
42
const vec4  eq_threshold  = vec4(15.0, 15.0, 15.0, 15.0);
43

44
const vec4 Ao = vec4( 1.0, -1.0, -1.0, 1.0 );
45
const vec4 Bo = vec4( 1.0,  1.0, -1.0,-1.0 );
46
const vec4 Co = vec4( 1.5,  0.5, -0.5, 0.5 );
47
const vec4 Ax = vec4( 1.0, -1.0, -1.0, 1.0 );
48
const vec4 Bx = vec4( 0.5,  2.0, -0.5,-2.0 );
49
const vec4 Cx = vec4( 1.0,  1.0, -0.5, 0.0 );
50
const vec4 Ay = vec4( 1.0, -1.0, -1.0, 1.0 );
51
const vec4 By = vec4( 2.0,  0.5, -2.0,-0.5 );
52
const vec4 Cy = vec4( 2.0,  0.0, -1.0, 0.5 );
53
const vec4 Ci = vec4(0.25, 0.25, 0.25, 0.25);
54

55
uniform sampler2D sampler0;
56
uniform vec2 u_texelDelta;
57
uniform vec2 u_pixelDelta;
58
varying vec2 v_texcoord0;
59

60
// Difference between vector components.
61
vec4 df(vec4 A, vec4 B) {
62
	return vec4(abs(A-B));
63
}
64

65
// Compare two vectors and return their components are different.
66
vec4 diff(vec4 A, vec4 B) {
67
	return vec4(notEqual(A, B));
68
}
69

70
// Determine if two vector components are equal based on a threshold.
71
vec4 eq(vec4 A, vec4 B) {
72
	return (step(df(A, B), eq_threshold));
73
}
74

75
// Determine if two vector components are NOT equal based on a threshold.
76
vec4 neq(vec4 A, vec4 B) {
77
	return (vec4(1.0, 1.0, 1.0, 1.0) - eq(A, B));
78
}
79

80
float c_df(vec3 c1, vec3 c2) {
81
	vec3 df = abs(c1 - c2);
82
	return df.r + df.g + df.b;
83
}
84

85
void main() {
86

87
 bool upscale = u_texelDelta.x > (1.6 * u_pixelDelta.x);
88
 vec3 res = texture2D(sampler0, v_texcoord0.xy).xyz;
89

90
 // Let's skip the whole scaling if output size smaller than 1.6x of input size
91
 if (upscale) {
92

93
	vec4 edri, edr, edr_l, edr_u, px; // px = pixel, edr = edge detection rule
94
	vec4 irlv0, irlv1, irlv2l, irlv2u;
95
	vec4 fx, fx_l, fx_u; // inequations of straight lines.
96

97
	vec2 pS  = 1.0 / u_texelDelta.xy;
98
	vec2 fp  = fract(v_texcoord0.xy*pS.xy);
99
	vec2 TexCoord_0 = v_texcoord0.xy-fp*u_pixelDelta.xy;
100
	vec2 dx  = vec2(u_texelDelta.x,0.0);
101
	vec2 dy  = vec2(0.0,u_texelDelta.y);
102
	vec2 y2  = dy + dy; vec2 x2  = dx + dx;
103

104
	vec4 delta   = vec4(1.0/XBR_SCALE, 1.0/XBR_SCALE, 1.0/XBR_SCALE, 1.0/XBR_SCALE);
105
	vec4 delta_l = vec4(0.5/XBR_SCALE, 1.0/XBR_SCALE, 0.5/XBR_SCALE, 1.0/XBR_SCALE);
106
	vec4 delta_u = delta_l.yxwz;
107

108
	vec3 A  = texture2D(sampler0, TexCoord_0 -dx -dy	).xyz;
109
	vec3 B  = texture2D(sampler0, TexCoord_0	 -dy	).xyz;
110
	vec3 C  = texture2D(sampler0, TexCoord_0 +dx -dy	).xyz;
111
	vec3 D  = texture2D(sampler0, TexCoord_0 -dx		).xyz;
112
	vec3 E  = texture2D(sampler0, TexCoord_0		).xyz;
113
	vec3 F  = texture2D(sampler0, TexCoord_0 +dx		).xyz;
114
	vec3 G  = texture2D(sampler0, TexCoord_0 -dx +dy	).xyz;
115
	vec3 H  = texture2D(sampler0, TexCoord_0	 +dy	).xyz;
116
	vec3 I  = texture2D(sampler0, TexCoord_0 +dx +dy	).xyz;
117
	vec3 A1 = texture2D(sampler0, TexCoord_0	 -dx -y2).xyz;
118
	vec3 C1 = texture2D(sampler0, TexCoord_0	 +dx -y2).xyz;
119
	vec3 A0 = texture2D(sampler0, TexCoord_0 -x2	     -dy).xyz;
120
	vec3 G0 = texture2D(sampler0, TexCoord_0 -x2	     +dy).xyz;
121
	vec3 C4 = texture2D(sampler0, TexCoord_0 +x2	     -dy).xyz;
122
	vec3 I4 = texture2D(sampler0, TexCoord_0 +x2	     +dy).xyz;
123
	vec3 G5 = texture2D(sampler0, TexCoord_0	 -dx +y2).xyz;
124
	vec3 I5 = texture2D(sampler0, TexCoord_0	 +dx +y2).xyz;
125
	vec3 B1 = texture2D(sampler0, TexCoord_0	     -y2).xyz;
126
	vec3 D0 = texture2D(sampler0, TexCoord_0 -x2		).xyz;
127
	vec3 H5 = texture2D(sampler0, TexCoord_0	     +y2).xyz;
128
	vec3 F4 = texture2D(sampler0, TexCoord_0 +x2		).xyz;
129

130
	vec4 b  = vec4(dot(B ,rgbw), dot(D ,rgbw), dot(H ,rgbw), dot(F ,rgbw));
131
	vec4 c  = vec4(dot(C ,rgbw), dot(A ,rgbw), dot(G ,rgbw), dot(I ,rgbw));
132
	vec4 d  = b.yzwx;
133
	vec4 e  = vec4(dot(E,rgbw));
134
	vec4 f  = b.wxyz;
135
	vec4 g  = c.zwxy;
136
	vec4 h  = b.zwxy;
137
	vec4 i  = c.wxyz;
138
	vec4 i4 = vec4(dot(I4,rgbw), dot(C1,rgbw), dot(A0,rgbw), dot(G5,rgbw));
139
	vec4 i5 = vec4(dot(I5,rgbw), dot(C4,rgbw), dot(A1,rgbw), dot(G0,rgbw));
140
	vec4 h5 = vec4(dot(H5,rgbw), dot(F4,rgbw), dot(B1,rgbw), dot(D0,rgbw));
141
	vec4 f4 = h5.yzwx;
142

143
	// These inequations define the line below which interpolation occurs.
144
	fx   = (Ao*fp.y+Bo*fp.x); 
145
	fx_l = (Ax*fp.y+Bx*fp.x);
146
	fx_u = (Ay*fp.y+By*fp.x);
147
	irlv1 = irlv0 = diff(e,f) * diff(e,h);
148
#if(CornerA==0) // A takes priority skipping other corners
149
	#define SMOOTH_TIPS
150
	// Corner C also default if no other ones used
151
	irlv1   = (irlv0  * ( neq(f,b) * neq(f,c) + neq(h,d) * neq(h,g) + eq(e,i) * (neq(f,f4) * neq(f,i4) + neq(h,h5) * neq(h,i5)) + eq(e,g) + eq(e,c)) );
152
	int select1 = 0;
153
#if(CornerB==1) // Corner B
154
	irlv1   = (irlv0 * ( neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c) ) );
155
	select1 = 1;
156
#endif
157
#if(CornerD==1) // Corner D
158
	if (select1==0) {
159
		vec4 c1 = i4.yzwx;
160
		vec4 g0 = i5.wxyz;
161
		irlv1   = (irlv0  *  ( neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c) ) * (diff(f,f4) * diff(f,i) + diff(h,h5) * diff(h,i) + diff(h,g) + diff(f,c) + eq(b,c1) * eq(d,g0)));
162
	}
163
#endif
164
#endif
165
	irlv2l = diff(e,g) * diff(d,g);
166
	irlv2u = diff(e,c) * diff(b,c);
167

168
	vec4 fx45i = clamp((fx   + delta   -Co - Ci) / (2.0*delta  ), 0.0, 1.0);
169
	vec4 fx45  = clamp((fx   + delta   -Co     ) / (2.0*delta  ), 0.0, 1.0);
170
	vec4 fx30  = clamp((fx_l + delta_l -Cx     ) / (2.0*delta_l), 0.0, 1.0);
171
	vec4 fx60  = clamp((fx_u + delta_u -Cy     ) / (2.0*delta_u), 0.0, 1.0);
172
	vec4 w1, w2;
173

174
	w1.x = dot(abs(E-C),rgbw) + dot(abs(E-G),rgbw) + dot(abs(I-H5),rgbw) + dot(abs(I-F4),rgbw) + 4.0*dot(abs(H-F),rgbw);
175
	w1.y = dot(abs(E-A),rgbw) + dot(abs(E-I),rgbw) + dot(abs(C-F4),rgbw) + dot(abs(C-B1),rgbw) + 4.0*dot(abs(F-B),rgbw);  
176
	w1.z = dot(abs(E-G),rgbw) + dot(abs(E-C),rgbw) + dot(abs(A-B1),rgbw) + dot(abs(A-D0),rgbw) + 4.0*dot(abs(B-D),rgbw);
177
	w1.w = dot(abs(E-I),rgbw) + dot(abs(E-A),rgbw) + dot(abs(G-D0),rgbw) + dot(abs(G-H5),rgbw) + 4.0*dot(abs(D-H),rgbw);
178
	w2.x = dot(abs(H-D),rgbw) + dot(abs(H-I5),rgbw) + dot(abs(F-I4),rgbw) + dot(abs(F-B),rgbw) + 4.0*dot(abs(E-I),rgbw);
179
	w2.y = dot(abs(F-H),rgbw) + dot(abs(F-C4),rgbw) + dot(abs(B-C1),rgbw) + dot(abs(B-D),rgbw) + 4.0*dot(abs(E-C),rgbw);
180
	w2.z = dot(abs(B-F),rgbw) + dot(abs(B-A1),rgbw) + dot(abs(D-A0),rgbw) + dot(abs(D-H),rgbw) + 4.0*dot(abs(E-A),rgbw); 
181
	w2.w = dot(abs(D-B),rgbw) + dot(abs(D-G0),rgbw) + dot(abs(H-G5),rgbw) + dot(abs(H-F),rgbw) + 4.0*dot(abs(E-G),rgbw);
182

183
	edri  = step(w1, w2) * irlv0;
184
	edr   = step(w1 + vec4(0.1, 0.1, 0.1, 0.1), w2) * step(vec4(0.5, 0.5, 0.5, 0.5), irlv1);
185

186
	w1.x = dot(abs(F-G),rgbw); w1.y = dot(abs(B-I),rgbw); w1.z = dot(abs(D-C),rgbw); w1.w = dot(abs(H-A),rgbw);
187
	w2.x = dot(abs(H-C),rgbw); w2.y = dot(abs(F-A),rgbw); w2.z = dot(abs(B-G),rgbw); w2.w = dot(abs(D-I),rgbw);
188

189
	edr_l = step( lv2_cf*w1, w2 ) * irlv2l * edr;
190
	edr_u = step( lv2_cf*w2, w1 ) * irlv2u * edr;
191

192
	fx45  = edr   * fx45;
193
	fx30  = edr_l * fx30;
194
	fx60  = edr_u * fx60;
195
	fx45i = edri  * fx45i;
196

197
	w1.x = dot(abs(E-F),rgbw); w1.y = dot(abs(E-B),rgbw); w1.z = dot(abs(E-D),rgbw); w1.w = dot(abs(E-H),rgbw);
198
	w2.x = dot(abs(E-H),rgbw); w2.y = dot(abs(E-F),rgbw); w2.z = dot(abs(E-B),rgbw); w2.w = dot(abs(E-D),rgbw);
199

200
	px = step(w1, w2);
201
#ifdef SMOOTH_TIPS
202
	vec4 maximos = max(max(fx30, fx60), max(fx45, fx45i));
203
#else
204
	vec4 maximos = max(max(fx30, fx60), fx45);
205
#endif
206
	vec3 res1 = E;
207
	res1 = mix(res1, mix(H, F, px.x), maximos.x);
208
	res1 = mix(res1, mix(B, D, px.z), maximos.z);
209

210
	vec3 res2 = E;
211
	res2 = mix(res2, mix(F, B, px.y), maximos.y);
212
	res2 = mix(res2, mix(D, H, px.w), maximos.w);
213

214
	res = mix(res1, res2, step(c_df(E, res1), c_df(E, res2)));
215
 }
216
	gl_FragColor.xyz = res;
217
	gl_FragColor.a = 1.0;
218
}
219