Grcov report - svg.rs

1

//! SVG tessellation, rendering, and geometric operations.

2

//!

3

//! This module provides:

4

//! - **Tessellation** of SVG primitives (paths, circles, rects, multi-polygons)

5

//!   via the lyon tessellation library (behind the `svg` feature flag).

6

//! - **CPU clip-mask rendering** via the agg-rust rasterizer (`render_node_clipmask_cpu`).

7

//! - **FXAA post-processing** for GPU-rendered textures (`apply_fxaa`).

8

//! - **Boolean polygon operations** (union, intersection, difference, XOR)

9

//!   on `SvgMultiPolygon` shapes via agg scanline boolean algebra.

10

//! - **SVG parsing and rendering** (`svg_parse`, `svg_render`) using an

11

//!   XML parser and the agg-rust rendering pipeline.

12

13

use alloc::boxed::Box;

14

use core::fmt;

15

16

#[cfg(not(feature = "svg"))]

17

pub use azul_core::svg::*;

18

// re-export everything except for Svg and SvgXmlNode

19

#[cfg(feature = "svg")]

20

pub use azul_core::svg::{

21

    c_void,

22

    FontDatabase,

23

    ImageRendering,

24

    Indent,

25

    OptionSvgDashPattern,

26

    ResultSvgSvgParseError,

27

    ResultSvgXmlNodeSvgParseError,

28

    ShapeRendering,

29

    SvgCircle,

30

    SvgColoredVertex,

31

    SvgColoredVertexVec,

32

    SvgColoredVertexVecDestructor,

33

    SvgDashPattern,

34

    SvgFillRule,

35

    SvgFillStyle,

36

    SvgFitTo,

37

    SvgLine,

38

    SvgLineCap,

39

    SvgLineJoin,

40

    SvgMultiPolygon,

41

    SvgMultiPolygonVec,

42

    SvgMultiPolygonVecDestructor,

43

    SvgNode,

44

    SvgParseError,

45

    SvgParseOptions,

46

    SvgPath,

47

    SvgPathElement,

48

    SvgPathElementVec,

49

    SvgPathElementVecDestructor,

50

    SvgPathVec,

51

    SvgPathVecDestructor,

52

    SvgRenderOptions,

53

    SvgRenderTransform,

54

55

    SvgSimpleNode,

56

    SvgSimpleNodeVec,

57

    SvgSimpleNodeVecDestructor,

58

    SvgSize,

59

    SvgStrokeStyle,

60

    SvgStyle,

61

    SvgStyledNode,

62

    SvgTransform,

63

    SvgVertex,

64

    SvgVertexVec,

65

    SvgVertexVecDestructor,

66

    SvgXmlOptions,

67

    TessellatedColoredSvgNode,

68

    TessellatedColoredSvgNodeVec,

69

    TessellatedColoredSvgNodeVecDestructor,

70

    // SvgXmlNode, Svg

71

    TessellatedGPUSvgNode,

72

    TessellatedSvgNode,

73

    TessellatedSvgNodeVec,

74

    TessellatedSvgNodeVecDestructor,

75

    TessellatedSvgNodeVecRef,

76

    TextRendering,

77

};

78

use azul_core::{

79

    geom::PhysicalSizeU32,

80

    gl::{GlContextPtr, Texture},

81

    resources::{RawImage, RawImageFormat},

82

};

83

#[cfg(feature = "svg")]

84

pub use azul_css::props::basic::animation::{

85

    SvgCubicCurve, SvgPoint, SvgQuadraticCurve, SvgRect, SvgVector,

86

};

87

use azul_css::{

88

    impl_result, impl_result_inner,

89

    props::basic::{ColorU, LayoutSize, OptionColorU, OptionLayoutSize},

90

    AzString, OptionI16, OptionString, OptionU16, StringVec, U8Vec,

91

};

92

#[cfg(feature = "svg")]

93

use lyon::{

94

    geom::euclid::{Point2D, Rect, Size2D, UnknownUnit},

95

    math::Point,

96

    path::Path,

97

    tessellation::{

98

        BuffersBuilder, FillOptions, FillTessellator, FillVertex, StrokeOptions, StrokeTessellator,

99

        StrokeVertex, VertexBuffers,

100

},

101

};

102

103

use crate::xml::XmlError;

104

105

#[cfg(feature = "svg")]

106

extern crate agg_rust;

107

108

use azul_core::gl::GL_RESTART_INDEX;

109

110

/// Kappa constant for approximating a circle with 4 cubic Bezier curves: 4/3 * (sqrt(2) - 1).

111

const CIRCLE_BEZIER_KAPPA: f64 = 0.552_284_749_8;

112

113

/// Default render size (width, height) when no target size is specified for SVG rendering.

114

const DEFAULT_SVG_RENDER_SIZE: (u32, u32) = (800, 600);

115

116

#[cfg(feature = "svg")]

117

40

