Zachary Levy
108 lines
4.5 KiB
GLSL
108 lines
4.5 KiB
GLSL
#version 450 core
|
|
|
|
// ---------- Vertex attributes (used in all modes) ----------
|
|
layout(location = 0) in vec2 v_position;
|
|
layout(location = 1) in vec2 v_uv;
|
|
layout(location = 2) in vec4 v_color;
|
|
|
|
// ---------- Outputs to fragment shader ----------
|
|
layout(location = 0) out mediump vec4 f_color;
|
|
layout(location = 1) out vec2 f_local_or_uv;
|
|
layout(location = 2) out vec4 f_params;
|
|
layout(location = 3) out vec4 f_params2;
|
|
layout(location = 4) flat out uint f_flags;
|
|
|
|
layout(location = 6) flat out vec4 f_uv_rect;
|
|
layout(location = 7) flat out uvec4 f_effects;
|
|
|
|
// ---------- Uniforms (single block — avoids spirv-cross reordering on Metal) ----------
|
|
// Mode values mirror Core_2D_Mode in core_2d.odin:
|
|
// 0 = Tessellated v_position is in logical pixels; shader scales by dpi_scale.
|
|
// 1 = SDF v_position is a unit-quad corner; world-space comes from
|
|
// primitives[gl_InstanceIndex].bounds (logical px). Shader
|
|
// scales by dpi_scale.
|
|
// 2 = Text v_position is in *physical* pixels already (the CPU baked
|
|
// the anchor snap and SDL_ttf glyph offsets, both physical).
|
|
// Shader must NOT rescale.
|
|
layout(set = 1, binding = 0) uniform Uniforms {
|
|
mat4 projection;
|
|
float dpi_scale;
|
|
uint mode;
|
|
};
|
|
|
|
// ---------- SDF primitive storage buffer ----------
|
|
// Mirrors the CPU-side Core_2D_Primitive in core_2d.odin. Named with the
|
|
// subsystem prefix so a project-wide grep on the type name matches both the GLSL
|
|
// declaration and the Odin declaration.
|
|
struct Core_2D_Primitive {
|
|
vec4 bounds; // 0-15
|
|
uint color; // 16-19
|
|
uint flags; // 20-23
|
|
uint rotation_sc; // 24-27: packed f16 pair (sin, cos)
|
|
float _pad; // 28-31
|
|
vec4 params; // 32-47
|
|
vec4 params2; // 48-63
|
|
vec4 uv_rect; // 64-79: texture UV coordinates (read when .Textured)
|
|
uvec4 effects; // 80-95: gradient/outline parameters (read when .Gradient/.Outline)
|
|
};
|
|
|
|
layout(std430, set = 0, binding = 0) readonly buffer Core_2D_Primitives {
|
|
Core_2D_Primitive primitives[];
|
|
};
|
|
|
|
// ---------- Entry point ----------
|
|
void main() {
|
|
if (mode == 1u) {
|
|
// ---- Mode 1: SDF instanced quads ----
|
|
Core_2D_Primitive p = primitives[gl_InstanceIndex];
|
|
|
|
vec2 corner = v_position; // unit quad corners: (0,0)-(1,1)
|
|
vec2 world_pos = mix(p.bounds.xy, p.bounds.zw, corner);
|
|
vec2 center = 0.5 * (p.bounds.xy + p.bounds.zw);
|
|
|
|
// Compute shape-local position. Apply inverse rotation here in the vertex
|
|
// shader; the rasterizer interpolates the rotated values across the quad,
|
|
// which is mathematically equivalent to per-fragment rotation under 2D ortho
|
|
// projection. Frees one fragment-shader varying and per-pixel rotation math.
|
|
vec2 local = (world_pos - center) * dpi_scale;
|
|
uint flags = (p.flags >> 8u) & 0xFFu;
|
|
if ((flags & 16u) != 0u) {
|
|
// Rotated flag (bit 4); rotation_sc holds packed f16 (sin, cos).
|
|
// Inverse rotation matrix R(-angle) = [[cos, sin], [-sin, cos]].
|
|
vec2 sc = unpackHalf2x16(p.rotation_sc);
|
|
local = vec2(sc.y * local.x + sc.x * local.y,
|
|
-sc.x * local.x + sc.y * local.y);
|
|
}
|
|
|
|
f_color = unpackUnorm4x8(p.color);
|
|
f_local_or_uv = local; // shape-local physical pixels (rotated if .Rotated set)
|
|
f_params = p.params;
|
|
f_params2 = p.params2;
|
|
f_flags = p.flags;
|
|
f_uv_rect = p.uv_rect;
|
|
f_effects = p.effects;
|
|
|
|
gl_Position = projection * vec4(world_pos * dpi_scale, 0.0, 1.0);
|
|
} else {
|
|
// ---- Mode 0 (Tessellated) and Mode 2 (Text) ----
|
|
// Both feed the raw-vertex pipeline (kind 0 in the fragment shader).
|
|
// They differ only in what coord space `v_position` is in:
|
|
// Mode 0 — logical pixels, scale here by dpi_scale.
|
|
// Mode 2 — physical pixels (CPU pre-scaled and snapped to integer
|
|
// physical pixels for atlas-aligned bilinear sampling).
|
|
// Do NOT rescale.
|
|
// `mode` is uniform across the workgroup, so the select compiles to a
|
|
// uniform-controlled branch with no SIMT divergence cost.
|
|
f_color = v_color;
|
|
f_local_or_uv = v_uv;
|
|
f_params = vec4(0.0);
|
|
f_params2 = vec4(0.0);
|
|
f_flags = 0u;
|
|
f_uv_rect = vec4(0.0);
|
|
f_effects = uvec4(0);
|
|
|
|
vec2 pos = (mode == 2u) ? v_position : (v_position * dpi_scale);
|
|
gl_Position = projection * vec4(pos, 0.0, 1.0);
|
|
}
|
|
}
|