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) via the lyon

5

//!   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) on `SvgMultiPolygon`

9

//!   shapes via agg scanline boolean algebra.

10

//! - **SVG parsing and rendering** (`svg_parse`, `svg_render`) using an XML parser and the agg-rust

11

//!   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

42

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

118

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

119

42

    match e {

120

38

        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

42

126

127

#[cfg(feature = "svg")]

128

78

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

129

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

130

78

    match e {

131

74

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

132

2

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

133

2

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

134

135

78

136

137

#[cfg(feature = "svg")]

138

37

fn translate_svg_stroke_style(e: SvgStrokeStyle) -> StrokeOptions {

139

37

    StrokeOptions::tolerance(e.tolerance)

140

37

        .with_start_cap(translate_svg_line_cap(e.start_cap))

141

37

        .with_end_cap(translate_svg_line_cap(e.end_cap))

142

37

        .with_line_join(translate_svg_line_join(e.line_join))

143

37

        .with_line_width(e.line_width)

144

37

        .with_miter_limit(e.miter_limit)

145

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

146

37

147

148

#[cfg(feature = "svg")]

149

21

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

150

21

    let mut builder = Path::builder();

151

152

21

    for p in polygon.rings.as_ref() {

153

21

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

154

4

            continue;

155

17

156

157

17

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

158

17

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

159

160

17

        builder.begin(first_point);

161

162

68

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

163

        /* NOTE: REVERSE ITERATOR */

164

165

68

            match q {

166

68

                SvgPathElement::Line(l) => {

167

68

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

168

68

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

17

        builder.end(p.is_closed());

186

187

188

21

    builder.build()

189

21

190

191

#[cfg(feature = "svg")]

192

15

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

193

    use lyon::{

194

        geom::Box2D,

195

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

196

};

197

198

15

    let mut builder = Path::builder();

199

200

47

    for p in polygon {

201

32

        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

13

            SvgSimpleNode::Circle(c) => {

238

13

                builder.add_circle(

239

13

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

240

13

                    c.radius,

241

13

                    Winding::Positive,

242

13

);

243

13

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

13

            SvgSimpleNode::Rect(c) => {

252

13

                builder.add_rectangle(

253

13

                    &Box2D::from_origin_and_size(

254

13

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

255

13

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

256

13

),

257

13

                    Winding::Positive,

258

13

);

259

13

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

15

    builder.build()

273

15

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

#[must_use]

278

110

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

279

110

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

280

110

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

281

110

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

282

110

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

283

284

110

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

285

110

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

286

110

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

287

110

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

288

289

110

    let int_min_x = p_min_x.max(q_min_x);

290

110

    let int_max_x = p_max_x.min(q_max_x);

291

110

    let int_min_y = p_min_y.max(q_min_y);

292

110

    let int_max_y = p_max_y.min(q_max_y);

293

294

110

    let two = 2.0;

295

110

    let mid_x = (int_min_x + int_max_x) / two;

296

110

    let mid_y = (int_min_y + int_max_y) / two;

297

298

    // condition ordinate values by subtracting midpoint

299

110

    let p1x = p.start.x - mid_x;

300

110

    let p1y = p.start.y - mid_y;

301

110

    let p2x = p.end.x - mid_x;

302

110

    let p2y = p.end.y - mid_y;

303

110

    let q1x = q.start.x - mid_x;

304

110

    let q1y = q.start.y - mid_y;

305

110

    let q2x = q.end.x - mid_x;

306

110

    let q2y = q.end.y - mid_y;

307

308

    // unrolled computation using homogeneous coordinates eqn

309

110

    let px = p1y - p2y;

310

110

    let py = p2x - p1x;

311

110

    let pw = p1x * p2y - p2x * p1y;

312

313

110

    let qx = q1y - q2y;

314

110

    let qy = q2x - q1x;

315

110

    let qw = q1x * q2y - q2x * q1y;

316

317

110

    let xw = py * qw - qy * pw;

318

110

    let yw = qx * pw - px * qw;

319

110

    let w = px * qy - qx * py;

320

321

110

    let x_int = xw / w;

322

110

    let y_int = yw / w;

323

324

    // check for parallel lines

325

110

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

326

85

        None

327

    } else {

328

        // de-condition intersection point

329

25

        Some(SvgPoint {

330

25

            x: x_int + mid_x,

331

25

            y: y_int + mid_y,

332

25

})

333

334

110

335

336

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

337

#[must_use]

338

2

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

339

2

    raw_line_intersection(p, &q)

340

2

341

342

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

343

#[must_use]

344

17

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

345

17

    if distance == 0.0 {

346

2

        return p.clone();

347

15

348

349

15

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

350

15

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

351

14

        items.push(*first);

352

14

353

354

15

    let mut items = items

355

15

        .iter()

356

62

        .map(|l| match l {

357

59

            SvgPathElement::Line(q) => {

358

59

                let normal = match q.outwards_normal() {

359

57

                    Some(s) => SvgPoint {

360

57

                        x: s.x * distance,

361

57

                        y: s.y * distance,

362

57

},

363

2

                    None => return *l,

364

};

365

366

57

                SvgPathElement::Line(SvgLine {

367

57

                    start: SvgPoint {

368

57

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

369

57

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

370

57

},

371

57

                    end: SvgPoint {

372

57

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

373

57

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

374

57

},

375

57

})

376

377

2

            SvgPathElement::QuadraticCurve(q) => {

378

2

                let n1 = match (SvgLine {

379

2

                    start: q.start,

380

2

                    end: q.ctrl,

381

2

382

2

                .outwards_normal())

383

384

2

                    Some(s) => SvgPoint {

385

2

                        x: s.x * distance,

386

2

                        y: s.y * distance,

387

2

},

388

                    None => return *l,

389

};

390

391

2

                let n2 = match (SvgLine {

392

2

                    start: q.ctrl,

393

2

                    end: q.end,

394

2

395

2

                .outwards_normal())

396

397

2

                    Some(s) => SvgPoint {

398

2

                        x: s.x * distance,

399

2

                        y: s.y * distance,

400

2

},

401

                    None => return *l,

402

};

403

404

2

                let nl1 = SvgLine {

405

2

                    start: SvgPoint {

406

2

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

407

2

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

408

2

},

409

2

                    end: SvgPoint {

410

2

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

411

2

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

412

2

},

413

2

};

414

415

2

                let nl2 = SvgLine {

416

2

                    start: SvgPoint {

417

2

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

418

2

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

419

2

},

420

2

                    end: SvgPoint {

421

2

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

422

2

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

423

2

},

424

2

};

425

426

2

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

427

                    return *l;

428

};

429

430

2

                SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

431

2

                    start: nl1.start,

432

2

                    ctrl: nctrl,

433

2

                    end: nl2.end,

434

2

})

435

436

1

            SvgPathElement::CubicCurve(q) => {

437

1

                let n1 = match (SvgLine {

438

1

                    start: q.start,

439

1

                    end: q.ctrl_1,

440

1

441

1

                .outwards_normal())

442

443

1

                    Some(s) => SvgPoint {

444

1

                        x: s.x * distance,

445

1

                        y: s.y * distance,

446

1

},

447

                    None => return *l,

448

};

449

450

1

                let n2 = match (SvgLine {

451

1

                    start: q.ctrl_1,

452

1

                    end: q.ctrl_2,

453

1

454

1

                .outwards_normal())

455

456

1

                    Some(s) => SvgPoint {

457

1

                        x: s.x * distance,

458

1

                        y: s.y * distance,

459

1

},

460

                    None => return *l,

461

};

462

463

1

                let n3 = match (SvgLine {

464

1

                    start: q.ctrl_2,

465

1

                    end: q.end,

466

1

467

1

                .outwards_normal())

468

469

1

                    Some(s) => SvgPoint {

470

1

                        x: s.x * distance,

471

1

                        y: s.y * distance,

472

1

},

473

                    None => return *l,

474

};

475

476

1

                let nl1 = SvgLine {

477

1

                    start: SvgPoint {

478

1

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

479

1

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

480

1

},

481

1

                    end: SvgPoint {

482

1

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

483

1

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

484

1

},

485

1

};

486

487

1

                let nl2 = SvgLine {

488

1

                    start: SvgPoint {

489

1

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

490

1

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

491

1

},

492

1

                    end: SvgPoint {

493

1

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

494

1

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

495

1

},

496

1

};

497

498

1

                let nl3 = SvgLine {

499

1

                    start: SvgPoint {

500

1

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

501

1

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

502

1

},

503

1

                    end: SvgPoint {

504

1

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

505

1

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

506

1

},

507

1

};

508

509

1

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

510

                    return *l;

511

};

512

513

1

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

514

                    return *l;

515

};

516

517

1

                SvgPathElement::CubicCurve(SvgCubicCurve {

518

1

                    start: nl1.start,

519

1

                    ctrl_1: nctrl_1,

520

1

                    ctrl_2: nctrl_2,

521

1

                    end: nl3.end,

522

1

})

523

524

62

})

525

15

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

526

527

34

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

528

34

        let a_end_line = match items[i] {

529

33

            SvgPathElement::Line(q) => q,

530

1

            SvgPathElement::QuadraticCurve(q) => SvgLine {

531

1

                start: q.ctrl,

532

1

                end: q.end,

533

1

},

534

            SvgPathElement::CubicCurve(q) => SvgLine {

535

                start: q.ctrl_2,

536

                end: q.end,

537

},

538

};

539

540

34

        let b_start_line = match items[i + 1] {

541

33

            SvgPathElement::Line(q) => q,

542

            SvgPathElement::QuadraticCurve(q) => SvgLine {

543

                start: q.ctrl,

544

                end: q.start,

545

},

546

1

            SvgPathElement::CubicCurve(q) => SvgLine {

547

1

                start: q.ctrl_1,

548

1

                end: q.start,

549

1

},

550

};

551

552

34

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

553

16

            items[i].set_last(intersect_pt);

554

16

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

555

18

556

557

558

15

    items.pop();

559

560

15

    SvgPath {

561

15

        items: items.into(),

562

15

563

17

564

565

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma;

566

                                   // keep explicit a*b+c

567

50

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

568

50

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

569

50

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

570

50

    let dt = dx.hypot(dy);

571

50

    let dt_short = dt - distance;

572

573

50

    SvgLine {

574

50

        start: line.start,

575

50

        end: SvgPoint {

576

50

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

577

50

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

578

50

},

579

50

580

50

581

582

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma;

583

                                   // keep explicit a*b+c

584

43

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

585

43

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

586

43

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

587

43

    let dt = dx.hypot(dy);

588

43

    let dt_short = dt - distance;

589

590

43

    SvgLine {

591

43

        start: SvgPoint {

592

43

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

593

43

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

594

43

},

595

43

        end: line.end,

596

43

597

43

598

599

// Creates a "bevel"

600

#[must_use]

601

11

pub fn svg_path_bevel(p: &SvgPath, distance: f32) -> SvgPath {

602

11

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

603

604

    // duplicate first & last items

605

11

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

606

11

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

607

11

    if let Some(first) = first {

608

10

        items.push(first);

609

10

610

11

    items.reverse();

611

11

    if let Some(last) = last {

612

10

        items.push(last);

613

10

614

11

    items.reverse();

615

616

11

    let mut final_items = Vec::new();

617

43

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

618

43

        let a = items[i];

619

43

        let b = items[i + 1];

620

43

        match (a, b) {

621

40

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

622

40

                let a_short = shorten_line_end_by(a, distance);

623

40

                let b_short = shorten_line_start_by(b, distance);

624

40

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

625

40

                final_items.push(SvgPathElement::CubicCurve(SvgCubicCurve {

626

40

                    start: a_short.end,

627

40

                    ctrl_1: a.end,

628

40

                    ctrl_2: b.start,

629

40

                    end: b_short.start,

630

40

                }));

631

40

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

632

40

633

3

            (other_a, other_b) => {

634

3

                final_items.push(other_a);

635

3

                final_items.push(other_b);

636

3

637

638

639

640

    // remove first & last items again

641

11

    final_items.pop();

642

11

    final_items.reverse();

643

11

    final_items.pop();

644

11

    final_items.reverse();

645

646

11

    SvgPath {

647

11

        items: final_items.into(),

648

11

649

11

650

651

#[cfg(feature = "svg")]

652

64

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

653

64

    let mut builder = Path::builder();

654

655

64

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

656

49

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

657

49

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

658

659

49

        builder.begin(first_point);

660

661

186

        for p in path.items.as_ref() {

662

186

            match p {

663

186

                SvgPathElement::Line(l) => {

664

186

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

665

186

666

                SvgPathElement::QuadraticCurve(qc) => {

667

                    builder.quadratic_bezier_to(

668

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

669

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

670

);

671

672

                SvgPathElement::CubicCurve(cc) => {

673

                    builder.cubic_bezier_to(

674

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

675

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

676

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

677

);

678

679

680

681

682

49

        builder.end(path.is_closed());

683

15

684

685

64

    builder.build()

686

64

687

688

#[cfg(feature = "svg")]

689

#[inline]

690

175

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

691

175

    TessellatedSvgNode {

692

175

        vertices: v.vertices.into(),

693

175

        indices: v.indices.into(),

694

175

695

175

696

697

#[cfg(feature = "svg")]

698

#[must_use]

699

16

pub fn tessellate_multi_polygon_fill(

700

16

    polygon: &SvgMultiPolygon,

701

16

    fill_style: SvgFillStyle,

702

16

) -> TessellatedSvgNode {

703

16

    let polygon = svg_multipolygon_to_lyon_path(polygon);

704

705

16

    let mut geometry = VertexBuffers::new();

706

16

    let mut tessellator = FillTessellator::new();

707

708

16

    let tess_result = tessellator.tessellate_path(

709

16

        &polygon,

710

16

        &FillOptions::tolerance(fill_style.tolerance),

711

60

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

712

60

            let xy_arr = vertex.position();

713

60

            SvgVertex {

714

60

                x: xy_arr.x,

715

60

                y: xy_arr.y,

716

60

717

60

}),

718

);

719

720

16

    if tess_result.is_err() {

721

        TessellatedSvgNode::empty()

722

    } else {

723

16

        vertex_buffers_to_tessellated_cpu_node(geometry)

724

725

16

726

727

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

728

pub fn tessellate_multi_polygon_fill(

729

    polygon: &SvgMultiPolygon,

730

    fill_style: SvgFillStyle,

731

) -> TessellatedSvgNode {

732

    TessellatedSvgNode::default()

733

734

735

#[cfg(feature = "svg")]

736

#[must_use]

737

13

pub fn tessellate_multi_shape_fill(

738

13

    ms: &[SvgSimpleNode],

739

13

    fill_style: SvgFillStyle,

740

13

) -> TessellatedSvgNode {

741

13

    let polygon = svg_multi_shape_to_lyon_path(ms);

742

743

13

    let mut geometry = VertexBuffers::new();

744

13

    let mut tessellator = FillTessellator::new();

745

746

13

    let tess_result = tessellator.tessellate_path(

747

13

        &polygon,

748

13

        &FillOptions::tolerance(fill_style.tolerance),

749

508

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

750

508

            let xy_arr = vertex.position();

751

508

            SvgVertex {

752

508

                x: xy_arr.x,

753

508

                y: xy_arr.y,

754

508

755

508

}),

756

);

757

758

13

    if tess_result.is_err() {

759

        TessellatedSvgNode::empty()

760

    } else {

761

13

        vertex_buffers_to_tessellated_cpu_node(geometry)

762

763

13

764

765

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

766

pub fn tessellate_multi_shape_fill(

767

    ms: &[SvgSimpleNode],

768

    fill_style: SvgFillStyle,

769

) -> TessellatedSvgNode {

770

    TessellatedSvgNode::default()

771

772

773

#[must_use]

774

27

pub fn svg_node_contains_point(

775

27

    node: &SvgNode,

776

27

    point: SvgPoint,

777

27

    fill_rule: SvgFillRule,

778

27

    tolerance: f32,

779

27

) -> bool {

780

27

    match node {

781

1

        SvgNode::MultiPolygonCollection(a) => a

782

1

            .as_ref()

783

1

            .iter()

784

1

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

785

1

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

786

4

        SvgNode::Path(a) => {

787

4

            if !a.is_closed() {

788

2

                return false;

789

2

790

2

            path_contains_point(a, point, fill_rule, tolerance)

791

792

8

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

793

9

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

794

4

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

795

1

            SvgSimpleNode::Path(a) => {

796

1

                if !a.is_closed() {

797

1

                    return false;

798

799

                path_contains_point(a, point, fill_rule, tolerance)

800

801

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

802

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

803

2

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

804

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

805

3

}),

806

807

27

808

809

#[cfg(feature = "svg")]

810

#[must_use]

811

17

pub fn path_contains_point(

812

17

    path: &SvgPath,

813

17

    point: SvgPoint,

814

17

    fill_rule: SvgFillRule,

815

17

    tolerance: f32,

816

17

) -> bool {

817

    use lyon::{

818

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

819

        path::FillRule as LyonFillRule,

820

};

821

17

    let path = svg_path_to_lyon_path_events(path);

822

17

    let fill_rule = match fill_rule {

823

15

        SvgFillRule::Winding => LyonFillRule::NonZero,

824

2

        SvgFillRule::EvenOdd => LyonFillRule::EvenOdd,

825

};

826

17

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

827

17

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

828

17

829

830

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

831

pub fn path_contains_point(

832

    path: &SvgPath,

833

    point: SvgPoint,

834

    fill_rule: SvgFillRule,

835

    tolerance: f32,

836

) -> bool {

837

    false

838

839

840

#[cfg(feature = "svg")]

841

#[must_use]

842

5

pub fn polygon_contains_point(

843

5

    polygon: &SvgMultiPolygon,

844

5

    point: SvgPoint,

845

5

    fill_rule: SvgFillRule,

846

5

    tolerance: f32,

847

5

) -> bool {

848

    use lyon::{

849

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

850

        path::FillRule as LyonFillRule,

851

};

852

5

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

853

3

        let path = svg_path_to_lyon_path_events(path);

854

3

        let fill_rule = match fill_rule {

855

3

            SvgFillRule::Winding => LyonFillRule::NonZero,

856

            SvgFillRule::EvenOdd => LyonFillRule::EvenOdd,

857

};

858

3

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

859

3

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

860

3

})

861

5

862

863

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

864

pub fn polygon_contains_point(

865

    polygon: &SvgMultiPolygon,

866

    point: SvgPoint,

867

    fill_rule: SvgFillRule,

868

    tolerance: f32,

869

) -> bool {

870

    false

871

872

873

#[cfg(feature = "svg")]

874

#[must_use]

875

1

pub fn tessellate_multi_shape_stroke(

876

1

    ms: &[SvgSimpleNode],

877

1

    stroke_style: SvgStrokeStyle,

878

1

) -> TessellatedSvgNode {

879

1

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

880

1

    let polygon = svg_multi_shape_to_lyon_path(ms);

881

882

1

    let mut stroke_geometry = VertexBuffers::new();

883

1

    let mut stroke_tess = StrokeTessellator::new();

884

885

1

    let tess_result = stroke_tess.tessellate_path(

886

1

        &polygon,

887

1

        &stroke_options,

888

98

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

889

98

            let xy_arr = vertex.position();

890

98

            SvgVertex {

891

98

                x: xy_arr.x,

892

98

                y: xy_arr.y,

893

98

894

98

}),

895

);

896

897

1

    if tess_result.is_err() {

898

        TessellatedSvgNode::empty()

899

    } else {

900

1

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

901

902

1

903

904

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

905

pub fn tessellate_multi_shape_stroke(

906

    polygon: &[SvgSimpleNode],

907

    stroke_style: SvgStrokeStyle,

908

) -> TessellatedSvgNode {

909

    TessellatedSvgNode::default()

910

911

912

#[cfg(feature = "svg")]

913

#[must_use]

914

1

pub fn tessellate_multi_polygon_stroke(

915

1

    polygon: &SvgMultiPolygon,

916

1

    stroke_style: SvgStrokeStyle,

917

1

) -> TessellatedSvgNode {

918

1

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

919

1

    let polygon = svg_multipolygon_to_lyon_path(polygon);

920

921

1

    let mut stroke_geometry = VertexBuffers::new();

922

1

    let mut stroke_tess = StrokeTessellator::new();

923

924

1

    let tess_result = stroke_tess.tessellate_path(

925

1

        &polygon,

926

1

        &stroke_options,

927

1

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

928

            let xy_arr = vertex.position();

929

            SvgVertex {

930

                x: xy_arr.x,

931

                y: xy_arr.y,

932

933

}),

934

);

935

936

1

    if tess_result.is_err() {

937

        TessellatedSvgNode::empty()

938

    } else {

939

1

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

940

941

1

942

943

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

944

pub fn tessellate_multi_polygon_stroke(

945

    polygon: &SvgMultiPolygon,

946

    stroke_style: SvgStrokeStyle,

947

) -> TessellatedSvgNode {

948

    TessellatedSvgNode::default()

949

950

951

#[cfg(feature = "svg")]

952

#[must_use]

953

32

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

954

32

    let polygon = svg_path_to_lyon_path_events(path);

955

956

32

    let mut geometry = VertexBuffers::new();

957

32

    let mut tessellator = FillTessellator::new();

958

959

32

    let tess_result = tessellator.tessellate_path(

960

32

        &polygon,

961

32

        &FillOptions::tolerance(fill_style.tolerance),

962

74

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

963

74

            let xy_arr = vertex.position();

964

74

            SvgVertex {

965

74

                x: xy_arr.x,

966

74

                y: xy_arr.y,

967

74

968

74

}),

969

);

970

971

32

    if tess_result.is_err() {

972

        TessellatedSvgNode::empty()

973

    } else {

974

32

        vertex_buffers_to_tessellated_cpu_node(geometry)

975

976

32

977

978

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

979

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

980

    TessellatedSvgNode::default()

981

982

983

#[cfg(feature = "svg")]

984

#[must_use]

985

11

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

986

11

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

987

11

    let polygon = svg_path_to_lyon_path_events(path);

988

989

11

    let mut stroke_geometry = VertexBuffers::new();

990

11

    let mut stroke_tess = StrokeTessellator::new();

991

992

11

    let tess_result = stroke_tess.tessellate_path(

993

11

        &polygon,

994

11

        &stroke_options,

995

101

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

996

100

            let xy_arr = vertex.position();

997

100

            SvgVertex {

998

100

                x: xy_arr.x,

999

100

                y: xy_arr.y,

1000

100

1001

100

}),

1002

);

1003

1004

11

    if tess_result.is_err() {

1005

        TessellatedSvgNode::empty()

1006

    } else {

1007

11

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1008

1009

11

1010

1011

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

1012

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

1013

    TessellatedSvgNode::default()

1014

1015

1016

#[cfg(feature = "svg")]

1017

#[must_use]

1018

23

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

1019

23

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

1020

1021

23

    let mut geometry = VertexBuffers::new();

1022

23

    let mut tesselator = FillTessellator::new();

1023

23

    let tess_result = tesselator.tessellate_circle(

1024

23

        center,

1025

23

        c.radius,

1026

23

        &FillOptions::tolerance(fill_style.tolerance),

1027

392

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

1028

392

            let xy_arr = vertex.position();

1029

392

            SvgVertex {

1030

392

                x: xy_arr.x,

1031

392

                y: xy_arr.y,

1032

392

1033

392

}),

1034

);

1035

1036

23

    if tess_result.is_err() {

1037

        TessellatedSvgNode::empty()

1038

    } else {

1039

23

        vertex_buffers_to_tessellated_cpu_node(geometry)

1040

1041

23

1042

1043

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

1044

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

1045

    TessellatedSvgNode::default()

1046

1047

1048

#[cfg(feature = "svg")]

1049

#[must_use]

1050

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

1051

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1052

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

1053

1054

    let mut stroke_geometry = VertexBuffers::new();

1055

    let mut tesselator = StrokeTessellator::new();

1056

1057

    let tess_result = tesselator.tessellate_circle(

1058

        center,

1059

        c.radius,

1060

        &stroke_options,

1061

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

1062

            let xy_arr = vertex.position();

1063

            SvgVertex {

1064

                x: xy_arr.x,

1065

                y: xy_arr.y,

1066

1067

}),

1068

);

1069

1070

    if tess_result.is_err() {

1071

        TessellatedSvgNode::empty()

1072

    } else {

1073

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1074

1075

1076

1077

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

1078

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

1079

    TessellatedSvgNode::default()

1080

1081

1082

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

1083

#[cfg(feature = "svg")]

1084

73

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

1085

/*

1086

    let radii = BorderRadii {

1087

        top_left: r.radius_top_left,

1088

        top_right: r.radius_top_right,

1089

        bottom_left: r.radius_bottom_left,

1090

        bottom_right: r.radius_bottom_right

1091

    };*/

1092

73

    lyon::geom::Box2D::from_origin_and_size(Point2D::new(r.x, r.y), Size2D::new(r.width, r.height))

1093

73

1094

1095

#[cfg(feature = "svg")]

1096

#[must_use]

1097

56

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

1098

56

    let rect = get_radii(r);

1099

56

    let mut geometry = VertexBuffers::new();

1100

56

    let mut tesselator = FillTessellator::new();

1101

1102

56

    let tess_result = tesselator.tessellate_rectangle(

1103

56

        &rect,

1104

56

        &FillOptions::tolerance(fill_style.tolerance),

1105

224

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

1106

224

            let xy_arr = vertex.position();

1107

224

            SvgVertex {

1108

224

                x: xy_arr.x,

1109

224

                y: xy_arr.y,

1110

224

1111

224

}),

1112

);

1113

1114

56

    if tess_result.is_err() {

1115

        TessellatedSvgNode::empty()

1116

    } else {

1117

56

        vertex_buffers_to_tessellated_cpu_node(geometry)

1118

1119

56

1120

1121

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

1122

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

1123

    TessellatedSvgNode::default()

1124

1125

1126

#[cfg(feature = "svg")]

1127

#[must_use]

1128

13

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

1129

13

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1130

13

    let rect = get_radii(r);

1131

1132

13

    let mut stroke_geometry = VertexBuffers::new();

1133

13

    let mut tesselator = StrokeTessellator::new();

1134

1135

13

    let tess_result = tesselator.tessellate_rectangle(

1136

13

        &rect,

1137

13

        &stroke_options,

1138

130

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

1139

130

            let xy_arr = vertex.position();

1140

130

            SvgVertex {

1141

130

                x: xy_arr.x,

1142

130

                y: xy_arr.y,

1143

130

1144

130

}),

1145

);

1146

1147

13

    if tess_result.is_err() {

1148

        TessellatedSvgNode::empty()

1149

    } else {

1150

13

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1151

1152

13

1153

1154

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

1155

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

1156

    TessellatedSvgNode::default()

1157

1158

1159

/// Tessellate the path using lyon

1160

#[cfg(feature = "svg")]

1161

#[must_use]

1162

2

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

1163

2

    match node.style {

1164

1

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

1165

1

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

1166

1167

2

1168

1169

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

1170

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

1171

    TessellatedSvgNode::default()

1172

1173

1174

#[cfg(feature = "svg")]

1175

#[must_use]

1176

3

pub fn tessellate_line_stroke(

1177

3

    svgline: &SvgLine,

1178

3

    stroke_style: SvgStrokeStyle,

1179

3

) -> TessellatedSvgNode {

1180

3

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1181

1182

3

    let mut builder = Path::builder();

1183

3

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

1184

3

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

1185

3

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

1186

3

    let path = builder.build();

1187

1188

3

    let mut stroke_geometry = VertexBuffers::new();

1189

3

    let mut stroke_tess = StrokeTessellator::new();

1190

1191

3

    let tess_result = stroke_tess.tessellate_path(

1192

3

        &path,

1193

3

        &stroke_options,

1194

8

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

1195

8

            let xy_arr = vertex.position();

1196

8

            SvgVertex {

1197

8

                x: xy_arr.x,

1198

8

                y: xy_arr.y,

1199

8

1200

8

}),

1201

);

1202

1203

3

    if tess_result.is_err() {

1204

        TessellatedSvgNode::empty()

1205

    } else {

1206

3

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1207

1208

3

1209

1210

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

1211

pub fn tessellate_line_stroke(

1212

    svgline: &SvgLine,

1213

    stroke_style: SvgStrokeStyle,

1214

) -> TessellatedSvgNode {

1215

    TessellatedSvgNode::default()

1216

1217

1218

#[cfg(feature = "svg")]

1219

#[must_use]

1220

2

pub fn tessellate_cubiccurve_stroke(

1221

2

    svgcubiccurve: &SvgCubicCurve,

1222

2

    stroke_style: SvgStrokeStyle,

1223

2

) -> TessellatedSvgNode {

1224

2

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1225

1226

2

    let mut builder = Path::builder();

1227

2

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

1228

2

    builder.cubic_bezier_to(

1229

2

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

1230

2

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

1231

2

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

1232

);

1233

2

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

1234

2

    let path = builder.build();

1235

1236

2

    let mut stroke_geometry = VertexBuffers::new();

1237

2

    let mut stroke_tess = StrokeTessellator::new();

1238

1239

2

    let tess_result = stroke_tess.tessellate_path(

1240

2

        &path,

1241

2

        &stroke_options,

1242

68

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

1243

68

            let xy_arr = vertex.position();

1244

68

            SvgVertex {

1245

68

                x: xy_arr.x,

1246

68

                y: xy_arr.y,

1247

68

1248

68

}),

1249

);

1250

1251

2

    if tess_result.is_err() {

1252

        TessellatedSvgNode::empty()

1253

    } else {

1254

2

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1255

1256

2

1257

1258

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

1259

pub fn tessellate_cubiccurve_stroke(

1260

    svgline: &SvgCubicCurve,

1261

    stroke_style: SvgStrokeStyle,

1262

) -> TessellatedSvgNode {

1263

    TessellatedSvgNode::default()

1264

1265

1266

#[cfg(feature = "svg")]

1267

#[must_use]

1268

2

pub fn tessellate_quadraticcurve_stroke(

1269

2

    svgquadraticcurve: &SvgQuadraticCurve,

1270

2

    stroke_style: SvgStrokeStyle,

1271

2

) -> TessellatedSvgNode {

1272

2

    let stroke_options: StrokeOptions = translate_svg_stroke_style(stroke_style);

1273

1274

2

    let mut builder = Path::builder();

1275

2

    builder.begin(Point2D::new(

1276

2

        svgquadraticcurve.start.x,

1277

2

        svgquadraticcurve.start.y,

1278

));

1279

2

    builder.quadratic_bezier_to(

1280

2

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

1281

2

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

1282

);

1283

2

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

1284

2

    let path = builder.build();

1285

1286

2

    let mut stroke_geometry = VertexBuffers::new();

1287

2

    let mut stroke_tess = StrokeTessellator::new();

1288

1289

2

    let tess_result = stroke_tess.tessellate_path(

1290

2

        &path,

1291

2

        &stroke_options,

1292

36

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

1293

36

            let xy_arr = vertex.position();

1294

36

            SvgVertex {

1295

36

                x: xy_arr.x,

1296

36

                y: xy_arr.y,

1297

36

1298

36

}),

1299

);

1300

1301

2

    if tess_result.is_err() {

1302

        TessellatedSvgNode::empty()

1303

    } else {

1304

2

        vertex_buffers_to_tessellated_cpu_node(stroke_geometry)

1305

1306

2

1307

1308

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

1309

pub fn tessellate_quadraticcurve_stroke(

1310

    svgquadraticcurve: &SvgQuadraticCurve,

1311

    stroke_style: SvgStrokeStyle,

1312

) -> TessellatedSvgNode {

1313

    TessellatedSvgNode::default()

1314

1315

1316

#[cfg(feature = "svg")]

1317

#[must_use]

1318

3

pub fn tessellate_svgpathelement_stroke(

1319

3

    svgpathelement: &SvgPathElement,

1320

3

    stroke_style: SvgStrokeStyle,

1321

3

) -> TessellatedSvgNode {

1322

3

    match svgpathelement {

1323

1

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

1324

1

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

1325

1

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

1326

1327

3

1328

1329

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

1330

pub fn tessellate_svgpathelement_stroke(

1331

    svgpathelement: &SvgPathElement,

1332

    stroke_style: SvgStrokeStyle,

1333

) -> TessellatedSvgNode {

1334

    TessellatedSvgNode::default()

1335

1336

1337

#[cfg(feature = "svg")]

1338

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

1339

#[must_use]

1340

8

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

1341

8

    let mut index_offset = 0;

1342

1343

    // note: can not be parallelized!

1344

8

    let all_index_offsets = nodes

1345

8

        .as_ref()

1346

8

        .iter()

1347

11

        .map(|t| {

1348

11

            let i = index_offset;

1349

11

            index_offset += t.vertices.len();

1350

11

1351

11

})

1352

8

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

1353

1354

8

    let all_vertices = nodes

1355

8

        .as_ref()

1356

8

        .iter()

1357

11

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

1358

8

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

1359

1360

8

    let all_indices = nodes

1361

8

        .as_ref()

1362

8

        .iter()

1363

8

        .enumerate()

1364

11

        .flat_map(|(buffer_index, t)| {

1365

            // since the vertex buffers are now joined,

1366

            // offset the indices by the vertex buffers lengths

1367

            // encountered so far

1368

11

            let vertex_buffer_offset: u32 = all_index_offsets

1369

11

                .get(buffer_index)

1370

11

                .copied()

1371

11

                .unwrap_or(0)

1372

11

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

1373

1374

11

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

1375

11

            if vertex_buffer_offset != 0 {

1376

23

                for i in &mut indices {

1377

18

                    if *i != GL_RESTART_INDEX {

1378

17

                        *i += vertex_buffer_offset;

1379

17

1380

1381

6

1382

1383

11

            indices.push(GL_RESTART_INDEX);

1384

1385

11

            indices

1386

11

})

1387

8

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

1388

1389

8

    TessellatedSvgNode {

1390

8

        vertices: all_vertices.into(),

1391

8

        indices: all_indices.into(),

1392

8

1393

8

1394

1395

#[cfg(feature = "svg")]

1396

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

1397

#[must_use]

1398

2

pub fn join_tessellated_colored_nodes(

1399

2

    nodes: &[TessellatedColoredSvgNode],

1400

2

) -> TessellatedColoredSvgNode {

1401

2

    let mut index_offset = 0;

1402

1403

    // note: can not be parallelized!

1404

2

    let all_index_offsets = nodes

1405

2

        .as_ref()

1406

2

        .iter()

1407

2

        .map(|t| {

1408

2

            let i = index_offset;

1409

2

            index_offset += t.vertices.len();

1410

2

1411

2

})

1412

2

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

1413

1414

2

    let all_vertices = nodes

1415

2

        .as_ref()

1416

2

        .iter()

1417

2

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

1418

2

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

1419

1420

2

    let all_indices = nodes

1421

2

        .as_ref()

1422

2

        .iter()

1423

2

        .enumerate()

1424

2

        .flat_map(|(buffer_index, t)| {

1425

            // since the vertex buffers are now joined,

1426

            // offset the indices by the vertex buffers lengths

1427

            // encountered so far

1428

2

            let vertex_buffer_offset: u32 = all_index_offsets

1429

2

                .get(buffer_index)

1430

2

                .copied()

1431

2

                .unwrap_or(0)

1432

2

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

1433

1434

2

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

1435

2

            if vertex_buffer_offset != 0 {

1436

2

                for i in &mut indices {

1437

1

                    if *i != GL_RESTART_INDEX {

1438

1

                        *i += vertex_buffer_offset;

1439

1

1440

1441

1

1442

1443

2

            indices.push(GL_RESTART_INDEX);

1444

1445

2

            indices

1446

2

})

1447

2

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

1448

1449

2

    TessellatedColoredSvgNode {

1450

2

        vertices: all_vertices.into(),

1451

2

        indices: all_indices.into(),

1452

2

1453

2

1454

1455

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

1456

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

1457

    TessellatedSvgNode::default()

1458

1459

1460

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

1461

pub fn join_tessellated_colored_nodes(

1462

    nodes: &[TessellatedColoredSvgNode],

1463

) -> TessellatedColoredSvgNode {

1464

    TessellatedColoredSvgNode::default()

1465

1466

1467

#[cfg(feature = "svg")]

1468

#[must_use]

1469

4

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

1470

4

    match &node {

1471

2

        SvgNode::MultiPolygonCollection(ref mpc) => {

1472

2

            let tessellated_multipolygons = mpc

1473

2

                .as_ref()

1474

2

                .iter()

1475

2

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

1476

2

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

1477

2

            join_tessellated_nodes(&tessellated_multipolygons)

1478

1479

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

1480

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

1481

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

1482

2

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

1483

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

1484

1485

4

1486

1487

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

1488

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

1489

    TessellatedSvgNode::default()

1490

1491

1492

#[cfg(feature = "svg")]

1493

#[must_use]

1494

2

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

1495

2

    match &node {

1496

        SvgNode::MultiPolygonCollection(ref mpc) => {

1497

            let tessellated_multipolygons = mpc

1498

                .as_ref()

1499

                .iter()

1500

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

1501

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

1502

            join_tessellated_nodes(&tessellated_multipolygons)

1503

1504

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

1505

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

1506

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

1507

2

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

1508

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

1509

1510

2

1511

1512

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

1513

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

1514

    TessellatedSvgNode::default()

1515

1516

1517

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

1518

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

1519

/// # Panics

1520

///

1521

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

1522

#[must_use]

1523

pub fn allocate_clipmask_texture(

1524

    gl_context: GlContextPtr,

1525

    size: PhysicalSizeU32,

1526

    _background: ColorU,

1527

) -> Texture {

1528

    use azul_core::gl::TextureFlags;

1529

1530

    let textures = gl_context.gen_textures(1);

1531

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

1532

1533

    Texture::create(

1534

        *texture_id,

1535

        TextureFlags {

1536

            is_opaque: true,

1537

            is_video_texture: false,

1538

},

1539

        size,

1540

        ColorU::TRANSPARENT,

1541

        gl_context,

1542

        RawImageFormat::R8,

1543

1544

1545

1546

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

1547

///

1548

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

1549

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

1550

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

1551

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

1552

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

1553

1554

1555

/// Applies FXAA with custom configuration parameters.

1556

#[allow(

1557

    clippy::cast_possible_truncation,

1558

    clippy::cast_possible_wrap,

1559

    clippy::cast_precision_loss,

1560

    clippy::cast_sign_loss

1561

)] // bounded layout/render numeric cast

1562

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

1563

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

1564

                                 // (one branch per case)

1565

pub fn apply_fxaa_with_config(

1566

    texture: &mut Texture,

1567

    config: &azul_core::gl_fxaa::FxaaConfig,

1568

) -> Option<()> {

1569

    use std::mem;

1570

1571

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

1572

    use gl_context_loader::gl;

1573

1574

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

1575

        return Some(());

1576

1577

1578

    // FXAA only works on RGBA8 textures

1579

    if texture.format != RawImageFormat::RGBA8 {

1580

        return Some(());

1581

1582

1583

    let texture_size = texture.size;

1584

    let gl_context = &texture.gl_context;

1585

    let fxaa_shader = gl_context.get_fxaa_shader();

1586

    let w = texture_size.width as f32;

1587

    let h = texture_size.height as f32;

1588

1589

    // Save GL state

1590

    let mut current_program = [0_i32];

1591

    let mut current_framebuffers = [0_i32];

1592

    let mut current_texture_2d = [0_i32];

1593

    let mut current_vertex_array_object = [0_i32];

1594

    let mut current_vertex_buffer = [0_i32];

1595

    let mut current_index_buffer = [0_i32];

1596

    let mut current_active_texture = [0_i32];

1597

    let mut current_blend_enabled = [0_u8];

1598

    let mut current_viewport = [0_i32; 4];

1599

1600

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

1601

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

1602

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

1603

    gl_context.get_integer_v(

1604

        gl::VERTEX_ARRAY_BINDING,

1605

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

1606

);

1607

    gl_context.get_integer_v(

1608

        gl::ARRAY_BUFFER_BINDING,

1609

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

1610

);

1611

    gl_context.get_integer_v(

1612

        gl::ELEMENT_ARRAY_BUFFER_BINDING,

1613

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

1614

);

1615

    gl_context.get_integer_v(gl::ACTIVE_TEXTURE, (&mut current_active_texture[..]).into());

1616

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

1617

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

1618

1619

    // 1. Create temporary output texture

1620

    let temp_textures = gl_context.gen_textures(1);

1621

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

1622

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

1623

    gl_context.tex_image_2d(

1624

        gl::TEXTURE_2D,

1625

0,

1626

        gl::RGBA as i32,

1627

        texture_size.width as i32,

1628

        texture_size.height as i32,

1629

0,

1630

        gl::RGBA,

1631

        gl::UNSIGNED_BYTE,

1632

        None.into(),

1633

);

1634

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

1635

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

1636

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

1637

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

1638

1639

    // 2. Create FBO targeting the temp texture

1640

    let fbos = gl_context.gen_framebuffers(1);

1641

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

1642

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

1643

    gl_context.framebuffer_texture_2d(

1644

        gl::FRAMEBUFFER,

1645

        gl::COLOR_ATTACHMENT0,

1646

        gl::TEXTURE_2D,

1647

        temp_tex_id,

1648

0,

1649

);

1650

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

1651

1652

    debug_assert!(

1653

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

1654

);

1655

1656

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

1657

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

1658

    let quad_vertices: [f32; 8] = [

1659

        -1.0, -1.0, // bottom-left

1660

        1.0, -1.0, // bottom-right

1661

        1.0, 1.0, // top-right

1662

        -1.0, 1.0, // top-left

1663

];

1664

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

1665

1666

    let vaos = gl_context.gen_vertex_arrays(1);

1667

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

1668

    gl_context.bind_vertex_array(vao_id);

1669

1670

    let vbos = gl_context.gen_buffers(1);

1671

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

1672

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

1673

    gl_context.buffer_data_untyped(

1674

        gl::ARRAY_BUFFER,

1675

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

1676

        GlVoidPtrConst {

1677

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

1678

            run_destructor: true,

1679

},

1680

        gl::STATIC_DRAW,

1681

);

1682

1683

    let ibos = gl_context.gen_buffers(1);

1684

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

1685

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

1686

    gl_context.buffer_data_untyped(

1687

        gl::ELEMENT_ARRAY_BUFFER,

1688

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

1689

        GlVoidPtrConst {

1690

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

1691

            run_destructor: true,

1692

},

1693

        gl::STATIC_DRAW,

1694

);

1695

1696

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

1697

    let vertex_type = VertexAttributeType::Float;

1698

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

1699

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

1700

    gl_context.enable_vertex_attrib_array(0);

1701

1702

    // 4. Render FXAA pass

1703

    gl_context.use_program(fxaa_shader);

1704

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

1705

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

1706

1707

    // Bind input texture to GL_TEXTURE0

1708

    gl_context.active_texture(gl::TEXTURE0);

1709

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

1710

1711

    // Set uniforms

1712

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

1713

    gl_context.uniform_1i(u_texture, 0);

1714

1715

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

1716

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

1717

1718

    let u_edge_threshold = gl_context.get_uniform_location(fxaa_shader, "uEdgeThreshold");

1719

    gl_context.uniform_1f(u_edge_threshold, config.edge_threshold);

1720

1721

    let u_edge_threshold_min = gl_context.get_uniform_location(fxaa_shader, "uEdgeThresholdMin");

1722

    gl_context.uniform_1f(u_edge_threshold_min, config.edge_threshold_min);

1723

1724

    // Draw the fullscreen quad

1725

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

1726

1727

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

1728

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

1729

    // and the old texture_id gets cleaned up.

1730

    let old_texture_id = texture.texture_id;

1731

    texture.texture_id = temp_tex_id;

1732

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

1733

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

1734

1735

    // 6. Cleanup: delete FBO, quad buffers

1736

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

1737

    gl_context.disable_vertex_attrib_array(0);

1738

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

1739

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

1740

1741

    // Restore GL state

1742

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

1743

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

1744

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

1745

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

1746

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

1747

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

1748

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

1749

    gl_context.viewport(

1750

        current_viewport[0],

1751

        current_viewport[1],

1752

        current_viewport[2],

1753

        current_viewport[3],

1754

);

1755

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

1756

        gl_context.enable(gl::BLEND);

1757

1758

1759

    Some(())

1760

1761

1762

#[cfg(feature = "svg")]

1763

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

1764

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

1765

                                 // (one branch per case)

1766

12

pub fn render_node_clipmask_cpu(

1767

12

    image: &mut RawImage,

1768

12

    node: &SvgNode,

1769

12

    style: SvgStyle,

1770

12

) -> Option<()> {

1771

    use agg_rust::{

1772

        basics::{FillingRule, VertexSource, PATH_FLAGS_NONE},

1773

        color::Rgba8,

1774

        conv_stroke::ConvStroke,

1775

        conv_transform::ConvTransform,

1776

        math_stroke::{LineCap, LineJoin},

1777

        path_storage::PathStorage,

1778

        pixfmt_rgba::{PixelFormat, PixfmtRgba32},

1779

        rasterizer_scanline_aa::RasterizerScanlineAa,

1780

        renderer_base::RendererBase,

1781

        renderer_scanline::render_scanlines_aa_solid,

1782

        rendering_buffer::RowAccessor,

1783

        scanline_u::ScanlineU8,

1784

        trans_affine::TransAffine,

1785

};

1786

    use azul_core::resources::RawImageData;

1787

1788

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

1789

    #[allow(clippy::match_same_arms)]

1790

    // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that

1791

    // can't merge)

1792

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse

1793

                                     // routine (one branch per case)

1794

9

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

1795

        macro_rules! build_path {

1796

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

1797

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

1798

                    return None;

1799

1800

1801

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

1802

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

1803

1804

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

1805

                    match path_element {

1806

                        SvgPathElement::Line(l) => {

1807

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

1808

1809

                        SvgPathElement::QuadraticCurve(qc) => {

1810

                            $path.curve3(

1811

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

1812

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

1813

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

1814

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

1815

);

1816

1817

                        SvgPathElement::CubicCurve(cc) => {

1818

                            $path.curve4(

1819

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

1820

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

1821

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

1822

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

1823

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

1824

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

1825

);

1826

1827

1828

1829

1830

                if $p.is_closed() {

1831

                    $path.close_polygon(PATH_FLAGS_NONE);

1832

1833

}};

1834

1835

1836

9

        let mut path = PathStorage::new();

1837

9

        match node {

1838

1

            SvgNode::MultiPolygonCollection(mpc) => {

1839

1

                for mp in mpc {

1840

                    for p in &mp.rings {

1841

                        build_path!(path, p);

1842

1843

1844

1845

1

            SvgNode::MultiPolygon(mp) => {

1846

1

                for p in &mp.rings {

1847

                    build_path!(path, p);

1848

1849

1850

1

            SvgNode::Path(p) => {

1851

1

                build_path!(path, p);

1852

1853

1

            SvgNode::Circle(c) => {

1854

1

                // Approximate circle with 4 cubic beziers

1855

1

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

1856

1

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

1857

1

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

1858

1

                let k = CIRCLE_BEZIER_KAPPA;

1859

1

                let kr = k * r;

1860

1

                path.move_to(cx + r, cy);

1861

1

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

1862

1

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

1863

1

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

1864

1

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

1865

1

                path.close_polygon(PATH_FLAGS_NONE);

1866

1

1867

4

            SvgNode::Rect(r) => {

1868

4

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

1869

4

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

1870

4

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

1871

4

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

1872

4

                path.move_to(x, y);

1873

4

                path.line_to(x + w, y);

1874

4

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

1875

4

                path.line_to(x, y + h);

1876

4

                path.close_polygon(PATH_FLAGS_NONE);

1877

4

1878

1

            SvgNode::MultiShape(ms) => {

1879

1

                for p in ms.as_ref() {

1880

                    match p {

1881

                        SvgSimpleNode::Path(p) => {

1882

                            build_path!(path, p);

1883

1884

                        SvgSimpleNode::Rect(r) => {

1885

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

1886

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

1887

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

1888

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

1889

                            path.move_to(x, y);

1890

                            path.line_to(x + w, y);

1891

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

1892

                            path.line_to(x, y + h);

1893

                            path.close_polygon(PATH_FLAGS_NONE);

1894

1895

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

1896

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

1897

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

1898

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

1899

                            let k = CIRCLE_BEZIER_KAPPA;

1900

                            let kr = k * r;

1901

                            path.move_to(cx + r, cy);

1902

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

1903

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

1904

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

1905

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

1906

                            path.close_polygon(PATH_FLAGS_NONE);

1907

1908

                        SvgSimpleNode::RectHole(r) => {

1909

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

1910

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

1911

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

1912

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

1913

                            path.move_to(x, y);

1914

                            path.line_to(x + w, y);

1915

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

1916

                            path.line_to(x, y + h);

1917

                            path.close_polygon(PATH_FLAGS_NONE);

1918

1919

1920

1921

1922

1923

8

        if path.total_vertices() == 0 {

1924

3

            return None;

1925

5

1926

5

        Some(path)

1927

9

1928

1929

12

    let w = image.width as u32;

1930

12

    let h = image.height as u32;

1931

12

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

1932

3

        return None;

1933

9

1934

1935

9

    let transform_data = style.get_transform();

1936

9

    let transform = TransAffine::new_custom(

1937

9

        f64::from(transform_data.sx),

1938

9

        f64::from(transform_data.ky),

1939

9

        f64::from(transform_data.kx),

1940

9

        f64::from(transform_data.sy),

1941

9

        f64::from(transform_data.tx),

1942

9

        f64::from(transform_data.ty),

1943

);

1944

1945

9

    let mut agg_path = agg_translate_node(node)?;

1946

5

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

1947

1948

    // Create pixel buffer and render

1949

5

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

1950

5

    let stride = (w * 4) as i32;

1951

5

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

1952

5

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

1953

5

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

1954

5

    let mut ras = RasterizerScanlineAa::new();

1955

5

    let mut sl = ScanlineU8::new();

1956

1957

5

    match style {

1958

4

        SvgStyle::Fill(fs) => {

1959

4

            ras.filling_rule(match fs.fill_rule {

1960

4

                SvgFillRule::Winding => FillingRule::NonZero,

1961

                SvgFillRule::EvenOdd => FillingRule::EvenOdd,

1962

});

1963

4

            if transform.is_identity(0.0001) {

1964

3

                ras.add_path(&mut agg_path, 0);

1965

3

            } else {

1966

1

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

1967

1

                ras.add_path(&mut transformed, 0);

1968

1

1969

4

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

1970

1971

1

        SvgStyle::Stroke(ss) => {

1972

1

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

1973

1

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

1974

1

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

1975

1

            stroke.set_line_cap(match ss.start_cap {

1976

1

                SvgLineCap::Butt => LineCap::Butt,

1977

                SvgLineCap::Square => LineCap::Square,

1978

                SvgLineCap::Round => LineCap::Round,

1979

});

1980

1

            stroke.set_line_join(match ss.line_join {

1981

1

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

1982

                SvgLineJoin::Round => LineJoin::Round,

1983

                SvgLineJoin::Bevel => LineJoin::Bevel,

1984

});

1985

1

            if transform.is_identity(0.0001) {

1986

1

                ras.add_path(&mut stroke, 0);

1987

1

            } else {

1988

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

1989

                ras.add_path(&mut transformed, 0);

1990

1991

1

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

1992

1993

1994

1995

    // Extract red channel from RGBA buffer

1996

320

    let red_channel = buf.chunks_exact(4).map(|r| r[0]).collect::<Vec<_>>();

1997

1998

5

    image.premultiplied_alpha = true;

1999

5

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

2000

5

    image.data_format = RawImageFormat::R8;

2001

2002

5

    Some(())

2003

12

2004

2005

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

2006

pub fn render_node_clipmask_cpu(

2007

    image: &mut RawImage,

2008

    node: &SvgNode,

2009

    style: SvgStyle,

2010

) -> Option<()> {

2011

    None

2012

2013

2014

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

2015

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

2016

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

2017

2018

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

2019

34

fn rasterize_multi_polygon(

2020

34

    mp: &SvgMultiPolygon,

2021

34

) -> agg_rust::rasterizer_scanline_aa::RasterizerScanlineAa {

2022

    use agg_rust::{

2023

        basics::{FillingRule, PATH_FLAGS_NONE},

2024

        path_storage::PathStorage,

2025

        rasterizer_scanline_aa::RasterizerScanlineAa,

2026

};

2027

2028

34

    let mut ras = RasterizerScanlineAa::new();

2029

34

    ras.filling_rule(FillingRule::NonZero);

2030

2031

34

    let mut path = PathStorage::new();

2032

34

    for ring in mp.rings.as_ref() {

2033

26

        let mut first = true;

2034

100

        for item in ring.items.as_ref() {

2035

100

            match item {

2036

96

                SvgPathElement::Line(l) => {

2037

96

                    if first {

2038

24

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

2039

24

                        first = false;

2040

72

2041

96

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

2042

2043

2

                SvgPathElement::QuadraticCurve(q) => {

2044

2

                    if first {

2045

2

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

2046

2

                        first = false;

2047

2

2048

2

                    path.curve3(

2049

2

                        f64::from(q.ctrl.x),

2050

2

                        f64::from(q.ctrl.y),

2051

2

                        f64::from(q.end.x),

2052

2

                        f64::from(q.end.y),

2053

);

2054

2055

2

                SvgPathElement::CubicCurve(c) => {

2056

2

                    if first {

2057

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

2058

                        first = false;

2059

2

2060

2

                    path.curve4(

2061

2

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

2062

2

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

2063

2

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

2064

2

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

2065

2

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

2066

2

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

2067

);

2068

2069

2070

2071

26

        path.close_polygon(PATH_FLAGS_NONE);

2072

2073

34

    ras.add_path(&mut path, 0);

2074

34

ras

2075

34

2076

2077

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

2078

/// horizontal span edges across consecutive scanlines.

2079

///

2080

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

2081

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

2082

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

2083

#[allow(

2084

    clippy::cast_possible_truncation,

2085

    clippy::cast_possible_wrap,

2086

    clippy::cast_precision_loss,

2087

    clippy::cast_sign_loss

2088

)] // bounded layout/render numeric cast

2089

18

fn storage_to_multi_polygon(

2090

18

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

2091

18

) -> SvgMultiPolygon {

2092

    use agg_rust::rasterizer_scanline_aa::Scanline;

2093

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

2094

2095

    // Collect solid spans per row

2096

18

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

2097

2098

18

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

2099

18

    if storage.rewind_scanlines() {

2100

10

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

2101

128

        while storage.sweep_scanline(&mut sl) {

2102

118

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

2103

118

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

2104

128

            for span in sl.begin() {

2105

                // Span with positive len: per-pixel coverage

2106

128

                let len = span.len;

2107

128

                if len <= 0 {

2108

                    continue;

2109

128

2110

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

2111

128

                let covers = sl.covers();

2112

128

                let mut x_start = None;

2113

1074

                for j in 0..len as usize {

2114

1074

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

2115

1074

                    if cov > 128 {

2116

1056

                        if x_start.is_none() {

2117

127

                            x_start = Some(span.x + j as i32);

2118

929

2119

18

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

2120

8

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

2121

10

2122

2123

128

                if let Some(xs) = x_start {

2124

119

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

2125

119

2126

2127

118

            if !row_spans.is_empty() {

2128

117

                rows.push((y, row_spans));

2129

117

2130

2131

8

2132

2133

18

    if rows.is_empty() {

2134

8

        return SvgMultiPolygon {

2135

8

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

2136

8

};

2137

10

2138

2139

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

2140

    // Then connect consecutive rows into closed polygons.

2141

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

2142

10

    let mut rings = Vec::new();

2143

2144

127

    for (y, spans) in &rows {

2145

117

        let yf = *y as f32;

2146

244

        for &(x0, x1) in spans {

2147

127

            let x0f = x0 as f32;

2148

127

            let x1f = x1 as f32;

2149

127

            // Create a small horizontal rectangle for this span

2150

127

            let elements = vec![

2151

127

                SvgPathElement::Line(SvgLine::new(

2152

127

                    SvgPoint { x: x0f, y: yf },

2153

127

                    SvgPoint { x: x1f, y: yf },

2154

127

)),

2155

127

                SvgPathElement::Line(SvgLine::new(

2156

127

                    SvgPoint { x: x1f, y: yf },

2157

127

                    SvgPoint {

2158

127

                        x: x1f,

2159

127

                        y: yf + 1.0,

2160

127

},

2161

127

)),

2162

127

                SvgPathElement::Line(SvgLine::new(

2163

127

                    SvgPoint {

2164

127

                        x: x1f,

2165

127

                        y: yf + 1.0,

2166

127

},

2167

127

                    SvgPoint {

2168

127

                        x: x0f,

2169

127

                        y: yf + 1.0,

2170

127

},

2171

127

)),

2172

127

                SvgPathElement::Line(SvgLine::new(

2173

127

                    SvgPoint {

2174

127

                        x: x0f,

2175

127

                        y: yf + 1.0,

2176

127

},

2177

127

                    SvgPoint { x: x0f, y: yf },

2178

127

)),

2179

127

];

2180

127

            rings.push(SvgPath {

2181

127

                items: SvgPathElementVec::from_vec(elements),

2182

127

});

2183

127

2184

2185

2186

10

    SvgMultiPolygon {

2187

10

        rings: SvgPathVec::from_vec(rings),

2188

10

2189

18

2190

2191

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

2192

17

fn svg_bool_op(

2193

17

    a: &SvgMultiPolygon,

2194

17

    b: &SvgMultiPolygon,

2195

17

    op: agg_rust::scanline_boolean_algebra::SBoolOp,

2196

17

) -> SvgMultiPolygon {

2197

    use agg_rust::{

2198

        scanline_boolean_algebra::sbool_combine_shapes_aa, scanline_storage_aa::ScanlineStorageAa,

2199

        scanline_u::ScanlineU8,

2200

};

2201

2202

17

    let mut ras1 = rasterize_multi_polygon(a);

2203

17

    let mut ras2 = rasterize_multi_polygon(b);

2204

2205

17

    let mut sl1 = ScanlineU8::new();

2206

17

    let mut sl2 = ScanlineU8::new();

2207

17

    let mut sl_result = ScanlineU8::new();

2208

17

    let mut storage1 = ScanlineStorageAa::new();

2209

17

    let mut storage2 = ScanlineStorageAa::new();

2210

17

    let mut storage_result = ScanlineStorageAa::new();

2211

2212

17

    sbool_combine_shapes_aa(

2213

17

op,

2214

17

        &mut ras1,

2215

17

        &mut ras2,

2216

17

        &mut sl1,

2217

17

        &mut sl2,

2218

17

        &mut sl_result,

2219

17

        &mut storage1,

2220

17

        &mut storage2,

2221

17

        &mut storage_result,

2222

);

2223

2224

17

    storage_to_multi_polygon(&mut storage_result)

2225

17

2226

2227

#[must_use]

2228

5

pub fn svg_multi_polygon_union(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2229

5

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

2230

5

2231

2232

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

2233

#[allow(clippy::needless_pass_by_value)]

2234

#[must_use]

2235

1

pub fn svg_multi_polygon_union_byval(a: &SvgMultiPolygon, b: SvgMultiPolygon) -> SvgMultiPolygon {

2236

1

    svg_multi_polygon_union(a, &b)

2237

1

2238

2239

#[must_use]

2240

4

pub fn svg_multi_polygon_intersection(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2241

4

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

2242

4

2243

2244

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

2245

#[allow(clippy::needless_pass_by_value)]

2246

#[must_use]

2247

1

pub fn svg_multi_polygon_intersection_byval(

2248

1

    a: &SvgMultiPolygon,

2249

1

    b: SvgMultiPolygon,

2250

1

) -> SvgMultiPolygon {

2251

1

    svg_multi_polygon_intersection(a, &b)

2252

1

2253

2254

#[must_use]

2255

4

pub fn svg_multi_polygon_difference(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2256

4

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

2257

4

2258

2259

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

2260

#[allow(clippy::needless_pass_by_value)]

2261

#[must_use]

2262

1

pub fn svg_multi_polygon_difference_byval(

2263

1

    a: &SvgMultiPolygon,

2264

1

    b: SvgMultiPolygon,

2265

1

) -> SvgMultiPolygon {

2266

1

    svg_multi_polygon_difference(a, &b)

2267

1

2268

2269

#[must_use]

2270

4

pub fn svg_multi_polygon_xor(a: &SvgMultiPolygon, b: &SvgMultiPolygon) -> SvgMultiPolygon {

2271

4

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

2272

4

2273

2274

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

2275

#[allow(clippy::needless_pass_by_value)]

2276

#[must_use]

2277

1

pub fn svg_multi_polygon_xor_byval(a: &SvgMultiPolygon, b: SvgMultiPolygon) -> SvgMultiPolygon {

2278

1

    svg_multi_polygon_xor(a, &b)

2279

1

2280

2281

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

2282

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

2283

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

2284

2285

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

2286

///

2287

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

2288

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

2289

#[derive(Debug, Clone)]

2290

#[repr(C)]

2291

pub struct ParsedSvgXmlNode {

2292

    pub run_destructor: bool,

2293

2294

2295

impl Drop for ParsedSvgXmlNode {

2296

6

    fn drop(&mut self) {

2297

6

        self.run_destructor = false;

2298

6

2299

2300

2301

/// # Errors

2302

///

2303

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

2304

5

pub fn svgxmlnode_parse(

2305

5

    svg_file_data: &[u8],

2306

5

    _options: SvgParseOptions,

2307

5

) -> Result<ParsedSvgXmlNode, SvgParseError> {

2308

    // Verify we can parse the XML

2309

5

    let s = core::str::from_utf8(svg_file_data).map_err(|_| SvgParseError::NotAnUtf8Str)?;

2310

4

    let _nodes = crate::xml::parse_xml_string(s).map_err(|_| SvgParseError::NoParserAvailable)?;

2311

3

    Ok(ParsedSvgXmlNode {

2312

3

        run_destructor: true,

2313

3

})

2314

5

2315

2316

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

2317

#[derive(Clone)]

2318

#[repr(C)]

2319

pub struct ParsedSvg {

2320

    pub svg_data: azul_css::U8Vec,

2321

    pub run_destructor: bool,

2322

2323

2324

impl Drop for ParsedSvg {

2325

31

    fn drop(&mut self) {

2326

31

        self.run_destructor = false;

2327

31

2328

2329

2330

impl_result!(

2331

    ParsedSvg,

2332

    SvgParseError,

2333

    ResultParsedSvgSvgParseError,

2334

    copy = false,

2335

    [Debug, Clone]

2336

);

2337

2338

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

2339

    fn from(_parsed: ParsedSvg) -> Self {

2340

        Self {

2341

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

2342

            run_destructor: false,

2343

2344

2345

2346

2347

impl fmt::Debug for ParsedSvg {

2348

2

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

2349

2

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

2350

2

2351

2352

2353

impl ParsedSvg {

2354

    /// # Errors

2355

///

2356

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

2357

12

    pub fn from_string(

2358

12

        svg_string: &str,

2359

12

        parse_options: SvgParseOptions,

2360

12

    ) -> Result<Self, SvgParseError> {

2361

12

        svg_parse(svg_string.as_bytes(), parse_options)

2362

12

2363

2364

    /// # Errors

2365

///

2366

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

2367

1

    pub fn from_bytes(

2368

1

        svg_bytes: &[u8],

2369

1

        parse_options: SvgParseOptions,

2370

1

    ) -> Result<Self, SvgParseError> {

2371

1

        svg_parse(svg_bytes, parse_options)

2372

1

2373

2374

    #[must_use]

2375

2

    pub const fn get_root(&self) -> ParsedSvgXmlNode {

2376

2

        svg_root(self)

2377

2

2378

2379

    #[must_use]

2380

6

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

2381

6

        svg_render(self, options)

2382

6

2383

2384

    #[must_use]

2385

11

    pub fn to_string(&self, _options: SvgXmlOptions) -> String {

2386

11

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

2387

11

2388

2389

2390

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

2391

/// # Errors

2392

///

2393

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

2394

41

pub fn svg_parse(

2395

41

    svg_file_data: &[u8],

2396

41

    _options: SvgParseOptions,

2397

41

) -> Result<ParsedSvg, SvgParseError> {

2398

    // Validate that it's parseable XML

2399

41

    let s = core::str::from_utf8(svg_file_data).map_err(|_| SvgParseError::NotAnUtf8Str)?;

2400

37

    let _nodes = crate::xml::parse_xml_string(s).map_err(|_| SvgParseError::NoParserAvailable)?;

2401

28

    Ok(ParsedSvg {

2402

28

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

2403

28

        run_destructor: true,

2404

28

})

2405

41

2406

2407

#[must_use]

2408

3

pub const fn svg_root(s: &ParsedSvg) -> ParsedSvgXmlNode {

2409

3

    ParsedSvgXmlNode {

2410

3

        run_destructor: true,

2411

3

2412

3

2413

2414

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

2415

///

2416

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

2417

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

2418

#[cfg(feature = "cpurender")]

2419

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

2420

#[must_use]

2421

9

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

2422

    use azul_core::resources::RawImageData;

2423

2424

9

    let (target_width, target_height) = options

2425

9

        .target_size

2426

9

        .as_ref()

2427

9

        .map_or(DEFAULT_SVG_RENDER_SIZE, |s| {

2428

9

            (s.width as u32, s.height as u32)

2429

9

});

2430

2431

9

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

2432

6

        return None;

2433

3

2434

2435

    // `background_color: None` = TRANSPARENT, which is what an SVG has. The

2436

    // rasteriser used to fill opaque white unconditionally and ignore this

2437

    // field entirely, so every themed icon arrived as a white tile.

2438

3

    let background = options

2439

3

        .background_color

2440

3

        .into_option()

2441

3

        .map(|c| (c.r, c.g, c.b, c.a));

2442

3

    let png_data = crate::cpurender::render_svg_to_png_over(

2443

3

        s.svg_data.as_ref(),

2444

3

        target_width,

2445

3

        target_height,

2446

3

        background,

2447

2448

3

    .ok()?;

2449

2450

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

2451

2

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

2452

2

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

2453

2

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

2454

2

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

2455

2

    buf.truncate(info.buffer_size());

2456

2457

2

    Some(RawImage {

2458

2

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

2459

2

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

2460

2

        width: info.width as usize,

2461

2

        height: info.height as usize,

2462

2

        premultiplied_alpha: false,

2463

2

        data_format: RawImageFormat::RGBA8,

2464

2

})

2465

9

2466

2467

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

2468

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

2469

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

2470

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

2471

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

2472

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

2473

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

2474

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

2475

    ANNOUNCE.call_once(|| {

2476

        eprintln!(

2477

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

2478

             rasterization always returns None (parsing/layout are unaffected). Rebuild \

2479

             azul-layout with the `cpurender` feature"

2480

);

2481

});

2482

    None

2483

2484

2485

#[must_use]

2486

2

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

2487

2

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

2488

2

2489

2490

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

2491

// Lyon tessellation (kept — no usvg dependency)

2492

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

2493

2494

/// Trait for tessellating `SvgMultiPolygon` shapes

2495

pub trait SvgMultiPolygonTessellation {

2496

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

2497

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

2498

2499

2500

impl SvgMultiPolygonTessellation for SvgMultiPolygon {

2501

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

2502

        tessellate_multi_polygon_fill(self, fill_style)

2503

2504

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

2505

        tessellate_multi_polygon_stroke(self, stroke_style)

2506

2507

2508

2509

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

2510

// Adversarial unit tests

2511

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

2512

//

2513

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

2514

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

2515

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

2516

2517

#[cfg(test)]

2518

mod autotest_generated {

2519

    use azul_core::resources::RawImageData;

2520

2521

    use super::*;

2522

2523

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

2524

    // helpers

2525

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

2526

2527

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

2528

        SvgPoint { x, y }

2529

2530

2531

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

2532

        SvgLine {

2533

            start: pt(x0, y0),

2534

            end: pt(x1, y1),

2535

2536

2537

2538

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

2539

        SvgPath {

2540

            items: SvgPathElementVec::from_vec(items),

2541

2542

2543

2544

    fn empty_path() -> SvgPath {

2545

        SvgPath {

2546

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

2547

2548

2549

2550

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

2551

    fn square_at(d: f32) -> SvgPath {

2552

        mk_path(vec![

2553

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

2554

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

2555

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

2556

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

2557

])

2558

2559

2560

    fn square_path() -> SvgPath {

2561

        square_at(0.0)

2562

2563

2564

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

2565

        SvgMultiPolygon {

2566

            rings: SvgPathVec::from_vec(rings),

2567

2568

2569

2570

    fn square_polygon() -> SvgMultiPolygon {

2571

        polygon_of(vec![square_path()])

2572

2573

2574

    fn empty_polygon() -> SvgMultiPolygon {

2575

        SvgMultiPolygon {

2576

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

2577

2578

2579

2580

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

2581

        SvgRect {

2582

            width: w,

2583

            height: h,

2584

x,

2585

y,

2586

            ..SvgRect::default()

2587

2588

2589

2590

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

2591

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

2592

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

2593

    const fn identity_transform() -> SvgTransform {

2594

        SvgTransform {

2595

            sx: 1.0,

2596

            kx: 0.0,

2597

            ky: 0.0,

2598

            sy: 1.0,

2599

            tx: 0.0,

2600

            ty: 0.0,

2601

2602

2603

2604

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

2605

        TessellatedSvgNode {

2606

            vertices: vertices

2607

                .iter()

2608

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

2609

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

2610

                .into(),

2611

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

2612

2613

2614

2615

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

2616

        RawImage {

2617

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

2618

            width: w,

2619

            height: h,

2620

            premultiplied_alpha: false,

2621

            data_format: RawImageFormat::R8,

2622

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

2623

2624

2625

2626

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

2627

        match &img.pixels {

2628

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

2629

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

2630

2631

2632

2633

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

2634

    fn assert_indices_in_range(t: &TessellatedSvgNode) {

2635

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

2636

        for i in t.indices.as_ref() {

2637

            if *i == GL_RESTART_INDEX {

2638

                continue;

2639

2640

            assert!(

2641

                (*i as usize) < verts,

2642

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

2643

);

2644

2645

2646

2647

    const MINIMAL_SVG: &[u8] =

2648

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

2649

2650

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

2651

    // translate_svg_line_join / translate_svg_line_cap

2652

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

2653

2654

    #[test]

2655

    fn translate_svg_line_join_maps_every_variant() {

2656

        use lyon::tessellation::LineJoin as L;

2657

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

2658

        assert_eq!(

2659

            translate_svg_line_join(SvgLineJoin::MiterClip),

2660

            L::MiterClip

2661

);

2662

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

2663

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

2664

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

2665

2666

2667

    #[test]

2668

    fn translate_svg_line_cap_maps_every_variant() {

2669

        use lyon::tessellation::LineCap as C;

2670

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

2671

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

2672

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

2673

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

2674

2675

2676

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

2677

    // translate_svg_stroke_style

2678

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

2679

2680

    #[test]

2681

    fn translate_svg_stroke_style_carries_every_field_across() {

2682

        let s = SvgStrokeStyle {

2683

            start_cap: SvgLineCap::Round,

2684

            end_cap: SvgLineCap::Square,

2685

            line_join: SvgLineJoin::Bevel,

2686

            line_width: 3.5,

2687

            miter_limit: 7.25,

2688

            tolerance: 0.25,

2689

            ..SvgStrokeStyle::default()

2690

};

2691

        let o = translate_svg_stroke_style(s);

2692

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

2693

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

2694

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

2695

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

2696

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

2697

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

2698

2699

2700

    #[test]

2701

    fn translate_svg_stroke_style_accepts_the_azul_default() {

2702

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

2703

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

2704

2705

2706

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

2707

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

2708

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

2709

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

2710

    #[test]

2711

    #[should_panic(expected = "limit")]

2712

    fn translate_svg_stroke_style_miter_limit_below_one_panics() {

2713

        let s = SvgStrokeStyle {

2714

            miter_limit: 0.0,

2715

            ..SvgStrokeStyle::default()

2716

};

2717

        let _ = translate_svg_stroke_style(s);

2718

2719

2720

    #[test]

2721

    #[should_panic(expected = "limit")]

2722

    fn translate_svg_stroke_style_nan_miter_limit_panics() {

2723

        let s = SvgStrokeStyle {

2724

            miter_limit: f32::NAN,

2725

            ..SvgStrokeStyle::default()

2726

};

2727

        let _ = translate_svg_stroke_style(s);

2728

2729

2730

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

2731

    // raw_line_intersection / raw_line_intersection_byval

2732

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

2733

2734

    #[test]

2735

    fn raw_line_intersection_crossing_diagonals_meet_in_the_middle() {

2736

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

2737

            .expect("crossing diagonals intersect");

2738

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

2739

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

2740

2741

2742

    #[test]

2743

    fn raw_line_intersection_parallel_lines_are_none() {

2744

        assert_eq!(

2745

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

2746

            None

2747

);

2748

2749

2750

    #[test]

2751

    fn raw_line_intersection_identical_lines_are_none() {

2752

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

2753

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

2754

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

2755

2756

2757

    #[test]

2758

    fn raw_line_intersection_zero_length_lines_are_none() {

2759

        assert_eq!(

2760

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

2761

            None

2762

);

2763

        assert_eq!(

2764

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

2765

            None

2766

);

2767

2768

2769

    #[test]

2770

    fn raw_line_intersection_never_leaks_nan_for_extreme_inputs() {

2771

        let extremes = [

2772

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

2773

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

2774

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

2775

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

2776

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

2777

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

2778

            ln(0.0, 0.0, 0.0, 0.0),

2779

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

2780

];

2781

        for p in &extremes {

2782

            for q in &extremes {

2783

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

2784

                    assert!(

2785

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

2786

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

2787

);

2788

2789

2790

2791

2792

2793

    #[test]

2794

    fn raw_line_intersection_byval_matches_the_by_ref_form() {

2795

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

2796

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

2797

        assert_eq!(

2798

            raw_line_intersection_byval(&p, q),

2799

            raw_line_intersection(&p, &q)

2800

);

2801

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

2802

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

2803

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

2804

2805

2806

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

2807

    // shorten_line_end_by / shorten_line_start_by

2808

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

2809

2810

    #[test]

2811

    fn shorten_line_end_by_trims_the_end_only() {

2812

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

2813

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

2814

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

2815

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

2816

2817

2818

    #[test]

2819

    fn shorten_line_end_by_zero_is_the_identity() {

2820

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

2821

        let out = shorten_line_end_by(l, 0.0);

2822

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

2823

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

2824

2825

2826

    #[test]

2827

    fn shorten_line_end_by_more_than_the_length_overshoots_past_the_start() {

2828

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

2829

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

2830

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

2831

2832

2833

    #[test]

2834

    fn shorten_line_end_by_negative_distance_extends_the_line() {

2835

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

2836

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

2837

2838

2839

    #[test]

2840

    fn shorten_line_end_by_degenerate_segment_yields_nan() {

2841

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

2842

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

2843

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

2844

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

2845

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

2846

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

2847

2848

2849

    #[test]

2850

    fn shorten_line_end_by_non_finite_distance_does_not_panic() {

2851

        for d in [

2852

            f32::NAN,

2853

            f32::INFINITY,

2854

            f32::NEG_INFINITY,

2855

            f32::MAX,

2856

            f32::MIN,

2857

] {

2858

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

2859

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

2860

2861

2862

2863

    #[test]

2864

    fn shorten_line_start_by_trims_the_start_only() {

2865

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

2866

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

2867

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

2868

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

2869

2870

2871

    #[test]

2872

    fn shorten_line_start_by_zero_is_the_identity() {

2873

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

2874

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

2875

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

2876

2877

2878

    #[test]

2879

    fn shorten_line_start_by_degenerate_segment_yields_nan() {

2880

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

2881

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

2882

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

2883

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

2884

2885

2886

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

2887

    // svg_path_offset

2888

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

2889

2890

    #[test]

2891

    fn svg_path_offset_zero_distance_returns_the_input_unchanged() {

2892

        let p = square_path();

2893

        assert_eq!(

2894

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

2895

2896

);

2897

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

2898

        assert_eq!(

2899

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

2900

2901

);

2902

2903

2904

    #[test]

2905

    fn svg_path_offset_empty_path_stays_empty() {

2906

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

2907

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

2908

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

2909

2910

2911

    #[test]

2912

    fn svg_path_offset_single_line_moves_along_its_outwards_normal() {

2913

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

2914

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

2915

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

2916

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

2917

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

2918

            SvgPathElement::Line(l) => {

2919

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

2920

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

2921

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

2922

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

2923

2924

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

2925

2926

2927

2928

    #[test]

2929

    fn svg_path_offset_preserves_the_item_count_for_any_distance() {

2930

        let p = square_path();

2931

        for d in [

2932

            1.0_f32,

2933

            -1.0,

2934

            1e-30,

2935

            1e30,

2936

            f32::MAX,

2937

            f32::MIN,

2938

            f32::NAN,

2939

            f32::INFINITY,

2940

            f32::NEG_INFINITY,

2941

] {

2942

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

2943

            assert_eq!(

2944

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

2945

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

2946

                "distance {d} changed the element count"

2947

);

2948

2949

2950

2951

    #[test]

2952

    fn svg_path_offset_degenerate_segments_are_passed_through_unchanged() {

2953

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

2954

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

2955

        assert_eq!(

2956

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

2957

2958

);

2959

2960

2961

    #[test]

2962

    fn svg_path_offset_ignores_its_join_and_cap_arguments() {

2963

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

2964

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

2965

        let p = square_path();

2966

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

2967

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

2968

        assert_eq!(a, b);

2969

2970

2971

    #[test]

2972

    fn svg_path_offset_handles_curve_elements() {

2973

        let p = mk_path(vec![

2974

            SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

2975

                start: pt(0.0, 0.0),

2976

                ctrl: pt(5.0, 10.0),

2977

                end: pt(10.0, 0.0),

2978

}),

2979

            SvgPathElement::CubicCurve(SvgCubicCurve {

2980

                start: pt(10.0, 0.0),

2981

                ctrl_1: pt(7.0, -5.0),

2982

                ctrl_2: pt(3.0, -5.0),

2983

                end: pt(0.0, 0.0),

2984

}),

2985

]);

2986

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

2987

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

2988

2989

2990

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

2991

    // svg_path_bevel

2992

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

2993

2994

    #[test]

2995

    fn svg_path_bevel_empty_path_stays_empty() {

2996

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

2997

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

2998

2999

3000

    #[test]

3001

    fn svg_path_bevel_single_line_expands_to_four_elements() {

3002

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

3003

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

3004

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

3005

        let out = svg_path_bevel(&p, 2.0);

3006

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

3007

        for e in out.items.as_ref() {

3008

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

3009

            assert!(

3010

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

3011

                "{e:?}"

3012

);

3013

3014

3015

3016

    #[test]

3017

    fn svg_path_bevel_non_line_pairs_are_passed_straight_through() {

3018

        let p = mk_path(vec![

3019

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

3020

            SvgPathElement::CubicCurve(SvgCubicCurve {

3021

                start: pt(10.0, 0.0),

3022

                ctrl_1: pt(12.0, 0.0),

3023

                ctrl_2: pt(14.0, 2.0),

3024

                end: pt(14.0, 4.0),

3025

}),

3026

]);

3027

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

3028

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

3029

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

3030

3031

3032

    #[test]

3033

    fn svg_path_bevel_zero_distance_keeps_every_coordinate_finite() {

3034

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

3035

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

3036

            assert!(

3037

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

3038

                "{e:?}"

3039

);

3040

3041

3042

3043

    #[test]

3044

    fn svg_path_bevel_extreme_distances_do_not_panic() {

3045

        let p = square_path();

3046

        for d in [

3047

            f32::NAN,

3048

            f32::INFINITY,

3049

            f32::NEG_INFINITY,

3050

            f32::MAX,

3051

            -f32::MAX,

3052

            1e-30,

3053

] {

3054

            assert!(

3055

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

3056

                "distance {d} produced an empty path"

3057

);

3058

3059

3060

3061

    #[test]

3062

    fn svg_path_bevel_degenerate_segments_do_not_panic() {

3063

        let p = mk_path(vec![

3064

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

3065

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

3066

]);

3067

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

3068

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

3069

3070

3071

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

3072

    // svg_node_contains_point / path_contains_point / polygon_contains_point

3073

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

3074

3075

    #[test]

3076

    fn svg_node_contains_point_rect_excludes_its_own_border() {

3077

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

3078

        assert!(svg_node_contains_point(

3079

            &node,

3080

            pt(5.0, 5.0),

3081

            SvgFillRule::Winding,

3082

0.1

3083

));

3084

        assert!(!svg_node_contains_point(

3085

            &node,

3086

            pt(15.0, 5.0),

3087

            SvgFillRule::Winding,

3088

0.1

3089

));

3090

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

3091

        assert!(!svg_node_contains_point(

3092

            &node,

3093

            pt(0.0, 0.0),

3094

            SvgFillRule::Winding,

3095

0.1

3096

));

3097

        assert!(!svg_node_contains_point(

3098

            &node,

3099

            pt(10.0, 10.0),

3100

            SvgFillRule::Winding,

3101

0.1

3102

));

3103

3104

3105

    #[test]

3106

    fn svg_node_contains_point_circle_excludes_its_own_rim() {

3107

        let node = SvgNode::Circle(SvgCircle {

3108

            center_x: 0.0,

3109

            center_y: 0.0,

3110

            radius: 5.0,

3111

});

3112

        assert!(svg_node_contains_point(

3113

            &node,

3114

            pt(0.0, 0.0),

3115

            SvgFillRule::Winding,

3116

0.1

3117

));

3118

        assert!(!svg_node_contains_point(

3119

            &node,

3120

            pt(5.0, 0.0),

3121

            SvgFillRule::Winding,

3122

0.1

3123

));

3124

        assert!(!svg_node_contains_point(

3125

            &node,

3126

            pt(100.0, 100.0),

3127

            SvgFillRule::Winding,

3128

0.1

3129

));

3130

3131

3132

    #[test]

3133

    fn svg_node_contains_point_nan_and_infinite_points_are_outside() {

3134

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

3135

        let c = SvgNode::Circle(SvgCircle {

3136

            center_x: 0.0,

3137

            center_y: 0.0,

3138

            radius: 5.0,

3139

});

3140

        for p in [

3141

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

3142

            pt(f32::NAN, 5.0),

3143

            pt(5.0, f32::NAN),

3144

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

3145

            pt(f32::NEG_INFINITY, 0.0),

3146

] {

3147

            assert!(

3148

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

3149

                "rect / {p:?}"

3150

);

3151

            assert!(

3152

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

3153

                "circle / {p:?}"

3154

);

3155

3156

3157

3158

    #[test]

3159

    fn svg_node_contains_point_empty_geometry_is_never_hit() {

3160

        for node in [

3161

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

3162

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

3163

            SvgNode::MultiPolygon(empty_polygon()),

3164

            SvgNode::Path(empty_path()),

3165

] {

3166

            assert!(

3167

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

3168

                "{node:?}"

3169

);

3170

3171

3172

3173

    #[test]

3174

    fn svg_node_contains_point_open_paths_short_circuit_to_false() {

3175

        let open = mk_path(vec![

3176

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

3177

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

3178

]);

3179

        assert!(!svg_node_contains_point(

3180

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

3181

            pt(5.0, 5.0),

3182

            SvgFillRule::Winding,

3183

0.1

3184

));

3185

        assert!(!svg_node_contains_point(

3186

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

3187

            pt(5.0, 5.0),

3188

            SvgFillRule::Winding,

3189

0.1

3190

));

3191

3192

3193

    #[test]

3194

    fn svg_node_contains_point_closed_square_path_is_hit() {

3195

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

3196

        assert!(svg_node_contains_point(

3197

            &node,

3198

            pt(5.0, 5.0),

3199

            SvgFillRule::Winding,

3200

0.1

3201

));

3202

        assert!(!svg_node_contains_point(

3203

            &node,

3204

            pt(50.0, 5.0),

3205

            SvgFillRule::Winding,

3206

0.1

3207

));

3208

3209

3210

    #[test]

3211

    fn svg_node_contains_point_lone_hole_reports_everything_outside_it() {

3212

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

3213

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

3214

        let hole = SvgCircle {

3215

            center_x: 0.0,

3216

            center_y: 0.0,

3217

            radius: 5.0,

3218

};

3219

        let node =

3220

            SvgNode::MultiShape(SvgSimpleNodeVec::from_vec(vec![SvgSimpleNode::CircleHole(

3221

                hole,

3222

            )]));

3223

        assert!(!svg_node_contains_point(

3224

            &node,

3225

            pt(0.0, 0.0),

3226

            SvgFillRule::Winding,

3227

0.1

3228

));

3229

        assert!(svg_node_contains_point(

3230

            &node,

3231

            pt(100.0, 100.0),

3232

            SvgFillRule::Winding,

3233

0.1

3234

));

3235

3236

3237

    #[test]

3238

    fn path_contains_point_square_positive_and_negative_controls() {

3239

        let sq = square_path();

3240

        assert!(path_contains_point(

3241

            &sq,

3242

            pt(5.0, 5.0),

3243

            SvgFillRule::Winding,

3244

0.1

3245

));

3246

        assert!(path_contains_point(

3247

            &sq,

3248

            pt(5.0, 5.0),

3249

            SvgFillRule::EvenOdd,

3250

0.1

3251

));

3252

        assert!(!path_contains_point(

3253

            &sq,

3254

            pt(-1.0, 5.0),

3255

            SvgFillRule::Winding,

3256

0.1

3257

));

3258

        assert!(!path_contains_point(

3259

            &sq,

3260

            pt(5.0, 100.0),

3261

            SvgFillRule::EvenOdd,

3262

0.1

3263

));

3264

3265

3266

    #[test]

3267

    fn path_contains_point_empty_path_is_never_hit() {

3268

        assert!(!path_contains_point(

3269

            &empty_path(),

3270

            pt(0.0, 0.0),

3271

            SvgFillRule::Winding,

3272

0.1

3273

));

3274

3275

3276

    #[test]

3277

    fn path_contains_point_tolerance_is_irrelevant_for_straight_edges() {

3278

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

3279

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

3280

        let sq = square_path();

3281

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

3282

            assert!(

3283

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

3284

                "tolerance {t}"

3285

);

3286

            assert!(

3287

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

3288

                "tolerance {t}"

3289

);

3290

3291

3292

3293

    #[test]

3294

    fn polygon_contains_point_square_ring() {

3295

        let poly = square_polygon();

3296

        assert!(polygon_contains_point(

3297

            &poly,

3298

            pt(5.0, 5.0),

3299

            SvgFillRule::Winding,

3300

0.1

3301

));

3302

        assert!(!polygon_contains_point(

3303

            &poly,

3304

            pt(-5.0, 5.0),

3305

            SvgFillRule::Winding,

3306

0.1

3307

));

3308

3309

3310

    #[test]

3311

    fn polygon_contains_point_without_rings_is_false() {

3312

        assert!(!polygon_contains_point(

3313

            &empty_polygon(),

3314

            pt(0.0, 0.0),

3315

            SvgFillRule::Winding,

3316

0.1

3317

));

3318

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

3319

        assert!(!polygon_contains_point(

3320

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

3321

            pt(0.0, 0.0),

3322

            SvgFillRule::Winding,

3323

0.1

3324

));

3325

3326

3327

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

3328

    // lyon path conversion helpers

3329

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

3330

3331

    #[test]

3332

    fn svg_multipolygon_to_lyon_path_of_an_empty_polygon_is_empty() {

3333

        assert_eq!(

3334

            svg_multipolygon_to_lyon_path(&empty_polygon())

3335

                .iter()

3336

                .count(),

3337

3338

);

3339

3340

3341

    #[test]

3342

    fn svg_multipolygon_to_lyon_path_skips_rings_without_items() {

3343

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

3344

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

3345

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

3346

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

3347

        assert_eq!(

3348

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

3349

            svg_multipolygon_to_lyon_path(&square_polygon())

3350

                .iter()

3351

                .count()

3352

);

3353

3354

3355

    #[test]

3356

    fn svg_multi_shape_to_lyon_path_of_an_empty_slice_is_empty() {

3357

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

3358

3359

3360

    #[test]

3361

    fn svg_path_to_lyon_path_events_of_an_empty_path_is_empty() {

3362

        assert_eq!(

3363

            svg_path_to_lyon_path_events(&empty_path()).iter().count(),

3364

3365

);

3366

3367

3368

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

3369

    // vertex_buffers_to_tessellated_cpu_node

3370

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

3371

3372

    #[test]

3373

    fn vertex_buffers_to_tessellated_cpu_node_moves_both_buffers_verbatim() {

3374

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

3375

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

3376

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

3377

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

3378

        let t = vertex_buffers_to_tessellated_cpu_node(vb);

3379

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

3380

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

3381

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

3382

3383

3384

    #[test]

3385

    fn vertex_buffers_to_tessellated_cpu_node_of_empty_buffers_is_empty() {

3386

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

3387

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

3388

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

3389

3390

3391

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

3392

    // tessellation

3393

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

3394

3395

    #[test]

3396

    fn tessellate_path_fill_of_a_square_produces_whole_triangles() {

3397

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

3398

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

3399

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

3400

        assert_indices_in_range(&t);

3401

3402

3403

    #[test]

3404

    fn tessellate_path_fill_and_stroke_of_an_empty_path_are_empty() {

3405

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

3406

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

3407

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

3408

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

3409

3410

3411

    #[test]

3412

    fn tessellate_circle_fill_zero_radius_is_empty() {

3413

        let t = tessellate_circle_fill(

3414

            &SvgCircle {

3415

                center_x: 0.0,

3416

                center_y: 0.0,

3417

                radius: 0.0,

3418

},

3419

            SvgFillStyle::default(),

3420

);

3421

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

3422

3423

3424

    #[test]

3425

    fn tessellate_circle_fill_negative_radius_matches_the_positive_one() {

3426

        let mk = |r: f32| {

3427

            tessellate_circle_fill(

3428

                &SvgCircle {

3429

                    center_x: 1.0,

3430

                    center_y: 2.0,

3431

                    radius: r,

3432

},

3433

                SvgFillStyle::default(),

3434

3435

};

3436

        let positive = mk(5.0);

3437

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

3438

        assert_eq!(

3439

            positive,

3440

            mk(-5.0),

3441

            "lyon takes |radius|; the sign must not matter"

3442

);

3443

3444

3445

    #[test]

3446

    fn tessellate_rect_fill_always_emits_exactly_two_triangles() {

3447

        for r in [

3448

            rect(0.0, 0.0, 10.0, 10.0),

3449

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

3450

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

3451

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

3452

] {

3453

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

3454

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

3455

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

3456

            assert_indices_in_range(&t);

3457

3458

3459

3460

    #[test]

3461

    fn tessellate_rect_stroke_of_a_real_rect_produces_geometry() {

3462

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

3463

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

3464

        assert_indices_in_range(&t);

3465

3466

3467

    #[test]

3468

    fn get_radii_maps_origin_and_size_onto_a_box() {

3469

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

3470

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

3471

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

3472

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

3473

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

3474

3475

3476

    #[test]

3477

    fn get_radii_ignores_the_corner_radii() {

3478

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

3479

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

3480

        let rounded = SvgRect {

3481

            radius_top_left: 3.0,

3482

            radius_top_right: 4.0,

3483

            radius_bottom_left: 5.0,

3484

            radius_bottom_right: 9.0,

3485

            ..base

3486

};

3487

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

3488

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

3489

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

3490

3491

3492

    #[test]

3493

    fn get_radii_of_a_negative_size_rect_produces_an_inverted_box() {

3494

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

3495

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

3496

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

3497

3498

3499

    #[test]

3500

    fn tessellate_multi_polygon_fill_of_an_empty_polygon_is_empty() {

3501

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

3502

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

3503

3504

3505

    #[test]

3506

    fn tessellate_multi_polygon_fill_skips_empty_rings() {

3507

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

3508

        assert_eq!(

3509

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

3510

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

3511

);

3512

3513

3514

    #[test]

3515

    fn tessellate_multi_shape_fill_of_an_empty_slice_is_empty() {

3516

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

3517

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

3518

3519

3520

    #[test]

3521

    fn tessellate_multi_shape_fill_of_a_plain_shape_produces_geometry() {

3522

        let ms = [

3523

            SvgSimpleNode::Circle(SvgCircle {

3524

                center_x: 40.0,

3525

                center_y: 40.0,

3526

                radius: 5.0,

3527

}),

3528

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

3529

];

3530

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

3531

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

3532

        assert_indices_in_range(&t);

3533

3534

3535

    #[test]

3536

    fn tessellate_multi_shape_fill_handles_every_simple_node_kind() {

3537

        let ms = [

3538

            SvgSimpleNode::Path(square_path()),

3539

            SvgSimpleNode::Circle(SvgCircle {

3540

                center_x: 40.0,

3541

                center_y: 40.0,

3542

                radius: 5.0,

3543

}),

3544

            SvgSimpleNode::CircleHole(SvgCircle {

3545

                center_x: 40.0,

3546

                center_y: 40.0,

3547

                radius: 2.0,

3548

}),

3549

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

3550

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

3551

];

3552

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

3553

        assert_indices_in_range(&tessellate_multi_shape_stroke(

3554

            &ms,

3555

            SvgStrokeStyle::default(),

3556

));

3557

3558

3559

    #[test]

3560

    fn tessellate_multi_polygon_stroke_of_an_empty_polygon_is_empty() {

3561

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

3562

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

3563

3564

3565

    #[test]

3566

    fn tessellate_styled_node_dispatches_on_the_style() {

3567

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

3568

        let fill = SvgStyledNode {

3569

            geometry: geo.clone(),

3570

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

3571

};

3572

        let stroke = SvgStyledNode {

3573

            geometry: geo.clone(),

3574

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

3575

};

3576

        assert_eq!(

3577

            tessellate_styled_node(&fill),

3578

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

3579

);

3580

        assert_eq!(

3581

            tessellate_styled_node(&stroke),

3582

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

3583

);

3584

3585

3586

    #[test]

3587

    fn tessellate_node_fill_of_a_collection_is_the_join_of_its_parts() {

3588

        let mp = square_polygon();

3589

        let node = SvgNode::MultiPolygonCollection(SvgMultiPolygonVec::from_vec(vec![

3590

            mp.clone(),

3591

            mp.clone(),

3592

        ]));

3593

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

3594

        assert_eq!(

3595

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

3596

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

3597

);

3598

3599

3600

    #[test]

3601

    fn tessellate_node_fill_of_an_empty_collection_is_empty() {

3602

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

3603

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

3604

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

3605

3606

3607

    #[test]

3608

    fn tessellate_svgpathelement_stroke_matches_the_per_kind_helpers() {

3609

        let ss = SvgStrokeStyle::default();

3610

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

3611

        assert_eq!(

3612

            tessellate_svgpathelement_stroke(&SvgPathElement::Line(l), ss),

3613

            tessellate_line_stroke(&l, ss)

3614

);

3615

        let q = SvgQuadraticCurve {

3616

            start: pt(0.0, 0.0),

3617

            ctrl: pt(5.0, 10.0),

3618

            end: pt(10.0, 0.0),

3619

};

3620

        assert_eq!(

3621

            tessellate_svgpathelement_stroke(&SvgPathElement::QuadraticCurve(q), ss),

3622

            tessellate_quadraticcurve_stroke(&q, ss)

3623

);

3624

        let c = SvgCubicCurve {

3625

            start: pt(0.0, 0.0),

3626

            ctrl_1: pt(3.0, 10.0),

3627

            ctrl_2: pt(7.0, -10.0),

3628

            end: pt(10.0, 0.0),

3629

};

3630

        assert_eq!(

3631

            tessellate_svgpathelement_stroke(&SvgPathElement::CubicCurve(c), ss),

3632

            tessellate_cubiccurve_stroke(&c, ss)

3633

);

3634

3635

3636

    #[test]

3637

    fn tessellate_line_stroke_of_a_zero_length_line_does_not_panic() {

3638

        let t = tessellate_line_stroke(&ln(3.0, 3.0, 3.0, 3.0), SvgStrokeStyle::default());

3639

        assert_indices_in_range(&t);

3640

3641

3642

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

3643

    // join_tessellated_nodes / join_tessellated_colored_nodes

3644

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

3645

3646

    #[test]

3647

    fn join_tessellated_nodes_of_nothing_is_empty() {

3648

        let t = join_tessellated_nodes(&[]);

3649

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

3650

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

3651

3652

3653

    #[test]

3654

    fn join_tessellated_nodes_offsets_and_terminates_each_buffer() {

3655

        let a = tess(&[(0.0, 0.0), (1.0, 0.0)], &[0, 1]);

3656

        let b = tess(&[(2.0, 0.0), (3.0, 0.0)], &[0, 1]);

3657

        let j = join_tessellated_nodes(&[a, b]);

3658

        assert_eq!(j.vertices.as_ref().len(), 4);

3659

        assert_eq!(

3660

            j.indices.as_ref(),

3661

            &[0u32, 1, GL_RESTART_INDEX, 2, 3, GL_RESTART_INDEX][..]

3662

);

3663

        assert_indices_in_range(&j);

3664

3665

3666

    #[test]

3667

    fn join_tessellated_nodes_leaves_existing_restart_markers_unshifted() {

3668

        let a = tess(&[(0.0, 0.0)], &[0]);

3669

        let b = tess(&[(1.0, 0.0), (2.0, 0.0)], &[0, GL_RESTART_INDEX, 1]);

3670

        let j = join_tessellated_nodes(&[a, b]);

3671

        assert_eq!(

3672

            j.indices.as_ref(),

3673

&[

3674

                0u32,

3675

                GL_RESTART_INDEX,

3676

1,

3677

                GL_RESTART_INDEX,

3678

2,

3679

                GL_RESTART_INDEX

3680

            ][..]

3681

);

3682

3683

3684

    #[test]

3685

    fn join_tessellated_nodes_single_node_is_only_terminated() {

3686

        let j = join_tessellated_nodes(&[tess(&[(0.0, 0.0), (1.0, 1.0)], &[0, 1, 0])]);

3687

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

3688

3689

3690

    #[test]

3691

    fn join_tessellated_nodes_can_alias_an_index_onto_the_restart_marker() {

3692

        // FINDING (pinned): the offset is applied with a bare `+=` and is only

3693

        // skipped for indices that *already* equal GL_RESTART_INDEX, so a large

3694

        // index can be shifted onto the sentinel and silently turn into a

3695

        // primitive-restart marker. (Anything past u32::MAX additionally

3696

        // overflow-panics in debug builds.)

3697

        let a = tess(&[(0.0, 0.0)], &[0]);

3698

        let b = tess(&[(1.0, 0.0)], &[GL_RESTART_INDEX - 1]);

3699

        let j = join_tessellated_nodes(&[a, b]);

3700

        assert_eq!(

3701

            j.indices.as_ref(),

3702

            &[0u32, GL_RESTART_INDEX, GL_RESTART_INDEX, GL_RESTART_INDEX][..]

3703

);

3704

3705

3706

    #[test]

3707

    fn join_tessellated_colored_nodes_of_nothing_is_empty() {

3708

        let t = join_tessellated_colored_nodes(&[]);

3709

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

3710

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

3711

3712

3713

    #[test]

3714

    fn join_tessellated_colored_nodes_offsets_like_the_plain_variant() {

3715

        fn colored(xs: &[f32], idx: &[u32]) -> TessellatedColoredSvgNode {

3716

            TessellatedColoredSvgNode {

3717

                vertices: xs

3718

                    .iter()

3719

                    .map(|&x| SvgColoredVertex {

3720

x,

3721

                        y: 0.0,

3722

                        z: 0.0,

3723

                        r: 1.0,

3724

                        g: 0.0,

3725

                        b: 0.0,

3726

                        a: 1.0,

3727

})

3728

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

3729

                    .into(),

3730

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

3731

3732

3733

        let j =

3734

            join_tessellated_colored_nodes(&[colored(&[0.0, 1.0], &[0, 1]), colored(&[2.0], &[0])]);

3735

        assert_eq!(j.vertices.as_ref().len(), 3);

3736

        assert_eq!(

3737

            j.indices.as_ref(),

3738

            &[0u32, 1, GL_RESTART_INDEX, 2, GL_RESTART_INDEX][..]

3739

);

3740

3741

3742

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

3743

    // boolean operations (agg scanline algebra)

3744

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

3745

3746

    #[test]

3747

    fn storage_to_multi_polygon_of_an_untouched_storage_is_empty() {

3748

        let mut storage = agg_rust::scanline_storage_aa::ScanlineStorageAa::new();

3749

        assert!(storage_to_multi_polygon(&mut storage)

3750

            .rings

3751

            .as_ref()

3752

            .is_empty());

3753

3754

3755

    #[test]

3756

    fn svg_multi_polygon_boolean_ops_on_two_empties_are_empty() {

3757

        let e = empty_polygon();

3758

        assert!(svg_multi_polygon_union(&e, &e).rings.as_ref().is_empty());

3759

        assert!(svg_multi_polygon_intersection(&e, &e)

3760

            .rings

3761

            .as_ref()

3762

            .is_empty());

3763

        assert!(svg_multi_polygon_difference(&e, &e)

3764

            .rings

3765

            .as_ref()

3766

            .is_empty());

3767

        assert!(svg_multi_polygon_xor(&e, &e).rings.as_ref().is_empty());

3768

3769

3770

    #[test]

3771

    fn svg_multi_polygon_union_of_a_square_with_itself_keeps_the_square() {

3772

        let sq = square_polygon();

3773

        let out = svg_multi_polygon_union(&sq, &sq);

3774

        assert!(

3775

            !out.rings.as_ref().is_empty(),

3776

            "a shape unioned with itself must not vanish"

3777

);

3778

        let b = out.get_bounds();

3779

        assert!(b.width > 0.0 && b.height > 0.0, "{b:?}");

3780

3781

3782

    #[test]

3783

    fn svg_multi_polygon_intersection_of_disjoint_squares_is_empty() {

3784

        let a = square_polygon();

3785

        let b = polygon_of(vec![square_at(100.0)]);

3786

        assert!(svg_multi_polygon_intersection(&a, &b)

3787

            .rings

3788

            .as_ref()

3789

            .is_empty());

3790

3791

3792

    #[test]

3793

    fn svg_multi_polygon_self_cancelling_ops_are_empty() {

3794

        let sq = square_polygon();

3795

        assert!(

3796

            svg_multi_polygon_difference(&sq, &sq)

3797

                .rings

3798

                .as_ref()

3799

                .is_empty(),

3800

            "A minus A must be empty"

3801

);

3802

        assert!(

3803

            svg_multi_polygon_xor(&sq, &sq).rings.as_ref().is_empty(),

3804

            "A xor A must be empty"

3805

);

3806

3807

3808

    #[test]

3809

    fn svg_multi_polygon_ops_accept_curve_rings() {

3810

        let ring = mk_path(vec![

3811

            SvgPathElement::QuadraticCurve(SvgQuadraticCurve {

3812

                start: pt(0.0, 0.0),

3813

                ctrl: pt(5.0, 12.0),

3814

                end: pt(10.0, 0.0),

3815

}),

3816

            SvgPathElement::CubicCurve(SvgCubicCurve {

3817

                start: pt(10.0, 0.0),

3818

                ctrl_1: pt(7.0, -6.0),

3819

                ctrl_2: pt(3.0, -6.0),

3820

                end: pt(0.0, 0.0),

3821

}),

3822

]);

3823

        let mp = polygon_of(vec![ring]);

3824

        assert!(!svg_multi_polygon_union(&mp, &mp).rings.as_ref().is_empty());

3825

3826

3827

    #[test]

3828

    fn svg_multi_polygon_byval_wrappers_match_the_by_ref_forms() {

3829

        let a = square_polygon();

3830

        let b = polygon_of(vec![square_at(5.0)]);

3831

        assert_eq!(

3832

            svg_multi_polygon_union_byval(&a, b.clone()),

3833

            svg_multi_polygon_union(&a, &b)

3834

);

3835

        assert_eq!(

3836

            svg_multi_polygon_intersection_byval(&a, b.clone()),

3837

            svg_multi_polygon_intersection(&a, &b)

3838

);

3839

        assert_eq!(

3840

            svg_multi_polygon_difference_byval(&a, b.clone()),

3841

            svg_multi_polygon_difference(&a, &b)

3842

);

3843

        assert_eq!(

3844

            svg_multi_polygon_xor_byval(&a, b.clone()),

3845

            svg_multi_polygon_xor(&a, &b)

3846

);

3847

3848

3849

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

3850

    // render_node_clipmask_cpu

3851

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

3852

3853

    #[test]

3854

    fn render_node_clipmask_cpu_zero_sized_image_is_none() {

3855

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

3856

        let style = SvgStyle::Fill(SvgFillStyle {

3857

            transform: identity_transform(),

3858

            ..SvgFillStyle::default()

3859

});

3860

        assert_eq!(

3861

            render_node_clipmask_cpu(&mut mask_image(0, 4), &node, style),

3862

            None

3863

);

3864

        assert_eq!(

3865

            render_node_clipmask_cpu(&mut mask_image(4, 0), &node, style),

3866

            None

3867

);

3868

        assert_eq!(

3869

            render_node_clipmask_cpu(&mut mask_image(0, 0), &node, style),

3870

            None

3871

);

3872

3873

3874

    #[test]

3875

    fn render_node_clipmask_cpu_geometry_less_nodes_are_none() {

3876

        let style = SvgStyle::Fill(SvgFillStyle {

3877

            transform: identity_transform(),

3878

            ..SvgFillStyle::default()

3879

});

3880

        for node in [

3881

            SvgNode::Path(empty_path()),

3882

            SvgNode::MultiPolygon(empty_polygon()),

3883

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

3884

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

3885

] {

3886

            assert_eq!(

3887

                render_node_clipmask_cpu(&mut mask_image(4, 4), &node, style),

3888

                None,

3889

                "{node:?}"

3890

);

3891

3892

3893

3894

    #[test]

3895

    fn render_node_clipmask_cpu_writes_a_single_channel_mask() {

3896

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

3897

        let style = SvgStyle::Fill(SvgFillStyle {

3898

            transform: identity_transform(),

3899

            ..SvgFillStyle::default()

3900

});

3901

        let mut img = mask_image(4, 4);

3902

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3903

        assert_eq!(img.data_format, RawImageFormat::R8);

3904

        assert!(img.premultiplied_alpha);

3905

        let bytes = mask_bytes(&img);

3906

        assert_eq!(bytes.len(), 16, "one byte per pixel");

3907

        assert!(

3908

            bytes.iter().any(|&b| b > 0),

3909

            "a rect covering the whole image must leave coverage"

3910

);

3911

3912

3913

    #[test]

3914

    fn render_node_clipmask_cpu_default_style_transform_is_not_the_identity() {

3915

        // FINDING (pinned): `SvgTransform::default()` is the *zero* matrix, so a

3916

        // style built straight from `SvgFillStyle::default()` collapses all

3917

        // geometry onto the origin instead of drawing it 1:1.

3918

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

3919

        let mut zeroed = mask_image(4, 4);

3920

        let mut identity = mask_image(4, 4);

3921

        assert_eq!(

3922

            render_node_clipmask_cpu(&mut zeroed, &node, SvgStyle::Fill(SvgFillStyle::default())),

3923

            Some(())

3924

);

3925

        assert_eq!(

3926

            render_node_clipmask_cpu(

3927

                &mut identity,

3928

                &node,

3929

                SvgStyle::Fill(SvgFillStyle {

3930

                    transform: identity_transform(),

3931

                    ..SvgFillStyle::default()

3932

})

3933

),

3934

            Some(())

3935

);

3936

        assert_ne!(mask_bytes(&zeroed), mask_bytes(&identity));

3937

3938

3939

    #[test]

3940

    fn render_node_clipmask_cpu_stroke_style_renders_without_panicking() {

3941

        let node = SvgNode::Circle(SvgCircle {

3942

            center_x: 8.0,

3943

            center_y: 8.0,

3944

            radius: 4.0,

3945

});

3946

        let style = SvgStyle::Stroke(SvgStrokeStyle {

3947

            transform: identity_transform(),

3948

            line_width: 2.0,

3949

            ..SvgStrokeStyle::default()

3950

});

3951

        let mut img = mask_image(16, 16);

3952

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3953

        assert_eq!(mask_bytes(&img).len(), 256);

3954

3955

3956

    #[test]

3957

    fn render_node_clipmask_cpu_geometry_far_outside_the_image_is_clipped_not_crashed() {

3958

        let node = SvgNode::Rect(rect(-1.0e6, -1.0e6, 10.0, 10.0));

3959

        let style = SvgStyle::Fill(SvgFillStyle {

3960

            transform: identity_transform(),

3961

            ..SvgFillStyle::default()

3962

});

3963

        let mut img = mask_image(4, 4);

3964

        assert_eq!(render_node_clipmask_cpu(&mut img, &node, style), Some(()));

3965

        assert!(mask_bytes(&img).iter().all(|&b| b == 0));

3966

3967

3968

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

3969

    // svgxmlnode_parse / svg_parse / ParsedSvg

3970

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

3971

3972

    #[test]

3973

    fn svg_parse_valid_minimal_input_keeps_the_bytes_verbatim() {

3974

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("positive control");

3975

        assert_eq!(p.svg_data.as_ref(), MINIMAL_SVG);

3976

        assert!(p.run_destructor);

3977

3978

3979

    #[test]

3980

    fn svg_parse_invalid_utf8_is_rejected() {

3981

        for bad in [

3982

            &[0xFFu8, 0xFE, 0x00][..],

3983

            &[0x80][..],

3984

            &[0xED, 0xA0, 0x80][..], // encoded surrogate

3985

            &[0xC0, 0x80][..],       // overlong NUL

3986

] {

3987

            assert_eq!(

3988

                svg_parse(bad, SvgParseOptions::default()).err(),

3989

                Some(SvgParseError::NotAnUtf8Str),

3990

                "{bad:?}"

3991

);

3992

3993

3994

3995

    #[test]

3996

    fn svg_parse_unclosed_elements_are_rejected() {

3997

        for bad in [&b"<svg"[..], &b"<svg>"[..], &b"<svg><g>"[..]] {

3998

            assert_eq!(

3999

                svg_parse(bad, SvgParseOptions::default()).err(),

4000

                Some(SvgParseError::NoParserAvailable),

4001

                "{bad:?}"

4002

);

4003

4004

4005

4006

    #[test]

4007

    fn svg_parse_accepts_input_that_is_not_svg_at_all() {

4008

        // PINNED leniency: `svg_parse` only checks that the bytes are UTF-8 and

4009

        // tokenize as XML — it never requires an <svg> root, so empty,

4010

        // whitespace-only and plain-text input all come back Ok.

4011

        for lenient in [

4012

            &b""[..],

4013

            &b"   "[..],

4014

            &b"\t\n\r "[..],

4015

            &b"garbage"[..],

4016

            &b"</svg>"[..],

4017

            &b"<html><body/></html>"[..],

4018

] {

4019

            let p = svg_parse(lenient, SvgParseOptions::default())

4020

                .unwrap_or_else(|e| panic!("{lenient:?} was rejected with {e:?}"));

4021

            assert_eq!(p.svg_data.as_ref(), lenient);

4022

4023

4024

4025

    #[test]

4026

    fn svg_parse_garbage_never_panics_and_never_invents_data() {

4027

        for data in [

4028

            &b"<<<<<<"[..],

4029

            &b"\x00\x01\x02\x03"[..],

4030

            &b"{\"json\": true}"[..],

4031

            &b"<svg <<>>"[..],

4032

            &b"&&&;;;"[..],

4033

            &b"<!--"[..],

4034

            &b"<?xml"[..],

4035

            &b"<!DOCTYPE"[..],

4036

] {

4037

            match svg_parse(data, SvgParseOptions::default()) {

4038

                Ok(p) => assert_eq!(p.svg_data.as_ref(), data, "{data:?}"),

4039

                Err(e) => assert_eq!(e, SvgParseError::NoParserAvailable, "{data:?}"),

4040

4041

4042

4043

4044

    #[test]

4045

    fn svg_parse_boundary_numeric_attributes_are_kept_as_opaque_strings() {

4046

        let src = concat!(

4047

            r#"<svg width="1e400" height="-0" a="9223372036854775807" "#,

4048

            r#"b="NaN" c="inf" d="0"><rect width="0"/></svg>"#

4049

);

4050

        let p = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("parse");

4051

        assert_eq!(p.to_string(SvgXmlOptions::default()), src);

4052

4053

4054

    #[test]

4055

    fn svg_parse_unicode_payloads_survive_untouched() {

4056

        for s in [

4057

            "<svg><text>\u{1F600}</text></svg>",

4058

            "<svg><text>e\u{0301}\u{0328}</text></svg>",

4059

            "<svg id=\"\u{65E5}\u{672C}\u{8A9E}\"/>",

4060

            "<svg>\u{200b}\u{1F600}</svg>",

4061

] {

4062

            let p = ParsedSvg::from_string(s, SvgParseOptions::default())

4063

                .unwrap_or_else(|e| panic!("{s:?} -> {e:?}"));

4064

            assert_eq!(p.to_string(SvgXmlOptions::default()), s);

4065

4066

4067

4068

    #[test]

4069

    fn svg_parse_leading_and_trailing_junk_is_tolerated_and_preserved() {

4070

        let src = "  <svg/>  trailing;garbage";

4071

        let p = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("lenient parse");

4072

        // The stored bytes are never trimmed — to_string gives back the original.

4073

        assert_eq!(p.to_string(SvgXmlOptions::default()), src);

4074

4075

4076

    #[test]

4077

    fn svg_parse_extremely_long_input_does_not_hang() {

4078

        let long = format!("<svg>{}</svg>", "a".repeat(1_000_000));

4079

        let p = ParsedSvg::from_string(&long, SvgParseOptions::default())

4080

            .expect("1 MB of text must parse");

4081

        assert_eq!(p.svg_data.as_ref().len(), long.len());

4082

4083

4084

    #[test]

4085

    fn svg_parse_many_sibling_elements_does_not_hang() {

4086

        let mut s = String::from("<svg>");

4087

        for _ in 0..50_000 {

4088

            s.push_str("<g/>");

4089

4090

        s.push_str("</svg>");

4091

        assert!(ParsedSvg::from_string(&s, SvgParseOptions::default()).is_ok());

4092

4093

4094

    #[test]

4095

    fn svg_parse_deeply_nested_input_does_not_stack_overflow() {

4096

        // The tokenizer loop is iterative, but the XmlNode tree it builds is torn

4097

        // down recursively — run on a big stack so a genuinely linear-depth drop

4098

        // is proven safe instead of coin-flipping on the 2 MiB default test stack.

4099

        let child = std::thread::Builder::new()

4100

            .stack_size(128 * 1024 * 1024)

4101

            .spawn(|| {

4102

                const DEPTH: usize = 10_000;

4103

                let mut s = String::from("<svg>");

4104

                for _ in 0..DEPTH {

4105

                    s.push_str("<g>");

4106

4107

                for _ in 0..DEPTH {

4108

                    s.push_str("</g>");

4109

4110

                s.push_str("</svg>");

4111

                ParsedSvg::from_string(&s, SvgParseOptions::default()).is_ok()

4112

})

4113

            .expect("spawn");

4114

        assert!(child

4115

            .join()

4116

            .expect("10k-deep nesting must not overflow the stack"));

4117

4118

4119

    #[test]

4120

    fn svgxmlnode_parse_mirrors_svg_parse_acceptance() {

4121

        assert!(svgxmlnode_parse(MINIMAL_SVG, SvgParseOptions::default()).is_ok());

4122

        assert!(svgxmlnode_parse(b"", SvgParseOptions::default()).is_ok());

4123

        assert_eq!(

4124

            svgxmlnode_parse(&[0xFF, 0xFE], SvgParseOptions::default()).err(),

4125

            Some(SvgParseError::NotAnUtf8Str)

4126

);

4127

        assert_eq!(

4128

            svgxmlnode_parse(b"<svg>", SvgParseOptions::default()).err(),

4129

            Some(SvgParseError::NoParserAvailable)

4130

);

4131

        let node = svgxmlnode_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4132

        assert!(node.run_destructor);

4133

4134

4135

    #[test]

4136

    fn parsed_svg_round_trips_through_to_string_and_back() {

4137

        let src = r#"<svg viewBox="0 0 8 8"><rect width="8" height="8"/></svg>"#;

4138

        let once = ParsedSvg::from_string(src, SvgParseOptions::default()).expect("parse");

4139

        let text = once.to_string(SvgXmlOptions::default());

4140

        assert_eq!(text, src);

4141

        let twice = ParsedSvg::from_string(&text, SvgParseOptions::default()).expect("re-parse");

4142

        assert_eq!(

4143

            twice.to_string(SvgXmlOptions::default()),

4144

            text,

4145

            "serialisation must be idempotent"

4146

);

4147

        assert_eq!(svg_to_string(&twice, SvgXmlOptions::default()), text);

4148

4149

4150

    #[test]

4151

    fn parsed_svg_from_bytes_and_from_string_agree() {

4152

        let a = ParsedSvg::from_bytes(MINIMAL_SVG, SvgParseOptions::default()).expect("bytes");

4153

        let b = ParsedSvg::from_string(

4154

            core::str::from_utf8(MINIMAL_SVG).expect("ascii"),

4155

            SvgParseOptions::default(),

4156

4157

        .expect("string");

4158

        assert_eq!(a.svg_data.as_ref(), b.svg_data.as_ref());

4159

4160

4161

    #[test]

4162

    fn parsed_svg_to_string_replaces_invalid_utf8_instead_of_panicking() {

4163

        // `ParsedSvg` is a plain #[repr(C)] FFI struct, so it can hold bytes that

4164

        // `svg_parse` would have rejected; `to_string` must stay lossy, not panic.

4165

        let p = ParsedSvg {

4166

            svg_data: vec![0xFFu8, 0xFE].into(),

4167

            run_destructor: true,

4168

};

4169

        assert_eq!(

4170

            p.to_string(SvgXmlOptions::default()),

4171

            "\u{FFFD}\u{FFFD}",

4172

            "each invalid byte becomes one replacement char"

4173

);

4174

        assert_eq!(

4175

            svg_to_string(&p, SvgXmlOptions::default()),

4176

            p.to_string(SvgXmlOptions::default())

4177

);

4178

4179

4180

    #[test]

4181

    fn parsed_svg_to_string_of_an_empty_document_is_empty() {

4182

        let p = ParsedSvg {

4183

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

4184

            run_destructor: true,

4185

};

4186

        assert!(p.to_string(SvgXmlOptions::default()).is_empty());

4187

        assert_eq!(format!("{p:?}"), "ParsedSvg(0 bytes)");

4188

4189

4190

    #[test]

4191

    fn parsed_svg_debug_reports_the_byte_length() {

4192

        let p = ParsedSvg {

4193

            svg_data: vec![1u8, 2, 3].into(),

4194

            run_destructor: true,

4195

};

4196

        assert_eq!(format!("{p:?}"), "ParsedSvg(3 bytes)");

4197

4198

4199

    #[test]

4200

    fn svg_root_and_get_root_agree() {

4201

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4202

        assert!(p.get_root().run_destructor);

4203

        assert!(svg_root(&p).run_destructor);

4204

        // …and stay well-defined for a document with no elements at all.

4205

        let empty = svg_parse(b"", SvgParseOptions::default()).expect("lenient parse");

4206

        assert!(empty.get_root().run_destructor);

4207

4208

4209

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

4210

    // svg_render

4211

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

4212

4213

    #[test]

4214

    fn svg_render_zero_target_size_is_none() {

4215

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4216

        for size in [

4217

            LayoutSize::new(0, 0),

4218

            LayoutSize::new(0, 8),

4219

            LayoutSize::new(8, 0),

4220

] {

4221

            let opts = SvgRenderOptions {

4222

                target_size: OptionLayoutSize::Some(size),

4223

                ..SvgRenderOptions::default()

4224

};

4225

            assert!(p.render(opts).is_none(), "{size:?}");

4226

            assert!(svg_render(&p, opts).is_none(), "{size:?}");

4227

4228

4229

4230

    #[cfg(feature = "cpurender")]

4231

    #[test]

4232

    fn svg_render_produces_an_image_of_the_requested_size() {

4233

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4234

        let opts = SvgRenderOptions {

4235

            target_size: OptionLayoutSize::Some(LayoutSize::new(8, 8)),

4236

            ..SvgRenderOptions::default()

4237

};

4238

        let img = p.render(opts).expect("a minimal <svg> must rasterize");

4239

        assert_eq!((img.width, img.height), (8, 8));

4240

        assert_eq!(img.data_format, RawImageFormat::RGBA8);

4241

        assert!(!img.premultiplied_alpha);

4242

4243

4244

    #[cfg(feature = "cpurender")]

4245

    #[test]

4246

    fn svg_render_of_a_document_without_an_svg_root_is_none() {

4247

        // `svg_parse` accepts it, but rasterization has nothing to draw.

4248

        let p =

4249

            svg_parse(b"<html><body/></html>", SvgParseOptions::default()).expect("lenient parse");

4250

        let opts = SvgRenderOptions {

4251

            target_size: OptionLayoutSize::Some(LayoutSize::new(4, 4)),

4252

            ..SvgRenderOptions::default()

4253

};

4254

        assert!(p.render(opts).is_none());

4255

4256

4257

    #[cfg(feature = "cpurender")]

4258

    #[test]

4259

    fn svg_render_one_by_one_target_is_the_smallest_valid_size() {

4260

        let p = svg_parse(MINIMAL_SVG, SvgParseOptions::default()).expect("parse");

4261

        let opts = SvgRenderOptions {

4262

            target_size: OptionLayoutSize::Some(LayoutSize::new(1, 1)),

4263

            ..SvgRenderOptions::default()

4264

};

4265

        let img = p.render(opts).expect("1x1 must still rasterize");

4266

        assert_eq!((img.width, img.height), (1, 1));

4267

4268