const fn translate_svg_line_join(e: SvgLineJoin) -> lyon::tessellation::LineJoin {

118

    use azul_core::svg::SvgLineJoin::{Miter, MiterClip, Round, Bevel};

119

40

    match e {

120

36

        Miter => lyon::tessellation::LineJoin::Miter,

121

1

        MiterClip => lyon::tessellation::LineJoin::MiterClip,

122

1

        Round => lyon::tessellation::LineJoin::Round,

123

2

        Bevel => lyon::tessellation::LineJoin::Bevel,

124

125

40

126

127

#[cfg(feature = "svg")]

128

74

const fn translate_svg_line_cap(e: SvgLineCap) -> lyon::tessellation::LineCap {

129

    use azul_core::svg::SvgLineCap::{Butt, Square, Round};

130

74

    match e {

131

70

        Butt => lyon::tessellation::LineCap::Butt,

132

2

        Square => lyon::tessellation::LineCap::Square,

133

2

        Round => lyon::tessellation::LineCap::Round,

134

135

74

136

137

#[cfg(feature = "svg")]

138

35

fn translate_svg_stroke_style(e: SvgStrokeStyle) -> StrokeOptions {

139

35

    StrokeOptions::tolerance(e.tolerance)

140

35

        .with_start_cap(translate_svg_line_cap(e.start_cap))

141

35

        .with_end_cap(translate_svg_line_cap(e.end_cap))

142

35

        .with_line_join(translate_svg_line_join(e.line_join))

143

35

        .with_line_width(e.line_width)

144

35

        .with_miter_limit(e.miter_limit)

145

    // TODO: e.apply_line_width - not present in lyon 17!

146

35

147

148

#[cfg(feature = "svg")]

149

20

fn svg_multipolygon_to_lyon_path(polygon: &SvgMultiPolygon) -> Path {

150

20

    let mut builder = Path::builder();

151

152

20

    for p in polygon.rings.as_ref() {

153

20

        if p.items.as_ref().is_empty() {

154

4

            continue;

155

16

156

157

16

        let start_item = p.items.as_ref()[0];

158

16

        let first_point = Point2D::new(start_item.get_start().x, start_item.get_start().y);

159

160

16

        builder.begin(first_point);

161

162

64

        for q in p.items.as_ref().iter().rev()

163

        /* NOTE: REVERSE ITERATOR */

164

165

64

            match q {

166

64

                SvgPathElement::Line(l) => {

167

64

                    builder.line_to(Point2D::new(l.end.x, l.end.y));

168

64

169

                SvgPathElement::QuadraticCurve(qc) => {

170

                    builder.quadratic_bezier_to(

171

                        Point2D::new(qc.ctrl.x, qc.ctrl.y),

172

                        Point2D::new(qc.end.x, qc.end.y),

173

);

174

175

                SvgPathElement::CubicCurve(cc) => {

176

                    builder.cubic_bezier_to(

177

                        Point2D::new(cc.ctrl_1.x, cc.ctrl_1.y),

178

                        Point2D::new(cc.ctrl_2.x, cc.ctrl_2.y),

179

                        Point2D::new(cc.end.x, cc.end.y),

180

);

181

182

183

184

185

16

        builder.end(p.is_closed());

186

187

188

20

    builder.build()

189

20

190

191

#[cfg(feature = "svg")]

192

14

fn svg_multi_shape_to_lyon_path(polygon: &[SvgSimpleNode]) -> Path {

193

    use lyon::{

194

        geom::Box2D,

195

        path::{traits::PathBuilder, Winding},

196

};

197

198

14

    let mut builder = Path::builder();

199

200

44

    for p in polygon {

201

30

        match p {

202

2

            SvgSimpleNode::Path(p) => {

203

2

                if p.items.as_ref().is_empty() {

204

                    continue;

205

2

206

207

2

                let start_item = p.items.as_ref()[0];

208

2

                let first_point = Point2D::new(start_item.get_start().x, start_item.get_start().y);

209

210

2

                builder.begin(first_point);

211

212

8

                for q in p.items.as_ref().iter().rev()

213

                /* NOTE: REVERSE ITERATOR */

214

215

8

                    match q {

216

8

                        SvgPathElement::Line(l) => {

217

8

                            builder.line_to(Point2D::new(l.end.x, l.end.y));

218

8

219

                        SvgPathElement::QuadraticCurve(qc) => {

220

                            builder.quadratic_bezier_to(

221

                                Point2D::new(qc.ctrl.x, qc.ctrl.y),

222

                                Point2D::new(qc.end.x, qc.end.y),

223

);

224

225

                        SvgPathElement::CubicCurve(cc) => {

226

                            builder.cubic_bezier_to(

227

                                Point2D::new(cc.ctrl_1.x, cc.ctrl_1.y),

228

                                Point2D::new(cc.ctrl_2.x, cc.ctrl_2.y),

229

                                Point2D::new(cc.end.x, cc.end.y),

230

);

231

232

233

234

235

2

                builder.end(p.is_closed());

236

237

12

            SvgSimpleNode::Circle(c) => {

238

12

                builder.add_circle(

239

12

                    Point::new(c.center_x, c.center_y),

240

12

                    c.radius,

241

12

                    Winding::Positive,

242

12

);

243

12

244

2

            SvgSimpleNode::CircleHole(c) => {

245

2

                builder.add_circle(

246

2

                    Point::new(c.center_x, c.center_y),

247

2

                    c.radius,

248

2

                    Winding::Negative,

249

2

);

250

2

251

12

            SvgSimpleNode::Rect(c) => {

252

12

                builder.add_rectangle(

253

12

                    &Box2D::from_origin_and_size(

254

12

                        Point::new(c.x, c.y),

255

12

                        Size2D::new(c.width, c.height),

256

12

),

257

12

                    Winding::Positive,

258

12

);

259

12

260

2

            SvgSimpleNode::RectHole(c) => {

261

2

                builder.add_rectangle(

262

2

                    &Box2D::from_origin_and_size(

263

2

                        Point::new(c.x, c.y),

264

2

                        Size2D::new(c.width, c.height),

265

2

),

266

2

                    Winding::Negative,

267

2

);

268

2

269

270

271

272

14

    builder.build()

273

14

274

275

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

276

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

277

110

#[must_use] pub fn raw_line_intersection(p: &SvgLine, q: &SvgLine) -> Option<SvgPoint> {

278

110

    let p_min_x = p.start.x.min(p.end.x);

279

110

    let p_min_y = p.start.y.min(p.end.y);

280

110

    let p_max_x = p.start.x.max(p.end.x);

281

110

    let p_max_y = p.start.y.max(p.end.y);

282

283

110

    let q_min_x = q.start.x.min(q.end.x);

284

110

    let q_min_y = q.start.y.min(q.end.y);

285

110

    let q_max_x = q.start.x.max(q.end.x);

286

110

    let q_max_y = q.start.y.max(q.end.y);

287

288

110

    let int_min_x = p_min_x.max(q_min_x);

289

110

    let int_max_x = p_max_x.min(q_max_x);

290

110

    let int_min_y = p_min_y.max(q_min_y);

291

110

    let int_max_y = p_max_y.min(q_max_y);

292

293

110

    let two = 2.0;

294

110

    let mid_x = (int_min_x + int_max_x) / two;

295

110

    let mid_y = (int_min_y + int_max_y) / two;

296

297

    // condition ordinate values by subtracting midpoint

298

110

    let p1x = p.start.x - mid_x;

299

110

    let p1y = p.start.y - mid_y;

300

110

    let p2x = p.end.x - mid_x;

301

110

    let p2y = p.end.y - mid_y;

302

110

    let q1x = q.start.x - mid_x;

303

110

    let q1y = q.start.y - mid_y;

304

110

    let q2x = q.end.x - mid_x;

305

110

    let q2y = q.end.y - mid_y;

306

307

    // unrolled computation using homogeneous coordinates eqn

308

110

    let px = p1y - p2y;

309

110

    let py = p2x - p1x;

310

110

    let pw = p1x * p2y - p2x * p1y;

311

312

110

    let qx = q1y - q2y;

313

110

    let qy = q2x - q1x;

314

110

    let qw = q1x * q2y - q2x * q1y;

315

316

110

    let xw = py * qw - qy * pw;

317

110

    let yw = qx * pw - px * qw;

318

110

    let w = px * qy - qx * py;

319

320

110

    let x_int = xw / w;

321

110

    let y_int = yw / w;

322

323

    // check for parallel lines

324

110

    if (x_int.is_nan() || x_int.is_infinite()) || (y_int.is_nan() || y_int.is_infinite()) {

325

85

        None

326

    } else {

327

        // de-condition intersection point

328

25

        Some(SvgPoint {

329

25

            x: x_int + mid_x,

330

25

            y: y_int + mid_y,

331

25

})

332

333

110

334

335

/// By-value wrapper for `raw_line_intersection` (for FFI)

336

2

#[must_use] pub fn raw_line_intersection_byval(p: &SvgLine, q: SvgLine) -> Option<SvgPoint> {

337

2

    raw_line_intersection(p, &q)

338

2

339

340

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

341

17

#[must_use] pub fn svg_path_offset(p: &SvgPath, distance: f32, join: SvgLineJoin, cap: SvgLineCap) -> SvgPath {

342

17

    if distance == 0.0 {

343

2

        return p.clone();

344

15

345

346

15

    let mut items = p.items.as_slice().to_vec();

347

15

    if let Some(mut first) = items.first() {

348

14

        items.push(*first);

349

14

350

351

15

    let mut items = items

352

15

        .iter()

353

62

        .map(|l| match l {

354

59

            SvgPathElement::Line(q) => {

355

59

                let normal = match q.outwards_normal() {

356

57

                    Some(s) => SvgPoint {

357

57

                        x: s.x * distance,

358

57

                        y: s.y * distance,

359

57

},

360

2

                    None => return *l,

361

};

362

363

57

                SvgPathElement::Line(SvgLine {

364

57

                    start: SvgPoint {

365

57

                        x: q.start.x + normal.x,

366

57

                        y: q.start.y + normal.y,

367

57

},

368

57

                    end: SvgPoint {

369

57

                        x: q.end.x + normal.x,

370

57

                        y: q.end.y + normal.y,

371

57

},

372

57

})

373

374

2

            SvgPathElement::QuadraticCurve(q) => {

375

2

                let n1 = match (SvgLine {

376

2

                    start: q.start,

377

2

                    end: q.ctrl,

378

2

379

2

                .outwards_normal())

380

381

2

                    Some(s) => SvgPoint {

382

2

                        x: s.x * distance,

383

2

                        y: s.y * distance,

384

2

},

385

                    None => return *l,

386

};

387

388

2

                let n2 = match (SvgLine {

389

2

                    start: q.ctrl,

390

2

                    end: q.end,

391

2

392

2

                .outwards_normal())

393

394

2

                    Some(s) => SvgPoint {

395

2

                        x: s.x * distance,

396

2

                        y: s.y * distance,

397

2

},

398

                    None => return *l,

399

};

400

401

2

                let nl1 = SvgLine {

402

2

                    start: SvgPoint {

403

2

                        x: q.start.x + n1.x,

404

2

                        y: q.start.y + n1.y,

405

2

},

406

2

                    end: SvgPoint {

407

2

                        x: q.ctrl.x + n1.x,

408

2

                        y: q.ctrl.y + n1.y,

409

2

},

410

2

};

411

412

2

                let nl2 = SvgLine {

413

2

                    start: SvgPoint {

414

2

                        x: q.ctrl.x + n2.x,

415

2

                        y: q.ctrl.y + n2.y,

416

2

},

417

2

                    end: SvgPoint {

418

2

                        x: q.end.x + n2.x,

419

2

                        y: q.end.y + n2.y,

420

2

},

421

2

};

422

423

2

                let Some(nctrl) = raw_line_intersection(&nl1, &nl2) else {

424

                    return *l;

425

};

426

427

2

                SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

428

2

                    start: nl1.start,

429

2

                    ctrl: nctrl,

430

2

                    end: nl2.end,

431

2

})

432

433

1

            SvgPathElement::CubicCurve(q) => {

434

1

                let n1 = match (SvgLine {

435

1

                    start: q.start,

436

1

                    end: q.ctrl_1,

437

1

438

1

                .outwards_normal())

439

440

1

                    Some(s) => SvgPoint {

441

1

                        x: s.x * distance,

442

1

                        y: s.y * distance,

443

1

},

444

                    None => return *l,

445

};

446

447

1

                let n2 = match (SvgLine {

448

1

                    start: q.ctrl_1,

449

1

                    end: q.ctrl_2,

450

1

451

1

                .outwards_normal())

452

453

1

                    Some(s) => SvgPoint {

454

1

                        x: s.x * distance,

455

1

                        y: s.y * distance,

456

1

},

457

                    None => return *l,

458

};

459

460

1

                let n3 = match (SvgLine {

461

1

                    start: q.ctrl_2,

462

1

                    end: q.end,

463

1

464

1

                .outwards_normal())

465

466

1

                    Some(s) => SvgPoint {

467

1

                        x: s.x * distance,

468

1

                        y: s.y * distance,

469

1

},

470

                    None => return *l,

471

};

472

473

1

                let nl1 = SvgLine {

474

1

                    start: SvgPoint {

475

1

                        x: q.start.x + n1.x,

476

1

                        y: q.start.y + n1.y,

477

1

},

478

1

                    end: SvgPoint {

479

1

                        x: q.ctrl_1.x + n1.x,

480

1

                        y: q.ctrl_1.y + n1.y,

481

1

},

482

1

};

483

484

1

                let nl2 = SvgLine {

485

1

                    start: SvgPoint {

486

1

                        x: q.ctrl_1.x + n2.x,

487

1

                        y: q.ctrl_1.y + n2.y,

488

1

},

489

1

                    end: SvgPoint {

490

1

                        x: q.ctrl_2.x + n2.x,

491

1

                        y: q.ctrl_2.y + n2.y,

492

1

},

493

1

};

494

495

1

                let nl3 = SvgLine {

496

1

                    start: SvgPoint {

497

1

                        x: q.ctrl_2.x + n3.x,

498

1

                        y: q.ctrl_2.y + n3.y,

499

1

},

500

1

                    end: SvgPoint {

501

1

                        x: q.end.x + n3.x,

502

1

                        y: q.end.y + n3.y,

503

1

},

504

1

};

505

506

1

                let Some(nctrl_1) = raw_line_intersection(&nl1, &nl2) else {

507

                    return *l;

508

};

509

510

1

                let Some(nctrl_2) = raw_line_intersection(&nl2, &nl3) else {

511

                    return *l;

512

};

513

514

1

                SvgPathElement::CubicCurve(SvgCubicCurve {

515

1

                    start: nl1.start,

516

1

                    ctrl_1: nctrl_1,

517

1

                    ctrl_2: nctrl_2,

518

1

                    end: nl3.end,

519

1

})

520

521

62

})

522

15

        .collect::<Vec<_>>();

523

524

34

    for i in 0..items.len().saturating_sub(2) {

525

34

        let a_end_line = match items[i] {

526

33

            SvgPathElement::Line(q) => q,

527

1

            SvgPathElement::QuadraticCurve(q) => SvgLine {

528

1

                start: q.ctrl,

529

1

                end: q.end,

530

1

},

531

            SvgPathElement::CubicCurve(q) => SvgLine {

532

                start: q.ctrl_2,

533

                end: q.end,

534

},

535

};

536

537

34

        let b_start_line = match items[i + 1] {

538

33

            SvgPathElement::Line(q) => q,

539

            SvgPathElement::QuadraticCurve(q) => SvgLine {

540

                start: q.ctrl,

541

                end: q.start,

542

},

543

1

            SvgPathElement::CubicCurve(q) => SvgLine {

544

1

                start: q.ctrl_1,

545

1

                end: q.start,

546

1

},

547

};

548

549

34

        if let Some(intersect_pt) = raw_line_intersection(&a_end_line, &b_start_line) {

550

16

            items[i].set_last(intersect_pt);

551

16

            items[i + 1].set_first(intersect_pt);

552

18

553

554

555

15

    items.pop();

556

557

15

    SvgPath {

558

15

        items: items.into(),

559

15

560

17

561

562

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

563

50

fn shorten_line_end_by(line: SvgLine, distance: f32) -> SvgLine {

564

50

    let dx = line.end.x - line.start.x;

565

50

    let dy = line.end.y - line.start.y;

566

50

    let dt = dx.hypot(dy);

567

50

    let dt_short = dt - distance;

568

569

50

    SvgLine {

570

50

        start: line.start,

571

50

        end: SvgPoint {

572

50

            x: line.start.x + (dt_short / dt) * dx,

573

50

            y: line.start.y + (dt_short / dt) * dy,

574

50

},

575

50

576

50

577

578

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

579

43

fn shorten_line_start_by(line: SvgLine, distance: f32) -> SvgLine {

580

43

    let dx = line.end.x - line.start.x;

581

43

    let dy = line.end.y - line.start.y;

582

43

    let dt = dx.hypot(dy);

583

43

    let dt_short = dt - distance;

584

585

43

    SvgLine {

586

43

        start: SvgPoint {

587

43

            x: line.start.x + (1.0 - dt_short / dt) * dx,

588

43

            y: line.start.y + (1.0 - dt_short / dt) * dy,

589

43

},

590

43

        end: line.end,

591

43

592

43

593

594

// Creates a "bevel"

595

11

#[must_use] pub fn svg_path_bevel(p: &SvgPath, distance: f32) -> SvgPath {

596

11

    let mut items = p.items.as_slice().to_vec();

597

598

    // duplicate first & last items

599

11

    let first = items.first().copied();

600

11

    let last = items.last().copied();

601

11

    if let Some(first) = first {

602

10

        items.push(first);

603

10

604

11

    items.reverse();

605

11

    if let Some(last) = last {

606

10

        items.push(last);

607

10

608

11

    items.reverse();

609

610

11

    let mut final_items = Vec::new();

611

43

    for i in 0..items.len().saturating_sub(1) {

612

43

        let a = items[i];

613

43

        let b = items[i + 1];

614

43

        match (a, b) {

615

40

            (SvgPathElement::Line(a), SvgPathElement::Line(b)) => {

616

40

                let a_short = shorten_line_end_by(a, distance);

617

40

                let b_short = shorten_line_start_by(b, distance);

618

40

                final_items.push(SvgPathElement::Line(a_short));

619

40

                final_items.push(SvgPathElement::CubicCurve(SvgCubicCurve {

620

40

                    start: a_short.end,

621

40

                    ctrl_1: a.end,

622

40

                    ctrl_2: b.start,

623

40

                    end: b_short.start,

624

40

                }));

625

40

                final_items.push(SvgPathElement::Line(b_short));

626

40

627

3

            (other_a, other_b) => {

628

3

                final_items.push(other_a);

629

3

                final_items.push(other_b);

630

3

631

632

633

634

    // remove first & last items again

635

11

    final_items.pop();

636

11

    final_items.reverse();

637

11

    final_items.pop();

638

11

    final_items.reverse();

639

640

11

    SvgPath {

641

11

        items: final_items.into(),

642

11

643

11

644

645

#[cfg(feature = "svg")]

646

60

fn svg_path_to_lyon_path_events(path: &SvgPath) -> Path {

647

60

    let mut builder = Path::builder();

648

649

60

    if !path.items.as_ref().is_empty() {

650

46

        let start_item = path.items.as_ref()[0];

651

46

        let first_point = Point2D::new(start_item.get_start().x, start_item.get_start().y);

652

653

46

        builder.begin(first_point);

654

655

175

        for p in path.items.as_ref() {

656

175

            match p {

657

175

                SvgPathElement::Line(l) => {

658

175

                    builder.line_to(Point2D::new(l.end.x, l.end.y));

659

175

660

                SvgPathElement::QuadraticCurve(qc) => {

661

                    builder.quadratic_bezier_to(

662

                        Point2D::new(qc.ctrl.x, qc.ctrl.y),

663

                        Point2D::new(qc.end.x, qc.end.y),

664

);

665

666

                SvgPathElement::CubicCurve(cc) => {

667

                    builder.cubic_bezier_to(

668

                        Point2D::new(cc.ctrl_1.x, cc.ctrl_1.y),

669

                        Point2D::new(cc.ctrl_2.x, cc.ctrl_2.y),

670

                        Point2D::new(cc.end.x, cc.end.y),

671

);

672

673

674

675

676

46

        builder.end(path.is_closed());

677

14

678

679

60

    builder.build()

680

60

681

682

#[cfg(feature = "svg")]

683

#[inline]

684

161

fn vertex_buffers_to_tessellated_cpu_node(v: VertexBuffers<SvgVertex, u32>) -> TessellatedSvgNode {

685

161

    TessellatedSvgNode {

686

161

        vertices: v.vertices.into(),

687

161

        indices: v.indices.into(),

688

161

689

161

690

691

#[cfg(feature = "svg")]

692

15

#[must_use] pub fn tessellate_multi_polygon_fill(

693

15

    polygon: &SvgMultiPolygon,

694

15

    fill_style: SvgFillStyle,

695

15

) -> TessellatedSvgNode {

696

15

    let polygon = svg_multipolygon_to_lyon_path(polygon);

697

698

15

    let mut geometry = VertexBuffers::new();

699

15

    let mut tessellator = FillTessellator::new();

700

701

15

    let tess_result = tessellator.tessellate_path(

702

15

        &polygon,

703

15

        &FillOptions::tolerance(fill_style.tolerance),

704

56

        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex<'_>| {

705

56

            let xy_arr = vertex.position();

706

56

            SvgVertex {

707

56

                x: xy_arr.x,

708

56

                y: xy_arr.y,

709

56

710

56

}),

711

);

712

713

15

    if tess_result.is_err() {

714

        TessellatedSvgNode::empty()

715

    } else {

716

15

        vertex_buffers_to_tessellated_cpu_node(geometry)

717

718

15

719

720

#[cfg(not(feature = "svg"))]

721

pub fn tessellate_multi_polygon_fill(

722

    polygon: &SvgMultiPolygon,

723

    fill_style: SvgFillStyle,

724

) -> TessellatedSvgNode {

725

    TessellatedSvgNode::default()

726

727

728

#[cfg(feature = "svg")]

729

12

#[must_use] pub fn tessellate_multi_shape_fill(

730

12

    ms: &[SvgSimpleNode],

731

12

    fill_style: SvgFillStyle,

732

12

) -> TessellatedSvgNode {

733

12

    let polygon = svg_multi_shape_to_lyon_path(ms);

734

735

12

    let mut geometry = VertexBuffers::new();

736

12

    let mut tessellator = FillTessellator::new();

737

738

12

    let tess_result = tessellator.tessellate_path(

739

12

        &polygon,

740

12

        &FillOptions::tolerance(fill_style.tolerance),

741

464

        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex<'_>| {

742

464

            let xy_arr = vertex.position();

743

464

            SvgVertex {

744

464

                x: xy_arr.x,

745

464

                y: xy_arr.y,

746

464

747

464

}),

748

);

749

750

12

    if tess_result.is_err() {

751

        TessellatedSvgNode::empty()

752

    } else {

753

12

        vertex_buffers_to_tessellated_cpu_node(geometry)

754

755

12

756

757

#[cfg(not(feature = "svg"))]

758

pub fn tessellate_multi_shape_fill(

759

    ms: &[SvgSimpleNode],

760

    fill_style: SvgFillStyle,

761

) -> TessellatedSvgNode {

762

    TessellatedSvgNode::default()

763

764

765

27

#[must_use] pub fn svg_node_contains_point(

766

27

    node: &SvgNode,

767

27

    point: SvgPoint,

768

27

    fill_rule: SvgFillRule,

769

27

    tolerance: f32,

770

27

) -> bool {

771

27

    match node {

772

1

        SvgNode::MultiPolygonCollection(a) => a

773

1

            .as_ref()

774

1

            .iter()

775

1

            .any(|e| polygon_contains_point(e, point, fill_rule, tolerance)),

776

1

        SvgNode::MultiPolygon(a) => polygon_contains_point(a, point, fill_rule, tolerance),

777

4

        SvgNode::Path(a) => {

778

4

            if !a.is_closed() {

779

2

                return false;

780

2

781

2

            path_contains_point(a, point, fill_rule, tolerance)

782

783

8

        SvgNode::Circle(a) => a.contains_point(point.x, point.y),

784

9

        SvgNode::Rect(a) => a.contains_point(point),

785

4

        SvgNode::MultiShape(a) => a.as_ref().iter().any(|e| match e {

786

1

            SvgSimpleNode::Path(a) => {

787

1

                if !a.is_closed() {

788

1

                    return false;

789

790

                path_contains_point(a, point, fill_rule, tolerance)

791

792

            SvgSimpleNode::Circle(a) => a.contains_point(point.x, point.y),

793

            SvgSimpleNode::Rect(a) => a.contains_point(point),

794

2

            SvgSimpleNode::CircleHole(a) => !a.contains_point(point.x, point.y),

795

            SvgSimpleNode::RectHole(a) => !a.contains_point(point),

796

3

}),

797

798

27

799

800

#[cfg(feature = "svg")]

801

17

#[must_use] pub fn path_contains_point(

802

17

    path: &SvgPath,

803

17

    point: SvgPoint,

804

17

    fill_rule: SvgFillRule,

805

17

    tolerance: f32,

806

17

) -> bool {

807

    use lyon::{

808

        algorithms::hit_test::hit_test_path, math::Point as LyonPoint,

809

        path::FillRule as LyonFillRule,

810

};

811

17

    let path = svg_path_to_lyon_path_events(path);

812

17

    let fill_rule = match fill_rule {

813

15

        SvgFillRule::Winding => LyonFillRule::NonZero,

814

2

        SvgFillRule::EvenOdd => LyonFillRule::EvenOdd,

815

};

816

17

    let point = LyonPoint::new(point.x, point.y);

817

17

    hit_test_path(&point, path.iter(), fill_rule, tolerance)

818

17

819

820

#[cfg(not(feature = "svg"))]

821

pub fn path_contains_point(

822

    path: &SvgPath,

823

    point: SvgPoint,

824

    fill_rule: SvgFillRule,

825

    tolerance: f32,

826

) -> bool {

827

    false

828

829

830

#[cfg(feature = "svg")]

831

5

#[must_use] pub fn polygon_contains_point(

832

5

    polygon: &SvgMultiPolygon,

833

5

    point: SvgPoint,

834

5

    fill_rule: SvgFillRule,

835

5

    tolerance: f32,

836

5

) -> bool {

837

    use lyon::{

838

        algorithms::hit_test::hit_test_path, math::Point as LyonPoint,

839

        path::FillRule as LyonFillRule,

840

};

841

5

    polygon.rings.iter().any(|path| {

842

3

        let path = svg_path_to_lyon_path_events(path);

843

3

        let fill_rule = match fill_rule {

844

3

            SvgFillRule::Winding => LyonFillRule::NonZero,

845

            SvgFillRule::EvenOdd => LyonFillRule::EvenOdd,

846

};

847

3

        let point = LyonPoint::new(point.x, point.y);

848

3

        hit_test_path(&point, path.iter(), fill_rule, tolerance)

849

3

})

850

5

851

852

#[cfg(not(feature = "svg"))]

853

pub fn polygon_contains_point(

854

    polygon: &SvgMultiPolygon,

855

    point: SvgPoint,

856

    fill_rule: SvgFillRule,

857

    tolerance: f32,

858

) -> bool {

859

    false

860

861

862

#[cfg(feature = "svg")]

863

1

#[must_use] pub fn tessellate_multi_shape_stroke(

864

1

    ms: &[SvgSimpleNode],

865

1

    stroke_style: SvgStrokeStyle,

866

1

) -> TessellatedSvgNode {

867

1

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

868

1

    let polygon = svg_multi_shape_to_lyon_path(ms);

869

870

1

    let mut stroke_geometry = VertexBuffers::new();

871

1

    let mut stroke_tess = StrokeTessellator::new();

872

873

1

    let tess_result = stroke_tess.tessellate_path(

874

1

        &polygon,

875

1

        &stroke_options,

876

98

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

877

98

            let xy_arr = vertex.position();

878

98

            SvgVertex {

879

98

                x: xy_arr.x,

880

98

                y: xy_arr.y,

881

98

882

98

}),

883

);

884

885

1

    if tess_result.is_err() {

886

        TessellatedSvgNode::empty()

887

    } else {

888

1

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

889

890

1

891

892

#[cfg(not(feature = "svg"))]

893

pub fn tessellate_multi_shape_stroke(

894

    polygon: &[SvgSimpleNode],

895

    stroke_style: SvgStrokeStyle,

896

) -> TessellatedSvgNode {

897

    TessellatedSvgNode::default()

898

899

900

#[cfg(feature = "svg")]

901

1

#[must_use] pub fn tessellate_multi_polygon_stroke(

902

1

    polygon: &SvgMultiPolygon,

903

1

    stroke_style: SvgStrokeStyle,

904

1

) -> TessellatedSvgNode {

905

1

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

906

1

    let polygon = svg_multipolygon_to_lyon_path(polygon);

907

908

1

    let mut stroke_geometry = VertexBuffers::new();

909

1

    let mut stroke_tess = StrokeTessellator::new();

910

911

1

    let tess_result = stroke_tess.tessellate_path(

912

1

        &polygon,

913

1

        &stroke_options,

914

1

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

915

            let xy_arr = vertex.position();

916

            SvgVertex {

917

                x: xy_arr.x,

918

                y: xy_arr.y,

919

920

}),

921

);

922

923

1

    if tess_result.is_err() {

924

        TessellatedSvgNode::empty()

925

    } else {

926

1

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

927

928

1

929

930

#[cfg(not(feature = "svg"))]

931

pub fn tessellate_multi_polygon_stroke(

932

    polygon: &SvgMultiPolygon,

933

    stroke_style: SvgStrokeStyle,

934

) -> TessellatedSvgNode {

935

    TessellatedSvgNode::default()

936

937

938

#[cfg(feature = "svg")]

939

29

#[must_use] pub fn tessellate_path_fill(path: &SvgPath, fill_style: SvgFillStyle) -> TessellatedSvgNode {

940

29

    let polygon = svg_path_to_lyon_path_events(path);

941

942

29

    let mut geometry = VertexBuffers::new();

943

29

    let mut tessellator = FillTessellator::new();

944

945

29

    let tess_result = tessellator.tessellate_path(

946

29

        &polygon,

947

29

        &FillOptions::tolerance(fill_style.tolerance),

948

67

        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex<'_>| {

949

67

            let xy_arr = vertex.position();

950

67

            SvgVertex {

951

67

                x: xy_arr.x,

952

67

                y: xy_arr.y,

953

67

954

67

}),

955

);

956

957

29

    if tess_result.is_err() {

958

        TessellatedSvgNode::empty()

959

    } else {

960

29

        vertex_buffers_to_tessellated_cpu_node(geometry)

961

962

29

963

964

#[cfg(not(feature = "svg"))]

965

pub fn tessellate_path_fill(path: &SvgPath, fill_style: SvgFillStyle) -> TessellatedSvgNode {

966

    TessellatedSvgNode::default()

967

968

969

#[cfg(feature = "svg")]

970

10

#[must_use] pub fn tessellate_path_stroke(path: &SvgPath, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

971

10

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

972

10

    let polygon = svg_path_to_lyon_path_events(path);

973

974

10

    let mut stroke_geometry = VertexBuffers::new();

975

10

    let mut stroke_tess = StrokeTessellator::new();

976

977

10

    let tess_result = stroke_tess.tessellate_path(

978

10

        &polygon,

979

10

        &stroke_options,

980

91

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

981

90

            let xy_arr = vertex.position();

982

90

            SvgVertex {

983

90

                x: xy_arr.x,

984

90

                y: xy_arr.y,

985

90

986

90

}),

987

);

988

989

10

    if tess_result.is_err() {

990

        TessellatedSvgNode::empty()

991

    } else {

992

10

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

993

994

10

995

996

#[cfg(not(feature = "svg"))]

997

pub fn tessellate_path_stroke(path: &SvgPath, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

998

    TessellatedSvgNode::default()

999

1000

1001

#[cfg(feature = "svg")]

1002

21

#[must_use] pub fn tessellate_circle_fill(c: &SvgCircle, fill_style: SvgFillStyle) -> TessellatedSvgNode {

1003

21

    let center = Point2D::new(c.center_x, c.center_y);

1004

1005

21

    let mut geometry = VertexBuffers::new();

1006

21

    let mut tesselator = FillTessellator::new();

1007

21

    let tess_result = tesselator.tessellate_circle(

1008

21

        center,

1009

21

        c.radius,

1010

21

        &FillOptions::tolerance(fill_style.tolerance),

1011

356

        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex<'_>| {

1012

356

            let xy_arr = vertex.position();

1013

356

            SvgVertex {

1014

356

                x: xy_arr.x,

1015

356

                y: xy_arr.y,

1016

356

1017

356

}),

1018

);

1019

1020

21

    if tess_result.is_err() {

1021

        TessellatedSvgNode::empty()

1022

    } else {

1023

21

        vertex_buffers_to_tessellated_cpu_node(geometry)

1024

1025

21

1026

1027

#[cfg(not(feature = "svg"))]

1028

pub fn tessellate_circle_fill(c: &SvgCircle, fill_style: SvgFillStyle) -> TessellatedSvgNode {

1029

    TessellatedSvgNode::default()

1030

1031

1032

#[cfg(feature = "svg")]

1033

#[must_use] pub fn tessellate_circle_stroke(c: &SvgCircle, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

1034

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1035

    let center = Point2D::new(c.center_x, c.center_y);

1036

1037

    let mut stroke_geometry = VertexBuffers::new();

1038

    let mut tesselator = StrokeTessellator::new();

1039

1040

    let tess_result = tesselator.tessellate_circle(

1041

        center,

1042

        c.radius,

1043

        &stroke_options,

1044

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

1045

            let xy_arr = vertex.position();

1046

            SvgVertex {

1047

                x: xy_arr.x,

1048

                y: xy_arr.y,

1049

1050

}),

1051

);

1052

1053

    if tess_result.is_err() {

1054

        TessellatedSvgNode::empty()

1055

    } else {

1056

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1057

1058

1059

1060

#[cfg(not(feature = "svg"))]

1061

pub fn tessellate_circle_stroke(c: &SvgCircle, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

1062

    TessellatedSvgNode::default()

1063

1064

1065

// TODO: radii not respected on latest version of lyon

1066

#[cfg(feature = "svg")]

1067

67

fn get_radii(r: &SvgRect) -> lyon::geom::Box2D<f32> {

1068

1069

/*

1070

    let radii = BorderRadii {

1071

        top_left: r.radius_top_left,

1072

        top_right: r.radius_top_right,

1073

        bottom_left: r.radius_bottom_left,

1074

        bottom_right: r.radius_bottom_right

1075

    };*/

1076

67

    lyon::geom::Box2D::from_origin_and_size(

1077

67

        Point2D::new(r.x, r.y),

1078

67

        Size2D::new(r.width, r.height),

1079

1080

67

1081

1082

#[cfg(feature = "svg")]

1083

51

#[must_use] pub fn tessellate_rect_fill(r: &SvgRect, fill_style: SvgFillStyle) -> TessellatedSvgNode {

1084

51

    let rect = get_radii(r);

1085

51

    let mut geometry = VertexBuffers::new();

1086

51

    let mut tesselator = FillTessellator::new();

1087

1088

51

    let tess_result = tesselator.tessellate_rectangle(

1089

51

        &rect,

1090

51

        &FillOptions::tolerance(fill_style.tolerance),

1091

204

        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex<'_>| {

1092

204

            let xy_arr = vertex.position();

1093

204

            SvgVertex {

1094

204

                x: xy_arr.x,

1095

204

                y: xy_arr.y,

1096

204

1097

204

}),

1098

);

1099

1100

51

    if tess_result.is_err() {

1101

        TessellatedSvgNode::empty()

1102

    } else {

1103

51

        vertex_buffers_to_tessellated_cpu_node(geometry)

1104

1105

51

1106

1107

#[cfg(not(feature = "svg"))]

1108

pub fn tessellate_rect_fill(r: &SvgRect, fill_style: SvgFillStyle) -> TessellatedSvgNode {

1109

    TessellatedSvgNode::default()

1110

1111

1112

#[cfg(feature = "svg")]

1113

12

#[must_use] pub fn tessellate_rect_stroke(r: &SvgRect, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

1114

12

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1115

12

    let rect = get_radii(r);

1116

1117

12

    let mut stroke_geometry = VertexBuffers::new();

1118

12

    let mut tesselator = StrokeTessellator::new();

1119

1120

12

    let tess_result = tesselator.tessellate_rectangle(

1121

12

        &rect,

1122

12

        &stroke_options,

1123

120

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

1124

120

            let xy_arr = vertex.position();

1125

120

            SvgVertex {

1126

120

                x: xy_arr.x,

1127

120

                y: xy_arr.y,

1128

120

1129

120

}),

1130

);

1131

1132

12

    if tess_result.is_err() {

1133

        TessellatedSvgNode::empty()

1134

    } else {

1135

12

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1136

1137

12

1138

1139

#[cfg(not(feature = "svg"))]

1140

pub fn tessellate_rect_stroke(r: &SvgRect, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

1141

    TessellatedSvgNode::default()

1142

1143

1144

/// Tessellate the path using lyon

1145

#[cfg(feature = "svg")]

1146

2

#[must_use] pub fn tessellate_styled_node(node: &SvgStyledNode) -> TessellatedSvgNode {

1147

2

    match node.style {

1148

1

        SvgStyle::Fill(fs) => tessellate_node_fill(&node.geometry, fs),

1149

1

        SvgStyle::Stroke(ss) => tessellate_node_stroke(&node.geometry, ss),

1150

1151

2

1152

1153

#[cfg(not(feature = "svg"))]

1154

pub fn tessellate_styled_node(node: &SvgStyledNode) -> TessellatedSvgNode {

1155

    TessellatedSvgNode::default()

1156

1157

1158

#[cfg(feature = "svg")]

1159

3

#[must_use] pub fn tessellate_line_stroke(

1160

3

    svgline: &SvgLine,

1161

3

    stroke_style: SvgStrokeStyle,

1162

3

) -> TessellatedSvgNode {

1163

3

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1164

1165

3

    let mut builder = Path::builder();

1166

3

    builder.begin(Point2D::new(svgline.start.x, svgline.start.y));

1167

3

    builder.line_to(Point2D::new(svgline.end.x, svgline.end.y));

1168

3

    builder.end(/* closed */ false);

1169

3

    let path = builder.build();

1170

1171

3

    let mut stroke_geometry = VertexBuffers::new();

1172

3

    let mut stroke_tess = StrokeTessellator::new();

1173

1174

3

    let tess_result = stroke_tess.tessellate_path(

1175

3

        &path,

1176

3

        &stroke_options,

1177

8

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

1178

8

            let xy_arr = vertex.position();

1179

8

            SvgVertex {

1180

8

                x: xy_arr.x,

1181

8

                y: xy_arr.y,

1182

8

1183

8

}),

1184

);

1185

1186

3

    if tess_result.is_err() {

1187

        TessellatedSvgNode::empty()

1188

    } else {

1189

3

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1190

1191

3

1192

1193

#[cfg(not(feature = "svg"))]

1194

pub fn tessellate_line_stroke(

1195

    svgline: &SvgLine,

1196

    stroke_style: SvgStrokeStyle,

1197

) -> TessellatedSvgNode {

1198

    TessellatedSvgNode::default()

1199

1200

1201

#[cfg(feature = "svg")]

1202

2

#[must_use] pub fn tessellate_cubiccurve_stroke(

1203

2

    svgcubiccurve: &SvgCubicCurve,

1204

2

    stroke_style: SvgStrokeStyle,

1205

2

) -> TessellatedSvgNode {

1206

2

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1207

1208

2

    let mut builder = Path::builder();

1209

2

    builder.begin(Point2D::new(svgcubiccurve.start.x, svgcubiccurve.start.y));

1210

2

    builder.cubic_bezier_to(

1211

2

        Point2D::new(svgcubiccurve.ctrl_1.x, svgcubiccurve.ctrl_1.y),

1212

2

        Point2D::new(svgcubiccurve.ctrl_2.x, svgcubiccurve.ctrl_2.y),

1213

2

        Point2D::new(svgcubiccurve.end.x, svgcubiccurve.end.y),

1214

);

1215

2

    builder.end(/* closed */ false);

1216

2

    let path = builder.build();

1217

1218

2

    let mut stroke_geometry = VertexBuffers::new();

1219

2

    let mut stroke_tess = StrokeTessellator::new();

1220

1221

2

    let tess_result = stroke_tess.tessellate_path(

1222

2

        &path,

1223

2

        &stroke_options,

1224

68

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

1225

68

            let xy_arr = vertex.position();

1226

68

            SvgVertex {

1227

68

                x: xy_arr.x,

1228

68

                y: xy_arr.y,

1229

68

1230

68

}),

1231

);

1232

1233

2

    if tess_result.is_err() {

1234

        TessellatedSvgNode::empty()

1235

    } else {

1236

2

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1237

1238

2

1239

1240

#[cfg(not(feature = "svg"))]

1241

pub fn tessellate_cubiccurve_stroke(

1242

    svgline: &SvgCubicCurve,

1243

    stroke_style: SvgStrokeStyle,

1244

) -> TessellatedSvgNode {

1245

    TessellatedSvgNode::default()

1246

1247

1248

#[cfg(feature = "svg")]

1249

2

#[must_use] pub fn tessellate_quadraticcurve_stroke(

1250

2

    svgquadraticcurve: &SvgQuadraticCurve,

1251

2

    stroke_style: SvgStrokeStyle,

1252

2

) -> TessellatedSvgNode {

1253

2

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1254

1255

2

    let mut builder = Path::builder();

1256

2

    builder.begin(Point2D::new(

1257

2

        svgquadraticcurve.start.x,

1258

2

        svgquadraticcurve.start.y,

1259

));

1260

2

    builder.quadratic_bezier_to(

1261

2

        Point2D::new(svgquadraticcurve.ctrl.x, svgquadraticcurve.ctrl.y),

1262

2

        Point2D::new(svgquadraticcurve.end.x, svgquadraticcurve.end.y),

1263

);

1264

2

    builder.end(/* closed */ false);

1265

2

    let path = builder.build();

1266

1267

2

    let mut stroke_geometry = VertexBuffers::new();

1268

2

    let mut stroke_tess = StrokeTessellator::new();

1269

1270

2

    let tess_result = stroke_tess.tessellate_path(

1271

2

        &path,

1272

2

        &stroke_options,

1273

36

        &mut BuffersBuilder::new(&mut stroke_geometry, |vertex: StrokeVertex<'_, '_>| {

1274

36

            let xy_arr = vertex.position();

1275

36

            SvgVertex {

1276

36

                x: xy_arr.x,

1277

36

                y: xy_arr.y,

1278

36

1279

36

}),

1280

);

1281

1282

2

    if tess_result.is_err() {

1283

        TessellatedSvgNode::empty()

1284

    } else {

1285

2

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1286

1287

2

1288

1289

#[cfg(not(feature = "svg"))]

1290

pub fn tessellate_quadraticcurve_stroke(

1291

    svgquadraticcurve: &SvgQuadraticCurve,

1292

    stroke_style: SvgStrokeStyle,

1293

) -> TessellatedSvgNode {

1294

    TessellatedSvgNode::default()

1295

1296

1297

#[cfg(feature = "svg")]

1298

3

#[must_use] pub fn tessellate_svgpathelement_stroke(

1299

3

    svgpathelement: &SvgPathElement,

1300

3

    stroke_style: SvgStrokeStyle,

1301

3

) -> TessellatedSvgNode {

1302

3

    match svgpathelement {

1303

1

        SvgPathElement::Line(l) => tessellate_line_stroke(l, stroke_style),

1304

1

        SvgPathElement::QuadraticCurve(l) => tessellate_quadraticcurve_stroke(l, stroke_style),

1305

1

        SvgPathElement::CubicCurve(l) => tessellate_cubiccurve_stroke(l, stroke_style),

1306

1307

3

1308

1309

#[cfg(not(feature = "svg"))]

1310

pub fn tessellate_svgpathelement_stroke(

1311

    svgpathelement: &SvgPathElement,

1312

    stroke_style: SvgStrokeStyle,

1313

) -> TessellatedSvgNode {

1314

    TessellatedSvgNode::default()

1315

1316

1317

#[cfg(feature = "svg")]

1318

#[allow(clippy::cast_possible_truncation)] // bounded layout/render numeric cast

1319

8

#[must_use] pub fn join_tessellated_nodes(nodes: &[TessellatedSvgNode]) -> TessellatedSvgNode {

1320

8

    let mut index_offset = 0;

1321

1322

    // note: can not be parallelized!

1323

8

    let all_index_offsets = nodes

1324

8

        .as_ref()

1325

8

        .iter()

1326

11

        .map(|t| {

1327

11

            let i = index_offset;

1328

11

            index_offset += t.vertices.len();

1329

11

1330

11

})

1331

8

        .collect::<Vec<_>>();

1332

1333

8

    let all_vertices = nodes

1334

8

        .as_ref()

1335

8

        .iter()

1336

11

        .flat_map(|t| t.vertices.clone().into_library_owned_vec())

1337

8

        .collect::<Vec<_>>();

1338

1339

8

    let all_indices = nodes

1340

8

        .as_ref()

1341

8

        .iter()

1342

8

        .enumerate()

1343

11

        .flat_map(|(buffer_index, t)| {

1344

            // since the vertex buffers are now joined,

1345

            // offset the indices by the vertex buffers lengths

1346

            // encountered so far

1347

11

            let vertex_buffer_offset: u32 = all_index_offsets

1348

11

                .get(buffer_index)

1349

11

                .copied()

1350

11

                .unwrap_or(0)

1351

11

                .min(core::u32::MAX as usize) as u32;

1352

1353

11

            let mut indices = t.indices.clone().into_library_owned_vec();

1354

11

            if vertex_buffer_offset != 0 {

1355

23

                for i in &mut indices {

1356

18

                    if *i != GL_RESTART_INDEX {

1357

17

                        *i += vertex_buffer_offset;

1358

17

1359

1360

6

1361

1362

11

            indices.push(GL_RESTART_INDEX);

1363

1364

11

            indices

1365

11

})

1366

8

        .collect::<Vec<_>>();

1367

1368

8

    TessellatedSvgNode {

1369

8

        vertices: all_vertices.into(),

1370

8

        indices: all_indices.into(),

1371

8

1372

8

1373

1374

#[cfg(feature = "svg")]

1375

#[allow(clippy::cast_possible_truncation)] // bounded layout/render numeric cast

1376

2

#[must_use] pub fn join_tessellated_colored_nodes(

1377

2

    nodes: &[TessellatedColoredSvgNode],

1378

2

) -> TessellatedColoredSvgNode {

1379

2

    let mut index_offset = 0;

1380

1381

    // note: can not be parallelized!

1382

2

    let all_index_offsets = nodes

1383

2

        .as_ref()

1384

2

        .iter()

1385

2

        .map(|t| {

1386

2

            let i = index_offset;

1387

2

            index_offset += t.vertices.len();

1388

2

1389

2

})

1390

2

        .collect::<Vec<_>>();

1391

1392

2

    let all_vertices = nodes

1393

2

        .as_ref()

1394

2

        .iter()

1395

2

        .flat_map(|t| t.vertices.clone().into_library_owned_vec())

1396

2

        .collect::<Vec<_>>();

1397

1398

2

    let all_indices = nodes

1399

2

        .as_ref()

1400

2

        .iter()

1401

2

        .enumerate()

1402

2

        .flat_map(|(buffer_index, t)| {

1403

            // since the vertex buffers are now joined,

1404

            // offset the indices by the vertex buffers lengths

1405

            // encountered so far

1406

2

            let vertex_buffer_offset: u32 = all_index_offsets

1407

2

                .get(buffer_index)

1408

2

                .copied()

1409

2

                .unwrap_or(0)

1410

2

                .min(core::u32::MAX as usize) as u32;

1411

1412

2

            let mut indices = t.indices.clone().into_library_owned_vec();

1413

2

            if vertex_buffer_offset != 0 {

1414

2

                for i in &mut indices {

1415

1

                    if *i != GL_RESTART_INDEX {

1416

1

                        *i += vertex_buffer_offset;

1417

1

1418

1419

1

1420

1421

2

            indices.push(GL_RESTART_INDEX);

1422

1423

2

            indices

1424

2

})

1425

2

        .collect::<Vec<_>>();

1426

1427

2

    TessellatedColoredSvgNode {

1428

2

        vertices: all_vertices.into(),

1429

2

        indices: all_indices.into(),

1430

2

1431

2

1432

1433

#[cfg(not(feature = "svg"))]

1434

pub fn join_tessellated_nodes(nodes: &[TessellatedSvgNode]) -> TessellatedSvgNode {

1435

    TessellatedSvgNode::default()

1436

1437

1438

#[cfg(not(feature = "svg"))]

1439

pub fn join_tessellated_colored_nodes(

1440

    nodes: &[TessellatedColoredSvgNode],

1441

) -> TessellatedColoredSvgNode {

1442

    TessellatedColoredSvgNode::default()

1443

1444

1445

#[cfg(feature = "svg")]

1446

4

#[must_use] pub fn tessellate_node_fill(node: &SvgNode, fs: SvgFillStyle) -> TessellatedSvgNode {

1447

4

    match &node {

1448

2

        SvgNode::MultiPolygonCollection(ref mpc) => {

1449

2

            let tessellated_multipolygons = mpc

1450

2

                .as_ref()

1451

2

                .iter()

1452

2

                .map(|mp| tessellate_multi_polygon_fill(mp, fs))

1453

2

                .collect::<Vec<_>>();

1454

2

            join_tessellated_nodes(&tessellated_multipolygons)

1455

1456

        SvgNode::MultiPolygon(ref mp) => tessellate_multi_polygon_fill(mp, fs),

1457

        SvgNode::Path(ref p) => tessellate_path_fill(p, fs),

1458

        SvgNode::Circle(ref c) => tessellate_circle_fill(c, fs),

1459

2

        SvgNode::Rect(ref r) => tessellate_rect_fill(r, fs),

1460

        SvgNode::MultiShape(ref r) => tessellate_multi_shape_fill(r.as_ref(), fs),

1461

1462

4

1463

1464

#[cfg(not(feature = "svg"))]

1465

pub fn tessellate_node_fill(node: &SvgNode, fs: SvgFillStyle) -> TessellatedSvgNode {

1466

    TessellatedSvgNode::default()

1467

1468

1469

#[cfg(feature = "svg")]

1470

2

#[must_use] pub fn tessellate_node_stroke(node: &SvgNode, ss: SvgStrokeStyle) -> TessellatedSvgNode {

1471

2

    match &node {

1472

        SvgNode::MultiPolygonCollection(ref mpc) => {

1473

            let tessellated_multipolygons = mpc

1474

                .as_ref()

1475

                .iter()

1476

                .map(|mp| tessellate_multi_polygon_stroke(mp, ss))

1477

                .collect::<Vec<_>>();

1478

            join_tessellated_nodes(&tessellated_multipolygons)

1479

1480

        SvgNode::MultiPolygon(ref mp) => tessellate_multi_polygon_stroke(mp, ss),

1481

        SvgNode::Path(ref p) => tessellate_path_stroke(p, ss),

1482

        SvgNode::Circle(ref c) => tessellate_circle_stroke(c, ss),

1483

2

        SvgNode::Rect(ref r) => tessellate_rect_stroke(r, ss),

1484

        SvgNode::MultiShape(ms) => tessellate_multi_shape_stroke(ms.as_ref(), ss),

1485

1486

2

1487

1488

#[cfg(not(feature = "svg"))]

1489

pub fn tessellate_node_stroke(node: &SvgNode, ss: SvgStrokeStyle) -> TessellatedSvgNode {

1490

    TessellatedSvgNode::default()

1491

1492

1493

// NOTE: This is a separate step both in order to reuse GPU textures

1494

// and also because texture allocation is heavy and can be offloaded to a different thread

1495

/// # Panics

1496

///

1497

/// Panics if the GL driver returned no texture id.

1498

#[must_use] pub fn allocate_clipmask_texture(

1499

    gl_context: GlContextPtr,

1500

    size: PhysicalSizeU32,

1501

    _background: ColorU,

1502

) -> Texture {

1503

    use azul_core::gl::TextureFlags;

1504

1505

    let textures = gl_context.gen_textures(1);

1506

    let texture_id = textures.get(0).unwrap();

1507

1508

    Texture::create(

1509

        *texture_id,

1510

        TextureFlags {

1511

            is_opaque: true,

1512

            is_video_texture: false,

1513

},

1514

        size,

1515

        ColorU::TRANSPARENT,

1516

        gl_context,

1517

        RawImageFormat::R8,

1518

1519

1520

1521

/// Applies an FXAA filter to the texture using the pre-compiled FXAA shader.

1522

///

1523

/// Renders a fullscreen quad with the FXAA fragment shader, reading from

1524

/// the input texture and writing to a temporary texture, then swaps the

1525

/// texture IDs so the caller gets the post-FXAA result.

1526

pub fn apply_fxaa(texture: &mut Texture) -> Option<()> {

1527

    apply_fxaa_with_config(texture, &azul_core::gl_fxaa::FxaaConfig::enabled())

1528

1529

1530

/// Applies FXAA with custom configuration parameters.

1531

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_precision_loss, clippy::cast_sign_loss)] // bounded layout/render numeric cast

1532

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

1533

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

1534

pub fn apply_fxaa_with_config(

1535

    texture: &mut Texture,

1536

    config: &azul_core::gl_fxaa::FxaaConfig,

1537

) -> Option<()> {

1538

    use std::mem;

1539

1540

    use azul_core::gl::{GLuint, GlVoidPtrConst, VertexAttributeType};

1541

    use gl_context_loader::gl;

1542

1543

    if !config.enabled || texture.size.width == 0 || texture.size.height == 0 {

1544

        return Some(());

1545

1546

1547

    // FXAA only works on RGBA8 textures

1548

    if texture.format != RawImageFormat::RGBA8 {

1549

        return Some(());

1550

1551

1552

    let texture_size = texture.size;

1553

    let gl_context = &texture.gl_context;

1554

    let fxaa_shader = gl_context.get_fxaa_shader();

1555

    let w = texture_size.width as f32;

1556

    let h = texture_size.height as f32;

1557

1558

    // Save GL state

1559

    let mut current_program = [0_i32];

1560

    let mut current_framebuffers = [0_i32];

1561

    let mut current_texture_2d = [0_i32];

1562

    let mut current_vertex_array_object = [0_i32];

1563

    let mut current_vertex_buffer = [0_i32];

1564

    let mut current_index_buffer = [0_i32];

1565

    let mut current_active_texture = [0_i32];

1566

    let mut current_blend_enabled = [0_u8];

1567

    let mut current_viewport = [0_i32; 4];

1568

1569

    gl_context.get_integer_v(gl::CURRENT_PROGRAM, (&mut current_program[..]).into());

1570

    gl_context.get_integer_v(gl::FRAMEBUFFER, (&mut current_framebuffers[..]).into());

1571

    gl_context.get_integer_v(gl::TEXTURE_2D, (&mut current_texture_2d[..]).into());

1572

    gl_context.get_integer_v(

1573

        gl::VERTEX_ARRAY_BINDING,

1574

        (&mut current_vertex_array_object[..]).into(),

1575

);

1576

    gl_context.get_integer_v(

1577

        gl::ARRAY_BUFFER_BINDING,

1578

        (&mut current_vertex_buffer[..]).into(),

1579

);

1580

    gl_context.get_integer_v(

1581

        gl::ELEMENT_ARRAY_BUFFER_BINDING,

1582

        (&mut current_index_buffer[..]).into(),

1583

);

1584

    gl_context.get_integer_v(

1585

        gl::ACTIVE_TEXTURE,

1586

        (&mut current_active_texture[..]).into(),

1587

);

1588

    gl_context.get_boolean_v(gl::BLEND, (&mut current_blend_enabled[..]).into());

1589

    gl_context.get_integer_v(gl::VIEWPORT, (&mut current_viewport[..]).into());

1590

1591

    // 1. Create temporary output texture

1592

    let temp_textures = gl_context.gen_textures(1);

1593

    let temp_tex_id = *temp_textures.get(0)?;

1594

    gl_context.bind_texture(gl::TEXTURE_2D, temp_tex_id);

1595

    gl_context.tex_image_2d(

1596

        gl::TEXTURE_2D,

1597

0,

1598

        gl::RGBA as i32,

1599

        texture_size.width as i32,

1600

        texture_size.height as i32,

1601

0,

1602

        gl::RGBA,

1603

        gl::UNSIGNED_BYTE,

1604

        None.into(),

1605

);

1606

    gl_context.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as i32);

1607

    gl_context.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as i32);

1608

    gl_context.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as i32);

1609

    gl_context.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as i32);

1610

1611

    // 2. Create FBO targeting the temp texture

1612

    let fbos = gl_context.gen_framebuffers(1);

1613

    let fbo_id = *fbos.get(0)?;

1614

    gl_context.bind_framebuffer(gl::FRAMEBUFFER, fbo_id);

1615

    gl_context.framebuffer_texture_2d(

1616

        gl::FRAMEBUFFER,

1617

        gl::COLOR_ATTACHMENT0,

1618

        gl::TEXTURE_2D,

1619

        temp_tex_id,

1620

0,

1621

);

1622

    gl_context.draw_buffers([gl::COLOR_ATTACHMENT0][..].into());

1623

1624

    debug_assert!(

1625

        gl_context.check_frame_buffer_status(gl::FRAMEBUFFER) == gl::FRAMEBUFFER_COMPLETE

1626

);

1627

1628

    // 3. Create fullscreen quad VAO/VBO/IBO

1629

    // Vertices in [-1, 1] range; the FXAA vertex shader converts to [0, 1] UVs

1630

    let quad_vertices: [f32; 8] = [

1631

        -1.0, -1.0, // bottom-left

1632

         1.0, -1.0, // bottom-right

1633

         1.0,  1.0, // top-right

1634

        -1.0,  1.0, // top-left

1635

];

1636

    let quad_indices: [u32; 6] = [0, 1, 2, 0, 2, 3];

1637

1638

    let vaos = gl_context.gen_vertex_arrays(1);

1639

    let vao_id = *vaos.get(0)?;

1640

    gl_context.bind_vertex_array(vao_id);

1641

1642

    let vbos = gl_context.gen_buffers(1);

1643

    let vbo_id = *vbos.get(0)?;

1644

    gl_context.bind_buffer(gl::ARRAY_BUFFER, vbo_id);

1645

    gl_context.buffer_data_untyped(

1646

        gl::ARRAY_BUFFER,

1647

        (size_of::<f32>() * quad_vertices.len()) as isize,

1648

        GlVoidPtrConst {

1649

            ptr: quad_vertices.as_ptr().cast::<c_void>(),

1650

            run_destructor: true,

1651

},

1652

        gl::STATIC_DRAW,

1653

);

1654

1655

    let ibos = gl_context.gen_buffers(1);

1656

    let ibo_id = *ibos.get(0)?;

1657

    gl_context.bind_buffer(gl::ELEMENT_ARRAY_BUFFER, ibo_id);

1658

    gl_context.buffer_data_untyped(

1659

        gl::ELEMENT_ARRAY_BUFFER,

1660

        (size_of::<u32>() * quad_indices.len()) as isize,

1661

        GlVoidPtrConst {

1662

            ptr: quad_indices.as_ptr().cast::<c_void>(),

1663

            run_destructor: true,

1664

},

1665

        gl::STATIC_DRAW,

1666

);

1667

1668

    // Set up vertex attribute for vAttrXY (location 0, bound at shader compilation)

1669

    let vertex_type = VertexAttributeType::Float;

1670

    let stride = vertex_type.get_mem_size() * 2; // 2 floats per vertex (x, y)

1671

    gl_context.vertex_attrib_pointer(0, 2, vertex_type.get_gl_id(), false, stride as i32, 0);

1672

    gl_context.enable_vertex_attrib_array(0);

1673

1674

    // 4. Render FXAA pass

1675

    gl_context.use_program(fxaa_shader);

1676

    gl_context.viewport(0, 0, texture_size.width as i32, texture_size.height as i32);

1677

    gl_context.disable(gl::BLEND); // FXAA reads exact colors, blending would corrupt output

1678

1679

    // Bind input texture to GL_TEXTURE0

1680

    gl_context.active_texture(gl::TEXTURE0);

1681

    gl_context.bind_texture(gl::TEXTURE_2D, texture.texture_id);

1682

1683

    // Set uniforms

1684

    let u_texture = gl_context.get_uniform_location(fxaa_shader, "uTexture");

1685

    gl_context.uniform_1i(u_texture, 0);

1686

1687

    let u_texel_size = gl_context.get_uniform_location(fxaa_shader, "uTexelSize");

1688

    gl_context.uniform_2f(u_texel_size, 1.0 / w, 1.0 / h);

1689

1690

    let u_edge_threshold =

1691

        gl_context.get_uniform_location(fxaa_shader, "uEdgeThreshold");

1692

    gl_context.uniform_1f(u_edge_threshold, config.edge_threshold);

1693

1694

    let u_edge_threshold_min =

1695

        gl_context.get_uniform_location(fxaa_shader, "uEdgeThresholdMin");

1696

    gl_context.uniform_1f(u_edge_threshold_min, config.edge_threshold_min);

1697

1698

    // Draw the fullscreen quad

1699

    gl_context.draw_elements(gl::TRIANGLES, 6, gl::UNSIGNED_INT, 0);

1700

1701

    // 5. Swap texture IDs: the temp texture now has the FXAA result.

1702

    // We swap so the caller's texture_id points to the anti-aliased result,

1703

    // and the old texture_id gets cleaned up.

1704

    let old_texture_id = texture.texture_id;

1705

    texture.texture_id = temp_tex_id;

1706

    // Delete the old texture (which was the input)

1707

    gl_context.delete_textures((&[old_texture_id])[..].into());

1708

1709

    // 6. Cleanup: delete FBO, quad buffers

1710

    gl_context.delete_framebuffers((&[fbo_id])[..].into());

1711

    gl_context.disable_vertex_attrib_array(0);

1712

    gl_context.delete_vertex_arrays((&[vao_id])[..].into());

1713

    gl_context.delete_buffers((&[vbo_id, ibo_id])[..].into());

1714

1715

    // Restore GL state

1716

    gl_context.bind_framebuffer(gl::FRAMEBUFFER, current_framebuffers[0] as u32);

1717

    gl_context.bind_texture(gl::TEXTURE_2D, current_texture_2d[0] as u32);

1718

    gl_context.bind_vertex_array(current_vertex_array_object[0] as u32);

1719

    gl_context.bind_buffer(gl::ELEMENT_ARRAY_BUFFER, current_index_buffer[0] as u32);

1720

    gl_context.bind_buffer(gl::ARRAY_BUFFER, current_vertex_buffer[0] as u32);

1721

    gl_context.use_program(current_program[0] as u32);

1722

    gl_context.active_texture(current_active_texture[0] as u32);

1723

    gl_context.viewport(

1724

        current_viewport[0],

1725

        current_viewport[1],

1726

        current_viewport[2],

1727

        current_viewport[3],

1728

);

1729

    if u32::from(current_blend_enabled[0]) == gl::TRUE {

1730

        gl_context.enable(gl::BLEND);

1731

1732

1733

    Some(())

1734

1735

1736

#[cfg(feature = "svg")]

1737

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)] // bounded layout/render numeric cast

1738

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

1739

12

pub fn render_node_clipmask_cpu(

1740

12

    image: &mut RawImage,

1741

12

    node: &SvgNode,

1742

12

    style: SvgStyle,

1743

12

) -> Option<()> {

1744

    use azul_core::resources::RawImageData;

1745

    use agg_rust::{

1746

        basics::{FillingRule, VertexSource, PATH_FLAGS_NONE},

1747

        path_storage::PathStorage,

1748

        color::Rgba8,

1749

        conv_stroke::ConvStroke,

1750

        conv_transform::ConvTransform,

1751

        math_stroke::{LineCap, LineJoin},

1752

        pixfmt_rgba::{PixfmtRgba32, PixelFormat},

1753

        rasterizer_scanline_aa::RasterizerScanlineAa,

1754

        renderer_base::RendererBase,

1755

        renderer_scanline::render_scanlines_aa_solid,

1756

        rendering_buffer::RowAccessor,

1757

        scanline_u::ScanlineU8,

1758

        trans_affine::TransAffine,

1759

};

1760

1761

    #[allow(clippy::many_single_char_names)] // domain-standard coordinate/geometry/short-lived names

1762

    #[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

1763

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

1764

9

    fn agg_translate_node(node: &SvgNode) -> Option<PathStorage> {

1765

        macro_rules! build_path {

1766

            ($path:expr, $p:expr) => {{

1767

                if $p.items.as_ref().is_empty() {

1768

                    return None;

1769

1770

1771

                let start = $p.items.as_ref()[0].get_start();

1772

                $path.move_to(f64::from(start.x), f64::from(start.y));

1773

1774

                for path_element in $p.items.as_ref() {

1775

                    match path_element {

1776

                        SvgPathElement::Line(l) => {

1777

                            $path.line_to(f64::from(l.end.x), f64::from(l.end.y));

1778

1779

                        SvgPathElement::QuadraticCurve(qc) => {

1780

                            $path.curve3(

1781

                                f64::from(qc.ctrl.x), f64::from(qc.ctrl.y),

1782

                                f64::from(qc.end.x), f64::from(qc.end.y),

1783

);

1784

1785

                        SvgPathElement::CubicCurve(cc) => {

1786

                            $path.curve4(

1787

                                f64::from(cc.ctrl_1.x), f64::from(cc.ctrl_1.y),

1788

                                f64::from(cc.ctrl_2.x), f64::from(cc.ctrl_2.y),

1789

                                f64::from(cc.end.x), f64::from(cc.end.y),

1790

);

1791

1792

1793

1794

1795

                if $p.is_closed() {

1796

                    $path.close_polygon(PATH_FLAGS_NONE);

1797

1798

}};

1799

1800

1801

9

        let mut path = PathStorage::new();

1802

9

        match node {

1803

1

            SvgNode::MultiPolygonCollection(mpc) => {

1804

1

                for mp in mpc {

1805

                    for p in &mp.rings {

1806

                        build_path!(path, p);

1807

1808

1809

1810

1

            SvgNode::MultiPolygon(mp) => {

1811

1

                for p in &mp.rings {

1812

                    build_path!(path, p);

1813

1814

1815

1

            SvgNode::Path(p) => {

1816

1

                build_path!(path, p);

1817

1818

1

            SvgNode::Circle(c) => {

1819

1

                // Approximate circle with 4 cubic beziers

1820

1

                let cx = f64::from(c.center_x);

1821

1

                let cy = f64::from(c.center_y);

1822

1

                let r = f64::from(c.radius);

1823

1

                let k = CIRCLE_BEZIER_KAPPA;

1824

1

                let kr = k * r;

1825

1

                path.move_to(cx + r, cy);

1826

1

                path.curve4(cx + r, cy + kr, cx + kr, cy + r, cx, cy + r);

1827

1

                path.curve4(cx - kr, cy + r, cx - r, cy + kr, cx - r, cy);

1828

1

                path.curve4(cx - r, cy - kr, cx - kr, cy - r, cx, cy - r);

1829

1

                path.curve4(cx + kr, cy - r, cx + r, cy - kr, cx + r, cy);

1830

1

                path.close_polygon(PATH_FLAGS_NONE);

1831

1

1832

4

            SvgNode::Rect(r) => {

1833

4

                let x = f64::from(r.x);

1834

4

                let y = f64::from(r.y);

1835

4

                let w = f64::from(r.width);

1836

4

                let h = f64::from(r.height);

1837

4

                path.move_to(x, y);

1838

4

                path.line_to(x + w, y);

1839

4

                path.line_to(x + w, y + h);

1840

4

                path.line_to(x, y + h);

1841

4

                path.close_polygon(PATH_FLAGS_NONE);

1842

4

1843

1

            SvgNode::MultiShape(ms) => {

1844

1

                for p in ms.as_ref() {

1845

                    match p {

1846

                        SvgSimpleNode::Path(p) => {

1847

                            build_path!(path, p);

1848

1849

                        SvgSimpleNode::Rect(r) => {

1850

                            let x = f64::from(r.x);

1851

                            let y = f64::from(r.y);

1852

                            let w = f64::from(r.width);

1853

                            let h = f64::from(r.height);

1854

                            path.move_to(x, y);

1855

                            path.line_to(x + w, y);

1856

                            path.line_to(x + w, y + h);

1857

                            path.line_to(x, y + h);

1858

                            path.close_polygon(PATH_FLAGS_NONE);

1859

1860

                        SvgSimpleNode::Circle(c) | SvgSimpleNode::CircleHole(c) => {

1861

                            let cx = f64::from(c.center_x);

1862

                            let cy = f64::from(c.center_y);

1863

                            let r = f64::from(c.radius);

1864

                            let k = CIRCLE_BEZIER_KAPPA;

1865

                            let kr = k * r;

1866

                            path.move_to(cx + r, cy);

1867

                            path.curve4(cx + r, cy + kr, cx + kr, cy + r, cx, cy + r);

1868

                            path.curve4(cx - kr, cy + r, cx - r, cy + kr, cx - r, cy);

1869

                            path.curve4(cx - r, cy - kr, cx - kr, cy - r, cx, cy - r);

1870

                            path.curve4(cx + kr, cy - r, cx + r, cy - kr, cx + r, cy);

1871

                            path.close_polygon(PATH_FLAGS_NONE);

1872

1873

                        SvgSimpleNode::RectHole(r) => {

1874

                            let x = f64::from(r.x);

1875

                            let y = f64::from(r.y);

1876

                            let w = f64::from(r.width);

1877

                            let h = f64::from(r.height);

1878

                            path.move_to(x, y);

1879

                            path.line_to(x + w, y);

1880

                            path.line_to(x + w, y + h);

1881

                            path.line_to(x, y + h);

1882

                            path.close_polygon(PATH_FLAGS_NONE);

1883

1884

1885

1886

1887

1888

8

        if path.total_vertices() == 0 {

1889

3

            return None;

1890

5

1891

5

        Some(path)

1892

9

1893

1894

12

    let w = image.width as u32;

1895

12

    let h = image.height as u32;

1896

12

    if w == 0 || h == 0 {

1897

3

        return None;

1898

9

1899

1900

9

    let transform_data = style.get_transform();

1901

9

    let transform = TransAffine::new_custom(

1902

9

        f64::from(transform_data.sx),

1903

9

        f64::from(transform_data.ky),

1904

9

        f64::from(transform_data.kx),

1905

9

        f64::from(transform_data.sy),

1906

9

        f64::from(transform_data.tx),

1907

9

        f64::from(transform_data.ty),

1908

);

1909

1910

9

    let mut agg_path = agg_translate_node(node)?;

1911

5

    let white = Rgba8::new(255, 255, 255, 255);

1912

1913

    // Create pixel buffer and render

1914

5

    let mut buf = vec![0u8; (w as usize) * (h as usize) * 4];

1915

5

    let stride = (w * 4) as i32;

1916

5

    let mut ra = unsafe { RowAccessor::new_with_buf(buf.as_mut_ptr(), w, h, stride) };

1917

5

    let mut pf = PixfmtRgba32::new(&mut ra);

1918

5

    let mut rb = RendererBase::new(pf);

1919

5

    let mut ras = RasterizerScanlineAa::new();

1920

5

    let mut sl = ScanlineU8::new();

1921

1922

5

    match style {

1923

4

        SvgStyle::Fill(fs) => {

1924

4

            ras.filling_rule(match fs.fill_rule {

1925

4

                SvgFillRule::Winding => FillingRule::NonZero,

1926

                SvgFillRule::EvenOdd => FillingRule::EvenOdd,

1927

});

1928

4

            if transform.is_identity(0.0001) {

1929

3

                ras.add_path(&mut agg_path, 0);

1930

3

            } else {

1931

1

                let mut transformed = ConvTransform::new(&mut agg_path, transform);

1932

1

                ras.add_path(&mut transformed, 0);

1933

1

1934

4

            render_scanlines_aa_solid(&mut ras, &mut sl, &mut rb, &white);

1935

1936

1

        SvgStyle::Stroke(ss) => {

1937

1

            let mut stroke = ConvStroke::new(agg_path);

1938

1

            stroke.set_width(f64::from(ss.line_width));

1939

1

            stroke.set_miter_limit(f64::from(ss.miter_limit));

1940

1

            stroke.set_line_cap(match ss.start_cap {

1941

1

                SvgLineCap::Butt => LineCap::Butt,

1942

                SvgLineCap::Square => LineCap::Square,

1943

                SvgLineCap::Round => LineCap::Round,

1944

});

1945

1

            stroke.set_line_join(match ss.line_join {

1946

1

                SvgLineJoin::Miter | SvgLineJoin::MiterClip => LineJoin::Miter,

1947

                SvgLineJoin::Round => LineJoin::Round,

1948

                SvgLineJoin::Bevel => LineJoin::Bevel,

1949

});

1950

1

            if transform.is_identity(0.0001) {

1951

1

                ras.add_path(&mut stroke, 0);

1952

1

            } else {

1953

                let mut transformed = ConvTransform::new(&mut stroke, transform);

1954

                ras.add_path(&mut transformed, 0);

1955

1956

1

            render_scanlines_aa_solid(&mut ras, &mut sl, &mut rb, &white);

1957

1958

1959

1960

    // Extract red channel from RGBA buffer

1961

5

    let red_channel = buf

1962

5

        .chunks_exact(4)

1963

320

        .map(|r| r[0])

1964

5

        .collect::<Vec<_>>();

1965

1966

5

    image.premultiplied_alpha = true;

1967

5

    image.pixels = RawImageData::U8(red_channel.into());

1968

5

    image.data_format = RawImageFormat::R8;

1969

1970

5

    Some(())

1971

12

1972

1973

#[cfg(not(feature = "svg"))]

1974

pub fn render_node_clipmask_cpu(

1975

    image: &mut RawImage,

1976

    node: &SvgNode,

1977

    style: SvgStyle,

1978

) -> Option<()> {

1979

    None

1980

1981

1982

// ============================================================================

1983

// Boolean operations on SvgMultiPolygon — via agg scanline boolean algebra

1984

// ============================================================================

1985

1986

/// Rasterize an `SvgMultiPolygon` into an agg `RasterizerScanlineAa`.

1987

34

fn rasterize_multi_polygon(mp: &SvgMultiPolygon) -> agg_rust::rasterizer_scanline_aa::RasterizerScanlineAa {

1988

    use agg_rust::{

1989

        basics::{FillingRule, PATH_FLAGS_NONE},

1990

        path_storage::PathStorage,

1991

        rasterizer_scanline_aa::RasterizerScanlineAa,

1992

};

1993

1994

34

    let mut ras = RasterizerScanlineAa::new();

1995

34

    ras.filling_rule(FillingRule::NonZero);

1996

1997

34

    let mut path = PathStorage::new();

1998

34

    for ring in mp.rings.as_ref() {

1999

26

        let mut first = true;

2000

100

        for item in ring.items.as_ref() {

2001

100

            match item {

2002

96

                SvgPathElement::Line(l) => {

2003

96

                    if first {

2004

24

                        path.move_to(f64::from(l.start.x), f64::from(l.start.y));

2005

24

                        first = false;

2006

72

2007

96

                    path.line_to(f64::from(l.end.x), f64::from(l.end.y));

2008

2009

2

                SvgPathElement::QuadraticCurve(q) => {

2010

2

                    if first {

2011

2

                        path.move_to(f64::from(q.start.x), f64::from(q.start.y));

2012

2

                        first = false;

2013

2

2014

2

                    path.curve3(f64::from(q.ctrl.x), f64::from(q.ctrl.y), f64::from(q.end.x), f64::from(q.end.y));

2015

2016

2

                SvgPathElement::CubicCurve(c) => {

2017

2

                    if first {

2018

                        path.move_to(f64::from(c.start.x), f64::from(c.start.y));

2019

                        first = false;

2020

2

2021

2

                    path.curve4(

2022

2

                        f64::from(c.ctrl_1.x), f64::from(c.ctrl_1.y),

2023

2

                        f64::from(c.ctrl_2.x), f64::from(c.ctrl_2.y),

2024

2

                        f64::from(c.end.x), f64::from(c.end.y),

2025

);

2026

2027

2028

2029

26

        path.close_polygon(PATH_FLAGS_NONE);

2030

2031

34

    ras.add_path(&mut path, 0);

2032

34

ras

2033

34

2034

2035

/// Extract polygon contours from a `ScanlineStorageAa` by tracing

2036

/// horizontal span edges across consecutive scanlines.

2037

///

2038

/// For each row, we collect the solid spans (coverage > 128). Then we

2039

/// trace left/right boundaries of connected span groups into closed

2040

/// polygons (go down on the left edge, come back up on the right edge).

2041

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_precision_loss, clippy::cast_sign_loss)] // bounded layout/render numeric cast

2042

18

fn storage_to_multi_polygon(

2043

18

    storage: &mut agg_rust::scanline_storage_aa::ScanlineStorageAa,

2044

18

) -> SvgMultiPolygon {

2045

    use agg_rust::rasterizer_scanline_aa::Scanline;

2046

    use azul_css::props::basic::SvgPoint;

2047

2048

    // Collect solid spans per row

2049

18

    let mut rows: Vec<(i32, Vec<(i32, i32)>)> = Vec::new(); // (y, [(x_start, x_end)])

2050

2051

18

    let mut sl = agg_rust::scanline_u::ScanlineU8::new();

2052

18

    if storage.rewind_scanlines() {

2053

10

        sl.reset(storage.min_x(), storage.max_x());

2054

128

        while storage.sweep_scanline(&mut sl) {

2055

118

            let y = Scanline::y(&sl);

2056

118

            let mut row_spans: Vec<(i32, i32)> = Vec::new();

2057

128

            for span in sl.begin() {

2058

                // Span with positive len: per-pixel coverage

2059

128

                let len = span.len;

2060

128

                if len <= 0 { continue; }

2061

                // Check if any pixel in the span has enough coverage

2062

128

                let covers = sl.covers();

2063

128

                let mut x_start = None;

2064

1074

                for j in 0..len as usize {

2065

1074

                    let cov = covers.get(span.cover_offset + j).copied().unwrap_or(0);

2066

1074

                    if cov > 128 {

2067

1056

                        if x_start.is_none() { x_start = Some(span.x + j as i32); }

2068

18

                    } else if let Some(xs) = x_start.take() {

2069

8

                        row_spans.push((xs, span.x + j as i32));

2070

10

2071

2072

128

                if let Some(xs) = x_start {

2073

119

                    row_spans.push((xs, span.x + len));

2074

119

2075

2076

118

            if !row_spans.is_empty() {

2077

117

                rows.push((y, row_spans));

2078

117

2079

2080

8

2081

2082

18

    if rows.is_empty() {

2083

8

        return SvgMultiPolygon { rings: SvgPathVec::from_const_slice(&[]) };

2084

10

2085

2086

    // Simple contour extraction: for each row, create horizontal line segments.

2087

    // Then connect consecutive rows into closed polygons.

2088

    // This produces axis-aligned polygons (staircase approximation).

2089

10

    let mut rings = Vec::new();

2090

2091

127

    for (y, spans) in &rows {

2092

117

        let yf = *y as f32;

2093

244

        for &(x0, x1) in spans {

2094

127

            let x0f = x0 as f32;

2095

127

            let x1f = x1 as f32;

2096

127

            // Create a small horizontal rectangle for this span

2097

127

            let elements = vec![

2098

127

                SvgPathElement::Line(SvgLine::new(

2099

127

                    SvgPoint { x: x0f, y: yf },

2100

127

                    SvgPoint { x: x1f, y: yf },

2101

127

)),

2102

127

                SvgPathElement::Line(SvgLine::new(

2103

127

                    SvgPoint { x: x1f, y: yf },

2104

127

                    SvgPoint { x: x1f, y: yf + 1.0 },

2105

127

)),

2106

127

                SvgPathElement::Line(SvgLine::new(

2107

127

                    SvgPoint { x: x1f, y: yf + 1.0 },

2108

127

                    SvgPoint { x: x0f, y: yf + 1.0 },

2109

127

)),

2110

127

                SvgPathElement::Line(SvgLine::new(

2111

127

                    SvgPoint { x: x0f, y: yf + 1.0 },

2112

127

                    SvgPoint { x: x0f, y: yf },

2113

127

)),

2114

127

];

2115

127

            rings.push(SvgPath { items: SvgPathElementVec::from_vec(elements) });

2116

127

2117

2118

2119

10

    SvgMultiPolygon { rings: SvgPathVec::from_vec(rings) }

2120

18

2121

2122

/// Perform a boolean operation on two `SvgMultiPolygon` shapes using agg scanline algebra.

2123

17

fn svg_bool_op(

2124

17

    a: &SvgMultiPolygon,

2125

17

    b: &SvgMultiPolygon,

2126

17

    op: agg_rust::scanline_boolean_algebra::SBoolOp,

2127

17

) -> SvgMultiPolygon {

2128

    use agg_rust::{

2129

        scanline_boolean_algebra::sbool_combine_shapes_aa,

2130

        scanline_storage_aa::ScanlineStorageAa,

2131

        scanline_u::ScanlineU8,

2132

};

2133

2134

17

    let mut ras1 = rasterize_multi_polygon(a);

2135

17

    let mut ras2 = rasterize_multi_polygon(b);

2136

2137

17

    let mut sl1 = ScanlineU8::new();

2138

17

    let mut sl2 = ScanlineU8::new();

2139

17

    let mut sl_result = ScanlineU8::new();

2140

17

    let mut storage1 = ScanlineStorageAa::new();

2141

17

    let mut storage2 = ScanlineStorageAa::new();

2142

17

    let mut storage_result = ScanlineStorageAa::new();

2143

2144

17

    sbool_combine_shapes_aa(

2145

17

op,

2146

17

        &mut ras1, &mut ras2,

2147

17

        &mut sl1, &mut sl2, &mut sl_result,

2148

17

        &mut storage1, &mut storage2, &mut storage_result,

2149

);

2150

2151

17

    storage_to_multi_polygon(&mut storage_result)

2152

17

2153

2154

5

#[must_use] pub fn svg_multi_polygon_union(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2155

5

    svg_bool_op(a, b, agg_rust::scanline_boolean_algebra::SBoolOp::Or)

2156

5

2157

2158

// FFI by-value variant: `b` is taken owned to mirror the exported api.json signature.

2159

#[allow(clippy::needless_pass_by_value)]

2160

1

#[must_use] pub fn svg_multi_polygon_union_byval(a: &SvgMultiPolygon, b: SvgMultiPolygon) -> SvgMultiPolygon {

2161

1

    svg_multi_polygon_union(a, &b)

2162

1

2163

2164

4

#[must_use] pub fn svg_multi_polygon_intersection(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2165

4

    svg_bool_op(a, b, agg_rust::scanline_boolean_algebra::SBoolOp::And)

2166

4

2167

2168

// FFI by-value variant: `b` is taken owned to mirror the exported api.json signature.

2169

#[allow(clippy::needless_pass_by_value)]

2170

1

#[must_use] pub fn svg_multi_polygon_intersection_byval(

2171

1

    a: &SvgMultiPolygon, b: SvgMultiPolygon,

2172

1

) -> SvgMultiPolygon {

2173

1

    svg_multi_polygon_intersection(a, &b)

2174

1

2175

2176

4

#[must_use] pub fn svg_multi_polygon_difference(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2177

4

    svg_bool_op(a, b, agg_rust::scanline_boolean_algebra::SBoolOp::AMinusB)

2178

4

2179

2180

// FFI by-value variant: `b` is taken owned to mirror the exported api.json signature.

2181

#[allow(clippy::needless_pass_by_value)]

2182

1

#[must_use] pub fn svg_multi_polygon_difference_byval(

2183

1

    a: &SvgMultiPolygon, b: SvgMultiPolygon,

2184

1

) -> SvgMultiPolygon {

2185

1

    svg_multi_polygon_difference(a, &b)

2186

1

2187

2188

4

#[must_use] pub fn svg_multi_polygon_xor(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2189

4

    svg_bool_op(a, b, agg_rust::scanline_boolean_algebra::SBoolOp::Xor)

2190

4

2191

2192

// FFI by-value variant: `b` is taken owned to mirror the exported api.json signature.

2193

#[allow(clippy::needless_pass_by_value)]

2194

1

#[must_use] pub fn svg_multi_polygon_xor_byval(a: &SvgMultiPolygon, b: SvgMultiPolygon) -> SvgMultiPolygon {

2195

1

    svg_multi_polygon_xor(a, &b)

2196

1

2197

2198

// ============================================================================

2199

// SVG Rendering — ParsedSvg wraps the XML tree, no usvg

2200

// ============================================================================

2201

2202

/// Parsed SVG document — wraps the XML node tree.

2203

///

2204

/// Previously wrapped `usvg::Tree`; now stores our own `XmlNode` tree parsed via xmlparser.

2205

/// Rendering uses the agg-rust pipeline in `cpurender::render_svg_to_png()`.

2206

#[derive(Debug, Clone)]

2207

#[repr(C)]

2208

pub struct ParsedSvgXmlNode {

2209

    pub run_destructor: bool,

2210

2211

2212

impl Drop for ParsedSvgXmlNode {

2213

6

    fn drop(&mut self) { self.run_destructor = false; }

2214

2215

2216

/// # Errors

2217

///

2218

/// Returns a `SvgParseError` if the input is not valid SVG.

2219

5

pub fn svgxmlnode_parse(

2220

5

    svg_file_data: &[u8],

2221

5

    _options: SvgParseOptions,

2222

5

) -> Result<ParsedSvgXmlNode, SvgParseError> {

2223

    // Verify we can parse the XML

2224

5

    let s = core::str::from_utf8(svg_file_data)

2225

5

        .map_err(|_| SvgParseError::NotAnUtf8Str)?;

2226

4

    let _nodes = crate::xml::parse_xml_string(s)

2227

4

        .map_err(|_| SvgParseError::NoParserAvailable)?;

2228

3

    Ok(ParsedSvgXmlNode { run_destructor: true })

2229

5

2230

2231

/// Parsed SVG document. Stores the raw SVG bytes for deferred rendering.

2232

#[derive(Clone)]

2233

#[repr(C)]

2234

pub struct ParsedSvg {

2235

    pub svg_data: azul_css::U8Vec,

2236

    pub run_destructor: bool,

2237

2238

2239

impl Drop for ParsedSvg {

2240

31

    fn drop(&mut self) { self.run_destructor = false; }

2241

2242

2243

impl_result!(

2244

    ParsedSvg,

2245

    SvgParseError,

2246

    ResultParsedSvgSvgParseError,

2247

    copy = false,

2248

    [Debug, Clone]

2249

);

2250

2251

impl From<ParsedSvg> for azul_core::svg::Svg {

2252

    fn from(_parsed: ParsedSvg) -> Self {

2253

        Self {

2254

            tree: core::ptr::null(),

2255

            run_destructor: false,

2256

2257

2258

2259

2260

impl fmt::Debug for ParsedSvg {

2261

2

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

2262

2

        write!(f, "ParsedSvg({} bytes)", self.svg_data.as_ref().len())

2263

2

2264

2265

2266

impl ParsedSvg {

2267

    /// # Errors

2268

///

2269

    /// Returns a `SvgParseError` if the input is not valid SVG.

2270

12

    pub fn from_string(

2271

12

        svg_string: &str,

2272

12

        parse_options: SvgParseOptions,

2273

12

    ) -> Result<Self, SvgParseError> {

2274

12

        svg_parse(svg_string.as_bytes(), parse_options)

2275

12

2276

2277

    /// # Errors

2278

///

2279

    /// Returns a `SvgParseError` if the input is not valid SVG.

2280

1

    pub fn from_bytes(

2281

1

        svg_bytes: &[u8],

2282

1

        parse_options: SvgParseOptions,

2283

1

    ) -> Result<Self, SvgParseError> {

2284

1

        svg_parse(svg_bytes, parse_options)

2285

1

2286

2287

2

    #[must_use] pub const fn get_root(&self) -> ParsedSvgXmlNode {

2288

2

        svg_root(self)

2289

2

2290

2291

6

    #[must_use] pub fn render(&self, options: SvgRenderOptions) -> Option<RawImage> {

2292

6

        svg_render(self, options)

2293

6

2294

2295

11

    #[must_use] pub fn to_string(&self, _options: SvgXmlOptions) -> String {

2296

11

        String::from_utf8_lossy(self.svg_data.as_ref()).into_owned()

2297

11

2298

2299

2300

/// Parse SVG data into a `ParsedSvg` (validates XML, stores bytes for deferred rendering).

2301

/// # Errors

2302

///

2303

/// Returns a `SvgParseError` if the input is not valid SVG.

2304

41

pub fn svg_parse(

2305

41

    svg_file_data: &[u8],

2306

41

    _options: SvgParseOptions,

2307

41

) -> Result<ParsedSvg, SvgParseError> {

2308

    // Validate that it's parseable XML

2309

41

    let s = core::str::from_utf8(svg_file_data)

2310

41

        .map_err(|_| SvgParseError::NotAnUtf8Str)?;

2311

37

    let _nodes = crate::xml::parse_xml_string(s)

2312

37

        .map_err(|_| SvgParseError::NoParserAvailable)?;

2313

28

    Ok(ParsedSvg {

2314

28

        svg_data: svg_file_data.to_vec().into(),

2315

28

        run_destructor: true,

2316

28

})

2317

41

2318

2319

3

#[must_use] pub const fn svg_root(s: &ParsedSvg) -> ParsedSvgXmlNode {

2320

3

    ParsedSvgXmlNode { run_destructor: true }

2321

3

2322

2323

/// Render a `ParsedSvg` to a `RawImage` using the agg-rust pipeline.

2324

///

2325

/// Requires the `cpurender` feature (the agg-rust + png rasterization pipeline).

2326

/// Without it, SVG parsing/layout still work but rasterizing yields `None`.

2327

#[cfg(feature = "cpurender")]

2328

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

2329

9

#[must_use] pub fn svg_render(s: &ParsedSvg, options: SvgRenderOptions) -> Option<RawImage> {

2330

    use azul_core::resources::RawImageData;

2331

2332

9

    let (target_width, target_height) = options.target_size.as_ref().map_or(DEFAULT_SVG_RENDER_SIZE, |s| (s.width as u32, s.height as u32));

2333

2334

9

    if target_width == 0 || target_height == 0 {

2335

6

        return None;

2336

3

2337

2338

3

    let png_data = crate::cpurender::render_svg_to_png(s.svg_data.as_ref(), target_width, target_height).ok()?;

2339

2340

    // Decode PNG back to raw RGBA (TODO: render_svg_to_rgba to avoid PNG round-trip)

2341

2

    let decoder = png::Decoder::new(std::io::Cursor::new(&png_data));

2342

2

    let mut reader = decoder.read_info().ok()?;

2343

2

    let mut buf = vec![0u8; reader.output_buffer_size()?];

2344

2

    let info = reader.next_frame(&mut buf).ok()?;

2345

2

    buf.truncate(info.buffer_size());

2346

2347

2

    Some(RawImage {

2348

2

        tag: Vec::new().into(),

2349

2

        pixels: RawImageData::U8(buf.into()),

2350

2

        width: info.width as usize,

2351

2

        height: info.height as usize,

2352

2

        premultiplied_alpha: false,

2353

2

        data_format: RawImageFormat::RGBA8,

2354

2

})

2355

9

2356

2357

/// `cpurender`-less stub: SVG rasterization needs the agg-rust pipeline, so

2358

/// without that feature there is nothing to render to. Parsing and layout are

2359

/// unaffected — only the raster output is unavailable.

2360

#[cfg(not(feature = "cpurender"))]

2361

pub fn svg_render(_s: &ParsedSvg, _options: SvgRenderOptions) -> Option<RawImage> {

2362

    // The caller asked for pixels and can NEVER get any from this build —

2363

    // a permanent None is otherwise indistinguishable from a bad SVG.

2364

    static ANNOUNCE: std::sync::Once = std::sync::Once::new();

2365

    ANNOUNCE.call_once(|| {

2366

        eprintln!(

2367

            "[azul][svg] svg_render called, but this build has no `cpurender` \

2368

             feature — SVG rasterization always returns None (parsing/layout are \

2369

             unaffected). Rebuild azul-layout with the `cpurender` feature"

2370

);

2371

});

2372

    None

2373

2374

2375

2

#[must_use] pub fn svg_to_string(s: &ParsedSvg, _options: SvgXmlOptions) -> String {

2376

2

    String::from_utf8_lossy(s.svg_data.as_ref()).into_owned()

2377

2

2378

2379

// ============================================================================

2380

// Lyon tessellation (kept — no usvg dependency)

2381

// ============================================================================

2382

2383

/// Trait for tessellating `SvgMultiPolygon` shapes

2384

pub trait SvgMultiPolygonTessellation {

2385

    fn tessellate_fill(&self, fill_style: SvgFillStyle) -> TessellatedSvgNode;

2386

    fn tessellate_stroke(&self, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode;

2387

2388

2389

impl SvgMultiPolygonTessellation for SvgMultiPolygon {

2390

    fn tessellate_fill(&self, fill_style: SvgFillStyle) -> TessellatedSvgNode {

2391

        tessellate_multi_polygon_fill(self, fill_style)

2392

2393

    fn tessellate_stroke(&self, stroke_style: SvgStrokeStyle) -> TessellatedSvgNode {

2394

        tessellate_multi_polygon_stroke(self, stroke_style)

2395

2396

2397

2398

// ============================================================================

2399

// Adversarial unit tests

2400

// ============================================================================

2401

//

2402

// The whole module is `#[cfg(feature = "svg")]`, so the `#[cfg(not(feature =

2403

// "svg"))]` stubs above are never compiled and are therefore not exercised here.

2404

// `cpurender` is a separate flag and is gated per-test.

2405

2406

#[cfg(test)]

2407

mod autotest_generated {

2408

    use azul_core::resources::RawImageData;

2409

2410

    use super::*;

2411

2412

    // ------------------------------------------------------------------

2413

    // helpers

2414

    // ------------------------------------------------------------------

2415

2416

    fn pt(x: f32, y: f32) -> SvgPoint {

2417

        SvgPoint { x, y }

2418

2419

2420

    fn ln(x0: f32, y0: f32, x1: f32, y1: f32) -> SvgLine {

2421

        SvgLine {

2422

            start: pt(x0, y0),

2423

            end: pt(x1, y1),

2424

2425

2426

2427

    fn mk_path(items: Vec<SvgPathElement>) -> SvgPath {

2428

        SvgPath {

2429

            items: SvgPathElementVec::from_vec(items),

2430

2431

2432

2433

    fn empty_path() -> SvgPath {

2434

        SvgPath {

2435

            items: SvgPathElementVec::from_const_slice(&[]),

2436

2437

2438

2439

    /// A closed, axis-aligned 10x10 square whose lower-left corner is at `d`.

2440

    fn square_at(d: f32) -> SvgPath {

2441

        mk_path(vec![

2442

            SvgPathElement::Line(ln(d, d, d + 10.0, d)),

2443

            SvgPathElement::Line(ln(d + 10.0, d, d + 10.0, d + 10.0)),

2444

            SvgPathElement::Line(ln(d + 10.0, d + 10.0, d, d + 10.0)),

2445

            SvgPathElement::Line(ln(d, d + 10.0, d, d)),

2446

])

2447

2448

2449

    fn square_path() -> SvgPath {

2450

        square_at(0.0)

2451

2452

2453

    fn polygon_of(rings: Vec<SvgPath>) -> SvgMultiPolygon {

2454

        SvgMultiPolygon {

2455

            rings: SvgPathVec::from_vec(rings),

2456

2457

2458

2459

    fn square_polygon() -> SvgMultiPolygon {

2460

        polygon_of(vec![square_path()])

2461

2462

2463

    fn empty_polygon() -> SvgMultiPolygon {

2464

        SvgMultiPolygon {

2465

            rings: SvgPathVec::from_const_slice(&[]),

2466

2467

2468

2469

    fn rect(x: f32, y: f32, w: f32, h: f32) -> SvgRect {

2470

        SvgRect {

2471

            width: w,

2472

            height: h,

2473

x,

2474

y,

2475

            ..SvgRect::default()

2476

2477

2478

2479

    /// `SvgTransform::default()` is the **zero** matrix (every field is `0.0`),

2480

    /// which collapses all geometry onto the origin — tests that want a real

2481

    /// 1:1 mapping must build the identity by hand.

2482

    const fn identity_transform() -> SvgTransform {

2483

        SvgTransform {

2484

            sx: 1.0,

2485

            kx: 0.0,

2486

            ky: 0.0,

2487

            sy: 1.0,

2488

            tx: 0.0,

2489

            ty: 0.0,

2490

2491

2492

2493

    fn tess(vertices: &[(f32, f32)], indices: &[u32]) -> TessellatedSvgNode {

2494

        TessellatedSvgNode {

2495

            vertices: vertices

2496

                .iter()

2497

                .map(|&(x, y)| SvgVertex { x, y })

2498

                .collect::<Vec<_>>()

2499

                .into(),

2500

            indices: indices.to_vec().into(),

2501

2502

2503

2504

    fn mask_image(w: usize, h: usize) -> RawImage {

2505

        RawImage {

2506

            pixels: RawImageData::U8(vec![0u8; w * h].into()),

2507

            width: w,

2508

            height: h,

2509

            premultiplied_alpha: false,

2510

            data_format: RawImageFormat::R8,

2511

            tag: Vec::new().into(),

2512

2513

2514

2515

    fn mask_bytes(img: &RawImage) -> Vec<u8> {

2516

        match &img.pixels {

2517

            RawImageData::U8(v) => v.as_ref().to_vec(),

2518

            _ => panic!("a clip mask must always come back as 8-bit data"),

2519

2520

2521

2522

    /// Every index must address a vertex that actually exists.

2523

    fn assert_indices_in_range(t: &TessellatedSvgNode) {

2524

        let verts = t.vertices.as_ref().len();

2525

        for i in t.indices.as_ref() {

2526

            if *i == GL_RESTART_INDEX {

2527

                continue;

2528

2529

            assert!(

2530

                (*i as usize) < verts,

2531

                "index {i} points past a {verts}-vertex buffer"

2532

);

2533

2534

2535

2536

    const MINIMAL_SVG: &[u8] =

2537

        br#"<svg viewBox="0 0 8 8"><rect x="0" y="0" width="8" height="8" fill="red"/></svg>"#;

2538

2539

    // ==================================================================

2540

    // translate_svg_line_join / translate_svg_line_cap

2541

    // ==================================================================

2542

2543

    #[test]

2544

    fn translate_svg_line_join_maps_every_variant() {

2545

        use lyon::tessellation::LineJoin as L;

2546

        assert_eq!(translate_svg_line_join(SvgLineJoin::Miter), L::Miter);

2547

        assert_eq!(translate_svg_line_join(SvgLineJoin::MiterClip), L::MiterClip);

2548

        assert_eq!(translate_svg_line_join(SvgLineJoin::Round), L::Round);

2549

        assert_eq!(translate_svg_line_join(SvgLineJoin::Bevel), L::Bevel);

2550

        assert_eq!(translate_svg_line_join(SvgLineJoin::default()), L::Miter);

2551

2552

2553

    #[test]

2554

    fn translate_svg_line_cap_maps_every_variant() {

2555

        use lyon::tessellation::LineCap as C;

2556

        assert_eq!(translate_svg_line_cap(SvgLineCap::Butt), C::Butt);

2557

        assert_eq!(translate_svg_line_cap(SvgLineCap::Square), C::Square);

2558

        assert_eq!(translate_svg_line_cap(SvgLineCap::Round), C::Round);

2559

        assert_eq!(translate_svg_line_cap(SvgLineCap::default()), C::Butt);

2560

2561

2562

    // ==================================================================

2563

    // translate_svg_stroke_style

2564

    // ==================================================================

2565

2566

    #[test]

2567

    fn translate_svg_stroke_style_carries_every_field_across() {

2568

        let s = SvgStrokeStyle {

2569

            start_cap: SvgLineCap::Round,

2570

            end_cap: SvgLineCap::Square,

2571

            line_join: SvgLineJoin::Bevel,

2572

            line_width: 3.5,

2573

            miter_limit: 7.25,

2574

            tolerance: 0.25,

2575

            ..SvgStrokeStyle::default()

2576

};

2577

        let o = translate_svg_stroke_style(s);

2578

        assert_eq!(o.start_cap, lyon::tessellation::LineCap::Round);

2579

        assert_eq!(o.end_cap, lyon::tessellation::LineCap::Square);

2580

        assert_eq!(o.line_join, lyon::tessellation::LineJoin::Bevel);

2581

        assert!((o.line_width - 3.5).abs() < 1e-6, "{o:?}");

2582

        assert!((o.miter_limit - 7.25).abs() < 1e-6, "{o:?}");

2583

        assert!((o.tolerance - 0.25).abs() < 1e-6, "{o:?}");

2584

2585

2586

    #[test]

2587

    fn translate_svg_stroke_style_accepts_the_azul_default() {

2588

        let o = translate_svg_stroke_style(SvgStrokeStyle::default());

2589

        assert!(o.miter_limit >= 1.0, "the default must clear lyon's assert");

2590

2591

2592

    // FINDING (pinned): lyon's `StrokeOptions::with_miter_limit` is a *hard*

2593

    // `assert!(limit >= 1.0)` (not a debug assert), so an `SvgStrokeStyle` whose

2594

    // miter_limit is below 1.0 aborts every stroke entry point instead of being

2595

    // clamped. `SvgStrokeStyle` accepts such a value without complaint.

2596

    #[test]

2597

    #[should_panic(expected = "limit")]

2598

    fn translate_svg_stroke_style_miter_limit_below_one_panics() {

2599

        let s = SvgStrokeStyle {

2600

            miter_limit: 0.0,

2601

            ..SvgStrokeStyle::default()

2602

};

2603

        let _ = translate_svg_stroke_style(s);

2604

2605

2606

    #[test]

2607

    #[should_panic(expected = "limit")]

2608

    fn translate_svg_stroke_style_nan_miter_limit_panics() {

2609

        let s = SvgStrokeStyle {

2610

            miter_limit: f32::NAN,

2611

            ..SvgStrokeStyle::default()

2612

};

2613

        let _ = translate_svg_stroke_style(s);

2614

2615

2616

    // ==================================================================

2617

    // raw_line_intersection / raw_line_intersection_byval

2618

    // ==================================================================

2619

2620

    #[test]

2621

    fn raw_line_intersection_crossing_diagonals_meet_in_the_middle() {

2622

        let i = raw_line_intersection(&ln(0.0, 0.0, 10.0, 10.0), &ln(0.0, 10.0, 10.0, 0.0))

2623

            .expect("crossing diagonals intersect");

2624

        assert!((i.x - 5.0).abs() < 1e-4, "{i:?}");

2625

        assert!((i.y - 5.0).abs() < 1e-4, "{i:?}");

2626

2627

2628

    #[test]

2629

    fn raw_line_intersection_parallel_lines_are_none() {

2630

        assert_eq!(

2631

            raw_line_intersection(&ln(0.0, 0.0, 10.0, 0.0), &ln(0.0, 5.0, 10.0, 5.0)),

2632

            None

2633

);

2634

2635

2636

    #[test]

2637

    fn raw_line_intersection_identical_lines_are_none() {

2638

        // Collinear overlap has infinitely many solutions -> 0/0 -> NaN -> None.

2639

        let l = ln(0.0, 0.0, 10.0, 0.0);

2640

        assert_eq!(raw_line_intersection(&l, &l), None);

2641

2642

2643

    #[test]

2644

    fn raw_line_intersection_zero_length_lines_are_none() {

2645

        assert_eq!(

2646

            raw_line_intersection(&ln(1.0, 1.0, 1.0, 1.0), &ln(0.0, 0.0, 2.0, 2.0)),

2647

            None

2648

);

2649

        assert_eq!(

2650

            raw_line_intersection(&ln(0.0, 0.0, 0.0, 0.0), &ln(0.0, 0.0, 0.0, 0.0)),

2651

            None

2652

);

2653

2654

2655

    #[test]

2656

    fn raw_line_intersection_never_leaks_nan_for_extreme_inputs() {

2657

        let extremes = [

2658

            ln(f32::NAN, 0.0, 1.0, 1.0),

2659

            ln(0.0, f32::NAN, 1.0, 1.0),

2660

            ln(f32::INFINITY, f32::INFINITY, 1.0, 1.0),

2661

            ln(f32::NEG_INFINITY, 0.0, f32::INFINITY, 0.0),

2662

            ln(f32::MAX, f32::MAX, f32::MIN, f32::MIN),

2663

            ln(f32::MIN_POSITIVE, 0.0, -f32::MIN_POSITIVE, 0.0),

2664

            ln(0.0, 0.0, 0.0, 0.0),

2665

            ln(-1.0, -1.0, 1.0, 1.0),

2666

];

2667

        for p in &extremes {

2668

            for q in &extremes {

2669

                if let Some(i) = raw_line_intersection(p, q) {

2670

                    assert!(

2671

                        !i.x.is_nan() && !i.y.is_nan(),

2672

                        "NaN escaped for {p:?} x {q:?} -> {i:?}"

2673

);

2674

2675

2676

2677

2678

2679

    #[test]

2680

    fn raw_line_intersection_byval_matches_the_by_ref_form() {

2681

        let p = ln(0.0, 0.0, 10.0, 10.0);

2682

        let q = ln(0.0, 10.0, 10.0, 0.0);

2683

        assert_eq!(

2684

            raw_line_intersection_byval(&p, q),

2685

            raw_line_intersection(&p, &q)

2686

);

2687

        let horizontal = ln(0.0, 0.0, 10.0, 0.0);

2688

        let parallel = ln(0.0, 5.0, 10.0, 5.0);

2689

        assert_eq!(raw_line_intersection_byval(&horizontal, parallel), None);

2690

2691

2692

    // ==================================================================

2693

    // shorten_line_end_by / shorten_line_start_by

2694

    // ==================================================================

2695

2696

    #[test]

2697

    fn shorten_line_end_by_trims_the_end_only() {

2698

        let out = shorten_line_end_by(ln(0.0, 0.0, 10.0, 0.0), 4.0);

2699

        assert_eq!(out.start, pt(0.0, 0.0));

2700

        assert!((out.end.x - 6.0).abs() < 1e-3, "{out:?}");

2701

        assert!(out.end.y.abs() < 1e-3, "{out:?}");

2702

2703

2704

    #[test]

2705

    fn shorten_line_end_by_zero_is_the_identity() {

2706

        let l = ln(1.0, 2.0, 11.0, 2.0);

2707

        let out = shorten_line_end_by(l, 0.0);

2708

        assert!((out.end.x - 11.0).abs() < 1e-3, "{out:?}");

2709

        assert!((out.end.y - 2.0).abs() < 1e-3, "{out:?}");

2710

2711

2712

    #[test]

2713

    fn shorten_line_end_by_more_than_the_length_overshoots_past_the_start() {

2714

        // 20 taken off a 10-long line puts the end 10 units *behind* the start.

2715

        let out = shorten_line_end_by(ln(0.0, 0.0, 10.0, 0.0), 20.0);

2716

        assert!((out.end.x + 10.0).abs() < 1e-3, "{out:?}");

2717

2718

2719

    #[test]

2720

    fn shorten_line_end_by_negative_distance_extends_the_line() {

2721

        let out = shorten_line_end_by(ln(0.0, 0.0, 10.0, 0.0), -5.0);

2722

        assert!((out.end.x - 15.0).abs() < 1e-3, "{out:?}");

2723

2724

2725

    #[test]

2726

    fn shorten_line_end_by_degenerate_segment_yields_nan() {

2727

        // LATENT DEFECT (pinned): a zero-length segment gives dt == 0, so

2728

        // (dt - distance) / dt is -inf and -inf * 0.0 == NaN. A fix that returns

2729

        // the line unchanged will flip this test loudly rather than silently.

2730

        let out = shorten_line_end_by(ln(5.0, 5.0, 5.0, 5.0), 1.0);

2731

        assert!(out.end.x.is_nan() && out.end.y.is_nan(), "{out:?}");

2732

        assert_eq!(out.start, pt(5.0, 5.0), "the start is never touched");

2733

2734

2735

    #[test]

2736

    fn shorten_line_end_by_non_finite_distance_does_not_panic() {

2737

        for d in [

2738

            f32::NAN,

2739

            f32::INFINITY,

2740

            f32::NEG_INFINITY,

2741

            f32::MAX,

2742

            f32::MIN,

2743

] {

2744

            let out = shorten_line_end_by(ln(0.0, 0.0, 10.0, 0.0), d);

2745

            assert_eq!(out.start, pt(0.0, 0.0), "distance {d}: start must survive");

2746

2747

2748

2749

    #[test]

2750

    fn shorten_line_start_by_trims_the_start_only() {

2751

        let out = shorten_line_start_by(ln(0.0, 0.0, 10.0, 0.0), 4.0);

2752

        assert_eq!(out.end, pt(10.0, 0.0));

2753

        assert!((out.start.x - 4.0).abs() < 1e-3, "{out:?}");

2754

        assert!(out.start.y.abs() < 1e-3, "{out:?}");

2755

2756

2757

    #[test]

2758

    fn shorten_line_start_by_zero_is_the_identity() {

2759

        let out = shorten_line_start_by(ln(2.0, 3.0, 12.0, 3.0), 0.0);

2760

        assert!((out.start.x - 2.0).abs() < 1e-3, "{out:?}");

2761

        assert!((out.start.y - 3.0).abs() < 1e-3, "{out:?}");

2762

2763

2764

    #[test]

2765

    fn shorten_line_start_by_degenerate_segment_yields_nan() {

2766

        // Same latent defect as `shorten_line_end_by`, mirrored onto the start.

2767

        let out = shorten_line_start_by(ln(-3.0, 7.0, -3.0, 7.0), 2.0);

2768

        assert!(out.start.x.is_nan() && out.start.y.is_nan(), "{out:?}");

2769

        assert_eq!(out.end, pt(-3.0, 7.0));

2770

2771

2772

    // ==================================================================

2773

    // svg_path_offset

2774

    // ==================================================================

2775

2776

    #[test]

2777

    fn svg_path_offset_zero_distance_returns_the_input_unchanged() {

2778

        let p = square_path();

2779

        assert_eq!(

2780

            svg_path_offset(&p, 0.0, SvgLineJoin::Miter, SvgLineCap::Butt),

2781

2782

);

2783

        // -0.0 == 0.0 under IEEE-754, so the early-out must fire for it too.

2784

        assert_eq!(

2785

            svg_path_offset(&p, -0.0, SvgLineJoin::Miter, SvgLineCap::Butt),

2786

2787

);

2788

2789

2790

    #[test]

2791

    fn svg_path_offset_empty_path_stays_empty() {

2792

        // The `items.pop()` at the end must not underflow on an empty vec.

2793

        let out = svg_path_offset(&empty_path(), 5.0, SvgLineJoin::Round, SvgLineCap::Round);

2794

        assert!(out.items.as_ref().is_empty());

2795

2796

2797

    #[test]

2798

    fn svg_path_offset_single_line_moves_along_its_outwards_normal() {

2799

        // (0,0)->(10,0) has inwards normal (0, 1), so outwards is (0, -1).

2800

        let p = mk_path(vec![SvgPathElement::Line(ln(0.0, 0.0, 10.0, 0.0))]);

2801

        let out = svg_path_offset(&p, 5.0, SvgLineJoin::Miter, SvgLineCap::Butt);

2802

        assert_eq!(out.items.as_ref().len(), 1);

2803

        match out.items.as_ref()[0] {

2804

            SvgPathElement::Line(l) => {

2805

                assert!(l.start.x.abs() < 1e-4, "{l:?}");

2806

                assert!((l.end.x - 10.0).abs() < 1e-4, "{l:?}");

2807

                assert!((l.start.y + 5.0).abs() < 1e-4, "{l:?}");

2808

                assert!((l.end.y + 5.0).abs() < 1e-4, "{l:?}");

2809

2810

            other => panic!("expected a line, got {other:?}"),

2811

2812

2813

2814

    #[test]

2815

    fn svg_path_offset_preserves_the_item_count_for_any_distance() {

2816

        let p = square_path();

2817

        for d in [

2818

            1.0_f32,

2819

            -1.0,

2820

            1e-30,

2821

            1e30,

2822

            f32::MAX,

2823

            f32::MIN,

2824

            f32::NAN,

2825

            f32::INFINITY,

2826

            f32::NEG_INFINITY,

2827

] {

2828

            let out = svg_path_offset(&p, d, SvgLineJoin::Miter, SvgLineCap::Butt);

2829

            assert_eq!(

2830

                out.items.as_ref().len(),

2831

                p.items.as_ref().len(),

2832

                "distance {d} changed the element count"

2833

);

2834

2835

2836

2837

    #[test]

2838

    fn svg_path_offset_degenerate_segments_are_passed_through_unchanged() {

2839

        // A zero-length line has no normal, so the element must come back as-is.

2840

        let p = mk_path(vec![SvgPathElement::Line(ln(4.0, 4.0, 4.0, 4.0))]);

2841

        assert_eq!(

2842

            svg_path_offset(&p, 9.0, SvgLineJoin::Bevel, SvgLineCap::Square),

2843

2844

);

2845

2846

2847

    #[test]

2848

    fn svg_path_offset_ignores_its_join_and_cap_arguments() {

2849

        // Documented gap (pinned): neither parameter is ever read; the function

2850

        // only offsets the segments and re-intersects the neighbours.

2851

        let p = square_path();

2852

        let a = svg_path_offset(&p, 3.0, SvgLineJoin::Miter, SvgLineCap::Butt);

2853

        let b = svg_path_offset(&p, 3.0, SvgLineJoin::Round, SvgLineCap::Round);

2854

        assert_eq!(a, b);

2855

2856

2857

    #[test]

2858

    fn svg_path_offset_handles_curve_elements() {

2859

        let p = mk_path(vec![

2860

            SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

2861

                start: pt(0.0, 0.0),

2862

                ctrl: pt(5.0, 10.0),

2863

                end: pt(10.0, 0.0),

2864

}),

2865

            SvgPathElement::CubicCurve(SvgCubicCurve {

2866

                start: pt(10.0, 0.0),

2867

                ctrl_1: pt(7.0, -5.0),

2868

                ctrl_2: pt(3.0, -5.0),

2869

                end: pt(0.0, 0.0),

2870

}),

2871

]);

2872

        let out = svg_path_offset(&p, 2.0, SvgLineJoin::Miter, SvgLineCap::Butt);

2873

        assert_eq!(out.items.as_ref().len(), 2);

2874

2875

2876

    // ==================================================================

2877

    // svg_path_bevel

2878

    // ==================================================================

2879

2880

    #[test]

2881

    fn svg_path_bevel_empty_path_stays_empty() {

2882

        // Two unconditional `pop()`s on an empty vec must not underflow.

2883

        assert!(svg_path_bevel(&empty_path(), 2.0).items.as_ref().is_empty());

2884

2885

2886

    #[test]

2887

    fn svg_path_bevel_single_line_expands_to_four_elements() {

2888

        // The single element is duplicated at both ends (3 items -> 2 pairs ->

2889

        // 6 pushes), then one element is trimmed off each side.

2890

        let p = mk_path(vec![SvgPathElement::Line(ln(0.0, 0.0, 10.0, 0.0))]);

2891

        let out = svg_path_bevel(&p, 2.0);

2892

        assert_eq!(out.items.as_ref().len(), 4);

2893

        for e in out.items.as_ref() {

2894

            let (s, t) = (e.get_start(), e.get_end());

2895

            assert!(

2896

                s.x.is_finite() && s.y.is_finite() && t.x.is_finite() && t.y.is_finite(),

2897

                "{e:?}"

2898

);

2899

2900

2901

2902

    #[test]

2903

    fn svg_path_bevel_non_line_pairs_are_passed_straight_through() {

2904

        let p = mk_path(vec![

2905

            SvgPathElement::Line(ln(0.0, 0.0, 10.0, 0.0)),

2906

            SvgPathElement::CubicCurve(SvgCubicCurve {

2907

                start: pt(10.0, 0.0),

2908

                ctrl_1: pt(12.0, 0.0),

2909

                ctrl_2: pt(14.0, 2.0),

2910

                end: pt(14.0, 4.0),

2911

}),

2912

]);

2913

        // No (Line, Line) pair survives the duplication, so every pair takes the

2914

        // 2-push fall-through arm: 3 pairs -> 6 pushes -> 4 after trimming.

2915

        assert_eq!(svg_path_bevel(&p, 1.0).items.as_ref().len(), 4);

2916

2917

2918

    #[test]

2919

    fn svg_path_bevel_zero_distance_keeps_every_coordinate_finite() {

2920

        for e in svg_path_bevel(&square_path(), 0.0).items.as_ref() {

2921

            let (s, t) = (e.get_start(), e.get_end());

2922

            assert!(

2923

                s.x.is_finite() && s.y.is_finite() && t.x.is_finite() && t.y.is_finite(),

2924

                "{e:?}"

2925

);

2926

2927

2928

2929

    #[test]

2930

    fn svg_path_bevel_extreme_distances_do_not_panic() {

2931

        let p = square_path();

2932

        for d in [

2933

            f32::NAN,

2934

            f32::INFINITY,

2935

            f32::NEG_INFINITY,

2936

            f32::MAX,

2937

            -f32::MAX,

2938

            1e-30,

2939

] {

2940

            assert!(

2941

                !svg_path_bevel(&p, d).items.as_ref().is_empty(),

2942

                "distance {d} produced an empty path"

2943

);

2944

2945

2946

2947

    #[test]

2948

    fn svg_path_bevel_degenerate_segments_do_not_panic() {

2949

        let p = mk_path(vec![

2950

            SvgPathElement::Line(ln(1.0, 1.0, 1.0, 1.0)),

2951

            SvgPathElement::Line(ln(1.0, 1.0, 1.0, 1.0)),

2952

]);

2953

        // NaN coordinates leak out of `shorten_line_*_by` here, but nothing panics.

2954

        assert!(!svg_path_bevel(&p, 3.0).items.as_ref().is_empty());

2955

2956

2957

    // ==================================================================

2958

    // svg_node_contains_point / path_contains_point / polygon_contains_point

2959

    // ==================================================================

2960

2961

    #[test]

2962

    fn svg_node_contains_point_rect_excludes_its_own_border() {

2963

        let node = SvgNode::Rect(rect(0.0, 0.0, 10.0, 10.0));

2964

        assert!(svg_node_contains_point(

2965

            &node,

2966

            pt(5.0, 5.0),

2967

            SvgFillRule::Winding,

2968

0.1

2969

));

2970

        assert!(!svg_node_contains_point(

2971

            &node,

2972

            pt(15.0, 5.0),

2973

            SvgFillRule::Winding,

2974

0.1

2975

));

2976

        // `>` / `<`, not `>=` / `<=`: the border itself is outside.

2977

        assert!(!svg_node_contains_point(

2978

            &node,

2979

            pt(0.0, 0.0),

2980

            SvgFillRule::Winding,

2981

0.1

2982

));

2983

        assert!(!svg_node_contains_point(

2984

            &node,

2985

            pt(10.0, 10.0),

2986

            SvgFillRule::Winding,

2987

0.1

2988

));

2989

2990

2991

    #[test]

2992

    fn svg_node_contains_point_circle_excludes_its_own_rim() {

2993

        let node = SvgNode::Circle(SvgCircle {

2994

            center_x: 0.0,

2995

            center_y: 0.0,

2996

            radius: 5.0,

2997

});

2998

        assert!(svg_node_contains_point(

2999

            &node,

3000

            pt(0.0, 0.0),

3001

            SvgFillRule::Winding,

3002

0.1

3003

));

3004

        assert!(!svg_node_contains_point(

3005

            &node,

3006

            pt(5.0, 0.0),

3007

            SvgFillRule::Winding,

3008

0.1

3009

));

3010

        assert!(!svg_node_contains_point(

3011

            &node,

3012

            pt(100.0, 100.0),

3013

            SvgFillRule::Winding,

3014

0.1

3015

));

3016

3017

3018

    #[test]

3019

    fn svg_node_contains_point_nan_and_infinite_points_are_outside() {

3020

        let r = SvgNode::Rect(rect(0.0, 0.0, 10.0, 10.0));

3021

        let c = SvgNode::Circle(SvgCircle {

3022

            center_x: 0.0,

3023

            center_y: 0.0,

3024

            radius: 5.0,

3025

});

3026

        for p in [

3027

            pt(f32::NAN, f32::NAN),

3028

            pt(f32::NAN, 5.0),

3029

            pt(5.0, f32::NAN),

3030

            pt(f32::INFINITY, f32::INFINITY),

3031

            pt(f32::NEG_INFINITY, 0.0),

3032

] {

3033

            assert!(

3034

                !svg_node_contains_point(&r, p, SvgFillRule::Winding, 0.1),

3035

                "rect / {p:?}"

3036

);

3037

            assert!(

3038

                !svg_node_contains_point(&c, p, SvgFillRule::EvenOdd, 0.1),

3039

                "circle / {p:?}"

3040

);

3041

3042

3043

3044

    #[test]

3045

    fn svg_node_contains_point_empty_geometry_is_never_hit() {

3046

        for node in [

3047

            SvgNode::MultiPolygonCollection(SvgMultiPolygonVec::from_const_slice(&[])),

3048

            SvgNode::MultiShape(SvgSimpleNodeVec::from_const_slice(&[])),

3049

            SvgNode::MultiPolygon(empty_polygon()),

3050

            SvgNode::Path(empty_path()),

3051

] {

3052

            assert!(

3053

                !svg_node_contains_point(&node, pt(0.0, 0.0), SvgFillRule::Winding, 0.1),

3054

                "{node:?}"

3055

);

3056

3057

3058

3059

    #[test]

3060

    fn svg_node_contains_point_open_paths_short_circuit_to_false() {

3061

        let open = mk_path(vec![

3062

            SvgPathElement::Line(ln(0.0, 0.0, 10.0, 0.0)),

3063

            SvgPathElement::Line(ln(10.0, 0.0, 10.0, 10.0)),

3064

]);

3065

        assert!(!svg_node_contains_point(

3066

            &SvgNode::Path(open.clone()),

3067

            pt(5.0, 5.0),

3068

            SvgFillRule::Winding,

3069

0.1

3070

));

3071

        assert!(!svg_node_contains_point(

3072

            &SvgNode::MultiShape(SvgSimpleNodeVec::from_vec(vec![SvgSimpleNode::Path(open)])),

3073

            pt(5.0, 5.0),

3074

            SvgFillRule::Winding,

3075

0.1

3076

));

3077

3078

3079

    #[test]

3080

    fn svg_node_contains_point_closed_square_path_is_hit() {

3081

        let node = SvgNode::Path(square_path());

3082

        assert!(svg_node_contains_point(

3083

            &node,

3084

            pt(5.0, 5.0),

3085

            SvgFillRule::Winding,

3086

0.1

3087

));

3088

        assert!(!svg_node_contains_point(

3089

            &node,

3090

            pt(50.0, 5.0),

3091

            SvgFillRule::Winding,

3092

0.1

3093

));

3094

3095

3096

    #[test]

3097

    fn svg_node_contains_point_lone_hole_reports_everything_outside_it() {

3098

        // Pinned semantics: a MultiShape made only of holes inverts, so every

3099

        // point *outside* the hole counts as a hit.

3100

        let hole = SvgCircle {

3101

            center_x: 0.0,

3102

            center_y: 0.0,

3103

            radius: 5.0,

3104

};

3105

        let node = SvgNode::MultiShape(SvgSimpleNodeVec::from_vec(vec![

3106

            SvgSimpleNode::CircleHole(hole),

3107

        ]));

3108

        assert!(!svg_node_contains_point(

3109

            &node,

3110

            pt(0.0, 0.0),

3111

            SvgFillRule::Winding,

3112

0.1

3113

));

3114

        assert!(svg_node_contains_point(

3115

            &node,

3116

            pt(100.0, 100.0),

3117

            SvgFillRule::Winding,

3118

0.1

3119

));

3120

3121

3122

    #[test]

3123

    fn path_contains_point_square_positive_and_negative_controls() {

3124

        let sq = square_path();

3125

        assert!(path_contains_point(

3126

            &sq,

3127

            pt(5.0, 5.0),

3128

            SvgFillRule::Winding,

3129

0.1

3130

));

3131

        assert!(path_contains_point(

3132

            &sq,

3133

            pt(5.0, 5.0),

3134

            SvgFillRule::EvenOdd,

3135

0.1

3136

));

3137

        assert!(!path_contains_point(

3138

            &sq,

3139

            pt(-1.0, 5.0),

3140

            SvgFillRule::Winding,

3141

0.1

3142

));

3143

        assert!(!path_contains_point(

3144

            &sq,

3145

            pt(5.0, 100.0),

3146

            SvgFillRule::EvenOdd,

3147

0.1

3148

));

3149

3150

3151

    #[test]

3152

    fn path_contains_point_empty_path_is_never_hit() {

3153

        assert!(!path_contains_point(

3154

            &empty_path(),

3155

            pt(0.0, 0.0),

3156

            SvgFillRule::Winding,

3157

0.1

3158

));

3159

3160

3161

    #[test]

3162

    fn path_contains_point_tolerance_is_irrelevant_for_straight_edges() {

3163

        // A line-only path is never flattened, so even 0 / negative / huge

3164

        // tolerances must give the same answer instead of hanging.

3165

        let sq = square_path();

3166

        for t in [0.0_f32, 1e-6, 1.0, 1e6, -1.0] {

3167

            assert!(

3168

                path_contains_point(&sq, pt(5.0, 5.0), SvgFillRule::Winding, t),

3169

                "tolerance {t}"

3170

);

3171

            assert!(

3172

                !path_contains_point(&sq, pt(-50.0, 5.0), SvgFillRule::Winding, t),

3173

                "tolerance {t}"

3174

);

3175

3176

3177

3178

    #[test]

3179

    fn polygon_contains_point_square_ring() {

3180

        let poly = square_polygon();

3181

        assert!(polygon_contains_point(

3182

            &poly,

3183

            pt(5.0, 5.0),

3184

            SvgFillRule::Winding,

3185

0.1

3186

));

3187

        assert!(!polygon_contains_point(

3188

            &poly,

3189

            pt(-5.0, 5.0),

3190

            SvgFillRule::Winding,

3191

0.1

3192

));

3193

3194

3195

    #[test]

3196

    fn polygon_contains_point_without_rings_is_false() {

3197

        assert!(!polygon_contains_point(

3198

            &empty_polygon(),

3199

            pt(0.0, 0.0),

3200

            SvgFillRule::Winding,

3201

0.1

3202

));

3203

        // A ring that carries no elements must not be treated as a hit either.

3204

        assert!(!polygon_contains_point(

3205

            &polygon_of(vec![empty_path()]),

3206

            pt(0.0, 0.0),

3207

            SvgFillRule::Winding,

3208

0.1

3209

));

3210

3211

3212

    // ==================================================================

3213

    // lyon path conversion helpers

3214

    // ==================================================================

3215

3216

    #[test]

3217

    fn svg_multipolygon_to_lyon_path_of_an_empty_polygon_is_empty() {

3218

        assert_eq!(svg_multipolygon_to_lyon_path(&empty_polygon()).iter().count(), 0);

3219

3220

3221

    #[test]

3222

    fn svg_multipolygon_to_lyon_path_skips_rings_without_items() {

3223

        let only_empty = polygon_of(vec![empty_path(), empty_path()]);

3224

        assert_eq!(svg_multipolygon_to_lyon_path(&only_empty).iter().count(), 0);

3225

        // …and an empty ring must not change the result of a real one.

3226

        let mixed = polygon_of(vec![empty_path(), square_path()]);

3227

        assert_eq!(

3228

            svg_multipolygon_to_lyon_path(&mixed).iter().count(),

3229

            svg_multipolygon_to_lyon_path(&square_polygon()).iter().count()

3230

);

3231

3232

3233

    #[test]

3234

    fn svg_multi_shape_to_lyon_path_of_an_empty_slice_is_empty() {

3235

        assert_eq!(svg_multi_shape_to_lyon_path(&[]).iter().count(), 0);

3236

3237

3238

    #[test]

3239

    fn svg_path_to_lyon_path_events_of_an_empty_path_is_empty() {

3240

        assert_eq!(svg_path_to_lyon_path_events(&empty_path()).iter().count(), 0);

3241

3242

3243

    // ==================================================================

3244

    // vertex_buffers_to_tessellated_cpu_node

3245

    // ==================================================================

3246

3247

    #[test]

3248

    fn vertex_buffers_to_tessellated_cpu_node_moves_both_buffers_verbatim() {

3249

        let mut vb: VertexBuffers<SvgVertex, u32> = VertexBuffers::new();

3250

        vb.vertices.push(SvgVertex { x: 1.0, y: 2.0 });

3251

        vb.vertices.push(SvgVertex { x: 3.0, y: 4.0 });

3252

        vb.indices.extend_from_slice(&[0, 1, 0]);

3253

        let t = vertex_buffers_to_tessellated_cpu_node(vb);

3254

        assert_eq!(t.vertices.as_ref().len(), 2);

3255

        assert_eq!(t.indices.as_ref(), &[0u32, 1, 0][..]);

3256

        assert!((t.vertices.as_ref()[1].x - 3.0).abs() < 1e-6);

3257

3258

3259

    #[test]

3260

    fn vertex_buffers_to_tessellated_cpu_node_of_empty_buffers_is_empty() {

3261

        let t = vertex_buffers_to_tessellated_cpu_node(VertexBuffers::<SvgVertex, u32>::new());

3262

        assert!(t.vertices.as_ref().is_empty());

3263

        assert!(t.indices.as_ref().is_empty());

3264

3265

3266

    // ==================================================================

3267

    // tessellation

3268

    // ==================================================================

3269

3270

    #[test]

3271

    fn tessellate_path_fill_of_a_square_produces_whole_triangles() {

3272

        let t = tessellate_path_fill(&square_path(), SvgFillStyle::default());

3273

        assert!(!t.vertices.as_ref().is_empty());

3274

        assert_eq!(t.indices.as_ref().len() % 3, 0);

3275

        assert_indices_in_range(&t);

3276

3277

3278

    #[test]

3279

    fn tessellate_path_fill_and_stroke_of_an_empty_path_are_empty() {

3280

        let f = tessellate_path_fill(&empty_path(), SvgFillStyle::default());

3281

        assert!(f.vertices.as_ref().is_empty() && f.indices.as_ref().is_empty());

3282

        let s = tessellate_path_stroke(&empty_path(), SvgStrokeStyle::default());

3283

        assert!(s.vertices.as_ref().is_empty() && s.indices.as_ref().is_empty());

3284

3285

3286

    #[test]

3287

    fn tessellate_circle_fill_zero_radius_is_empty() {

3288

        let t = tessellate_circle_fill(

3289

            &SvgCircle {

3290

                center_x: 0.0,

3291

                center_y: 0.0,

3292

                radius: 0.0,

3293

},

3294

            SvgFillStyle::default(),

3295

);

3296

        assert!(t.vertices.as_ref().is_empty());

3297

3298

3299

    #[test]

3300

    fn tessellate_circle_fill_negative_radius_matches_the_positive_one() {

3301

        let mk = |r: f32| {

3302

            tessellate_circle_fill(

3303

                &SvgCircle {

3304

                    center_x: 1.0,

3305

                    center_y: 2.0,

3306

                    radius: r,

3307

},

3308

                SvgFillStyle::default(),

3309

3310

};

3311

        let positive = mk(5.0);

3312

        assert!(!positive.vertices.as_ref().is_empty());

3313

        assert_eq!(positive, mk(-5.0), "lyon takes |radius|; the sign must not matter");

3314

3315

3316

    #[test]

3317

    fn tessellate_rect_fill_always_emits_exactly_two_triangles() {

3318

        for r in [

3319

            rect(0.0, 0.0, 10.0, 10.0),

3320

            rect(0.0, 0.0, 0.0, 0.0),                     // fully degenerate

3321

            rect(5.0, 5.0, -10.0, -10.0),                 // inverted

3322

            rect(-f32::MAX, -f32::MAX, f32::MAX, f32::MAX), // extreme but finite

3323

] {

3324

            let t = tessellate_rect_fill(&r, SvgFillStyle::default());

3325

            assert_eq!(t.vertices.as_ref().len(), 4, "{r:?}");

3326

            assert_eq!(t.indices.as_ref().len(), 6, "{r:?}");

3327

            assert_indices_in_range(&t);

3328

3329

3330

3331

    #[test]

3332

    fn tessellate_rect_stroke_of_a_real_rect_produces_geometry() {

3333

        let t = tessellate_rect_stroke(&rect(0.0, 0.0, 10.0, 10.0), SvgStrokeStyle::default());

3334

        assert!(!t.vertices.as_ref().is_empty());

3335

        assert_indices_in_range(&t);

3336

3337

3338

    #[test]

3339

    fn get_radii_maps_origin_and_size_onto_a_box() {

3340

        let b = get_radii(&rect(1.0, 2.0, 4.0, 6.0));

3341

        assert!((b.min.x - 1.0).abs() < 1e-6, "{b:?}");

3342

        assert!((b.min.y - 2.0).abs() < 1e-6, "{b:?}");

3343

        assert!((b.max.x - 5.0).abs() < 1e-6, "{b:?}");

3344

        assert!((b.max.y - 8.0).abs() < 1e-6, "{b:?}");

3345

3346

3347

    #[test]

3348

    fn get_radii_ignores_the_corner_radii() {

3349

        // Matches the source TODO: "radii not respected on latest version of lyon".

3350

        let base = rect(1.0, 2.0, 4.0, 6.0);

3351

        let rounded = SvgRect {

3352

            radius_top_left: 3.0,

3353

            radius_top_right: 4.0,

3354

            radius_bottom_left: 5.0,

3355

            radius_bottom_right: 9.0,

3356

            ..base

3357

};

3358

        let (a, b) = (get_radii(&base), get_radii(&rounded));

3359

        assert!((a.min.x - b.min.x).abs() < 1e-6 && (a.min.y - b.min.y).abs() < 1e-6);

3360

        assert!((a.max.x - b.max.x).abs() < 1e-6 && (a.max.y - b.max.y).abs() < 1e-6);

3361

3362

3363

    #[test]

3364

    fn get_radii_of_a_negative_size_rect_produces_an_inverted_box() {

3365

        let b = get_radii(&rect(5.0, 5.0, -3.0, -4.0));

3366

        assert!(b.max.x < b.min.x, "{b:?}");

3367

        assert!(b.max.y < b.min.y, "{b:?}");

3368

3369

3370

    #[test]

3371

    fn tessellate_multi_polygon_fill_of_an_empty_polygon_is_empty() {

3372

        let t = tessellate_multi_polygon_fill(&empty_polygon(), SvgFillStyle::default());

3373

        assert!(t.vertices.as_ref().is_empty());

3374

3375

3376

    #[test]

3377

    fn tessellate_multi_polygon_fill_skips_empty_rings() {

3378

        let with_empty = polygon_of(vec![empty_path(), square_path()]);

3379

        assert_eq!(

3380

            tessellate_multi_polygon_fill(&with_empty, SvgFillStyle::default()),

3381

            tessellate_multi_polygon_fill(&square_polygon(), SvgFillStyle::default()),

3382

);

3383

3384

3385

    #[test]

3386

    fn tessellate_multi_shape_fill_of_an_empty_slice_is_empty() {

3387

        let t = tessellate_multi_shape_fill(&[], SvgFillStyle::default());

3388

        assert!(t.vertices.as_ref().is_empty());

3389

3390

3391

    #[test]

3392

    fn tessellate_multi_shape_fill_of_a_plain_shape_produces_geometry() {

3393

        let ms = [

3394

            SvgSimpleNode::Circle(SvgCircle {

3395

                center_x: 40.0,

3396

                center_y: 40.0,

3397

                radius: 5.0,

3398

}),

3399

            SvgSimpleNode::Rect(rect(60.0, 0.0, 5.0, 5.0)),

3400

];

3401

        let t = tessellate_multi_shape_fill(&ms, SvgFillStyle::default());

3402

        assert!(!t.vertices.as_ref().is_empty());

3403

        assert_indices_in_range(&t);

3404

3405

3406

    #[test]

3407

    fn tessellate_multi_shape_fill_handles_every_simple_node_kind() {

3408

        let ms = [

3409

            SvgSimpleNode::Path(square_path()),

3410

            SvgSimpleNode::Circle(SvgCircle {

3411

                center_x: 40.0,

3412

                center_y: 40.0,

3413

                radius: 5.0,

3414

}),

3415

            SvgSimpleNode::CircleHole(SvgCircle {

3416

                center_x: 40.0,

3417

                center_y: 40.0,

3418

                radius: 2.0,

3419

}),

3420

            SvgSimpleNode::Rect(rect(60.0, 0.0, 5.0, 5.0)),

3421

            SvgSimpleNode::RectHole(rect(61.0, 1.0, 2.0, 2.0)),

3422

];

3423

        assert_indices_in_range(&tessellate_multi_shape_fill(&ms, SvgFillStyle::default()));

3424

        assert_indices_in_range(&tessellate_multi_shape_stroke(

3425

            &ms,

3426

            SvgStrokeStyle::default(),

3427

));

3428

3429

3430

    #[test]

3431

    fn tessellate_multi_polygon_stroke_of_an_empty_polygon_is_empty() {

3432

        let t = tessellate_multi_polygon_stroke(&empty_polygon(), SvgStrokeStyle::default());

3433

        assert!(t.vertices.as_ref().is_empty());

3434

3435

3436

    #[test]

3437

    fn tessellate_styled_node_dispatches_on_the_style() {

3438

        let geo = SvgNode::Rect(rect(0.0, 0.0, 10.0, 10.0));

3439

        let fill = SvgStyledNode {

3440

            geometry: geo.clone(),

3441

            style: SvgStyle::Fill(SvgFillStyle::default()),

3442

};

3443

        let stroke = SvgStyledNode {

3444

            geometry: geo.clone(),

3445

            style: SvgStyle::Stroke(SvgStrokeStyle::default()),

3446

};

3447

        assert_eq!(

3448

            tessellate_styled_node(&fill),

3449

            tessellate_node_fill(&geo, SvgFillStyle::default())

3450

);

3451

        assert_eq!(

3452

            tessellate_styled_node(&stroke),

3453

            tessellate_node_stroke(&geo, SvgStrokeStyle::default())

3454

);

3455

3456

3457

    #[test]

3458

    fn tessellate_node_fill_of_a_collection_is_the_join_of_its_parts() {

3459

        let mp = square_polygon();

3460

        let node =

3461

            SvgNode::MultiPolygonCollection(SvgMultiPolygonVec::from_vec(vec![mp.clone(), mp.clone()]));

3462

        let one = tessellate_multi_polygon_fill(&mp, SvgFillStyle::default());

3463

        assert_eq!(

3464

            tessellate_node_fill(&node, SvgFillStyle::default()),

3465

            join_tessellated_nodes(&[one.clone(), one])

3466

);

3467

3468

3469

    #[test]

3470

    fn tessellate_node_fill_of_an_empty_collection_is_empty() {

3471

        let node = SvgNode::MultiPolygonCollection(SvgMultiPolygonVec::from_const_slice(&[]));

3472

        let t = tessellate_node_fill(&node, SvgFillStyle::default());

3473

        assert!(t.vertices.as_ref().is_empty() && t.indices.as_ref().is_empty());

3474

3475

3476

    #[test]

3477

    fn tessellate_svgpathelement_stroke_matches_the_per_kind_helpers() {

3478

        let ss = SvgStrokeStyle::default();

3479

        let l = ln(0.0, 0.0, 10.0, 10.0);

3480

        assert_eq!(

3481

            tessellate_svgpathelement_stroke(&SvgPathElement::Line(l), ss),

3482

            tessellate_line_stroke(&l, ss)

3483

);

3484

        let q = SvgQuadraticCurve {

3485

            start: pt(0.0, 0.0),

3486

            ctrl: pt(5.0, 10.0),

3487

            end: pt(10.0, 0.0),

3488

};

3489

        assert_eq!(

3490

            tessellate_svgpathelement_stroke(&SvgPathElement::QuadraticCurve(q), ss),

3491

            tessellate_quadraticcurve_stroke(&q, ss)

3492

);

3493

        let c = SvgCubicCurve {

3494

            start: pt(0.0, 0.0),

3495

            ctrl_1: pt(3.0, 10.0),

3496

            ctrl_2: pt(7.0, -10.0),

3497

            end: pt(10.0, 0.0),

3498

};

3499

        assert_eq!(

3500

            tessellate_svgpathelement_stroke(&SvgPathElement::CubicCurve(c), ss),

3501

            tessellate_cubiccurve_stroke(&c, ss)

3502

);

3503

3504

3505

    #[test]

3506

    fn tessellate_line_stroke_of_a_zero_length_line_does_not_panic() {

3507

        let t = tessellate_line_stroke(&ln(3.0, 3.0, 3.0, 3.0), SvgStrokeStyle::default());

3508

        assert_indices_in_range(&t);

3509

3510

3511

    // ==================================================================

3512

    // join_tessellated_nodes / join_tessellated_colored_nodes

3513

    // ==================================================================

3514

3515

    #[test]

3516

    fn join_tessellated_nodes_of_nothing_is_empty() {

3517

        let t = join_tessellated_nodes(&[]);

3518

        assert!(t.vertices.as_ref().is_empty());

3519

        assert!(t.indices.as_ref().is_empty());

3520

3521

3522

    #[test]

3523

    fn join_tessellated_nodes_offsets_and_terminates_each_buffer() {

3524

        let a = tess(&[(0.0, 0.0), (1.0, 0.0)], &[0, 1]);

3525

        let b = tess(&[(2.0, 0.0), (3.0, 0.0)], &[0, 1]);

3526

        let j = join_tessellated_nodes(&[a, b]);

3527

        assert_eq!(j.vertices.as_ref().len(), 4);

3528

        assert_eq!(

3529

            j.indices.as_ref(),

3530

            &[0u32, 1, GL_RESTART_INDEX, 2, 3, GL_RESTART_INDEX][..]

3531

);

3532

        assert_indices_in_range(&j);

3533

3534

3535

    #[test]

3536

    fn join_tessellated_nodes_leaves_existing_restart_markers_unshifted() {

3537

        let a = tess(&[(0.0, 0.0)], &[0]);

3538

        let b = tess(&[(1.0, 0.0), (2.0, 0.0)], &[0, GL_RESTART_INDEX, 1]);

3539

        let j = join_tessellated_nodes(&[a, b]);

3540

        assert_eq!(

3541

            j.indices.as_ref(),

3542

&[

3543

                0u32,

3544

                GL_RESTART_INDEX,

3545

1,

3546

                GL_RESTART_INDEX,

3547

2,

3548

                GL_RESTART_INDEX

3549

            ][..]

3550

);

3551

3552

3553

    #[test]

3554

    fn join_tessellated_nodes_single_node_is_only_terminated() {

3555

        let j = join_tessellated_nodes(&[tess(&[(0.0, 0.0), (1.0, 1.0)], &[0, 1, 0])]);

3556

        assert_eq!(j.indices.as_ref(), &[0u32, 1, 0, GL_RESTART_INDEX][..]);

3557

3558

3559

    #[test]

3560

    fn join_tessellated_nodes_can_alias_an_index_onto_the_restart_marker() {

3561

        // FINDING (pinned): the offset is applied with a bare `+=` and is only

3562

        // skipped for indices that *already* equal GL_RESTART_INDEX, so a large

3563

        // index can be shifted onto the sentinel and silently turn into a

3564

        // primitive-restart marker. (Anything past u32::MAX additionally

3565

        // overflow-panics in debug builds.)

3566

        let a = tess(&[(0.0, 0.0)], &[0]);

3567

        let b = tess(&[(1.0, 0.0)], &[GL_RESTART_INDEX - 1]);

3568

        let j = join_tessellated_nodes(&[a, b]);

3569

        assert_eq!(

3570

            j.indices.as_ref(),

3571

&[

3572

                0u32,

3573

                GL_RESTART_INDEX,

3574

                GL_RESTART_INDEX,

3575

                GL_RESTART_INDEX

3576

            ][..]

3577

);

3578

3579

3580

    #[test]

3581

    fn join_tessellated_colored_nodes_of_nothing_is_empty() {

3582

        let t = join_tessellated_colored_nodes(&[]);

3583

        assert!(t.vertices.as_ref().is_empty());

3584

        assert!(t.indices.as_ref().is_empty());

3585

3586

3587

    #[test]

3588

    fn join_tessellated_colored_nodes_offsets_like_the_plain_variant() {

3589

        fn colored(xs: &[f32], idx: &[u32]) -> TessellatedColoredSvgNode {

3590

            TessellatedColoredSvgNode {

3591

                vertices: xs

3592

                    .iter()

3593

                    .map(|&x| SvgColoredVertex {

3594

x,

3595

                        y: 0.0,

3596

                        z: 0.0,

3597

                        r: 1.0,

3598

                        g: 0.0,

3599

                        b: 0.0,

3600

                        a: 1.0,

3601

})

3602

                    .collect::<Vec<_>>()

3603

                    .into(),

3604

                indices: idx.to_vec().into(),

3605

3606

3607

        let j = join_tessellated_colored_nodes(&[

3608

            colored(&[0.0, 1.0], &[0, 1]),

3609

            colored(&[2.0], &[0]),

3610

]);

3611

        assert_eq!(j.vertices.as_ref().len(), 3);

3612

        assert_eq!(

3613

            j.indices.as_ref(),

3614

            &[0u32, 1, GL_RESTART_INDEX, 2, GL_RESTART_INDEX][..]

3615

);

3616

3617

3618

    // ==================================================================

3619

    // boolean operations (agg scanline algebra)

3620

    // ==================================================================

3621

3622

    #[test]

3623

    fn storage_to_multi_polygon_of_an_untouched_storage_is_empty() {

3624

        let mut storage = agg_rust::scanline_storage_aa::ScanlineStorageAa::new();

3625

        assert!(storage_to_multi_polygon(&mut storage).rings.as_ref().is_empty());

3626

3627

3628

    #[test]

3629

    fn svg_multi_polygon_boolean_ops_on_two_empties_are_empty() {

3630

        let e = empty_polygon();

3631

        assert!(svg_multi_polygon_union(&e, &e).rings.as_ref().is_empty());

3632

        assert!(svg_multi_polygon_intersection(&e, &e).rings.as_ref().is_empty());

3633

        assert!(svg_multi_polygon_difference(&e, &e).rings.as_ref().is_empty());

3634

        assert!(svg_multi_polygon_xor(&e, &e).rings.as_ref().is_empty());

3635

3636

3637

    #[test]

3638

    fn svg_multi_polygon_union_of_a_square_with_itself_keeps_the_square() {

3639

        let sq = square_polygon();

3640

        let out = svg_multi_polygon_union(&sq, &sq);

3641

        assert!(

3642

            !out.rings.as_ref().is_empty(),

3643

            "a shape unioned with itself must not vanish"

3644

);

3645

        let b = out.get_bounds();

3646

        assert!(b.width > 0.0 && b.height > 0.0, "{b:?}");

3647

3648

3649

    #[test]

3650

    fn svg_multi_polygon_intersection_of_disjoint_squares_is_empty() {

3651

        let a = square_polygon();

3652

        let b = polygon_of(vec![square_at(100.0)]);

3653

        assert!(svg_multi_polygon_intersection(&a, &b)

3654

            .rings

3655

            .as_ref()

3656

            .is_empty());

3657

3658

3659

    #[test]

3660

    fn svg_multi_polygon_self_cancelling_ops_are_empty() {

3661

        let sq = square_polygon();

3662

        assert!(

3663

            svg_multi_polygon_difference(&sq, &sq).rings.as_ref().is_empty(),

3664

            "A minus A must be empty"

3665

);

3666

        assert!(

3667

            svg_multi_polygon_xor(&sq, &sq).rings.as_ref().is_empty(),

3668

            "A xor A must be empty"

3669

);

3670

3671

3672

    #[test]

3673

    fn svg_multi_polygon_ops_accept_curve_rings() {

3674

        let ring = mk_path(vec![

3675

            SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

3676

                start: pt(0.0, 0.0),

3677

                ctrl: pt(5.0, 12.0),

3678

                end: pt(10.0, 0.0),

3679

}),

3680

            SvgPathElement::CubicCurve(SvgCubicCurve {

3681

                start: pt(10.0, 0.0),

3682

                ctrl_1: pt(7.0, -6.0),

3683

                ctrl_2: pt(3.0, -6.0),

3684

                end: pt(0.0, 0.0),

3685

}),

3686

]);

3687

        let mp = polygon_of(vec![ring]);

3688

        assert!(!svg_multi_polygon_union(&mp, &mp).rings.as_ref().is_empty());

3689

3690

3691

    #[test]

3692

    fn svg_multi_polygon_byval_wrappers_match_the_by_ref_forms() {

3693

        let a = square_polygon();

3694

        let b = polygon_of(vec![square_at(5.0)]);

3695

        assert_eq!(

3696

            svg_multi_polygon_union_byval(&a, b.clone()),

3697

            svg_multi_polygon_union(&a, &b)

3698

);

3699

        assert_eq!(

3700

            svg_multi_polygon_intersection_byval(&a, b.clone()),

3701

            svg_multi_polygon_intersection(&a, &b)

3702

);

3703

        assert_eq!(

3704

            svg_multi_polygon_difference_byval(&a, b.clone()),

3705

            svg_multi_polygon_difference(&a, &b)

3706

);

3707

        assert_eq!(

3708

            svg_multi_polygon_xor_byval(&a, b.clone()),

3709

            svg_multi_polygon_xor(&a, &b)

3710

);

3711

3712

3713

    // ==================================================================

3714

    // render_node_clipmask_cpu

3715

    // ==================================================================

3716

3717

    #[test]

3718

    fn render_node_clipmask_cpu_zero_sized_image_is_none() {

3719

        let node = SvgNode::Rect(rect(0.0, 0.0, 4.0, 4.0));

3720

        let style = SvgStyle::Fill(SvgFillStyle {

3721

            transform: identity_transform(),

3722

            ..SvgFillStyle::default()

3723

});

3724

        assert_eq!(

3725

            render_node_clipmask_cpu(&mut mask_image(0, 4), &node, style),

3726

            None

3727

);

3728

        assert_eq!(

3729

            render_node_clipmask_cpu(&mut mask_image(4, 0), &node, style),

3730

            None

3731

);

3732

        assert_eq!(

3733

            render_node_clipmask_cpu(&mut mask_image(0, 0), &node, style),

3734

            None

3735

);

3736

3737

3738

    #[test]

3739

    fn render_node_clipmask_cpu_geometry_less_nodes_are_none() {

3740

        let style = SvgStyle::Fill(SvgFillStyle {

3741

            transform: identity_transform(),

3742

            ..SvgFillStyle::default()

3743

});

3744

        for node in [

3745

            SvgNode::Path(empty_path()),

3746

            SvgNode::MultiPolygon(empty_polygon()),

3747

            SvgNode::MultiShape(SvgSimpleNodeVec::from_const_slice(&[])),

3748

            SvgNode::MultiPolygonCollection(SvgMultiPolygonVec::from_const_slice(&[])),

3749

] {

3750

            assert_eq!(

3751

                render_node_clipmask_cpu(&mut mask_image(4, 4), &node, style),

3752

                None,

3753

                "{node:?}"

3754

);

3755

3756

3757

3758

    #[test]

3759

    fn render_node_clipmask_cpu_writes_a_single_channel_mask() {

3760

        let node = SvgNode::Rect(rect(0.0, 0.0, 4.0, 4.0));

3761

        let style = SvgStyle::Fill(SvgFillStyle {

3762

            transform: identity_transform(),

3763

            ..SvgFillStyle::default()

3764

});

3765

        let mut img = mask_image(4, 4);

3766

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3767

        assert_eq!(img.data_format, RawImageFormat::R8);

3768

        assert!(img.premultiplied_alpha);

3769

        let bytes = mask_bytes(&img);

3770

        assert_eq!(bytes.len(), 16, "one byte per pixel");

3771

        assert!(

3772

            bytes.iter().any(|&b| b > 0),

3773

            "a rect covering the whole image must leave coverage"

3774

);

3775

3776

3777

    #[test]

3778

    fn render_node_clipmask_cpu_default_style_transform_is_not_the_identity() {

3779

        // FINDING (pinned): `SvgTransform::default()` is the *zero* matrix, so a

3780

        // style built straight from `SvgFillStyle::default()` collapses all

3781

        // geometry onto the origin instead of drawing it 1:1.

3782

        let node = SvgNode::Rect(rect(0.0, 0.0, 4.0, 4.0));

3783

        let mut zeroed = mask_image(4, 4);

3784

        let mut identity = mask_image(4, 4);

3785

        assert_eq!(

3786

            render_node_clipmask_cpu(&mut zeroed, &node, SvgStyle::Fill(SvgFillStyle::default())),

3787

            Some(())

3788

);

3789

        assert_eq!(

3790

            render_node_clipmask_cpu(

3791

                &mut identity,

3792

                &node,

3793

                SvgStyle::Fill(SvgFillStyle {

3794

                    transform: identity_transform(),

3795

                    ..SvgFillStyle::default()

3796

})

3797

),

3798

            Some(())

3799

);

3800

        assert_ne!(mask_bytes(&zeroed), mask_bytes(&identity));

3801

3802

3803

    #[test]

3804

    fn render_node_clipmask_cpu_stroke_style_renders_without_panicking() {

3805

        let node = SvgNode::Circle(SvgCircle {

3806

            center_x: 8.0,

3807

            center_y: 8.0,

3808

            radius: 4.0,

3809

});

3810

        let style = SvgStyle::Stroke(SvgStrokeStyle {

3811

            transform: identity_transform(),

3812

            line_width: 2.0,

3813

            ..SvgStrokeStyle::default()

3814

});

3815

        let mut img = mask_image(16, 16);

3816

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3817

        assert_eq!(mask_bytes(&img).len(), 256);

3818

3819

3820

    #[test]

3821

    fn render_node_clipmask_cpu_geometry_far_outside_the_image_is_clipped_not_crashed() {

3822

        let node = SvgNode::Rect(rect(-1.0e6, -1.0e6, 10.0, 10.0));

3823

        let style = SvgStyle::Fill(SvgFillStyle {

3824

            transform: identity_transform(),

3825

            ..SvgFillStyle::default()

3826

});

3827

        let mut img = mask_image(4, 4);

3828

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3829

        assert!(mask_bytes(&img).iter().all(|&b| b == 0));

3830

3831

3832

    // ==================================================================

3833

    // svgxmlnode_parse / svg_parse / ParsedSvg

3834

    // ==================================================================

3835

3836

    #[test]

3837

    fn svg_parse_valid_minimal_input_keeps_the_bytes_verbatim() {

3838

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("positive control");

3839

        assert_eq!(p.svg_data.as_ref(), MINIMAL_SVG);

3840

        assert!(p.run_destructor);

3841

3842

3843

    #[test]

3844

    fn svg_parse_invalid_utf8_is_rejected() {

3845

        for bad in [

3846

            &[0xFFu8, 0xFE, 0x00][..],

3847

            &[0x80][..],

3848

            &[0xED, 0xA0, 0x80][..], // encoded surrogate

3849

            &[0xC0, 0x80][..],       // overlong NUL

3850

] {

3851

            assert_eq!(

3852

                svg_parse(bad, SvgParseOptions::default()).err(),

3853

                Some(SvgParseError::NotAnUtf8Str),

3854

                "{bad:?}"

3855

);

3856

3857

3858

3859

    #[test]

3860

    fn svg_parse_unclosed_elements_are_rejected() {

3861

        for bad in [&b"<svg"[..], &b"<svg>"[..], &b"<svg><g>"[..]] {

3862

            assert_eq!(

3863

                svg_parse(bad, SvgParseOptions::default()).err(),

3864

                Some(SvgParseError::NoParserAvailable),

3865

                "{bad:?}"

3866

);

3867

3868

3869

3870

    #[test]

3871

    fn svg_parse_accepts_input_that_is_not_svg_at_all() {

3872

        // PINNED leniency: `svg_parse` only checks that the bytes are UTF-8 and

3873

        // tokenize as XML — it never requires an <svg> root, so empty,

3874

        // whitespace-only and plain-text input all come back Ok.

3875

        for lenient in [

3876

            &b""[..],

3877

            &b"   "[..],

3878

            &b"\t\n\r "[..],

3879

            &b"garbage"[..],

3880

            &b"</svg>"[..],

3881

            &b"<html><body/></html>"[..],

3882

] {

3883

            let p = svg_parse(lenient, SvgParseOptions::default())

3884

                .unwrap_or_else(|e| panic!("{lenient:?} was rejected with {e:?}"));

3885

            assert_eq!(p.svg_data.as_ref(), lenient);

3886

3887

3888

3889

    #[test]

3890

    fn svg_parse_garbage_never_panics_and_never_invents_data() {

3891

        for data in [

3892

            &b"<<<<<<"[..],

3893

            &b"\x00\x01\x02\x03"[..],

3894

            &b"{\"json\": true}"[..],

3895

            &b"<svg <<>>"[..],

3896

            &b"&&&;;;"[..],

3897

            &b"<!--"[..],

3898

            &b"<?xml"[..],

3899

            &b"<!DOCTYPE"[..],

3900

] {

3901

            match svg_parse(data, SvgParseOptions::default()) {

3902

                Ok(p) => assert_eq!(p.svg_data.as_ref(), data, "{data:?}"),

3903

                Err(e) => assert_eq!(e, SvgParseError::NoParserAvailable, "{data:?}"),

3904

3905

3906

3907

3908

    #[test]

3909

    fn svg_parse_boundary_numeric_attributes_are_kept_as_opaque_strings() {

3910

        let src = concat!(

3911

            r#"<svg width="1e400" height="-0" a="9223372036854775807" "#,

3912

            r#"b="NaN" c="inf" d="0"><rect width="0"/></svg>"#

3913

);

3914

        let p = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("parse");

3915

        assert_eq!(p.to_string(SvgXmlOptions::default()), src);

3916

3917

3918

    #[test]

3919

    fn svg_parse_unicode_payloads_survive_untouched() {

3920

        for s in [

3921

            "<svg><text>\u{1F600}</text></svg>",

3922

            "<svg><text>e\u{0301}\u{0328}</text></svg>",

3923

            "<svg id=\"\u{65E5}\u{672C}\u{8A9E}\"/>",

3924

            "<svg>\u{200b}\u{1F600}</svg>",

3925

] {

3926

            let p = ParsedSvg::from_string(s, SvgParseOptions::default())

3927

                .unwrap_or_else(|e| panic!("{s:?} -> {e:?}"));

3928

            assert_eq!(p.to_string(SvgXmlOptions::default()), s);

3929

3930

3931

3932

    #[test]

3933

    fn svg_parse_leading_and_trailing_junk_is_tolerated_and_preserved() {

3934

        let src = "  <svg/>  trailing;garbage";

3935

        let p = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("lenient parse");

3936

        // The stored bytes are never trimmed — to_string gives back the original.

3937

        assert_eq!(p.to_string(SvgXmlOptions::default()), src);

3938

3939

3940

    #[test]

3941

    fn svg_parse_extremely_long_input_does_not_hang() {

3942

        let long = format!("<svg>{}</svg>", "a".repeat(1_000_000));

3943

        let p = ParsedSvg::from_string(&long, SvgParseOptions::default())

3944

            .expect("1 MB of text must parse");

3945

        assert_eq!(p.svg_data.as_ref().len(), long.len());

3946

3947

3948

    #[test]

3949

    fn svg_parse_many_sibling_elements_does_not_hang() {

3950

        let mut s = String::from("<svg>");

3951

        for _ in 0..50_000 {

3952

            s.push_str("<g/>");

3953

3954

        s.push_str("</svg>");

3955

        assert!(ParsedSvg::from_string(&s, SvgParseOptions::default()).is_ok());

3956

3957

3958

    #[test]

3959

    fn svg_parse_deeply_nested_input_does_not_stack_overflow() {

3960

        // The tokenizer loop is iterative, but the XmlNode tree it builds is torn

3961

        // down recursively — run on a big stack so a genuinely linear-depth drop

3962

        // is proven safe instead of coin-flipping on the 2 MiB default test stack.

3963

        let child = std::thread::Builder::new()

3964

            .stack_size(128 * 1024 * 1024)

3965

            .spawn(|| {

3966

                const DEPTH: usize = 10_000;

3967

                let mut s = String::from("<svg>");

3968

                for _ in 0..DEPTH {

3969

                    s.push_str("<g>");

3970

3971

                for _ in 0..DEPTH {

3972

                    s.push_str("</g>");

3973

3974

                s.push_str("</svg>");

3975

                ParsedSvg::from_string(&s, SvgParseOptions::default()).is_ok()

3976

})

3977

            .expect("spawn");

3978

        assert!(child

3979

            .join()

3980

            .expect("10k-deep nesting must not overflow the stack"));

3981

3982

3983

    #[test]

3984

    fn svgxmlnode_parse_mirrors_svg_parse_acceptance() {

3985

        assert!(svgxmlnode_parse(MINIMAL_SVG, SvgParseOptions::default()).is_ok());

3986

        assert!(svgxmlnode_parse(b"", SvgParseOptions::default()).is_ok());

3987

        assert_eq!(

3988

            svgxmlnode_parse(&[0xFF, 0xFE], SvgParseOptions::default()).err(),

3989

            Some(SvgParseError::NotAnUtf8Str)

3990

);

3991

        assert_eq!(

3992

            svgxmlnode_parse(b"<svg>", SvgParseOptions::default()).err(),

3993

            Some(SvgParseError::NoParserAvailable)

3994

);

3995

        let node = svgxmlnode_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

3996

        assert!(node.run_destructor);

3997

3998

3999

    #[test]

4000

    fn parsed_svg_round_trips_through_to_string_and_back() {

4001

        let src = r#"<svg viewBox="0 0 8 8"><rect width="8" height="8"/></svg>"#;

4002

        let once = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("parse");

4003

        let text = once.to_string(SvgXmlOptions::default());

4004

        assert_eq!(text, src);

4005

        let twice = ParsedSvg::from_string(&text, SvgParseOptions::default()).expect("re-parse");

4006

        assert_eq!(

4007

            twice.to_string(SvgXmlOptions::default()),

4008

            text,

4009

            "serialisation must be idempotent"

4010

);

4011

        assert_eq!(svg_to_string(&twice, SvgXmlOptions::default()), text);

4012

4013

4014

    #[test]

4015

    fn parsed_svg_from_bytes_and_from_string_agree() {

4016

        let a = ParsedSvg::from_bytes(MINIMAL_SVG, SvgParseOptions::default()).expect("bytes");

4017

        let b = ParsedSvg::from_string(

4018

            core::str::from_utf8(MINIMAL_SVG).expect("ascii"),

4019

            SvgParseOptions::default(),

4020

4021

        .expect("string");

4022

        assert_eq!(a.svg_data.as_ref(), b.svg_data.as_ref());

4023

4024

4025

    #[test]

4026

    fn parsed_svg_to_string_replaces_invalid_utf8_instead_of_panicking() {

4027

        // `ParsedSvg` is a plain #[repr(C)] FFI struct, so it can hold bytes that

4028

        // `svg_parse` would have rejected; `to_string` must stay lossy, not panic.

4029

        let p = ParsedSvg {

4030

            svg_data: vec![0xFFu8, 0xFE].into(),

4031

            run_destructor: true,

4032

};

4033

        assert_eq!(

4034

            p.to_string(SvgXmlOptions::default()),

4035

            "\u{FFFD}\u{FFFD}",

4036

            "each invalid byte becomes one replacement char"

4037

);

4038

        assert_eq!(

4039

            svg_to_string(&p, SvgXmlOptions::default()),

4040

            p.to_string(SvgXmlOptions::default())

4041

);

4042

4043

4044

    #[test]

4045

    fn parsed_svg_to_string_of_an_empty_document_is_empty() {

4046

        let p = ParsedSvg {

4047

            svg_data: Vec::new().into(),

4048

            run_destructor: true,

4049

};

4050

        assert!(p.to_string(SvgXmlOptions::default()).is_empty());

4051

        assert_eq!(format!("{p:?}"), "ParsedSvg(0 bytes)");

4052

4053

4054

    #[test]

4055

    fn parsed_svg_debug_reports_the_byte_length() {

4056

        let p = ParsedSvg {

4057

            svg_data: vec![1u8, 2, 3].into(),

4058

            run_destructor: true,

4059

};

4060

        assert_eq!(format!("{p:?}"), "ParsedSvg(3 bytes)");

4061

4062

4063

    #[test]

4064

    fn svg_root_and_get_root_agree() {

4065

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4066

        assert!(p.get_root().run_destructor);

4067

        assert!(svg_root(&p).run_destructor);

4068

        // …and stay well-defined for a document with no elements at all.

4069

        let empty = svg_parse(b"", SvgParseOptions::default()).expect("lenient parse");

4070

        assert!(empty.get_root().run_destructor);

4071

4072

4073

    // ==================================================================

4074

    // svg_render

4075

    // ==================================================================

4076

4077

    #[test]

4078

    fn svg_render_zero_target_size_is_none() {

4079

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4080

        for size in [

4081

            LayoutSize::new(0, 0),

4082

            LayoutSize::new(0, 8),

4083

            LayoutSize::new(8, 0),

4084

] {

4085

            let opts = SvgRenderOptions {

4086

                target_size: OptionLayoutSize::Some(size),

4087

                ..SvgRenderOptions::default()

4088

};

4089

            assert!(p.render(opts).is_none(), "{size:?}");

4090

            assert!(svg_render(&p, opts).is_none(), "{size:?}");

4091

4092

4093

4094

    #[cfg(feature = "cpurender")]

4095

    #[test]

4096

    fn svg_render_produces_an_image_of_the_requested_size() {

4097

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4098

        let opts = SvgRenderOptions {

4099

            target_size: OptionLayoutSize::Some(LayoutSize::new(8, 8)),

4100

            ..SvgRenderOptions::default()

4101

};

4102

        let img = p.render(opts).expect("a minimal <svg> must rasterize");

4103

        assert_eq!((img.width, img.height), (8, 8));

4104

        assert_eq!(img.data_format, RawImageFormat::RGBA8);

4105

        assert!(!img.premultiplied_alpha);

4106

4107

4108

    #[cfg(feature = "cpurender")]

4109

    #[test]

4110

    fn svg_render_of_a_document_without_an_svg_root_is_none() {

4111

        // `svg_parse` accepts it, but rasterization has nothing to draw.

4112

        let p = svg_parse(b"<html><body/></html>", SvgParseOptions::default())

4113

            .expect("lenient parse");

4114

        let opts = SvgRenderOptions {

4115

            target_size: OptionLayoutSize::Some(LayoutSize::new(4, 4)),

4116

            ..SvgRenderOptions::default()

4117

};

4118

        assert!(p.render(opts).is_none());

4119

4120

4121

    #[cfg(feature = "cpurender")]

4122

    #[test]

4123

    fn svg_render_one_by_one_target_is_the_smallest_valid_size() {

4124

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4125

        let opts = SvgRenderOptions {

4126

            target_size: OptionLayoutSize::Some(LayoutSize::new(1, 1)),

4127

            ..SvgRenderOptions::default()

4128

};

4129

        let img = p.render(opts).expect("1x1 must still rasterize");

4130

        assert_eq!((img.width, img.height), (1, 1));

4131

4132