216 lines
9.1 KiB
Plaintext
216 lines
9.1 KiB
Plaintext
|
#version 440 core
|
||
|
|
|
||
|
|
#include <globals.glsl>
|
||
|
|
#include <constants.glsl>
|
||
|
|
|
||
|
|
layout(location = 0) in vec2 f_uv;
|
||
|
|
layout(location = 1) in vec4 f_color;
|
||
|
|
layout(location = 2) flat in vec2 f_scale;
|
||
|
|
layout(location = 3) flat in uint f_mode;
|
||
|
|
|
||
|
|
layout (std140, set = 1, binding = 0)
|
||
|
|
uniform u_locals {
|
||
|
|
vec4 w_pos;
|
||
|
|
};
|
||
|
|
|
||
|
|
layout(set = 2, binding = 0)
|
||
|
|
uniform texture2D t_tex;
|
||
|
|
layout(set = 2, binding = 1)
|
||
|
|
uniform sampler s_tex;
|
||
|
|
layout (std140, set = 2, binding = 2)
|
||
|
|
uniform tex_locals {
|
||
|
|
uvec2 texture_size;
|
||
|
|
};
|
||
|
|
|
||
|
|
layout(location = 0) out vec4 tgt_color;
|
||
|
|
|
||
|
|
// Adjusts the provided uv value to account for coverage of pixels from the
|
||
|
|
// sampled texture by the current fragment when upscaling.
|
||
|
|
//
|
||
|
|
// * `pos` - Position in the sampled texture in pixel coordinates. This is
|
||
|
|
// where the center of the current fragment lies on the sampled texture.
|
||
|
|
// * `scale` - Scaling of pixels from the sampled texture to the render target.
|
||
|
|
// This is the amount of fragments that each pixel from the sampled texture
|
||
|
|
// covers.
|
||
|
|
float upscale_adjust(float pos, float scale) {
|
||
|
|
// To retain crisp borders of upscaled pixel art, images are upscaled
|
||
|
|
// following the algorithm outlined here:
|
||
|
|
//
|
||
|
|
// https://csantosbh.wordpress.com/2014/01/25/manual-texture-filtering-for-pixelated-games-in-webgl/
|
||
|
|
//
|
||
|
|
// `min(x * scale, 0.5) + max((x - 1.0) * scale, 0.0)`
|
||
|
|
//
|
||
|
|
float frac = fract(pos);
|
||
|
|
// Right of nearest pixel in the sampled texture.
|
||
|
|
float base = floor(pos);
|
||
|
|
// This will be 0.5 when the current fragment lies entirely inside a pixel
|
||
|
|
// in the sampled texture.
|
||
|
|
float adjustment = min(frac * scale, 0.5) + max((frac - 1.0) * scale + 0.5, 0.0);
|
||
|
|
return base + adjustment;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Computes info needed for downscaling using two samples in a single
|
||
|
|
// dimension. This info includes the two position to sample at (called
|
||
|
|
// `offsets` even though they aren't actually offsets from the supplied
|
||
|
|
// position) and the `weights` to multiply each of those samples by before
|
||
|
|
// combining them.
|
||
|
|
//
|
||
|
|
// See `upscale_adjust` for semantics of `pos` and `scale` parameters.
|
||
|
|
//
|
||
|
|
// Ouput via `weights` and `offsets` parameters.
|
||
|
|
void downscale_params(float pos, float scale, out vec2 weights, out vec2 offsets) {
|
||
|
|
// For `scale` 0.33333..1.0 we round to the nearest pixel edge and split
|
||
|
|
// there. We compute the length of each side. Then the sampling point is
|
||
|
|
// computed as this distance from the split point via this formula where
|
||
|
|
// `l` is the length of that side of split:
|
||
|
|
//
|
||
|
|
// `1.5 - (1.0 / max(l, 1.0))`
|
||
|
|
//
|
||
|
|
// For `scale` ..0.3333 the current fragment can potentially span more than
|
||
|
|
// 4 pixels (within a single dimension) in the sampled texture. So we can't
|
||
|
|
// perfectly compute the contribution of each covered pixel in the sampled
|
||
|
|
// texture with only 2 samples (along each dimension). Thus, we fallback to
|
||
|
|
// an imperfect technique of just sampling 1 pixel length from the center
|
||
|
|
// on each side of the nearest pixel edge. An alternative might be to
|
||
|
|
// pre-compute mipmap levels that could be sampled from, although this
|
||
|
|
// could interact poorly with the atlas.
|
||
|
|
if (scale > (1.0 / 3.0)) {
|
||
|
|
// Width of the fragment in terms of pixels in the sampled texture.
|
||
|
|
float width = 1.0 / scale;
|
||
|
|
// Right side of the fragment in the sampled texture.
|
||
|
|
float right = pos - width / 2.0;
|
||
|
|
float split = round(pos);
|
||
|
|
float right_len = split - right;
|
||
|
|
float left_len = width - right_len;
|
||
|
|
float right_sample_offset = 1.5 - (1.0 / max(right_len, 1.0));
|
||
|
|
float left_sample_offset = 1.5 - (1.0 / max(left_len, 1.0));
|
||
|
|
offsets = vec2(split) + vec2(-right_sample_offset, left_sample_offset);
|
||
|
|
weights = vec2(right_len, left_len) / width;
|
||
|
|
} else {
|
||
|
|
offsets = round(pos) + vec2(-1.0, 1.0);
|
||
|
|
// We split in the middle so weights for both sides are the same.
|
||
|
|
weights = vec2(0.5);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 1 sample
|
||
|
|
vec4 upscale_xy(vec2 uv_pixel, vec2 scale) {
|
||
|
|
// When slowly panning something (e.g. the map), a very small amount of
|
||
|
|
// wobbling is still observable (not as much as nearest sampling). It
|
||
|
|
// is possible to eliminate this by making the edges slightly blurry by
|
||
|
|
// lowering the scale a bit here. However, this does make edges little
|
||
|
|
// less crisp and can cause bleeding in from other images packed into
|
||
|
|
// the atlas in the current setup.
|
||
|
|
vec2 adjusted = vec2(upscale_adjust(uv_pixel.x, scale.x), upscale_adjust(uv_pixel.y, scale.y));
|
||
|
|
// Convert back to 0.0..1.0 by dividing by texture size.
|
||
|
|
vec2 uv = adjusted / texture_size;
|
||
|
|
return textureLod(sampler2D(t_tex, s_tex), uv, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 2 samples
|
||
|
|
vec4 upscale_x_downscale_y(vec2 uv_pixel, vec2 scale) {
|
||
|
|
float x_adjusted = upscale_adjust(uv_pixel.x, scale.x);
|
||
|
|
vec2 weights, offsets;
|
||
|
|
downscale_params(uv_pixel.y, scale.y, weights, offsets);
|
||
|
|
vec2 uv0 = vec2(x_adjusted, offsets[0]) / texture_size;
|
||
|
|
vec2 uv1 = vec2(x_adjusted, offsets[1]) / texture_size;
|
||
|
|
vec4 s0 = textureLod(sampler2D(t_tex, s_tex), uv0, 0);
|
||
|
|
vec4 s1 = textureLod(sampler2D(t_tex, s_tex), uv1, 0);
|
||
|
|
return s0 * weights[0] + s1 * weights[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
// 2 samples
|
||
|
|
vec4 downscale_x_upscale_y(vec2 uv_pixel, vec2 scale) {
|
||
|
|
float y_adjusted = upscale_adjust(uv_pixel.y, scale.y);
|
||
|
|
vec2 weights, offsets;
|
||
|
|
downscale_params(uv_pixel.x, scale.x, weights, offsets);
|
||
|
|
vec2 uv0 = vec2(offsets[0], y_adjusted) / texture_size;
|
||
|
|
vec2 uv1 = vec2(offsets[1], y_adjusted) / texture_size;
|
||
|
|
vec4 s0 = textureLod(sampler2D(t_tex, s_tex), uv0, 0);
|
||
|
|
vec4 s1 = textureLod(sampler2D(t_tex, s_tex), uv1, 0);
|
||
|
|
return s0 * weights[0] + s1 * weights[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
// 4 samples
|
||
|
|
vec4 downscale_xy(vec2 uv_pixel, vec2 scale) {
|
||
|
|
vec2 weights_x, offsets_x, weights_y, offsets_y;
|
||
|
|
downscale_params(uv_pixel.x, scale.x, weights_x, offsets_x);
|
||
|
|
downscale_params(uv_pixel.y, scale.y, weights_y, offsets_y);
|
||
|
|
vec2 uv0 = vec2(offsets_x[0], offsets_y[0]) / texture_size;
|
||
|
|
vec2 uv1 = vec2(offsets_x[1], offsets_y[0]) / texture_size;
|
||
|
|
vec2 uv2 = vec2(offsets_x[0], offsets_y[1]) / texture_size;
|
||
|
|
vec2 uv3 = vec2(offsets_x[1], offsets_y[1]) / texture_size;
|
||
|
|
vec4 s0 = textureLod(sampler2D(t_tex, s_tex), uv0, 0);
|
||
|
|
vec4 s1 = textureLod(sampler2D(t_tex, s_tex), uv1, 0);
|
||
|
|
vec4 s2 = textureLod(sampler2D(t_tex, s_tex), uv2, 0);
|
||
|
|
vec4 s3 = textureLod(sampler2D(t_tex, s_tex), uv3, 0);
|
||
|
|
vec4 s01 = s0 * weights_x[0] + s1 * weights_x[1];
|
||
|
|
vec4 s23 = s2 * weights_x[0] + s3 * weights_x[1];
|
||
|
|
// Useful to visualize things below the limit where downscaling is supposed
|
||
|
|
// to be perfectly accurate.
|
||
|
|
/*if (scale.x < (1.0 / 3.0)) {
|
||
|
|
return vec4(1, 0, 0, 1);
|
||
|
|
}*/
|
||
|
|
return s01 * weights_y[0] + s23 * weights_y[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
// Text
|
||
|
|
if (f_mode == uint(0)) {
|
||
|
|
// NOTE: This now uses linear filter since all `Texture::new_dynamic`
|
||
|
|
// was changed to this by default. Glyphs are usually rasterized to be
|
||
|
|
// pretty close to the target size (so the filter change may have no
|
||
|
|
// effect), but there are thresholds within which the same rasterized
|
||
|
|
// glyph will be re-used. I wasn't able to observe any differences.
|
||
|
|
vec2 uv = f_uv;
|
||
|
|
#ifdef EXPERIMENTAL_UINEARESTSCALING
|
||
|
|
uv = (floor(uv * texture_size) + 0.5) / texture_size;
|
||
|
|
#endif
|
||
|
|
tgt_color = f_color * vec4(1.0, 1.0, 1.0, textureLod(sampler2D(t_tex, s_tex), uv, 0).a);
|
||
|
|
// Image
|
||
|
|
// HACK: bit 0 is set for both ordinary and north-facing images.
|
||
|
|
} else if ((f_mode & uint(1)) == uint(1)) {
|
||
|
|
// NOTE: We don't have to account for bleeding over the border of an image
|
||
|
|
// due to how the ui currently handles rendering images. Currently, any
|
||
|
|
// edges of an image being rendered that don't line up with a pixel are
|
||
|
|
// snapped to a pixel, so we will never render any pixels containing an
|
||
|
|
// image that lie partly outside that image (and thus the sampling here
|
||
|
|
// will never try to sample outside an image). So we don't have to
|
||
|
|
// worry about bleeding in the atlas and/or what the border behavior
|
||
|
|
// should be.
|
||
|
|
|
||
|
|
// Convert to sampled pixel coordinates.
|
||
|
|
vec2 uv_pixel = f_uv * texture_size;
|
||
|
|
vec4 image_color;
|
||
|
|
#ifdef EXPERIMENTAL_UINEARESTSCALING
|
||
|
|
vec2 uv = (floor(uv_pixel) + 0.5) / texture_size;
|
||
|
|
image_color = textureLod(sampler2D(t_tex, s_tex), uv, 0);
|
||
|
|
#else
|
||
|
|
if (f_scale.x >= 1.0) {
|
||
|
|
if (f_scale.y >= 1.0) {
|
||
|
|
image_color = upscale_xy(uv_pixel, f_scale);
|
||
|
|
} else {
|
||
|
|
image_color = upscale_x_downscale_y(uv_pixel, f_scale);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (f_scale.y >= 1.0) {
|
||
|
|
image_color = downscale_x_upscale_y(uv_pixel, f_scale);
|
||
|
|
} else {
|
||
|
|
image_color = downscale_xy(uv_pixel, f_scale);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// un-premultiply alpha (linear filtering above requires alpha to be
|
||
|
|
// pre-multiplied)
|
||
|
|
if (image_color.a > 0.001) {
|
||
|
|
image_color.rgb /= image_color.a;
|
||
|
|
}
|
||
|
|
|
||
|
|
tgt_color = f_color * image_color;
|
||
|
|
// 2D Geometry
|
||
|
|
} else if (f_mode == uint(2)) {
|
||
|
|
tgt_color = f_color;
|
||
|
|
}
|
||
|
|
}
|