ddidderr
568ce784f9
Ports the terminal-independent half of ZIG/src/renderer (OpenGL only): - opengl/*: buffers, frames, pipelines, render passes, samplers, targets, textures and the OpenGL GraphicsAPI backend on top of glow; the GTK GLArea glue is replaced by a get_proc_address loader closure - the GLSL shaders, copied verbatim and embedded; uniform/vertex structs as bytemuck Pod types with std140 offsets asserted in tests - shadertoy custom shaders converted with naga (GLSL in -> validate -> GLSL 430 out) instead of glslang + spirv-cross - size (screen/grid/cell/padding math), cursor style logic, backend health, options and message types The crate opts into unsafe_code = "deny"; unsafe glow calls live only in opengl/gl.rs. A headless EGL integration test builds every pipeline and the converted shadertoy shaders on Mesa and reads back rendered pixels. Note: Zig's shadertoy Uniforms order the selection background/foreground colors opposite to the GLSL block (likely an upstream bug); kept as in Zig for parity and recorded in the notes. Deferred to the next renderer pass: generic, cell, image, link, row, State, Thread, Overlay (need terminal render state). Test Plan: - cargo test -p ghostty-renderer (33 tests incl. tests/egl_headless.rs)
64 lines
1.9 KiB
GLSL
64 lines
1.9 KiB
GLSL
#include "common.glsl"
|
|
|
|
// Position the FragCoord origin to the upper left
|
|
// so as to align with our texture's directionality.
|
|
layout(origin_upper_left) in vec4 gl_FragCoord;
|
|
|
|
layout(binding = 0) uniform sampler2D image;
|
|
|
|
flat in vec4 bg_color;
|
|
flat in vec2 offset;
|
|
flat in vec2 scale;
|
|
flat in float opacity;
|
|
flat in uint repeat;
|
|
|
|
layout(location = 0) out vec4 out_FragColor;
|
|
|
|
void main() {
|
|
bool use_linear_blending = (bools & USE_LINEAR_BLENDING) != 0;
|
|
|
|
// Our texture coordinate is based on the screen position, offset by the
|
|
// dest rect origin, and scaled by the ratio between the dest rect size
|
|
// and the original texture size, which effectively scales the original
|
|
// size of the texture to the dest rect size.
|
|
vec2 tex_coord = (gl_FragCoord.xy - offset) * scale;
|
|
|
|
vec2 tex_size = textureSize(image, 0);
|
|
|
|
// If we need to repeat the texture, wrap the coordinates.
|
|
if (repeat != 0) {
|
|
tex_coord = mod(mod(tex_coord, tex_size) + tex_size, tex_size);
|
|
}
|
|
|
|
vec4 rgba;
|
|
// If we're out of bounds, we have no color,
|
|
// otherwise we sample the texture for it.
|
|
if (any(lessThan(tex_coord, vec2(0.0))) ||
|
|
any(greaterThan(tex_coord, tex_size)))
|
|
{
|
|
rgba = vec4(0.0);
|
|
} else {
|
|
// We divide by the texture size to normalize for sampling.
|
|
rgba = texture(image, tex_coord / tex_size);
|
|
|
|
if (!use_linear_blending) {
|
|
rgba = unlinearize(rgba);
|
|
}
|
|
|
|
rgba.rgb *= rgba.a;
|
|
}
|
|
|
|
// Multiply it by the configured opacity, but cap it at
|
|
// the value that will make it fully opaque relative to
|
|
// the background color alpha, so it isn't overexposed.
|
|
rgba *= min(opacity, 1.0 / bg_color.a);
|
|
|
|
// Blend it on to a fully opaque version of the background color.
|
|
rgba += max(vec4(0.0), vec4(bg_color.rgb, 1.0) * vec4(1.0 - rgba.a));
|
|
|
|
// Multiply everything by the background color alpha.
|
|
rgba *= bg_color.a;
|
|
|
|
out_FragColor = rgba;
|
|
}
|