998 lines
28 KiB
Odin
998 lines
28 KiB
Odin
package draw
|
||
|
||
import "core:math"
|
||
|
||
SMOOTH_CIRCLE_ERROR_RATE :: 0.1
|
||
|
||
// ----- Adaptive tessellation ----
|
||
|
||
auto_segments :: proc(radius: f32, arc_degrees: f32) -> int {
|
||
if radius <= 0 do return 4
|
||
phys_radius := radius * GLOB.dpi_scaling
|
||
acos_arg := clamp(2 * math.pow(1 - SMOOTH_CIRCLE_ERROR_RATE / phys_radius, 2) - 1, -1, 1)
|
||
th := math.acos(acos_arg)
|
||
if th <= 0 do return 4
|
||
full_circle_segs := int(math.ceil(2 * math.PI / th))
|
||
segs := int(f32(full_circle_segs) * arc_degrees / 360.0)
|
||
min_segs := max(int(math.ceil(f64(arc_degrees / 90.0))), 4)
|
||
return max(segs, min_segs)
|
||
}
|
||
|
||
// ----- Internal helpers ----
|
||
|
||
@(private = "file")
|
||
extrude_line :: proc(
|
||
start, end_pos: [2]f32,
|
||
thick: f32,
|
||
color: Color,
|
||
vertices: []Vertex,
|
||
offset: int,
|
||
) -> int {
|
||
direction := end_pos - start
|
||
dx := direction[0]
|
||
dy := direction[1]
|
||
length := math.sqrt(dx * dx + dy * dy)
|
||
if length < 0.0001 do return 0
|
||
|
||
scale := thick / (2 * length)
|
||
perpendicular := [2]f32{-dy * scale, dx * scale}
|
||
|
||
p0 := start + perpendicular
|
||
p1 := start - perpendicular
|
||
p2 := end_pos - perpendicular
|
||
p3 := end_pos + perpendicular
|
||
|
||
vertices[offset + 0] = sv(p0, color)
|
||
vertices[offset + 1] = sv(p1, color)
|
||
vertices[offset + 2] = sv(p2, color)
|
||
vertices[offset + 3] = sv(p0, color)
|
||
vertices[offset + 4] = sv(p2, color)
|
||
vertices[offset + 5] = sv(p3, color)
|
||
|
||
return 6
|
||
}
|
||
|
||
// Create a vertex for solid-color shape drawing (no texture, UV defaults to zero).
|
||
@(private = "file")
|
||
sv :: proc(pos: [2]f32, color: Color) -> Vertex {
|
||
return Vertex{position = pos, color = color}
|
||
}
|
||
|
||
@(private = "file")
|
||
emit_rect :: proc(x, y, w, h: f32, color: Color, vertices: []Vertex, offset: int) {
|
||
vertices[offset + 0] = sv({x, y}, color)
|
||
vertices[offset + 1] = sv({x + w, y}, color)
|
||
vertices[offset + 2] = sv({x + w, y + h}, color)
|
||
vertices[offset + 3] = sv({x, y}, color)
|
||
vertices[offset + 4] = sv({x + w, y + h}, color)
|
||
vertices[offset + 5] = sv({x, y + h}, color)
|
||
}
|
||
|
||
// ----- Drawing functions ----
|
||
|
||
pixel :: proc(layer: ^Layer, pos: [2]f32, color: Color) {
|
||
vertices: [6]Vertex
|
||
emit_rect(pos[0], pos[1], 1, 1, color, vertices[:], 0)
|
||
prepare_shape(layer, vertices[:])
|
||
}
|
||
|
||
rectangle_gradient :: proc(
|
||
layer: ^Layer,
|
||
rect: Rectangle,
|
||
top_left, top_right, bottom_left, bottom_right: Color,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
vertices := make([]Vertex, 6, temp_allocator)
|
||
|
||
tl := [2]f32{rect.x, rect.y}
|
||
tr := [2]f32{rect.x + rect.w, rect.y}
|
||
br := [2]f32{rect.x + rect.w, rect.y + rect.h}
|
||
bl := [2]f32{rect.x, rect.y + rect.h}
|
||
|
||
vertices[0] = sv(tl, top_left)
|
||
vertices[1] = sv(tr, top_right)
|
||
vertices[2] = sv(br, bottom_right)
|
||
vertices[3] = sv(tl, top_left)
|
||
vertices[4] = sv(br, bottom_right)
|
||
vertices[5] = sv(bl, bottom_left)
|
||
|
||
prepare_shape(layer, vertices)
|
||
}
|
||
|
||
circle_sector :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius: f32,
|
||
start_angle, end_angle: f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
segments: int = 0,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
arc_length := abs(end_angle - start_angle)
|
||
segs := segments > 0 ? segments : auto_segments(radius, arc_length)
|
||
|
||
vertex_count := segs * 3
|
||
vertices := make([]Vertex, vertex_count, temp_allocator)
|
||
|
||
start_rad := math.to_radians(start_angle)
|
||
end_rad := math.to_radians(end_angle)
|
||
step_angle := (end_rad - start_rad) / f32(segs)
|
||
|
||
if !needs_transform(origin, rotation) {
|
||
for i in 0 ..< segs {
|
||
current_angle := start_rad + step_angle * f32(i)
|
||
next_angle := start_rad + step_angle * f32(i + 1)
|
||
|
||
edge_current := center + [2]f32{math.cos(current_angle) * radius, math.sin(current_angle) * radius}
|
||
edge_next := center + [2]f32{math.cos(next_angle) * radius, math.sin(next_angle) * radius}
|
||
|
||
idx := i * 3
|
||
vertices[idx + 0] = sv(center, color)
|
||
vertices[idx + 1] = sv(edge_next, color)
|
||
vertices[idx + 2] = sv(edge_current, color)
|
||
}
|
||
} else {
|
||
xform := build_pivot_rot(center, origin, rotation)
|
||
center_local := [2]f32{0, 0}
|
||
for i in 0 ..< segs {
|
||
current_angle := start_rad + step_angle * f32(i)
|
||
next_angle := start_rad + step_angle * f32(i + 1)
|
||
|
||
edge_current := [2]f32{math.cos(current_angle) * radius, math.sin(current_angle) * radius}
|
||
edge_next := [2]f32{math.cos(next_angle) * radius, math.sin(next_angle) * radius}
|
||
|
||
idx := i * 3
|
||
vertices[idx + 0] = sv(apply_transform(xform, center_local), color)
|
||
vertices[idx + 1] = sv(apply_transform(xform, edge_next), color)
|
||
vertices[idx + 2] = sv(apply_transform(xform, edge_current), color)
|
||
}
|
||
}
|
||
|
||
prepare_shape(layer, vertices)
|
||
}
|
||
|
||
circle_gradient :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius: f32,
|
||
inner, outer: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
segments: int = 0,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
segs := segments > 0 ? segments : auto_segments(radius, 360)
|
||
|
||
vertex_count := segs * 3
|
||
vertices := make([]Vertex, vertex_count, temp_allocator)
|
||
|
||
step_angle := math.TAU / f32(segs)
|
||
|
||
if !needs_transform(origin, rotation) {
|
||
for i in 0 ..< segs {
|
||
current_angle := step_angle * f32(i)
|
||
next_angle := step_angle * f32(i + 1)
|
||
|
||
edge_current := center + [2]f32{math.cos(current_angle) * radius, math.sin(current_angle) * radius}
|
||
edge_next := center + [2]f32{math.cos(next_angle) * radius, math.sin(next_angle) * radius}
|
||
|
||
idx := i * 3
|
||
vertices[idx + 0] = sv(center, inner)
|
||
vertices[idx + 1] = sv(edge_next, outer)
|
||
vertices[idx + 2] = sv(edge_current, outer)
|
||
}
|
||
} else {
|
||
xform := build_pivot_rot(center, origin, rotation)
|
||
center_local := [2]f32{0, 0}
|
||
for i in 0 ..< segs {
|
||
current_angle := step_angle * f32(i)
|
||
next_angle := step_angle * f32(i + 1)
|
||
|
||
edge_current := [2]f32{math.cos(current_angle) * radius, math.sin(current_angle) * radius}
|
||
edge_next := [2]f32{math.cos(next_angle) * radius, math.sin(next_angle) * radius}
|
||
|
||
idx := i * 3
|
||
vertices[idx + 0] = sv(apply_transform(xform, center_local), inner)
|
||
vertices[idx + 1] = sv(apply_transform(xform, edge_next), outer)
|
||
vertices[idx + 2] = sv(apply_transform(xform, edge_current), outer)
|
||
}
|
||
}
|
||
|
||
prepare_shape(layer, vertices)
|
||
}
|
||
|
||
triangle :: proc(
|
||
layer: ^Layer,
|
||
v1, v2, v3: [2]f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
) {
|
||
if !needs_transform(origin, rotation) {
|
||
vertices := [3]Vertex{sv(v1, color), sv(v2, color), sv(v3, color)}
|
||
prepare_shape(layer, vertices[:])
|
||
return
|
||
}
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
xform := build_pivot_rot(mn, origin, rotation)
|
||
local_v1 := v1 - mn
|
||
local_v2 := v2 - mn
|
||
local_v3 := v3 - mn
|
||
vertices := [3]Vertex {
|
||
sv(apply_transform(xform, local_v1), color),
|
||
sv(apply_transform(xform, local_v2), color),
|
||
sv(apply_transform(xform, local_v3), color),
|
||
}
|
||
prepare_shape(layer, vertices[:])
|
||
}
|
||
|
||
triangle_lines :: proc(
|
||
layer: ^Layer,
|
||
v1, v2, v3: [2]f32,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
vertices := make([]Vertex, 18, temp_allocator)
|
||
write_offset := 0
|
||
|
||
if !needs_transform(origin, rotation) {
|
||
write_offset += extrude_line(v1, v2, thick, color, vertices, write_offset)
|
||
write_offset += extrude_line(v2, v3, thick, color, vertices, write_offset)
|
||
write_offset += extrude_line(v3, v1, thick, color, vertices, write_offset)
|
||
} else {
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
xform := build_pivot_rot(mn, origin, rotation)
|
||
tv1 := apply_transform(xform, v1 - mn)
|
||
tv2 := apply_transform(xform, v2 - mn)
|
||
tv3 := apply_transform(xform, v3 - mn)
|
||
write_offset += extrude_line(tv1, tv2, thick, color, vertices, write_offset)
|
||
write_offset += extrude_line(tv2, tv3, thick, color, vertices, write_offset)
|
||
write_offset += extrude_line(tv3, tv1, thick, color, vertices, write_offset)
|
||
}
|
||
|
||
if write_offset > 0 {
|
||
prepare_shape(layer, vertices[:write_offset])
|
||
}
|
||
}
|
||
|
||
triangle_fan :: proc(
|
||
layer: ^Layer,
|
||
points: [][2]f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
if len(points) < 3 do return
|
||
|
||
triangle_count := len(points) - 2
|
||
vertex_count := triangle_count * 3
|
||
vertices := make([]Vertex, vertex_count, temp_allocator)
|
||
|
||
if !needs_transform(origin, rotation) {
|
||
for i in 1 ..< len(points) - 1 {
|
||
idx := (i - 1) * 3
|
||
vertices[idx + 0] = sv(points[0], color)
|
||
vertices[idx + 1] = sv(points[i], color)
|
||
vertices[idx + 2] = sv(points[i + 1], color)
|
||
}
|
||
} else {
|
||
mn := [2]f32{max(f32), max(f32)}
|
||
for p in points {
|
||
mn.x = min(mn.x, p.x)
|
||
mn.y = min(mn.y, p.y)
|
||
}
|
||
xform := build_pivot_rot(mn, origin, rotation)
|
||
for i in 1 ..< len(points) - 1 {
|
||
idx := (i - 1) * 3
|
||
vertices[idx + 0] = sv(apply_transform(xform, points[0] - mn), color)
|
||
vertices[idx + 1] = sv(apply_transform(xform, points[i] - mn), color)
|
||
vertices[idx + 2] = sv(apply_transform(xform, points[i + 1] - mn), color)
|
||
}
|
||
}
|
||
|
||
prepare_shape(layer, vertices)
|
||
}
|
||
|
||
triangle_strip :: proc(
|
||
layer: ^Layer,
|
||
points: [][2]f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
temp_allocator := context.temp_allocator,
|
||
) {
|
||
if len(points) < 3 do return
|
||
|
||
triangle_count := len(points) - 2
|
||
vertex_count := triangle_count * 3
|
||
vertices := make([]Vertex, vertex_count, temp_allocator)
|
||
|
||
if !needs_transform(origin, rotation) {
|
||
for i in 0 ..< triangle_count {
|
||
idx := i * 3
|
||
if i % 2 == 0 {
|
||
vertices[idx + 0] = sv(points[i], color)
|
||
vertices[idx + 1] = sv(points[i + 1], color)
|
||
vertices[idx + 2] = sv(points[i + 2], color)
|
||
} else {
|
||
vertices[idx + 0] = sv(points[i + 1], color)
|
||
vertices[idx + 1] = sv(points[i], color)
|
||
vertices[idx + 2] = sv(points[i + 2], color)
|
||
}
|
||
}
|
||
} else {
|
||
mn := [2]f32{max(f32), max(f32)}
|
||
for p in points {
|
||
mn.x = min(mn.x, p.x)
|
||
mn.y = min(mn.y, p.y)
|
||
}
|
||
xform := build_pivot_rot(mn, origin, rotation)
|
||
for i in 0 ..< triangle_count {
|
||
idx := i * 3
|
||
if i % 2 == 0 {
|
||
vertices[idx + 0] = sv(apply_transform(xform, points[i] - mn), color)
|
||
vertices[idx + 1] = sv(apply_transform(xform, points[i + 1] - mn), color)
|
||
vertices[idx + 2] = sv(apply_transform(xform, points[i + 2] - mn), color)
|
||
} else {
|
||
vertices[idx + 0] = sv(apply_transform(xform, points[i + 1] - mn), color)
|
||
vertices[idx + 1] = sv(apply_transform(xform, points[i] - mn), color)
|
||
vertices[idx + 2] = sv(apply_transform(xform, points[i + 2] - mn), color)
|
||
}
|
||
}
|
||
}
|
||
|
||
prepare_shape(layer, vertices)
|
||
}
|
||
|
||
// ----- SDF drawing functions ----
|
||
|
||
// Compute new center position after rotating a center-parametrized shape
|
||
// around a pivot point. The pivot is at (center + origin) in world space.
|
||
@(private = "file")
|
||
compute_pivot_center :: proc(center: [2]f32, origin: [2]f32, rotation_deg: f32) -> [2]f32 {
|
||
if origin == {0, 0} do return center
|
||
theta := math.to_radians(rotation_deg)
|
||
c, s := math.cos(theta), math.sin(theta)
|
||
// pivot = center + origin; new_center = pivot + R(θ) * (center - pivot)
|
||
return center + origin + {c * (-origin.x) - s * (-origin.y), s * (-origin.x) + c * (-origin.y)}
|
||
}
|
||
|
||
// Compute the AABB half-extents of a rectangle with half-size (hx, hy) rotated by rot_rad.
|
||
@(private = "file")
|
||
rotated_aabb_half :: proc(hx, hy, rot_rad: f32) -> [2]f32 {
|
||
c_r := abs(math.cos(rot_rad))
|
||
s_r := abs(math.sin(rot_rad))
|
||
return {hx * c_r + hy * s_r, hx * s_r + hy * c_r}
|
||
}
|
||
|
||
// Draw a filled rectangle via SDF (analytical anti-aliasing at all orientations).
|
||
// `roundness` is a 0–1 fraction controlling uniform corner rounding — 0 is sharp, 1 is fully rounded.
|
||
// For per-corner pixel-precise rounding, use `rectangle_corners` instead.
|
||
rectangle :: proc(
|
||
layer: ^Layer,
|
||
rect: Rectangle,
|
||
color: Color,
|
||
roundness: f32 = 0,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
cr := min(rect.w, rect.h) * clamp(roundness, 0, 1) * 0.5
|
||
rectangle_corners(layer, rect, {cr, cr, cr, cr}, color, origin, rotation, soft_px)
|
||
}
|
||
|
||
// Draw a stroked rectangle via SDF (analytical anti-aliasing at all orientations).
|
||
// `roundness` is a 0–1 fraction controlling uniform corner rounding — 0 is sharp, 1 is fully rounded.
|
||
// For per-corner pixel-precise rounding, use `rectangle_corners_lines` instead.
|
||
rectangle_lines :: proc(
|
||
layer: ^Layer,
|
||
rect: Rectangle,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
roundness: f32 = 0,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
cr := min(rect.w, rect.h) * clamp(roundness, 0, 1) * 0.5
|
||
rectangle_corners_lines(layer, rect, {cr, cr, cr, cr}, color, thick, origin, rotation, soft_px)
|
||
}
|
||
|
||
// Draw a rectangle with per-corner rounding radii via SDF.
|
||
rectangle_corners :: proc(
|
||
layer: ^Layer,
|
||
rect: Rectangle,
|
||
radii: [4]f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
max_radius := min(rect.w, rect.h) * 0.5
|
||
tl := clamp(radii[0], 0, max_radius)
|
||
tr := clamp(radii[1], 0, max_radius)
|
||
br := clamp(radii[2], 0, max_radius)
|
||
bl := clamp(radii[3], 0, max_radius)
|
||
|
||
pad := soft_px / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
hx := rect.w * 0.5
|
||
hy := rect.h * 0.5
|
||
rot_rad: f32 = 0
|
||
center_x := rect.x + hx
|
||
center_y := rect.y + hy
|
||
|
||
if needs_transform(origin, rotation) {
|
||
rot_rad = math.to_radians(rotation)
|
||
xform := build_pivot_rot({rect.x, rect.y}, origin, rotation)
|
||
new_center := apply_transform(xform, {hx, hy})
|
||
center_x = new_center.x
|
||
center_y = new_center.y
|
||
}
|
||
|
||
bhx, bhy := hx, hy
|
||
if rot_rad != 0 {
|
||
expanded := rotated_aabb_half(hx, hy, rot_rad)
|
||
bhx = expanded.x
|
||
bhy = expanded.y
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {center_x - bhx - pad, center_y - bhy - pad, center_x + bhx + pad, center_y + bhy + pad},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.RRect, {}),
|
||
rotation = rot_rad,
|
||
}
|
||
prim.params.rrect = RRect_Params {
|
||
half_size = {hx * dpi, hy * dpi},
|
||
radii = {tr * dpi, br * dpi, tl * dpi, bl * dpi},
|
||
soft_px = soft_px,
|
||
stroke_px = 0,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a stroked rectangle with per-corner rounding radii via SDF.
|
||
rectangle_corners_lines :: proc(
|
||
layer: ^Layer,
|
||
rect: Rectangle,
|
||
radii: [4]f32,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
max_radius := min(rect.w, rect.h) * 0.5
|
||
tl := clamp(radii[0], 0, max_radius)
|
||
tr := clamp(radii[1], 0, max_radius)
|
||
br := clamp(radii[2], 0, max_radius)
|
||
bl := clamp(radii[3], 0, max_radius)
|
||
|
||
pad := (thick * 0.5 + soft_px) / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
hx := rect.w * 0.5
|
||
hy := rect.h * 0.5
|
||
rot_rad: f32 = 0
|
||
center_x := rect.x + hx
|
||
center_y := rect.y + hy
|
||
|
||
if needs_transform(origin, rotation) {
|
||
rot_rad = math.to_radians(rotation)
|
||
xform := build_pivot_rot({rect.x, rect.y}, origin, rotation)
|
||
new_center := apply_transform(xform, {hx, hy})
|
||
center_x = new_center.x
|
||
center_y = new_center.y
|
||
}
|
||
|
||
bhx, bhy := hx, hy
|
||
if rot_rad != 0 {
|
||
expanded := rotated_aabb_half(hx, hy, rot_rad)
|
||
bhx = expanded.x
|
||
bhy = expanded.y
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {center_x - bhx - pad, center_y - bhy - pad, center_x + bhx + pad, center_y + bhy + pad},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.RRect, {.Stroke}),
|
||
rotation = rot_rad,
|
||
}
|
||
prim.params.rrect = RRect_Params {
|
||
half_size = {hx * dpi, hy * dpi},
|
||
radii = {tr * dpi, br * dpi, tl * dpi, bl * dpi},
|
||
soft_px = soft_px,
|
||
stroke_px = thick * dpi,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a filled circle via SDF.
|
||
circle :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius: f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
pad := soft_px / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
if origin != {0, 0} {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - radius - pad,
|
||
actual_center.y - radius - pad,
|
||
actual_center.x + radius + pad,
|
||
actual_center.y + radius + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Circle, {}),
|
||
// rotation stays 0 — circle is rotationally symmetric
|
||
}
|
||
prim.params.circle = Circle_Params {
|
||
radius = radius * dpi,
|
||
soft_px = soft_px,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a stroked circle via SDF.
|
||
circle_lines :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius: f32,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
pad := (thick * 0.5 + soft_px) / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
if origin != {0, 0} {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - radius - pad,
|
||
actual_center.y - radius - pad,
|
||
actual_center.x + radius + pad,
|
||
actual_center.y + radius + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Circle, {.Stroke}),
|
||
}
|
||
prim.params.circle = Circle_Params {
|
||
radius = radius * dpi,
|
||
soft_px = soft_px,
|
||
stroke_px = thick * dpi,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a filled ellipse via SDF.
|
||
ellipse :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius_h, radius_v: f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
pad := soft_px / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
rot_rad: f32 = 0
|
||
if needs_transform(origin, rotation) {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
rot_rad = math.to_radians(rotation)
|
||
}
|
||
|
||
// When rotated, expand the bounds AABB to enclose the rotated ellipse
|
||
bound_h, bound_v := radius_h, radius_v
|
||
if rot_rad != 0 {
|
||
expanded := rotated_aabb_half(radius_h, radius_v, rot_rad)
|
||
bound_h = expanded.x
|
||
bound_v = expanded.y
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - bound_h - pad,
|
||
actual_center.y - bound_v - pad,
|
||
actual_center.x + bound_h + pad,
|
||
actual_center.y + bound_v + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Ellipse, {}),
|
||
rotation = rot_rad,
|
||
}
|
||
prim.params.ellipse = Ellipse_Params {
|
||
radii = {radius_h * dpi, radius_v * dpi},
|
||
soft_px = soft_px,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a stroked ellipse via SDF.
|
||
ellipse_lines :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
radius_h, radius_v: f32,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
// Extra 10% padding: iq's sdEllipse has precision degradation near the tips of highly
|
||
// eccentric ellipses, so the quad needs additional breathing room beyond the stroke width.
|
||
extra := max(radius_h, radius_v) * 0.1 + thick * 0.5
|
||
pad := (extra + soft_px) / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
rot_rad: f32 = 0
|
||
if needs_transform(origin, rotation) {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
rot_rad = math.to_radians(rotation)
|
||
}
|
||
|
||
bound_h, bound_v := radius_h, radius_v
|
||
if rot_rad != 0 {
|
||
expanded := rotated_aabb_half(radius_h, radius_v, rot_rad)
|
||
bound_h = expanded.x
|
||
bound_v = expanded.y
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - bound_h - pad,
|
||
actual_center.y - bound_v - pad,
|
||
actual_center.x + bound_h + pad,
|
||
actual_center.y + bound_v + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Ellipse, {.Stroke}),
|
||
rotation = rot_rad,
|
||
}
|
||
prim.params.ellipse = Ellipse_Params {
|
||
radii = {radius_h * dpi, radius_v * dpi},
|
||
soft_px = soft_px,
|
||
stroke_px = thick * dpi,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a filled ring arc via SDF.
|
||
ring :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
inner_radius, outer_radius: f32,
|
||
start_angle, end_angle: f32,
|
||
color: Color,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
pad := soft_px / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
rotation_offset: f32 = 0
|
||
if needs_transform(origin, rotation) {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
rotation_offset = math.to_radians(rotation)
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - outer_radius - pad,
|
||
actual_center.y - outer_radius - pad,
|
||
actual_center.x + outer_radius + pad,
|
||
actual_center.y + outer_radius + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Ring_Arc, {}),
|
||
// No shader rotation — arc rotation handled by offsetting start/end angles
|
||
}
|
||
prim.params.ring_arc = Ring_Arc_Params {
|
||
inner_radius = inner_radius * dpi,
|
||
outer_radius = outer_radius * dpi,
|
||
start_rad = math.to_radians(start_angle) + rotation_offset,
|
||
end_rad = math.to_radians(end_angle) + rotation_offset,
|
||
soft_px = soft_px,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw stroked ring arc outlines via SDF.
|
||
ring_lines :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
inner_radius, outer_radius: f32,
|
||
start_angle, end_angle: f32,
|
||
color: Color,
|
||
thick: f32 = 1,
|
||
origin: [2]f32 = {0, 0},
|
||
rotation: f32 = 0,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
// Compute effective angles and pivot-translated center up front
|
||
eff_start := start_angle + rotation
|
||
eff_end := end_angle + rotation
|
||
|
||
actual_center := center
|
||
if needs_transform(origin, rotation) {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
}
|
||
|
||
// Inner arc outline (pass already-transformed center; no further origin/rotation)
|
||
ring(
|
||
layer,
|
||
actual_center,
|
||
max(0, inner_radius - thick * 0.5),
|
||
inner_radius + thick * 0.5,
|
||
eff_start,
|
||
eff_end,
|
||
color,
|
||
soft_px = soft_px,
|
||
)
|
||
// Outer arc outline
|
||
ring(
|
||
layer,
|
||
actual_center,
|
||
max(0, outer_radius - thick * 0.5),
|
||
outer_radius + thick * 0.5,
|
||
eff_start,
|
||
eff_end,
|
||
color,
|
||
soft_px = soft_px,
|
||
)
|
||
// Start cap
|
||
start_rad := math.to_radians(eff_start)
|
||
end_rad := math.to_radians(eff_end)
|
||
inner_start := actual_center + {math.cos(start_rad) * inner_radius, math.sin(start_rad) * inner_radius}
|
||
outer_start := actual_center + {math.cos(start_rad) * outer_radius, math.sin(start_rad) * outer_radius}
|
||
line(layer, inner_start, outer_start, color, thick, soft_px)
|
||
// End cap
|
||
inner_end := actual_center + {math.cos(end_rad) * inner_radius, math.sin(end_rad) * inner_radius}
|
||
outer_end := actual_center + {math.cos(end_rad) * outer_radius, math.sin(end_rad) * outer_radius}
|
||
line(layer, inner_end, outer_end, color, thick, soft_px)
|
||
}
|
||
|
||
// Draw a line segment via SDF.
|
||
line :: proc(layer: ^Layer, start, end_pos: [2]f32, color: Color, thick: f32 = 1, soft_px: f32 = 1.0) {
|
||
cap := thick * 0.5 + soft_px / GLOB.dpi_scaling
|
||
min_x := min(start.x, end_pos.x) - cap
|
||
max_x := max(start.x, end_pos.x) + cap
|
||
min_y := min(start.y, end_pos.y) - cap
|
||
max_y := max(start.y, end_pos.y) + cap
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
center := [2]f32{(min_x + max_x) * 0.5, (min_y + max_y) * 0.5}
|
||
local_a := (start - center) * dpi
|
||
local_b := (end_pos - center) * dpi
|
||
|
||
prim := Primitive {
|
||
bounds = {min_x, min_y, max_x, max_y},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.Segment, {}),
|
||
}
|
||
prim.params.segment = Segment_Params {
|
||
a = local_a,
|
||
b = local_b,
|
||
width = thick * dpi,
|
||
soft_px = soft_px,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a line strip via decomposed SDF segments.
|
||
line_strip :: proc(layer: ^Layer, points: [][2]f32, color: Color, thick: f32 = 1, soft_px: f32 = 1.0) {
|
||
if len(points) < 2 do return
|
||
for i in 0 ..< len(points) - 1 {
|
||
line(layer, points[i], points[i + 1], color, thick, soft_px)
|
||
}
|
||
}
|
||
|
||
// Draw a filled regular polygon via SDF.
|
||
poly :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
sides: int,
|
||
radius: f32,
|
||
color: Color,
|
||
rotation: f32 = 0,
|
||
origin: [2]f32 = {0, 0},
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
if sides < 3 do return
|
||
pad := soft_px / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
if origin != {0, 0} && rotation != 0 {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - radius - pad,
|
||
actual_center.y - radius - pad,
|
||
actual_center.x + radius + pad,
|
||
actual_center.y + radius + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.NGon, {}),
|
||
}
|
||
prim.params.ngon = NGon_Params {
|
||
radius = radius * math.cos(math.PI / f32(sides)) * dpi,
|
||
rotation = math.to_radians(rotation),
|
||
sides = f32(sides),
|
||
soft_px = soft_px,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// Draw a stroked regular polygon via SDF.
|
||
poly_lines :: proc(
|
||
layer: ^Layer,
|
||
center: [2]f32,
|
||
sides: int,
|
||
radius: f32,
|
||
color: Color,
|
||
rotation: f32 = 0,
|
||
origin: [2]f32 = {0, 0},
|
||
thick: f32 = 1,
|
||
soft_px: f32 = 1.0,
|
||
) {
|
||
if sides < 3 do return
|
||
pad := (thick * 0.5 + soft_px) / GLOB.dpi_scaling
|
||
dpi := GLOB.dpi_scaling
|
||
|
||
actual_center := center
|
||
if origin != {0, 0} && rotation != 0 {
|
||
actual_center = compute_pivot_center(center, origin, rotation)
|
||
}
|
||
|
||
prim := Primitive {
|
||
bounds = {
|
||
actual_center.x - radius - pad,
|
||
actual_center.y - radius - pad,
|
||
actual_center.x + radius + pad,
|
||
actual_center.y + radius + pad,
|
||
},
|
||
color = color,
|
||
kind_flags = pack_kind_flags(.NGon, {.Stroke}),
|
||
}
|
||
prim.params.ngon = NGon_Params {
|
||
radius = radius * math.cos(math.PI / f32(sides)) * dpi,
|
||
rotation = math.to_radians(rotation),
|
||
sides = f32(sides),
|
||
soft_px = soft_px,
|
||
stroke_px = thick * dpi,
|
||
}
|
||
prepare_sdf_primitive(layer, prim)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------------
|
||
// ----- Anchor helpers ----------------
|
||
// ---------------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// Return [2]f32 pixel offsets for use as the `origin` parameter of draw calls.
|
||
// Composable with normal vector +/- arithmetic.
|
||
//
|
||
// Text anchor helpers are in text.odin (they depend on measure_text / SDL_ttf).
|
||
|
||
// ----- Rectangle anchors (origin measured from rect's top-left) --------------------------------------------------
|
||
|
||
center_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w * 0.5, r.h * 0.5}
|
||
}
|
||
|
||
top_left_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {0, 0}
|
||
}
|
||
|
||
top_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w * 0.5, 0}
|
||
}
|
||
|
||
top_right_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w, 0}
|
||
}
|
||
|
||
left_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {0, r.h * 0.5}
|
||
}
|
||
|
||
right_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w, r.h * 0.5}
|
||
}
|
||
|
||
bottom_left_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {0, r.h}
|
||
}
|
||
|
||
bottom_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w * 0.5, r.h}
|
||
}
|
||
|
||
bottom_right_of_rect :: #force_inline proc(r: Rectangle) -> [2]f32 {
|
||
return {r.w, r.h}
|
||
}
|
||
|
||
// ----- Triangle anchors (origin measured from AABB top-left) -----------------------------------------------------
|
||
|
||
center_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
return (v1 + v2 + v3) / 3 - mn
|
||
}
|
||
|
||
top_left_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
return {0, 0}
|
||
}
|
||
|
||
top_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn_x := min(v1.x, v2.x, v3.x)
|
||
mx_x := max(v1.x, v2.x, v3.x)
|
||
return {(mx_x - mn_x) * 0.5, 0}
|
||
}
|
||
|
||
top_right_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn_x := min(v1.x, v2.x, v3.x)
|
||
mx_x := max(v1.x, v2.x, v3.x)
|
||
return {mx_x - mn_x, 0}
|
||
}
|
||
|
||
left_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn_y := min(v1.y, v2.y, v3.y)
|
||
mx_y := max(v1.y, v2.y, v3.y)
|
||
return {0, (mx_y - mn_y) * 0.5}
|
||
}
|
||
|
||
right_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
mx := [2]f32{max(v1.x, v2.x, v3.x), max(v1.y, v2.y, v3.y)}
|
||
return {mx.x - mn.x, (mx.y - mn.y) * 0.5}
|
||
}
|
||
|
||
bottom_left_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn_y := min(v1.y, v2.y, v3.y)
|
||
mx_y := max(v1.y, v2.y, v3.y)
|
||
return {0, mx_y - mn_y}
|
||
}
|
||
|
||
bottom_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
mx := [2]f32{max(v1.x, v2.x, v3.x), max(v1.y, v2.y, v3.y)}
|
||
return {(mx.x - mn.x) * 0.5, mx.y - mn.y}
|
||
}
|
||
|
||
bottom_right_of_triangle :: #force_inline proc(v1, v2, v3: [2]f32) -> [2]f32 {
|
||
mn := [2]f32{min(v1.x, v2.x, v3.x), min(v1.y, v2.y, v3.y)}
|
||
mx := [2]f32{max(v1.x, v2.x, v3.x), max(v1.y, v2.y, v3.y)}
|
||
return mx - mn
|
||
}
|