first commit
This commit is contained in:
Hakan Seven
parent
d52c6440ff
commit
d2fdac7f1e
274 changed files with 89330 additions and 0 deletions
585
src/scene/cxf.rs
Normal file
585
src/scene/cxf.rs
Normal file
|
|
@ -0,0 +1,585 @@
|
|||
//! CXF vector font and shape parser.
|
||||
//!
|
||||
//! Handles both linetype shape files (ltypeshp.cxf) and full font files
|
||||
//! (Standard.cxf, NormalLatin2.cxf, etc.) with a single parser.
|
||||
//!
|
||||
//! Supported CXF geometry commands:
|
||||
//! L x0,y0,x1,y1 — single line segment
|
||||
//! PL x,y,b,... — open polyline (x, y, bulge triplets)
|
||||
//! PLC x,y,b,... — closed polyline
|
||||
//! A cx,cy,r,start,end — arc CCW, angles in degrees
|
||||
//! AR cx,cy,r,start,end — arc CW, angles in degrees
|
||||
//!
|
||||
//! Entry type decision rule:
|
||||
//! [XXXX] LABEL
|
||||
//! - If LABEL is exactly one character AND equals char::from_u32(hex)
|
||||
//! -> stored as a Unicode glyph (font use-case, e.g. [0041] A)
|
||||
//! - Otherwise -> stored as a named shape (ltypeshp, e.g. [0042] BAT)
|
||||
//!
|
||||
//! Glyph coordinate space:
|
||||
//! Origin = left baseline corner.
|
||||
//! Cap height = 9 glyph units.
|
||||
//! Scale factor = text_height / 9.0.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::f32::consts::TAU;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
// ── Embedded assets ───────────────────────────────────────────────────────
|
||||
|
||||
const SRC_LTYPESHP: &str = include_str!("../../assets/fonts/ltypeshp.cxf");
|
||||
const SRC_STANDARD: &str = include_str!("../../assets/fonts/Standard.cxf");
|
||||
const SRC_NORMAL: &str = include_str!("../../assets/fonts/NormalLatin2.cxf");
|
||||
const SRC_COURIER: &str = include_str!("../../assets/fonts/CourierCad.cxf");
|
||||
const SRC_SANS: &str = include_str!("../../assets/fonts/SansNS.cxf");
|
||||
const SRC_ITALIC: &str = include_str!("../../assets/fonts/ItalicT.cxf");
|
||||
const SRC_GOTHIC: &str = include_str!("../../assets/fonts/GothITT.cxf");
|
||||
const SRC_CURSIVE: &str = include_str!("../../assets/fonts/Cursive.cxf");
|
||||
const SRC_SCRIPTC: &str = include_str!("../../assets/fonts/ScriptS.cxf");
|
||||
|
||||
// ── Public types ──────────────────────────────────────────────────────────
|
||||
|
||||
/// One glyph or shape: a list of open 2-D polyline strokes in local units.
|
||||
#[derive(Clone, Default)]
|
||||
pub struct CxfGlyph {
|
||||
/// Each stroke is a list of [x, y] points forming a connected polyline.
|
||||
pub strokes: Vec<Vec<[f32; 2]>>,
|
||||
/// Advance width in glyph units (rightmost X of all strokes).
|
||||
pub advance: f32,
|
||||
}
|
||||
|
||||
/// A parsed CXF file.
|
||||
#[derive(Clone)]
|
||||
pub struct CxfFile {
|
||||
/// Font/file name from the `# Name:` header.
|
||||
pub name: String,
|
||||
/// Extra space between characters in glyph units (`# LetterSpacing:`).
|
||||
pub letter_spacing: f32,
|
||||
/// Space character width in glyph units (`# WordSpacing:`).
|
||||
pub word_spacing: f32,
|
||||
/// Line height multiplier relative to text height (`# LineSpacingFactor:`).
|
||||
pub line_spacing: f32,
|
||||
/// Named shapes keyed by uppercase name — used for ltypeshp.
|
||||
shapes: HashMap<String, CxfGlyph>,
|
||||
/// Unicode glyphs keyed by character — used for font files.
|
||||
glyphs: HashMap<char, CxfGlyph>,
|
||||
}
|
||||
|
||||
impl CxfFile {
|
||||
/// Look up a linetype shape by name (case-insensitive).
|
||||
pub fn shape(&self, name: &str) -> Option<&CxfGlyph> {
|
||||
self.shapes.get(&name.to_ascii_uppercase())
|
||||
}
|
||||
|
||||
/// Look up a font glyph by Unicode character.
|
||||
pub fn glyph(&self, c: char) -> Option<&CxfGlyph> {
|
||||
self.glyphs.get(&c)
|
||||
}
|
||||
}
|
||||
|
||||
// ── Static registries ─────────────────────────────────────────────────────
|
||||
|
||||
static SHAPES: OnceLock<CxfFile> = OnceLock::new();
|
||||
static FONTS: OnceLock<HashMap<String, CxfFile>> = OnceLock::new();
|
||||
|
||||
fn shapes_file() -> &'static CxfFile {
|
||||
SHAPES.get_or_init(|| parse(SRC_LTYPESHP))
|
||||
}
|
||||
|
||||
fn fonts_map() -> &'static HashMap<String, CxfFile> {
|
||||
FONTS.get_or_init(|| {
|
||||
let mut map = HashMap::new();
|
||||
let mut insert = |src: &str, aliases: &[&str]| {
|
||||
let f = parse(src);
|
||||
map.insert(f.name.to_ascii_uppercase(), f.clone());
|
||||
for alias in aliases {
|
||||
map.insert(alias.to_ascii_uppercase(), f.clone());
|
||||
}
|
||||
};
|
||||
|
||||
insert(SRC_STANDARD, &["STANDARD", "TXT", "TXT.SHX", "SIMPLEX"]);
|
||||
insert(
|
||||
SRC_NORMAL,
|
||||
&["NORMAL", "NORMALLATIN2", "ROMANS", "ROMANS.SHX"],
|
||||
);
|
||||
insert(SRC_COURIER, &["COURIER", "COURIERCAD", "COURIERCAD"]);
|
||||
insert(SRC_SANS, &["SANS", "SANSNS"]);
|
||||
insert(SRC_ITALIC, &["ITALIC", "ITALICT"]);
|
||||
insert(SRC_GOTHIC, &["GOTHIC", "GOTHITT"]);
|
||||
insert(SRC_CURSIVE, &["CURSIVE"]);
|
||||
insert(SRC_SCRIPTC, &["SCRIPTS", "SCRIPTC", "SCRIPT"]);
|
||||
map
|
||||
})
|
||||
}
|
||||
|
||||
// ── Public API — linetype shapes ──────────────────────────────────────────
|
||||
|
||||
/// Look up a linetype shape by name (case-insensitive). Used by `complex_lt.rs`.
|
||||
pub fn get(name: &str) -> Option<&'static CxfGlyph> {
|
||||
shapes_file().shape(name)
|
||||
}
|
||||
|
||||
// ── Public API — text tessellation ────────────────────────────────────────
|
||||
|
||||
/// Return a font by name (case-insensitive).
|
||||
/// Falls back to Standard → Normal → any available font.
|
||||
pub fn get_font(name: &str) -> &'static CxfFile {
|
||||
let map = fonts_map();
|
||||
let key = name.to_ascii_uppercase();
|
||||
map.get(&key)
|
||||
.or_else(|| map.get("STANDARD"))
|
||||
.or_else(|| map.get("NORMAL"))
|
||||
.or_else(|| map.values().next())
|
||||
.expect("at least one CXF font must be embedded")
|
||||
}
|
||||
|
||||
/// Tessellate a text string into world-space 2-D strokes.
|
||||
///
|
||||
/// - `origin` — insertion point [world_x, world_y]
|
||||
/// - `height` — text height in world units (cap height = 9 glyph units)
|
||||
/// - `rotation` — rotation angle in radians (CCW positive)
|
||||
/// - `font_name` — e.g. "Standard", "Romans", "Courier" (case-insensitive)
|
||||
/// - `text` — the string to render
|
||||
///
|
||||
/// Returns one Vec<[f32;2]> per stroke. Strokes from different glyphs are
|
||||
/// separate entries.
|
||||
#[allow(dead_code)]
|
||||
pub fn tessellate_text(
|
||||
origin: [f32; 2],
|
||||
height: f32,
|
||||
rotation: f32,
|
||||
font_name: &str,
|
||||
text: &str,
|
||||
) -> Vec<Vec<[f32; 2]>> {
|
||||
if text.is_empty() || height <= 0.0 {
|
||||
return vec![];
|
||||
}
|
||||
|
||||
let font = get_font(font_name);
|
||||
let scale = height / 9.0; // CXF cap height = 9 glyph units
|
||||
let (cos_r, sin_r) = (rotation.cos(), rotation.sin());
|
||||
|
||||
let xform = |gx: f32, gy: f32, cursor_x: f32| -> [f32; 2] {
|
||||
let lx = (cursor_x + gx) * scale;
|
||||
let ly = gy * scale;
|
||||
[
|
||||
origin[0] + lx * cos_r - ly * sin_r,
|
||||
origin[1] + lx * sin_r + ly * cos_r,
|
||||
]
|
||||
};
|
||||
|
||||
let mut out: Vec<Vec<[f32; 2]>> = Vec::new();
|
||||
let mut cursor_x: f32 = 0.0;
|
||||
|
||||
for ch in text.chars() {
|
||||
if ch == ' ' {
|
||||
cursor_x += font.word_spacing;
|
||||
continue;
|
||||
}
|
||||
match font.glyph(ch) {
|
||||
Some(glyph) => {
|
||||
for stroke in &glyph.strokes {
|
||||
if stroke.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
out.push(
|
||||
stroke
|
||||
.iter()
|
||||
.map(|&[gx, gy]| xform(gx, gy, cursor_x))
|
||||
.collect(),
|
||||
);
|
||||
}
|
||||
cursor_x += glyph.advance + font.letter_spacing;
|
||||
}
|
||||
None => {
|
||||
cursor_x += 6.0 + font.letter_spacing;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
pub fn tessellate_text_ex(
|
||||
origin: [f32; 2],
|
||||
height: f32,
|
||||
rotation: f32,
|
||||
width_factor: f32,
|
||||
oblique_angle: f32,
|
||||
font_name: &str,
|
||||
text: &str,
|
||||
) -> Vec<Vec<[f32; 2]>> {
|
||||
if text.is_empty() || height <= 0.0 {
|
||||
return vec![];
|
||||
}
|
||||
|
||||
let font = get_font(font_name);
|
||||
let scale = height / 9.0;
|
||||
let wf = width_factor.clamp(0.01, 100.0);
|
||||
let ob = oblique_angle.tan(); // shear multiplier
|
||||
let (cos_r, sin_r) = (rotation.cos(), rotation.sin());
|
||||
|
||||
let xform = |gx: f32, gy: f32, cursor_x: f32| -> [f32; 2] {
|
||||
let sx = (cursor_x + gx) * scale * wf + gy * scale * ob;
|
||||
let sy = gy * scale;
|
||||
[
|
||||
origin[0] + sx * cos_r - sy * sin_r,
|
||||
origin[1] + sx * sin_r + sy * cos_r,
|
||||
]
|
||||
};
|
||||
|
||||
let mut out: Vec<Vec<[f32; 2]>> = Vec::new();
|
||||
let mut cursor_x: f32 = 0.0;
|
||||
|
||||
for ch in text.chars() {
|
||||
if ch == ' ' {
|
||||
cursor_x += font.word_spacing;
|
||||
continue;
|
||||
}
|
||||
match font.glyph(ch) {
|
||||
Some(glyph) => {
|
||||
for stroke in &glyph.strokes {
|
||||
if stroke.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
out.push(
|
||||
stroke
|
||||
.iter()
|
||||
.map(|&[gx, gy]| xform(gx, gy, cursor_x))
|
||||
.collect(),
|
||||
);
|
||||
}
|
||||
cursor_x += (glyph.advance + font.letter_spacing) * wf;
|
||||
}
|
||||
None => {
|
||||
cursor_x += (6.0 + font.letter_spacing) * wf;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Parser ────────────────────────────────────────────────────────────────
|
||||
|
||||
fn parse(src: &str) -> CxfFile {
|
||||
let mut file = CxfFile {
|
||||
name: String::from("Unknown"),
|
||||
letter_spacing: 3.0,
|
||||
word_spacing: 6.75,
|
||||
line_spacing: 1.0,
|
||||
shapes: HashMap::new(),
|
||||
glyphs: HashMap::new(),
|
||||
};
|
||||
|
||||
let mut cur_char: Option<char> = None;
|
||||
let mut cur_name: Option<String> = None;
|
||||
let mut cur_strokes: Vec<Vec<[f32; 2]>> = Vec::new();
|
||||
let mut cur_max_x: f32 = 0.0;
|
||||
|
||||
for raw in src.lines() {
|
||||
let line = raw.trim();
|
||||
if line.is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Header ────────────────────────────────────────────────────────
|
||||
if line.starts_with('#') {
|
||||
if let Some(rest) = line.strip_prefix("# Name:") {
|
||||
file.name = rest.trim().to_string();
|
||||
} else if let Some(rest) = line.strip_prefix("# LetterSpacing:") {
|
||||
if let Ok(v) = rest.trim().parse::<f32>() {
|
||||
file.letter_spacing = v;
|
||||
}
|
||||
} else if let Some(rest) = line.strip_prefix("# WordSpacing:") {
|
||||
if let Ok(v) = rest.trim().parse::<f32>() {
|
||||
file.word_spacing = v;
|
||||
}
|
||||
} else if let Some(rest) = line.strip_prefix("# LineSpacingFactor:") {
|
||||
if let Ok(v) = rest.trim().parse::<f32>() {
|
||||
file.line_spacing = v;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Entry header: `[XXXX] LABEL` ─────────────────────────────────
|
||||
if line.starts_with('[') {
|
||||
flush_entry(
|
||||
&mut file,
|
||||
&mut cur_char,
|
||||
&mut cur_name,
|
||||
&mut cur_strokes,
|
||||
&mut cur_max_x,
|
||||
);
|
||||
|
||||
let hex_end = match line.find(']') {
|
||||
Some(i) => i,
|
||||
None => continue,
|
||||
};
|
||||
let hex_str = line[1..hex_end].trim();
|
||||
let label = line[hex_end + 1..].trim();
|
||||
|
||||
if let Ok(cp) = u32::from_str_radix(hex_str, 16) {
|
||||
let cp_char = char::from_u32(cp);
|
||||
|
||||
// Glyph: label is exactly the one character that the codepoint maps to.
|
||||
// Shape: label is a word (different from the codepoint char) or empty
|
||||
// with a non-printable / non-matching codepoint.
|
||||
let is_glyph = match cp_char {
|
||||
Some(ch) => label.chars().count() == 1 && label.chars().next() == Some(ch),
|
||||
None => false,
|
||||
};
|
||||
|
||||
if is_glyph {
|
||||
cur_char = cp_char;
|
||||
cur_name = None;
|
||||
} else if !label.is_empty() {
|
||||
cur_name = Some(label.to_string());
|
||||
cur_char = None;
|
||||
} else if let Some(ch) = cp_char {
|
||||
// No label but valid codepoint — treat as glyph.
|
||||
cur_char = Some(ch);
|
||||
cur_name = None;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Geometry (only inside a valid entry) ──────────────────────────
|
||||
if cur_char.is_none() && cur_name.is_none() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let up = line.to_ascii_uppercase();
|
||||
|
||||
if up.starts_with("PLC ") {
|
||||
if let Some(s) = parse_triplet_poly(&line[4..], true) {
|
||||
update_max_x(&s, &mut cur_max_x);
|
||||
if !s.is_empty() {
|
||||
cur_strokes.push(s);
|
||||
}
|
||||
}
|
||||
} else if up.starts_with("PL ") {
|
||||
if let Some(s) = parse_triplet_poly(&line[3..], false) {
|
||||
update_max_x(&s, &mut cur_max_x);
|
||||
if !s.is_empty() {
|
||||
cur_strokes.push(s);
|
||||
}
|
||||
}
|
||||
} else if up.starts_with("AR ") {
|
||||
if let Some(s) = parse_arc(&line[3..], true) {
|
||||
update_max_x(&s, &mut cur_max_x);
|
||||
cur_strokes.push(s);
|
||||
}
|
||||
} else if up.starts_with("A ") {
|
||||
if let Some(s) = parse_arc(&line[2..], false) {
|
||||
update_max_x(&s, &mut cur_max_x);
|
||||
cur_strokes.push(s);
|
||||
}
|
||||
} else if up.starts_with("L ") {
|
||||
let vals: Vec<f32> = line[2..]
|
||||
.split(',')
|
||||
.filter_map(|s| s.trim().parse().ok())
|
||||
.collect();
|
||||
if vals.len() >= 4 {
|
||||
let s = vec![[vals[0], vals[1]], [vals[2], vals[3]]];
|
||||
update_max_x(&s, &mut cur_max_x);
|
||||
cur_strokes.push(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
flush_entry(
|
||||
&mut file,
|
||||
&mut cur_char,
|
||||
&mut cur_name,
|
||||
&mut cur_strokes,
|
||||
&mut cur_max_x,
|
||||
);
|
||||
file
|
||||
}
|
||||
|
||||
fn flush_entry(
|
||||
file: &mut CxfFile,
|
||||
cur_char: &mut Option<char>,
|
||||
cur_name: &mut Option<String>,
|
||||
cur_strokes: &mut Vec<Vec<[f32; 2]>>,
|
||||
cur_max_x: &mut f32,
|
||||
) {
|
||||
let strokes = std::mem::take(cur_strokes);
|
||||
let advance = *cur_max_x;
|
||||
*cur_max_x = 0.0;
|
||||
let glyph = CxfGlyph { strokes, advance };
|
||||
|
||||
if let Some(ch) = cur_char.take() {
|
||||
file.glyphs.insert(ch, glyph);
|
||||
} else if let Some(name) = cur_name.take() {
|
||||
file.shapes.insert(name.to_ascii_uppercase(), glyph);
|
||||
}
|
||||
}
|
||||
|
||||
fn update_max_x(stroke: &[[f32; 2]], max_x: &mut f32) {
|
||||
for &[x, _] in stroke {
|
||||
if x > *max_x {
|
||||
*max_x = x;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Arc tessellation ──────────────────────────────────────────────────────
|
||||
|
||||
/// Parse `cx,cy,radius,start_deg,end_deg` and tessellate into a polyline.
|
||||
/// `reversed = true` → CW sweep (AR), `false` → CCW (A).
|
||||
fn parse_arc(data: &str, reversed: bool) -> Option<Vec<[f32; 2]>> {
|
||||
let vals: Vec<f32> = data
|
||||
.split(',')
|
||||
.filter_map(|s| s.trim().parse().ok())
|
||||
.collect();
|
||||
if vals.len() < 5 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let (cx, cy, r) = (vals[0], vals[1], vals[2]);
|
||||
let sa = vals[3].to_radians();
|
||||
let ea = vals[4].to_radians();
|
||||
if r <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let sweep = if reversed {
|
||||
let mut s = ea - sa;
|
||||
if s > 0.0 {
|
||||
s -= TAU;
|
||||
}
|
||||
if s.abs() < 1e-6 {
|
||||
s = -TAU;
|
||||
}
|
||||
s
|
||||
} else {
|
||||
let mut s = ea - sa;
|
||||
if s < 0.0 {
|
||||
s += TAU;
|
||||
}
|
||||
if s.abs() < 1e-6 {
|
||||
s = TAU;
|
||||
}
|
||||
s
|
||||
};
|
||||
|
||||
let segs = ((sweep.abs() / TAU) * 64.0).ceil().clamp(4.0, 64.0) as u32;
|
||||
let mut pts = Vec::with_capacity(segs as usize + 1);
|
||||
for i in 0..=segs {
|
||||
let t = sa + sweep * (i as f32 / segs as f32);
|
||||
pts.push([cx + r * t.cos(), cy + r * t.sin()]);
|
||||
}
|
||||
Some(pts)
|
||||
}
|
||||
|
||||
// ── Polyline (bulge) tessellation ─────────────────────────────────────────
|
||||
|
||||
/// Parse `(x, y, bulge)` triplets from a PL / PLC command.
|
||||
fn parse_triplet_poly(data: &str, closed: bool) -> Option<Vec<[f32; 2]>> {
|
||||
let vals: Vec<f32> = data
|
||||
.split(',')
|
||||
.filter_map(|s| s.trim().parse().ok())
|
||||
.collect();
|
||||
let n = vals.len();
|
||||
if n < 6 || n % 3 != 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let triplets: Vec<([f32; 2], f32)> = (0..n)
|
||||
.step_by(3)
|
||||
.map(|i| ([vals[i], vals[i + 1]], vals[i + 2]))
|
||||
.collect();
|
||||
let tc = triplets.len();
|
||||
let mut pts: Vec<[f32; 2]> = Vec::with_capacity(tc * 6);
|
||||
|
||||
for (idx, &(start, bulge)) in triplets.iter().enumerate() {
|
||||
let end = if idx + 1 < tc {
|
||||
triplets[idx + 1].0
|
||||
} else if closed && tc > 0 {
|
||||
triplets[0].0
|
||||
} else {
|
||||
if pts.last() != Some(&start) {
|
||||
pts.push(start);
|
||||
}
|
||||
break;
|
||||
};
|
||||
|
||||
if pts.last() != Some(&start) {
|
||||
pts.push(start);
|
||||
}
|
||||
|
||||
if bulge.abs() < 1e-7 {
|
||||
pts.push(end);
|
||||
} else {
|
||||
bulge_arc(&mut pts, start, end, bulge, 16);
|
||||
}
|
||||
}
|
||||
|
||||
if closed {
|
||||
if let Some(&first) = pts.first() {
|
||||
if pts.last() != Some(&first) {
|
||||
pts.push(first);
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(pts)
|
||||
}
|
||||
|
||||
/// Approximate a bulge arc from `p0` to `p1`.
|
||||
/// `bulge = tan(included_angle / 4)`: positive = CCW, negative = CW.
|
||||
fn bulge_arc(out: &mut Vec<[f32; 2]>, p0: [f32; 2], p1: [f32; 2], bulge: f32, n: usize) {
|
||||
let (x1, y1) = (p0[0], p0[1]);
|
||||
let (x2, y2) = (p1[0], p1[1]);
|
||||
|
||||
let theta = 4.0 * bulge.atan();
|
||||
let dx = x2 - x1;
|
||||
let dy = y2 - y1;
|
||||
let d = (dx * dx + dy * dy).sqrt();
|
||||
if d < 1e-10 {
|
||||
out.push(p1);
|
||||
return;
|
||||
}
|
||||
|
||||
let half_theta = theta * 0.5;
|
||||
let r = (d * 0.5) / half_theta.sin().abs();
|
||||
let px = -dy / d;
|
||||
let py = dx / d;
|
||||
let d_mc = r * half_theta.cos();
|
||||
let sign = if bulge > 0.0 { 1.0_f32 } else { -1.0_f32 };
|
||||
// Center lies to the LEFT of chord for CCW (bulge>0) and to the RIGHT for CW (bulge<0).
|
||||
// px = -dy/d is the left-perpendicular unit vector of the chord.
|
||||
// CCW (sign=+1): center = mid + perp * d_mc (left)
|
||||
// CW (sign=-1): center = mid - perp * d_mc (right)
|
||||
let cx = (x1 + x2) * 0.5 + sign * px * d_mc;
|
||||
let cy = (y1 + y2) * 0.5 + sign * py * d_mc;
|
||||
|
||||
let a1 = (y1 - cy).atan2(x1 - cx);
|
||||
let a2 = (y2 - cy).atan2(x2 - cx);
|
||||
|
||||
// With the corrected center, raw sweep (a2-a1) is already in the right
|
||||
// range for most arcs. A single clamp is sufficient — no loop needed.
|
||||
let mut sweep = a2 - a1;
|
||||
if bulge > 0.0 {
|
||||
// CCW: sweep must be in (0, TAU].
|
||||
if sweep <= 0.0 {
|
||||
sweep += TAU;
|
||||
}
|
||||
} else {
|
||||
// CW: sweep must be in [-TAU, 0).
|
||||
if sweep >= 0.0 {
|
||||
sweep -= TAU;
|
||||
}
|
||||
}
|
||||
if sweep.abs() < 1e-7 {
|
||||
sweep = if bulge > 0.0 { TAU } else { -TAU };
|
||||
}
|
||||
|
||||
for i in 1..=n {
|
||||
let t = i as f32 / n as f32;
|
||||
let a = a1 + sweep * t;
|
||||
out.push([cx + r * a.cos(), cy + r * a.sin()]);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue