Grcov report - pixmap.rs

1

use agg_rust::{

2

    basics::{FillingRule, VertexSource},

3

    color::Rgba8,

4

    conv_transform::ConvTransform,

5

    gradient_lut::GradientLut,

6

    path_storage::PathStorage,

7

    pixfmt_rgba::PixfmtRgba32,

8

    rasterizer_scanline_aa::RasterizerScanlineAa,

9

    renderer_base::RendererBase,

10

    renderer_scanline::{render_scanlines_aa, render_scanlines_aa_solid},

11

    rendering_buffer::RowAccessor,

12

    scanline_u::ScanlineU8,

13

    span_allocator::SpanAllocator,

14

    span_gradient::{GradientFunction, SpanGradient},

15

    span_interpolator_linear::SpanInterpolatorLinear,

16

    trans_affine::TransAffine,

17

};

18

use azul_core::geom::{LogicalPosition, LogicalRect, LogicalSize};

19

20

use super::*;

21

22

pub const IDENTITY_EPSILON_F64: f64 = 0.0001;

23

24

/// Compute the intersection of two logical rects.

25

#[must_use]

26

20

pub fn rect_intersection(a: &LogicalRect, b: &LogicalRect) -> Option<LogicalRect> {

27

20

    let x1 = a.origin.x.max(b.origin.x);

28

20

    let y1 = a.origin.y.max(b.origin.y);

29

20

    let x2 = (a.origin.x + a.size.width).min(b.origin.x + b.size.width);

30

20

    let y2 = (a.origin.y + a.size.height).min(b.origin.y + b.size.height);

31

20

    if x2 > x1 && y2 > y1 {

32

15

        Some(LogicalRect {

33

15

            origin: LogicalPosition { x: x1, y: y1 },

34

15

            size: LogicalSize {

35

15

                width: x2 - x1,

36

15

                height: y2 - y1,

37

15

},

38

15

})

39

    } else {

40

5

        None

41

42

20

43

44

/// Blit `src` onto `dst` at pixel position (`px_x`, `px_y`) with opacity.

45

#[allow(

46

    clippy::cast_possible_truncation,

47

    clippy::cast_possible_wrap,

48

    clippy::cast_sign_loss

49

)] // bounded pixel/coord/colour/glyph cast

50

238

pub fn blit_pixmap(src: &AzulPixmap, dst: &mut AzulPixmap, px_x: i32, px_y: i32, opacity: f32) {

51

238

    blit_pixmap_clipped(src, dst, px_x, px_y, opacity, None);

52

238

53

54

/// [`blit_pixmap`] with an optional DEST-space clip rect `(x0, y0, x1, y1)`

55

/// in device pixels (half-open). What keeps a layer nested inside a scroll

56

/// frame from painting outside that frame once the frame has scrolled it

57

/// past an edge.

58

276

pub fn blit_pixmap_clipped(

59

276

    src: &AzulPixmap,

60

276

    dst: &mut AzulPixmap,

61

276

    px_x: i32,

62

276

    px_y: i32,

63

276

    opacity: f32,

64

276

    clip: Option<(i32, i32, i32, i32)>,

65

276

) {

66

276

    let sw = src.width as i32;

67

276

    let sh = src.height as i32;

68

276

    let dw = dst.width as i32;

69

276

    let dh = dst.height as i32;

70

276

    let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

71

72

71074

    for sy in 0..sh {

73

        // saturating: px_y/px_x are caller-supplied device offsets that a large-but-legal

74

        // CSS transform can push to ~i32::MAX; a plain `+` overflows. A saturated result

75

        // fails the bounds check below and is skipped, which is the intended outcome.

76

71074

        let dy = px_y.saturating_add(sy);

77

71074

        if dy < 0 || dy >= dh {

78

99

            continue;

79

70975

80

70975

        if let Some((_, cy0, _, cy1)) = clip {

81

1650

            if dy < cy0 || dy >= cy1 {

82

25

                continue;

83

1625

84

69325

85

34354571

        for sx in 0..sw {

86

34354571

            let dx = px_x.saturating_add(sx);

87

34354571

            if dx < 0 || dx >= dw {

88

128865

                continue;

89

34225706

90

34225706

            if let Some((cx0, _, cx1, _)) = clip {

91

443300

                if dx < cx0 || dx >= cx1 {

92

400

                    continue;

93

442900

94

33782406

95

34225306

            let si = ((sy * sw + sx) * 4) as usize;

96

34225306

            let di = ((dy * dw + dx) * 4) as usize;

97

34225306

            if si + 3 >= src.data.len() || di + 3 >= dst.data.len() {

98

                continue;

99

34225306

100

101

34225306

            let sr = u32::from(src.data[si]);

102

34225306

            let sg = u32::from(src.data[si + 1]);

103

34225306

            let sb = u32::from(src.data[si + 2]);

104

34225306

            let sa = (u32::from(src.data[si + 3]) * op) / 255;

105

106

34225306

            if sa == 0 {

107

56031

                continue;

108

34169275

109

34169275

            if sa == 255 {

110

34169274

                dst.data[di] = sr as u8;

111

34169274

                dst.data[di + 1] = sg as u8;

112

34169274

                dst.data[di + 2] = sb as u8;

113

34169274

                dst.data[di + 3] = 255;

114

34169274

            } else {

115

1

                let inv_sa = 255 - sa;

116

1

                dst.data[di] = ((sr * sa + u32::from(dst.data[di]) * inv_sa) / 255) as u8;

117

1

                dst.data[di + 1] = ((sg * sa + u32::from(dst.data[di + 1]) * inv_sa) / 255) as u8;

118

1

                dst.data[di + 2] = ((sb * sa + u32::from(dst.data[di + 2]) * inv_sa) / 255) as u8;

119

1

                dst.data[di + 3] =

120

1

                    ((sa + u32::from(dst.data[di + 3]) * inv_sa / 255).min(255)) as u8;

121

1

122

123

124

276

125

126

/// Blit `src` into `dst` through an affine map from SRC DEVICE-PIXEL

127

/// coordinates to DST DEVICE-PIXEL coordinates.

128

///

129

/// This is how a composited layer with a live transform (drag, CSS

130

/// `transform`, diff-driven animation) reaches the screen on the CPU path:

131

/// the layer's pixbuf holds its content at LAYOUT position in layer-local

132

/// space, and this maps every pixel through the layer's matrix at composite

133

/// time. `blit_pixmap` above is the identity fast path — for years it was the

134

/// ONLY path, which is why a transformed layer rendered at its layout

135

/// position no matter what its matrix said.

136

///

137

/// Inverse mapping with bilinear sampling: iterate the dest-space bounding box

138

/// of the transformed src rect, map each dest pixel back through the inverted

139

/// matrix, sample src bilinearly (edge-clamped), blend with `opacity`. A

140

/// non-invertible matrix (degenerate scale) draws nothing — a collapsed layer

141

/// has no area.

142

#[allow(

143

    clippy::cast_possible_truncation,

144

    clippy::cast_sign_loss,

145

    clippy::cast_precision_loss

146

)]

147

// bounded pixel/coord/colour casts

148

1

pub fn blit_pixmap_affine(src: &AzulPixmap, dst: &mut AzulPixmap, m: &TransAffine, opacity: f32) {

149

1

    blit_pixmap_affine_clipped(src, dst, m, opacity, None);

150

1

151

152

/// [`blit_pixmap_affine`] with an optional DEST-space clip rect

153

/// `(x0, y0, x1, y1)` in device pixels. The clip is what keeps a keyframed

154

/// exit inside its own box: `-azul-animation-out` may translate the retained

155

/// content, and without a clip the slide paints over neighbouring components

156

/// (the sliding-out scrollbar over the body margin was the reported case).

157

#[allow(

158

    clippy::cast_possible_truncation,

159

    clippy::cast_sign_loss,

160

    clippy::cast_precision_loss

161

)]

162

// bounded pixel/coord/colour casts

163

63

pub fn blit_pixmap_affine_clipped(

164

63

    src: &AzulPixmap,

165

63

    dst: &mut AzulPixmap,

166

63

    m: &TransAffine,

167

63

    opacity: f32,

168

63

    clip: Option<(i32, i32, i32, i32)>,

169

63

) {

170

63

    let sw = src.width as i32;

171

63

    let sh = src.height as i32;

172

63

    let dw = dst.width as i32;

173

63

    let dh = dst.height as i32;

174

63

    if sw == 0 || sh == 0 || dw == 0 || dh == 0 {

175

        return;

176

63

177

63

    let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

178

63

    if op == 0 {

179

        return;

180

63

181

182

63

    let mut inv = *m;

183

    // agg's invert() on a degenerate matrix produces non-finite values; the

184

    // finite-check below skips those pixels, so the collapsed-layer case

185

    // degrades to "draws nothing" rather than UB or garbage.

186

63

    inv.invert();

187

188

    // Dest-space bounding box of the four transformed src corners.

189

63

    let corners = [

190

63

        (0.0, 0.0),

191

63

        (f64::from(sw), 0.0),

192

63

        (0.0, f64::from(sh)),

193

63

        (f64::from(sw), f64::from(sh)),

194

63

];

195

63

    let (mut min_x, mut min_y) = (f64::INFINITY, f64::INFINITY);

196

63

    let (mut max_x, mut max_y) = (f64::NEG_INFINITY, f64::NEG_INFINITY);

197

315

    for (cx, cy) in corners {

198

252

        let (mut x, mut y) = (cx, cy);

199

252

        m.transform(&mut x, &mut y);

200

252

        min_x = min_x.min(x);

201

252

        min_y = min_y.min(y);

202

252

        max_x = max_x.max(x);

203

252

        max_y = max_y.max(y);

204

252

205

63

    if !(min_x.is_finite() && min_y.is_finite() && max_x.is_finite() && max_y.is_finite()) {

206

        return;

207

63

208

63

    let mut x0 = (min_x.floor() as i32).max(0);

209

63

    let mut y0 = (min_y.floor() as i32).max(0);

210

63

    let mut x1 = (max_x.ceil() as i32).min(dw);

211

63

    let mut y1 = (max_y.ceil() as i32).min(dh);

212

63

    if let Some((cx0, cy0, cx1, cy1)) = clip {

213

24

        x0 = x0.max(cx0);

214

24

        y0 = y0.max(cy0);

215

24

        x1 = x1.min(cx1);

216

24

        y1 = y1.min(cy1);

217

39

218

219

13129

    for dy in y0..y1 {

220

2753276

        for dx in x0..x1 {

221

            // Sample at the dest pixel CENTER, mapped back to src space.

222

2753276

            let (mut fx, mut fy) = (f64::from(dx) + 0.5, f64::from(dy) + 0.5);

223

2753276

            inv.transform(&mut fx, &mut fy);

224

2753276

            if !(fx.is_finite() && fy.is_finite()) {

225

                return;

226

2753276

227

            // Back to texel space (pixel centers at n + 0.5).

228

2753276

            let sx_f = fx - 0.5;

229

2753276

            let sy_f = fy - 0.5;

230

            // Outside the src rect entirely (with the half-texel skirt the

231

            // bilinear kernel needs) → transparent, nothing to blend.

232

2753276

            if sx_f <= -1.0 || sy_f <= -1.0 || sx_f >= f64::from(sw) || sy_f >= f64::from(sh) {

233

9

                continue;

234

2753267

235

2753267

            let x_lo = sx_f.floor() as i32;

236

2753267

            let y_lo = sy_f.floor() as i32;

237

2753267

            let wx = (sx_f - f64::from(x_lo)) as f32;

238

2753267

            let wy = (sy_f - f64::from(y_lo)) as f32;

239

240

            // Edge-clamped 2x2 fetch. Weights of taps that clamp collapse

241

            // onto the edge texel, which is the standard clamp-to-edge rule.

242

11013068

            let fetch = |x: i32, y: i32| -> [f32; 4] {

243

11013068

                let cx = x.clamp(0, sw - 1);

244

11013068

                let cy = y.clamp(0, sh - 1);

245

11013068

                let i = ((cy * sw + cx) * 4) as usize;

246

11013068

247

11013068

                    f32::from(src.data[i]),

248

11013068

                    f32::from(src.data[i + 1]),

249

11013068

                    f32::from(src.data[i + 2]),

250

11013068

                    f32::from(src.data[i + 3]),

251

11013068

252

11013068

};

253

2753267

            let p00 = fetch(x_lo, y_lo);

254

2753267

            let p10 = fetch(x_lo + 1, y_lo);

255

2753267

            let p01 = fetch(x_lo, y_lo + 1);

256

2753267

            let p11 = fetch(x_lo + 1, y_lo + 1);

257

            // Outside-the-rect taps are transparent, not clamped: without

258

            // this the border row of an opaque layer smears outward to the

259

            // whole bbox edge instead of fading over one pixel.

260

11013068

            let zero_if_out = |x: i32, y: i32, p: [f32; 4]| -> [f32; 4] {

261

11013068

                if x < 0 || y < 0 || x >= sw || y >= sh {

262

48599

                    [0.0, 0.0, 0.0, 0.0]

263

                } else {

264

10964469

265

266

11013068

};

267

2753267

            let p00 = zero_if_out(x_lo, y_lo, p00);

268

2753267

            let p10 = zero_if_out(x_lo + 1, y_lo, p10);

269

2753267

            let p01 = zero_if_out(x_lo, y_lo + 1, p01);

270

2753267

            let p11 = zero_if_out(x_lo + 1, y_lo + 1, p11);

271

272

8259801

            let lerp2 = |a: [f32; 4], b: [f32; 4], t: f32| -> [f32; 4] {

273

8259801

274

8259801

                    a[0] + (b[0] - a[0]) * t,

275

8259801

                    a[1] + (b[1] - a[1]) * t,

276

8259801

                    a[2] + (b[2] - a[2]) * t,

277

8259801

                    a[3] + (b[3] - a[3]) * t,

278

8259801

279

8259801

};

280

2753267

            let top = lerp2(p00, p10, wx);

281

2753267

            let bot = lerp2(p01, p11, wx);

282

2753267

            let px = lerp2(top, bot, wy);

283

284

2753267

            let sa = ((px[3] as u32) * op) / 255;

285

2753267

            if sa == 0 {

286

248557

                continue;

287

2504710

288

2504710

            let di = ((dy * dw + dx) * 4) as usize;

289

2504710

            if di + 3 >= dst.data.len() {

290

                continue;

291

2504710

292

2504710

            let (sr, sg, sb) = (px[0] as u32, px[1] as u32, px[2] as u32);

293

2504710

            if sa >= 255 {

294

2465121

                dst.data[di] = sr as u8;

295

2465121

                dst.data[di + 1] = sg as u8;

296

2465121

                dst.data[di + 2] = sb as u8;

297

2465121

                dst.data[di + 3] = 255;

298

2465162

            } else {

299

39589

                let inv_sa = 255 - sa;

300

39589

                dst.data[di] = ((sr * sa + u32::from(dst.data[di]) * inv_sa) / 255) as u8;

301

39589

                dst.data[di + 1] = ((sg * sa + u32::from(dst.data[di + 1]) * inv_sa) / 255) as u8;

302

39589

                dst.data[di + 2] = ((sb * sa + u32::from(dst.data[di + 2]) * inv_sa) / 255) as u8;

303

39589

                dst.data[di + 3] =

304

39589

                    ((sa + u32::from(dst.data[di + 3]) * inv_sa / 255).min(255)) as u8;

305

39589

306

307

308

63

309

310

/// Projective twin of [`blit_pixmap_affine`]: `h` is a row-major 3x3

311

/// homography over column vectors (`compositor::Mat3`) mapping SRC pixels to

312

/// DEST pixels with a perspective divide. This is how a `perspective()

313

/// rotateX()` tilt reaches the screen on the CPU path — the affine blit

314

/// cannot foreshorten. Inverse mapping per dest pixel (the homography's

315

/// adjugate), bilinear sampling, the same blend as the affine blit. Dest

316

/// pixels that map behind the eye (`w <= 0`) or outside the source draw

317

/// nothing; a singular matrix draws nothing.

318

#[allow(

319

    clippy::cast_possible_truncation,

320

    clippy::cast_sign_loss,

321

    clippy::cast_precision_loss

322

)]

323

#[allow(

324

    clippy::many_single_char_names,

325

    clippy::similar_names,

326

    clippy::too_many_lines

327

)]

328

4

pub fn blit_pixmap_projective(src: &AzulPixmap, dst: &mut AzulPixmap, h: &[f64; 9], opacity: f32) {

329

4

    blit_pixmap_projective_clipped(src, dst, h, opacity, None);

330

4

331

332

/// [`blit_pixmap_projective`] with an optional DEST-space clip rect

333

/// `(x0, y0, x1, y1)` in device pixels (half-open), intersected with the

334

/// projected bounding box.

335

#[allow(

336

    clippy::cast_possible_truncation,

337

    clippy::cast_sign_loss,

338

    clippy::cast_precision_loss

339

)]

340

// bounded pixel/coord/colour casts

341

#[allow(clippy::many_single_char_names)] // homography coefficients: a..i is THE notation

342

4

pub fn blit_pixmap_projective_clipped(

343

4

    src: &AzulPixmap,

344

4

    dst: &mut AzulPixmap,

345

4

    h: &[f64; 9],

346

4

    opacity: f32,

347

4

    clip: Option<(i32, i32, i32, i32)>,

348

4

) {

349

4

    let sw = src.width as i32;

350

4

    let sh = src.height as i32;

351

4

    let dw = dst.width as i32;

352

4

    let dh = dst.height as i32;

353

4

    if sw == 0 || sh == 0 || dw == 0 || dh == 0 {

354

        return;

355

4

356

4

    let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

357

4

    if op == 0 {

358

        return;

359

4

360

361

    // Inverse via the adjugate; a singular matrix has no area.

362

4

    let (a, b, c, d, e, f, g, hh, i) = (h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], h[8]);

363

4

    let det = a * (e * i - f * hh) - b * (d * i - f * g) + c * (d * hh - e * g);

364

4

    if !det.is_finite() || det.abs() < 1e-12 {

365

1

        return;

366

3

367

3

    let inv = [

368

3

        (e * i - f * hh) / det,

369

3

        (c * hh - b * i) / det,

370

3

        (b * f - c * e) / det,

371

3

        (f * g - d * i) / det,

372

3

        (a * i - c * g) / det,

373

3

        (c * d - a * f) / det,

374

3

        (d * hh - e * g) / det,

375

3

        (b * g - a * hh) / det,

376

3

        (a * e - b * d) / det,

377

3

];

378

379

    // Dest-space bounding box of the four projected src corners. A corner

380

    // behind the eye has no finite image: fall back to the whole dest.

381

3

    let corners = [

382

3

        (0.0, 0.0),

383

3

        (f64::from(sw), 0.0),

384

3

        (0.0, f64::from(sh)),

385

3

        (f64::from(sw), f64::from(sh)),

386

3

];

387

3

    let (mut min_x, mut min_y) = (f64::INFINITY, f64::INFINITY);

388

3

    let (mut max_x, mut max_y) = (f64::NEG_INFINITY, f64::NEG_INFINITY);

389

3

    let mut behind = false;

390

13

    for (cx, cy) in corners {

391

11

        let w = g * cx + hh * cy + i;

392

11

        if w <= 1e-9 {

393

1

            behind = true;

394

1

            break;

395

10

396

10

        let x = (a * cx + b * cy + c) / w;

397

10

        let y = (d * cx + e * cy + f) / w;

398

10

        min_x = min_x.min(x);

399

10

        min_y = min_y.min(y);

400

10

        max_x = max_x.max(x);

401

10

        max_y = max_y.max(y);

402

403

3

    let (x0, y0, x1, y1) = if behind

404

2

        || !(min_x.is_finite() && min_y.is_finite() && max_x.is_finite() && max_y.is_finite())

405

406

1

        (0, 0, dw, dh)

407

    } else {

408

2

409

2

            (min_x.floor() as i32).max(0),

410

2

            (min_y.floor() as i32).max(0),

411

2

            (max_x.ceil() as i32).min(dw),

412

2

            (max_y.ceil() as i32).min(dh),

413

2

414

};

415

3

    let (x0, y0, x1, y1) = match clip {

416

        Some((cx0, cy0, cx1, cy1)) => (x0.max(cx0), y0.max(cy0), x1.min(cx1), y1.min(cy1)),

417

3

        None => (x0, y0, x1, y1),

418

};

419

420

11

    for dy in y0..y1 {

421

158

        for dx in x0..x1 {

422

158

            let (px_c, py_c) = (f64::from(dx) + 0.5, f64::from(dy) + 0.5);

423

158

            let s = inv[6] * px_c + inv[7] * py_c + inv[8];

424

158

            if !(s.is_finite()) || s <= 1e-9 {

425

                continue;

426

158

427

158

            let fx = (inv[0] * px_c + inv[1] * py_c + inv[2]) / s;

428

158

            let fy = (inv[3] * px_c + inv[4] * py_c + inv[5]) / s;

429

158

            if !(fx.is_finite() && fy.is_finite()) {

430

                continue;

431

158

432

158

            let sx_f = fx - 0.5;

433

158

            let sy_f = fy - 0.5;

434

158

            if sx_f <= -1.0 || sy_f <= -1.0 || sx_f >= f64::from(sw) || sy_f >= f64::from(sh) {

435

55

                continue;

436

103

437

103

            let x_lo = sx_f.floor() as i32;

438

103

            let y_lo = sy_f.floor() as i32;

439

103

            let wx = (sx_f - f64::from(x_lo)) as f32;

440

103

            let wy = (sy_f - f64::from(y_lo)) as f32;

441

412

            let fetch = |x: i32, y: i32| -> [f32; 4] {

442

412

                if x < 0 || y < 0 || x >= sw || y >= sh {

443

68

                    return [0.0, 0.0, 0.0, 0.0];

444

344

445

344

                let idx = ((y * sw + x) * 4) as usize;

446

344

447

344

                    f32::from(src.data[idx]),

448

344

                    f32::from(src.data[idx + 1]),

449

344

                    f32::from(src.data[idx + 2]),

450

344

                    f32::from(src.data[idx + 3]),

451

344

452

412

};

453

309

            let lerp2 = |p: [f32; 4], q: [f32; 4], t: f32| -> [f32; 4] {

454

309

455

309

                    p[0] + (q[0] - p[0]) * t,

456

309

                    p[1] + (q[1] - p[1]) * t,

457

309

                    p[2] + (q[2] - p[2]) * t,

458

309

                    p[3] + (q[3] - p[3]) * t,

459

309

460

309

};

461

103

            let top = lerp2(fetch(x_lo, y_lo), fetch(x_lo + 1, y_lo), wx);

462

103

            let bot = lerp2(fetch(x_lo, y_lo + 1), fetch(x_lo + 1, y_lo + 1), wx);

463

103

            let px = lerp2(top, bot, wy);

464

465

103

            let sa = ((px[3] as u32) * op) / 255;

466

103

            if sa == 0 {

467

                continue;

468

103

469

103

            let di = ((dy * dw + dx) * 4) as usize;

470

103

            if di + 3 >= dst.data.len() {

471

                continue;

472

103

473

103

            let (sr, sg, sb) = (px[0] as u32, px[1] as u32, px[2] as u32);

474

103

            if sa >= 255 {

475

53

                dst.data[di] = sr as u8;

476

53

                dst.data[di + 1] = sg as u8;

477

53

                dst.data[di + 2] = sb as u8;

478

53

                dst.data[di + 3] = 255;

479

53

            } else {

480

50

                let inv_sa = 255 - sa;

481

50

                dst.data[di] = ((sr * sa + u32::from(dst.data[di]) * inv_sa) / 255) as u8;

482

50

                dst.data[di + 1] = ((sg * sa + u32::from(dst.data[di + 1]) * inv_sa) / 255) as u8;

483

50

                dst.data[di + 2] = ((sb * sa + u32::from(dst.data[di + 2]) * inv_sa) / 255) as u8;

484

50

                dst.data[di + 3] =

485

50

                    ((sa + u32::from(dst.data[di + 3]) * inv_sa / 255).min(255)) as u8;

486

50

487

488

489

4

490

491

/// Shift pixel data in a pixmap by (dx, dy) pixels, clearing exposed regions.

492

#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph

493

                                                             // cast

494

20

pub fn shift_pixbuf(pixmap: &mut AzulPixmap, dx: i32, dy: i32) {

495

    use core::cmp::Ordering;

496

20

    let w = pixmap.width as i32;

497

20

    let h = pixmap.height as i32;

498

    // `i32::MIN.abs()` panics — MIN has no positive i32 counterpart. `unsigned_abs`

499

    // is total. `w`/`h` come from unsigned dimensions, so they are never negative.

500

20

    if dx.unsigned_abs() >= w.unsigned_abs() || dy.unsigned_abs() >= h.unsigned_abs() {

501

        // Entire buffer is exposed — just clear it

502

7

        pixmap.fill(0, 0, 0, 0);

503

7

        return;

504

13

505

506

13

    let stride = (w * 4) as usize;

507

13

    let data = &mut pixmap.data;

508

509

    // Shift rows vertically

510

13

    match dy.cmp(&0) {

511

        Ordering::Greater => {

512

            // Shift down: copy from top to bottom

513

30

            for row in (0..h - dy).rev() {

514

30

                let src_start = (row * w * 4) as usize;

515

30

                let dst_start = ((row + dy) * w * 4) as usize;

516

30

                data.copy_within(src_start..src_start + stride, dst_start);

517

30

518

            // Clear top rows

519

16

            for row in 0..dy {

520

16

                let start = (row * w * 4) as usize;

521

16

                data[start..start + stride].fill(0);

522

16

523

524

        Ordering::Less => {

525

3

            let ady = -dy;

526

            // Shift up: copy from bottom to top

527

6

            for row in ady..h {

528

6

                let src_start = (row * w * 4) as usize;

529

6

                let dst_start = ((row - ady) * w * 4) as usize;

530

6

                data.copy_within(src_start..src_start + stride, dst_start);

531

6

532

            // Clear bottom rows

533

5

            for row in (h - ady)..h {

534

5

                let start = (row * w * 4) as usize;

535

5

                data[start..start + stride].fill(0);

536

5

537

538

5

        Ordering::Equal => {}

539

540

541

    // Shift columns horizontally

542

13

    match dx.cmp(&0) {

543

        Ordering::Greater => {

544

14

            for row in 0..h {

545

14

                let row_start = (row * w * 4) as usize;

546

14

                let shift = (dx * 4) as usize;

547

14

                // Shift right within the row

548

14

                data.copy_within(row_start..row_start + stride - shift, row_start + shift);

549

14

                // Clear left columns

550

14

                data[row_start..row_start + shift].fill(0);

551

14

552

553

        Ordering::Less => {

554

3

            let adx = (-dx * 4) as usize;

555

11

            for row in 0..h {

556

11

                let row_start = (row * w * 4) as usize;

557

11

                data.copy_within(row_start + adx..row_start + stride, row_start);

558

11

                // Clear right columns

559

11

                data[row_start + stride - adx..row_start + stride].fill(0);

560

11

561

562

6

        Ordering::Equal => {}

563

564

20

565

566

/// (#27) Pixmap storage: owned heap, or BORROWED external memory — a

567

/// platform backbuffer such as a mapped Wayland shm slot. All slice

568

/// access goes through `Deref`, so the raster/compositor sites are

569

/// storage-blind; only construction and resize know the difference

570

/// (resize always converts to owned — a borrowed target's size is the

571

/// creator's contract). Borrowed storage is NEVER freed here.

572

pub enum PixBuf {

573

    Owned(Vec<u8>),

574

    /// SAFETY (creator's obligations, see [`AzulPixmap::from_external`]):

575

    /// `ptr` stays valid and EXCLUSIVELY ours for the pixmap's lifetime.

576

    Borrowed {

577

        ptr: *mut u8,

578

        len: usize,

579

},

580

581

582

impl core::ops::Deref for PixBuf {

583

    type Target = [u8];

584

    #[inline]

585

264988291

    fn deref(&self) -> &[u8] {

586

264988291

        match self {

587

264988287

            Self::Owned(v) => v,

588

4

            Self::Borrowed { ptr, len } => unsafe { core::slice::from_raw_parts(*ptr, *len) },

589

590

264988291

591

592

593

impl core::ops::DerefMut for PixBuf {

594

    #[inline]

595

153113384

    fn deref_mut(&mut self) -> &mut [u8] {

596

153113384

        match self {

597

153113383

            Self::Owned(v) => v,

598

1

            Self::Borrowed { ptr, len } => unsafe { core::slice::from_raw_parts_mut(*ptr, *len) },

599

600

153113384

601

602

603

/// Byte-content equality, storage-blind (tests compare rendered frames).

604

impl PartialEq for PixBuf {

605

2

    fn eq(&self, other: &Self) -> bool {

606

2

        **self == **other

607

2

608

609

610

impl Clone for PixBuf {

611

    /// Cloning SNAPSHOTS: a borrowed frame clones to an owned copy (the

612

    /// clone must not alias the platform buffer).

613

84

    fn clone(&self) -> Self {

614

84

        Self::Owned(self.to_vec())

615

84

616

617

618

impl PixBuf {

619

    /// Take the bytes as an owned Vec (borrowed storage copies out).

620

19

    pub(crate) fn into_vec(self) -> Vec<u8> {

621

19

        match self {

622

18

            Self::Owned(v) => v,

623

1

            Self::Borrowed { .. } => self.to_vec(),

624

625

19

626

627

628

impl From<Vec<u8>> for PixBuf {

629

3955

    fn from(v: Vec<u8>) -> Self {

630

3955

        Self::Owned(v)

631

3955

632

633

634

impl core::fmt::Debug for PixBuf {

635

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

636

        match self {

637

            Self::Owned(v) => write!(f, "PixBuf::Owned({} B)", v.len()),

638

            Self::Borrowed { len, .. } => write!(f, "PixBuf::Borrowed({len} B)"),

639

640

641

642

643

// SAFETY: the raw pointer is only reachable while the creator's

644

// validity+exclusivity contract holds (from_external is unsafe); under

645

// that contract the buffer is an ordinary exclusive byte region and may

646

// move across threads with its pixmap.

647

unsafe impl Send for PixBuf {}

648

649

/// A simple RGBA pixel buffer. Replaces `tiny_skia::Pixmap`.

650

#[derive(Debug)]

651

pub struct AzulPixmap {

652

    pub(crate) data: PixBuf,

653

    /// Width in DEVICE pixels — for a render at `dpi_factor` N this is the

654

    /// logical width times N, not the logical width.

655

    pub width: u32,

656

    /// Height in DEVICE pixels. See [`AzulPixmap::width`].

657

    pub height: u32,

658

659

660

impl AzulPixmap {

661

    /// (#27) Wrap EXTERNAL storage — a platform backbuffer such as a

662

    /// mapped Wayland shm slot — as a render target, no copy, no

663

    /// ownership. Returns `None` on zero dimensions.

664

///

665

    /// # Safety

666

    /// The caller guarantees, for the ENTIRE lifetime of the returned

667

    /// pixmap (and anything it moves into): `ptr..ptr+width*height*4`

668

    /// is valid, writable, and accessed EXCLUSIVELY through this pixmap

669

    /// (for shm: the compositor has released the buffer and it will not

670

    /// be re-attached while this pixmap lives).

671

5

    pub unsafe fn from_external(ptr: *mut u8, width: u32, height: u32) -> Option<Self> {

672

5

        if width == 0 || height == 0 || ptr.is_null() {

673

3

            return None;

674

2

675

2

        let len = (width as usize)

676

2

            .checked_mul(height as usize)?

677

2

            .checked_mul(4)?;

678

2

        Some(Self {

679

2

            data: PixBuf::Borrowed { ptr, len },

680

2

            width,

681

2

            height,

682

2

})

683

5

684

685

    /// (#27) Whether this pixmap renders into borrowed platform memory.

686

    #[must_use]

687

2

    pub const fn is_external(&self) -> bool {

688

2

        matches!(self.data, PixBuf::Borrowed { .. })

689

2

690

691

    /// Create a new pixmap filled with opaque white.

692

    #[must_use]

693

3552

    pub fn new(width: u32, height: u32) -> Option<Self> {

694

3552

        if width == 0 || height == 0 {

695

21

            return None;

696

3531

697

        // checked: author-controllable dimensions (e.g. an SVG intrinsic size) can make

698

        // width*height*4 overflow usize — a debug panic, and a silently-undersized

699

        // buffer in release. Refuse absurd sizes instead.

700

3531

        let len = (width as usize)

701

3531

            .checked_mul(height as usize)

702

3531

            .and_then(|n| n.checked_mul(4))?;

703

3530

        let data = PixBuf::from(vec![255u8; len]); // opaque white

704

3530

        Some(Self {

705

3530

            data,

706

3530

            width,

707

3530

            height,

708

3530

})

709

3552

710

711

    /// Fill the entire pixmap with a single color.

712

3649

    pub fn fill(&mut self, r: u8, g: u8, b: u8, a: u8) {

713

808043361

        for chunk in self.data.chunks_exact_mut(4) {

714

808043361

            chunk[0] = r;

715

808043361

            chunk[1] = g;

716

808043361

            chunk[2] = b;

717

808043361

            chunk[3] = a;

718

808043361

719

3649

720

721

    /// Fill a rectangular region with a single color (pixel coordinates).

722

    #[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

723

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

724

                                             // names

725

10977

    pub fn fill_rect(&mut self, x: i32, y: i32, w: i32, h: i32, r: u8, g: u8, b: u8, a: u8) {

726

10977

        let pw = self.width as i32;

727

10977

        let ph = self.height as i32;

728

10977

        let x0 = x.max(0).min(pw);

729

10977

        let y0 = y.max(0).min(ph);

730

        // saturating: a non-finite/huge layout size casts to i32::MAX, and `x + w`

731

        // would then overflow (debug panic). Clamp instead.

732

        // `.clamp(x0, ..)` (not just `.max(0)`): a NEGATIVE w gives x1 < x0, and the

733

        // `data[start..end]` slice below panics on a reversed range. Force x1 >= x0.

734

10977

        let x1 = x.saturating_add(w).clamp(x0, pw);

735

10977

        let y1 = y.saturating_add(h).clamp(y0, ph);

736

1332805

        for row in y0..y1 {

737

1332805

            let start = (row * pw + x0) as usize * 4;

738

1332805

            let end = (row * pw + x1) as usize * 4;

739

1332805

            if end <= self.data.len() {

740

651742719

                for chunk in self.data[start..end].chunks_exact_mut(4) {

741

651742719

                    chunk[0] = r;

742

651742719

                    chunk[1] = g;

743

651742719

                    chunk[2] = b;

744

651742719

                    chunk[3] = a;

745

651742719

746

747

748

10977

749

750

    /// Raw RGBA pixel data.

751

    #[must_use]

752

18714

    pub fn data(&self) -> &[u8] {

753

18714

        &self.data

754

18714

755

756

    /// Mutable raw RGBA pixel data.

757

412

    pub fn data_mut(&mut self) -> &mut [u8] {

758

412

        &mut self.data

759

412

760

761

    /// Width in pixels.

762

    #[must_use]

763

36247

    pub const fn width(&self) -> u32 {

764

36247

        self.width

765

36247

766

767

    /// Height in pixels.

768

    #[must_use]

769

35665

    pub const fn height(&self) -> u32 {

770

35665

        self.height

771

35665

772

773

    /// Create a clone of this pixmap (for filter application).

774

    #[must_use]

775

83

    pub fn clone_pixmap(&self) -> Self {

776

83

        Self {

777

83

            data: self.data.clone(),

778

83

            width: self.width,

779

83

            height: self.height,

780

83

781

83

782

783

    /// Resize the pixmap preserving existing content in the top-left corner.

784

    /// New right/bottom strips are filled with the specified color.

785

    /// Only grows — returns None if new dimensions are smaller (caller should realloc).

786

15

    pub fn resize_grow_only(

787

15

        &mut self,

788

15

        new_width: u32,

789

15

        new_height: u32,

790

15

        fill_r: u8,

791

15

        fill_g: u8,

792

15

        fill_b: u8,

793

15

        fill_a: u8,

794

15

    ) -> Option<()> {

795

15

        if new_width < self.width || new_height < self.height {

796

4

            return None;

797

11

798

11

        if new_width == self.width && new_height == self.height {

799

1

            return Some(());

800

10

801

802

10

        let old_w = self.width as usize;

803

10

        let old_h = self.height as usize;

804

10

        let new_w = new_width as usize;

805

10

        let new_h = new_height as usize;

806

10

        let mut new_data = vec![fill_a; new_w * new_h * 4];

807

808

        // Fill entire buffer with fill color first (covers right + bottom strips)

809

3242428

        for chunk in new_data.chunks_exact_mut(4) {

810

3242428

            chunk[0] = fill_r;

811

3242428

            chunk[1] = fill_g;

812

3242428

            chunk[2] = fill_b;

813

3242428

            chunk[3] = fill_a;

814

3242428

815

816

        // Copy old rows into top-left corner

817

10

        let old_stride = old_w * 4;

818

10

        let new_stride = new_w * 4;

819

3304

        for row in 0..old_h {

820

3304

            let src = row * old_stride;

821

3304

            let dst = row * new_stride;

822

3304

            new_data[dst..dst + old_stride].copy_from_slice(&self.data[src..src + old_stride]);

823

3304

824

825

10

        self.data = new_data.into();

826

10

        self.width = new_width;

827

10

        self.height = new_height;

828

10

        Some(())

829

15

830

831

    /// Resize the pixmap, reusing existing content for the overlapping region.

832

    /// Works for both growing and shrinking. New areas are filled with the given color.

833

36

    pub fn resize_reuse(

834

36

        &mut self,

835

36

        new_width: u32,

836

36

        new_height: u32,

837

36

        fill_r: u8,

838

36

        fill_g: u8,

839

36

        fill_b: u8,

840

36

        fill_a: u8,

841

36

) {

842

36

        if new_width == self.width && new_height == self.height {

843

1

            return;

844

35

845

846

35

        let old_w = self.width as usize;

847

35

        let old_h = self.height as usize;

848

35

        let new_w = new_width as usize;

849

35

        let new_h = new_height as usize;

850

35

        let new_stride = new_w * 4;

851

35

        let old_stride = old_w * 4;

852

853

35

        let mut new_data = vec![0u8; new_w * new_h * 4];

854

855

        // Fill entire buffer with fill color

856

4800003

        for chunk in new_data.chunks_exact_mut(4) {

857

4800003

            chunk[0] = fill_r;

858

4800003

            chunk[1] = fill_g;

859

4800003

            chunk[2] = fill_b;

860

4800003

            chunk[3] = fill_a;

861

4800003

862

863

        // Copy overlapping region from old to new

864

35

        let copy_rows = old_h.min(new_h);

865

35

        let copy_cols_bytes = old_stride.min(new_stride);

866

5897

        for row in 0..copy_rows {

867

5897

            let src = row * old_stride;

868

5897

            let dst = row * new_stride;

869

5897

            new_data[dst..dst + copy_cols_bytes]

870

5897

                .copy_from_slice(&self.data[src..src + copy_cols_bytes]);

871

5897

872

873

35

        self.data = new_data.into();

874

35

        self.width = new_width;

875

35

        self.height = new_height;

876

36

877

878

    /// Encode to PNG using the `png` crate.

879

    /// # Errors

880

///

881

    /// Returns an error string if PNG encoding fails.

882

775

    pub fn encode_png(&self) -> Result<Vec<u8>, String> {

883

775

        let mut buf = Vec::new();

884

885

775

            let mut encoder = png::Encoder::new(&mut buf, self.width, self.height);

886

775

            encoder.set_color(png::ColorType::Rgba);

887

775

            encoder.set_depth(png::BitDepth::Eight);

888

775

            let mut writer = encoder

889

775

                .write_header()

890

775

                .map_err(|e| format!("PNG header error: {e}"))?;

891

774

            writer

892

774

                .write_image_data(&self.data)

893

774

                .map_err(|e| format!("PNG write error: {e}"))?;

894

895

774

        Ok(buf)

896

775

897

898

    /// Decode a PNG byte slice into an `AzulPixmap`.

899

    /// # Errors

900

///

901

    /// Returns an error string if `png_bytes` is not a valid PNG.

902

403

    pub fn decode_png(png_bytes: &[u8]) -> Result<Self, String> {

903

403

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

904

403

        let mut reader = decoder

905

403

            .read_info()

906

403

            .map_err(|e| format!("PNG decode error: {e}"))?;

907

382

        let buf_size = reader

908

382

            .output_buffer_size()

909

382

            .ok_or_else(|| "PNG: unknown output buffer size".to_string())?;

910

382

        let mut buf = vec![0u8; buf_size];

911

382

        let info = reader

912

382

            .next_frame(&mut buf)

913

382

            .map_err(|e| format!("PNG frame error: {e}"))?;

914

        // Require the stream to reach IEND. next_frame() returns Ok as soon as the

915

        // deflate stream has yielded enough bytes for the declared image, so a TRUNCATED

916

        // PNG still "decodes"; finish() enforces a proper end and rejects the truncation.

917

381

        reader

918

381

            .finish()

919

381

            .map_err(|e| format!("PNG truncated or corrupt: {e}"))?;

920

380

        let width = info.width;

921

380

        let height = info.height;

922

923

        // Convert to RGBA if needed

924

380

        let data = match info.color_type {

925

377

            png::ColorType::Rgba => buf[..info.buffer_size()].to_vec(),

926

            png::ColorType::Rgb => {

927

1

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

928

2

                for chunk in buf[..info.buffer_size()].chunks_exact(3) {

929

2

                    rgba.push(chunk[0]);

930

2

                    rgba.push(chunk[1]);

931

2

                    rgba.push(chunk[2]);

932

2

                    rgba.push(255);

933

2

934

1

                rgba

935

936

            png::ColorType::Grayscale => {

937

1

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

938

2

                for &v in &buf[..info.buffer_size()] {

939

2

                    rgba.push(v);

940

2

                    rgba.push(v);

941

2

                    rgba.push(v);

942

2

                    rgba.push(255);

943

2

944

1

                rgba

945

946

1

            other => return Err(format!("Unsupported PNG color type: {other:?}")),

947

};

948

949

379

        Ok(Self {

950

379

            data: data.into(),

951

379

            width,

952

379

            height,

953

379

})

954

403

955

956

957

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

958

// Pixel-diff comparison for regression testing

959

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

960

961

/// Result of comparing two pixmaps pixel-by-pixel.

962

#[derive(Copy, Debug, Clone)]

963

pub struct PixelDiffResult {

964

    /// Number of pixels that differ beyond the threshold.

965

    pub diff_count: u64,

966

    /// Total number of pixels compared.

967

    pub total_pixels: u64,

968

    /// Maximum per-channel delta found across all pixels.

969

    pub max_delta: u8,

970

    /// Whether dimensions matched.

971

    pub dimensions_match: bool,

972

    /// Width of the reference image.

973

    pub ref_width: u32,

974

    /// Height of the reference image.

975

    pub ref_height: u32,

976

    /// Width of the test image.

977

    pub test_width: u32,

978

    /// Height of the test image.

979

    pub test_height: u32,

980

981

982

impl PixelDiffResult {

983

    /// True if the images are identical within tolerance.

984

    #[must_use]

985

16

    pub const fn is_match(&self) -> bool {

986

16

        self.dimensions_match && self.diff_count == 0

987

16

988

989

    /// Fraction of pixels that differ (0.0 = identical, 1.0 = all different).

990

    #[allow(clippy::cast_precision_loss)] // bounded pixel/coord/colour/glyph cast

991

    #[must_use]

992

13

    pub fn diff_ratio(&self) -> f64 {

993

13

        if self.total_pixels == 0 {

994

3

0.0

995

        } else {

996

10

            self.diff_count as f64 / self.total_pixels as f64

997

998

13

999

1000

1001

/// Compare two pixmaps pixel-by-pixel with a per-channel tolerance.

1002

///

1003

/// `threshold` is the maximum allowed per-channel difference (0 = exact match,

1004

/// 2-3 = anti-aliasing tolerance, 10+ = loose match).

1005

#[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

1006

#[must_use]

1007

136

pub fn pixel_diff(reference: &AzulPixmap, test: &AzulPixmap, threshold: u8) -> PixelDiffResult {

1008

136

    let dimensions_match = reference.width == test.width && reference.height == test.height;

1009

136

    if !dimensions_match {

1010

2

        return PixelDiffResult {

1011

2

            diff_count: 0,

1012

2

            total_pixels: 0,

1013

2

            max_delta: 0,

1014

2

            dimensions_match: false,

1015

2

            ref_width: reference.width,

1016

2

            ref_height: reference.height,

1017

2

            test_width: test.width,

1018

2

            test_height: test.height,

1019

2

};

1020

134

1021

1022

134

    let total_pixels = u64::from(reference.width) * u64::from(reference.height);

1023

134

    let mut diff_count = 0u64;

1024

134

    let mut max_delta = 0u8;

1025

1026

5248149

    for (ref_chunk, test_chunk) in reference

1027

134

        .data

1028

134

        .chunks_exact(4)

1029

134

        .zip(test.data.chunks_exact(4))

1030

1031

5248149

        let mut pixel_differs = false;

1032

26240745

        for c in 0..4 {

1033

20992596

            let delta = (i16::from(ref_chunk[c]) - i16::from(test_chunk[c])).unsigned_abs() as u8;

1034

20992596

            if delta > threshold {

1035

102660

                pixel_differs = true;

1036

20889936

1037

20992596

            if delta > max_delta {

1038

100

                max_delta = delta;

1039

20992496

1040

1041

5248149

        if pixel_differs {

1042

45877

            diff_count += 1;

1043

5202305

1044

1045

1046

134

    PixelDiffResult {

1047

134

        diff_count,

1048

134

        total_pixels,

1049

134

        max_delta,

1050

134

        dimensions_match: true,

1051

134

        ref_width: reference.width,

1052

134

        ref_height: reference.height,

1053

134

        test_width: test.width,

1054

134

        test_height: test.height,

1055

134

1056

136

1057

1058

/// Compare a rendered pixmap against a reference PNG file.

1059

///

1060

/// Returns `Ok(result)` with the diff stats, or `Err` if the reference

1061

/// file cannot be read/decoded.

1062

/// # Errors

1063

///

1064

/// Returns an error string if the images cannot be loaded or compared.

1065

15

pub fn compare_against_reference(

1066

15

    rendered: &AzulPixmap,

1067

15

    reference_png_path: &str,

1068

15

    threshold: u8,

1069

15

) -> Result<PixelDiffResult, String> {

1070

15

    let ref_bytes = std::fs::read(reference_png_path)

1071

15

        .map_err(|e| format!("Cannot read reference image {reference_png_path}: {e}"))?;

1072

3

    let reference = AzulPixmap::decode_png(&ref_bytes)?;

1073

2

    Ok(pixel_diff(&reference, rendered, threshold))

1074

15

1075

1076

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

1077

// Simple rect type (replaces tiny_skia::Rect)

1078

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

1079

1080

#[derive(Debug, Clone, Copy)]

1081

pub struct AzRect {

1082

    pub(crate) x: f32,

1083

    pub(crate) y: f32,

1084

    pub(crate) width: f32,

1085

    pub(crate) height: f32,

1086

1087

1088

/// Intersect a freshly-pushed clip with the currently-active one.

1089

///

1090

/// `None`

1091

/// means "no clip". An EMPTY intersection clips everything (zero-area rect) —

1092

/// it must NOT degrade to `None`/unclipped, or nested clips could escape

1093

/// their parents.

1094

#[must_use]

1095

1352

pub fn intersect_clips(current: Option<AzRect>, new: Option<AzRect>) -> Option<AzRect> {

1096

1352

    match (current, new) {

1097

503

        (Some(cur), Some(new)) => {

1098

503

            let x0 = cur.x.max(new.x);

1099

503

            let y0 = cur.y.max(new.y);

1100

503

            let x1 = (cur.x + cur.width).min(new.x + new.width);

1101

503

            let y1 = (cur.y + cur.height).min(new.y + new.height);

1102

503

            Some(AzRect {

1103

503

                x: x0,

1104

503

                y: y0,

1105

503

                width: (x1 - x0).max(0.0),

1106

503

                height: (y1 - y0).max(0.0),

1107

503

})

1108

1109

1

        (Some(cur), None) => Some(cur),

1110

848

        (None, new) => new,

1111

1112

1352

1113

1114

impl AzRect {

1115

    /// A zero-area rect used as an explicit "clip away everything" value — distinct from

1116

    /// `None`, which means "no clip / unclipped".

1117

    pub(crate) const DENY_ALL: Self = Self {

1118

        x: 0.0,

1119

        y: 0.0,

1120

        width: 0.0,

1121

        height: 0.0,

1122

};

1123

1124

20409

    pub(crate) fn from_xywh(x: f32, y: f32, w: f32, h: f32) -> Option<Self> {

1125

20409

        if w <= 0.0

1126

20344

            || h <= 0.0

1127

20339

            || !x.is_finite()

1128

20313

            || !y.is_finite()

1129

20310

            || !w.is_finite()

1130

20296

            || !h.is_finite()

1131

1132

115

            return None;

1133

20294

1134

20294

        Some(Self {

1135

20294

x,

1136

20294

y,

1137

20294

            width: w,

1138

20294

            height: h,

1139

20294

})

1140

20409

1141

1142

    /// Intersect this rect with a clip rect. Returns None if fully clipped.

1143

7903

    pub(crate) fn clip(&self, clip: &Self) -> Option<Self> {

1144

7903

        let x1 = self.x.max(clip.x);

1145

7903

        let y1 = self.y.max(clip.y);

1146

7903

        let x2 = (self.x + self.width).min(clip.x + clip.width);

1147

7903

        let y2 = (self.y + self.height).min(clip.y + clip.height);

1148

7903

        if x2 > x1 && y2 > y1 {

1149

7665

            Some(Self {

1150

7665

                x: x1,

1151

7665

                y: y1,

1152

7665

                width: x2 - x1,

1153

7665

                height: y2 - y1,

1154

7665

})

1155

        } else {

1156

238

            None

1157

1158

7903

1159

1160

1161

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

1162

// AGG helper: fill a PathStorage with a solid color into an AzulPixmap

1163

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

1164

1165

/// Wraps a `VertexSource` and clamps every coordinate to a finite range the AGG

1166

/// rasterizer can handle. A coordinate of ~1e30 (or ±inf) saturates the rasterizer's

1167

/// 24.8 fixed-point conversion to ~`i32::MAX` and makes its scanline sweep run once per

1168

/// row crossed — O(coordinate magnitude), i.e. an effective hang (>1GB RAM, spins

1169

/// forever) on a large-but-legal transform or an SVG numeric attribute. Anything far

1170

/// outside the target contributes no visible pixels, so clamping it to just off-screen

1171

/// is visually equivalent and bounds the work to the visible area.

1172

struct ClampVertexSource<'a> {

1173

    inner: &'a mut dyn VertexSource,

1174

    limit: f64,

1175

1176

1177

impl VertexSource for ClampVertexSource<'_> {

1178

8585

    fn rewind(&mut self, path_id: u32) {

1179

8585

        self.inner.rewind(path_id);

1180

8585

1181

1182

237822

    fn vertex(&mut self, x: &mut f64, y: &mut f64) -> u32 {

1183

237822

        let cmd = self.inner.vertex(x, y);

1184

237822

        *x = if x.is_nan() {

1185

61

0.0

1186

        } else {

1187

237761

            x.clamp(-self.limit, self.limit)

1188

};

1189

237822

        *y = if y.is_nan() {

1190

57

0.0

1191

        } else {

1192

237765

            y.clamp(-self.limit, self.limit)

1193

};

1194

237822

cmd

1195

237822

1196

1197

1198

/// Coordinate clamp limit for a `w`×`h` target: far larger than any on-screen coordinate

1199

/// (so real geometry is untouched) yet small enough that the rasterizer's work stays

1200

/// bounded. Off-screen geometry gets pinned just outside the target.

1201

8585

fn coord_clamp_limit(w: u32, h: u32) -> f64 {

1202

8585

    (f64::from(w) + f64::from(h)).mul_add(4.0, 4096.0)

1203

8585

1204

1205

8216

pub fn agg_fill_path(

1206

8216

    pixmap: &mut AzulPixmap,

1207

8216

    path: &mut dyn VertexSource,

1208

8216

    color: &Rgba8,

1209

8216

    rule: FillingRule,

1210

8216

) {

1211

8216

    agg_fill_path_clipped(pixmap, path, color, rule, None);

1212

8216

1213

1214

/// Fill a path with an optional pixel-level clip box.

1215

///

1216

/// When `clip` is `Some`, `RendererBase::clip_box_i()` restricts all

1217

/// scanline output to the clip region.  This handles scroll-frame clips,

1218

/// border-radius is TODO (would need a mask), transforms are handled by

1219

/// transforming the clip box through the inverse transform before setting it.

1220

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)] // bounded pixel/coord/colour/glyph cast

1221

#[allow(clippy::similar_names)] // clip-box coordinate names (clip_x0/y0/x1/y1)

1222

/// Build an agg path from SVG geometry, mapping every coordinate on the way.

1223

///

1224

/// `mx`/`my` take USER SPACE to device pixels. Mapping the POINTS (rather than

1225

/// pre-transforming the path) is what lets a stroke scale correctly: a

1226

/// transform applied to the finished outline would scale the stroke WIDTH with

1227

/// it, so a 2-unit rule in a 16-unit icon would come out 8px wide in a 64px

1228

/// slot.

1229

///

1230

/// One builder for both consumers - the clip-mask rasteriser and the stroke -

1231

/// because two copies of a curve-by-curve translation drift apart silently:

1232

/// the reader only sees the shape being wrong, never which copy did it.

1233

60

pub fn svg_path_to_agg(

1234

60

    path: &azul_core::svg::SvgMultiPolygon,

1235

60

    mx: &dyn Fn(f32) -> f64,

1236

60

    my: &dyn Fn(f32) -> f64,

1237

60

) -> PathStorage {

1238

    use azul_core::svg::SvgPathElement;

1239

1240

60

    let mut out = PathStorage::new();

1241

60

    for ring in path.rings.as_ref() {

1242

60

        let mut first = true;

1243

120

        for item in ring.items.as_ref() {

1244

120

            match item {

1245

120

                SvgPathElement::Line(l) => {

1246

120

                    if first {

1247

60

                        out.move_to(mx(l.start.x), my(l.start.y));

1248

60

                        first = false;

1249

60

1250

120

                    out.line_to(mx(l.end.x), my(l.end.y));

1251

1252

                SvgPathElement::QuadraticCurve(q) => {

1253

                    if first {

1254

                        out.move_to(mx(q.start.x), my(q.start.y));

1255

                        first = false;

1256

1257

                    out.curve3(mx(q.ctrl.x), my(q.ctrl.y), mx(q.end.x), my(q.end.y));

1258

1259

                SvgPathElement::CubicCurve(c) => {

1260

                    if first {

1261

                        out.move_to(mx(c.start.x), my(c.start.y));

1262

                        first = false;

1263

1264

                    out.curve4(

1265

                        mx(c.ctrl_1.x),

1266

                        my(c.ctrl_1.y),

1267

                        mx(c.ctrl_2.x),

1268

                        my(c.ctrl_2.y),

1269

                        mx(c.end.x),

1270

                        my(c.end.y),

1271

);

1272

1273

1274

1275

1276

60

out

1277

60

1278

1279

/// The user-space -> device-pixel mapping for SVG geometry painted into

1280

/// `bounds`.

1281

///

1282

/// With a `view_box` the geometry is in the `<svg>`'s own coordinate system

1283

/// and is SCALED into the box the element ended up with, then translated to

1284

/// it. Without one the geometry is already window-logical and only the scale

1285

/// factor applies. Returns `(scale_x, scale_y, offset_x, offset_y)` in device

1286

/// px, to be used as `(x + off) * scale`-style closures by the caller.

1287

#[must_use]

1288

60

pub fn svg_user_space_mapping(

1289

60

    bounds: &LogicalRect,

1290

60

    view_box: Option<(f32, f32, f32, f32)>,

1291

60

    dpi_factor: f32,

1292

60

) -> (f32, f32, f32, f32) {

1293

60

    match view_box {

1294

60

        Some((min_x, min_y, vb_w, vb_h)) if vb_w > 0.0 && vb_h > 0.0 => (

1295

60

            bounds.size.width * dpi_factor / vb_w,

1296

60

            bounds.size.height * dpi_factor / vb_h,

1297

60

            -min_x,

1298

60

            -min_y,

1299

60

),

1300

        _ => (dpi_factor, dpi_factor, 0.0, 0.0),

1301

1302

60

1303

1304

8560

pub fn agg_fill_path_clipped(

1305

8560

    pixmap: &mut AzulPixmap,

1306

8560

    path: &mut dyn VertexSource,

1307

8560

    color: &Rgba8,

1308

8560

    rule: FillingRule,

1309

8560

    clip: Option<AzRect>,

1310

8560

) {

1311

8560

    let w = pixmap.width;

1312

8560

    let h = pixmap.height;

1313

8560

    let stride = (w * 4) as i32;

1314

8560

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

1315

8560

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

1316

8560

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

1317

8560

    if let Some(c) = clip {

1318

        // A degenerate (non-positive-area) clip means "nothing visible". Bail BEFORE

1319

        // building the integer clip box: `(c.x + c.width) as i32 - 1` for width 0 is

1320

        // `c.x - 1`, an INVERTED box that clip_box_i()'s normalize() silently repairs

1321

        // into a small VALID box — so an empty clip used to paint a few pixels.

1322

80

        if c.width <= 0.0 || c.height <= 0.0 {

1323

2

            return;

1324

78

1325

78

        rb.clip_box_i(

1326

78

            c.x as i32,

1327

78

            c.y as i32,

1328

78

            (c.x + c.width) as i32 - 1,

1329

78

            (c.y + c.height) as i32 - 1,

1330

);

1331

8480

1332

8558

    let mut ras = RasterizerScanlineAa::new();

1333

8558

    ras.filling_rule(rule);

1334

    // Clip GEOMETRY to the target pixmap (intersected with any caller clip) before

1335

    // rasterizing. Without this, the scanline sweep runs once per row the path crosses,

1336

    // so a huge/infinite coordinate — reachable from a large-but-legal CSS transform or

1337

    // SVG attribute — is O(coordinate magnitude), i.e. an effective hang. Clamping the

1338

    // rasterizer's clip box bounds the work to the visible area.

1339

8558

    let (clip_x0, clip_y0, clip_x1, clip_y1) = clip.map_or_else(

1340

8480

        || (0.0, 0.0, f64::from(w), f64::from(h)),

1341

78

        |c| {

1342

78

1343

78

                f64::from(c.x).max(0.0),

1344

78

                f64::from(c.y).max(0.0),

1345

78

                f64::from(c.x + c.width).min(f64::from(w)),

1346

78

                f64::from(c.y + c.height).min(f64::from(h)),

1347

78

1348

78

},

1349

);

1350

8558

    ras.clip_box(clip_x0, clip_y0, clip_x1, clip_y1);

1351

    // Clamp coordinates before rasterizing — see ClampVertexSource. This is the actual

1352

    // guard against the huge/infinite-coordinate hang (the rasterizer's own clip_box

1353

    // above does not bound the work for saturated fixed-point coords).

1354

8558

    let mut clamped = ClampVertexSource {

1355

8558

        inner: path,

1356

8558

        limit: coord_clamp_limit(w, h),

1357

8558

};

1358

8558

    ras.add_path(&mut clamped, 0);

1359

8558

    let mut sl = ScanlineU8::new();

1360

8558

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

1361

8560

1362

1363

#[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot

1364

                                             // pixel/coord path or to avoid churning call sites for

1365

                                             // a perf-neutral change)

1366

4

fn agg_fill_transformed_path(

1367

4

    pixmap: &mut AzulPixmap,

1368

4

    path: &mut PathStorage,

1369

4

    color: &Rgba8,

1370

4

    rule: FillingRule,

1371

4

    transform: &TransAffine,

1372

4

) {

1373

4

    agg_fill_transformed_path_clipped(pixmap, path, color, rule, transform, None);

1374

4

1375

1376

#[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot

1377

                                             // pixel/coord path or to avoid churning call sites for

1378

                                             // a perf-neutral change)

1379

6

fn agg_fill_transformed_path_clipped(

1380

6

    pixmap: &mut AzulPixmap,

1381

6

    path: &mut PathStorage,

1382

6

    color: &Rgba8,

1383

6

    rule: FillingRule,

1384

6

    transform: &TransAffine,

1385

6

    clip: Option<AzRect>,

1386

6

) {

1387

6

    if transform.is_identity(IDENTITY_EPSILON_F64) {

1388

2

        agg_fill_path_clipped(pixmap, path, color, rule, clip);

1389

4

    } else {

1390

4

        let mut transformed = ConvTransform::new(path, *transform);

1391

4

        agg_fill_path_clipped(pixmap, &mut transformed, color, rule, clip);

1392

4

1393

6

1394

1395

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

1396

// AGG helper: fill a path with a gradient into an AzulPixmap

1397

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

1398

1399

3

fn agg_fill_gradient<G: GradientFunction>(

1400

3

    pixmap: &mut AzulPixmap,

1401

3

    path: &mut dyn VertexSource,

1402

3

    lut: &GradientLut,

1403

3

    gradient_fn: G,

1404

3

    transform: TransAffine,

1405

3

    d1: f64,

1406

3

    d2: f64,

1407

3

) {

1408

3

    agg_fill_gradient_clipped(pixmap, path, lut, gradient_fn, transform, d1, d2, None);

1409

3

1410

1411

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)] // bounded pixel/coord/colour/glyph cast

1412

#[allow(clippy::similar_names)] // clip-box / gradient coordinate names (clip_x0/y0/x1/y1, d1/d2)

1413

28

pub fn agg_fill_gradient_clipped<G: GradientFunction>(

1414

28

    pixmap: &mut AzulPixmap,

1415

28

    path: &mut dyn VertexSource,

1416

28

    lut: &GradientLut,

1417

28

    gradient_fn: G,

1418

28

    transform: TransAffine,

1419

28

    d1: f64,

1420

28

    d2: f64,

1421

28

    clip: Option<AzRect>,

1422

28

) {

1423

28

    let w = pixmap.width;

1424

28

    let h = pixmap.height;

1425

28

    let stride = (w * 4) as i32;

1426

28

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

1427

28

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

1428

28

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

1429

28

    if let Some(c) = clip {

1430

        // Degenerate clip = nothing visible; bail before the inverted-box trap (see

1431

        // agg_fill_path_clipped).

1432

2

        if c.width <= 0.0 || c.height <= 0.0 {

1433

1

            return;

1434

1

1435

1

        rb.clip_box_i(

1436

1

            c.x as i32,

1437

1

            c.y as i32,

1438

1

            (c.x + c.width) as i32 - 1,

1439

1

            (c.y + c.height) as i32 - 1,

1440

);

1441

26

1442

27

    let mut ras = RasterizerScanlineAa::new();

1443

27

    ras.filling_rule(FillingRule::NonZero);

1444

27

    let (clip_x0, clip_y0, clip_x1, clip_y1) = clip.map_or_else(

1445

26

        || (0.0, 0.0, f64::from(w), f64::from(h)),

1446

1

        |c| {

1447

1

1448

1

                f64::from(c.x).max(0.0),

1449

1

                f64::from(c.y).max(0.0),

1450

1

                f64::from(c.x + c.width).min(f64::from(w)),

1451

1

                f64::from(c.y + c.height).min(f64::from(h)),

1452

1

1453

1

},

1454

);

1455

27

    ras.clip_box(clip_x0, clip_y0, clip_x1, clip_y1);

1456

27

    let mut clamped = ClampVertexSource {

1457

27

        inner: path,

1458

27

        limit: coord_clamp_limit(w, h),

1459

27

};

1460

27

    ras.add_path(&mut clamped, 0);

1461

27

    let mut sl = ScanlineU8::new();

1462

1463

27

    let interp = SpanInterpolatorLinear::new(transform);

1464

    // Clamp gradient distances to a range ALL of SpanGradient's internal i32 math can

1465

    // hold. It rounds d1/d2 to 24.8 fixed-point AND later computes `(d - d1) * color_size`

1466

    // (span_gradient.rs) — with color_size 256 and the extra ×256 of fixed-point, even a

1467

    // few-million value overflows i32. ±8192 keeps every product in range and is far

1468

    // beyond any real gradient extent (callers pass 0..100); pathological NaN/±inf/f64::MAX

1469

    // just pin to the edge.

1470

54

    let clamp_d = |d: f64| {

1471

54

        if d.is_nan() {

1472

3

0.0

1473

        } else {

1474

51

            d.clamp(-8192.0, 8192.0)

1475

1476

54

};

1477

27

    let mut sg = SpanGradient::new(interp, gradient_fn, lut, clamp_d(d1), clamp_d(d2));

1478

27

    let mut alloc = SpanAllocator::<Rgba8>::new();

1479

27

    render_scanlines_aa(&mut ras, &mut sl, &mut rb, &mut alloc, &mut sg);

1480

28

1481

1482

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

1483

// Gradient helpers

1484

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

1485

1486

#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1487

/// [`blit_buffer`] restricted to a sub-rectangle of the SOURCE buffer.

1488

/// `(sx, sy, w, h)` select the source region; `(dx, dy)` is where that

1489

/// region's top-left lands in `dst`. Exists for the box-shadow ring blit:

1490

/// an outset shadow must not paint inside the border box (CSS), and the

1491

/// interior of a page-sized shadow buffer is the single largest

1492

/// alpha-blend a repaint used to do.

1493

198

pub fn blit_buffer_sub(

1494

198

    dst: &mut AzulPixmap,

1495

198

    src: &[u8],

1496

198

    src_w: u32,

1497

198

    src_h: u32,

1498

198

    sx: u32,

1499

198

    sy: u32,

1500

198

    w: u32,

1501

198

    h: u32,

1502

198

    dx: i32,

1503

198

    dy: i32,

1504

198

) {

1505

198

    let dw = dst.width as i32;

1506

198

    let dh = dst.height as i32;

1507

198

    let x_end = sx.saturating_add(w).min(src_w);

1508

198

    let y_end = sy.saturating_add(h).min(src_h);

1509

1510

5953

    for py in sy..y_end {

1511

5953

        let ty = dy.saturating_add((py - sy) as i32);

1512

5953

        if ty < 0 || ty >= dh {

1513

            continue;

1514

5953

1515

107051

        for px in sx..x_end {

1516

107051

            let tx = dx.saturating_add((px - sx) as i32);

1517

107051

            if tx < 0 || tx >= dw {

1518

                continue;

1519

107051

1520

107051

            let si = ((py * src_w + px) * 4) as usize;

1521

107051

            let di = ((ty as u32 * dst.width + tx as u32) * 4) as usize;

1522

107051

            if si + 3 >= src.len() || di + 3 >= dst.data.len() {

1523

                continue;

1524

107051

1525

107051

            let sa = u32::from(src[si + 3]);

1526

107051

            if sa == 0 {

1527

5768

                continue;

1528

101283

1529

101283

            if sa == 255 {

1530

1335

                dst.data[di] = src[si];

1531

1335

                dst.data[di + 1] = src[si + 1];

1532

1335

                dst.data[di + 2] = src[si + 2];

1533

1335

                dst.data[di + 3] = 255;

1534

99948

            } else {

1535

99948

                let inv_sa = 255 - sa;

1536

99948

                dst.data[di] =

1537

99948

                    ((u32::from(src[si]) + u32::from(dst.data[di]) * inv_sa / 255).min(255)) as u8;

1538

99948

                dst.data[di + 1] = ((u32::from(src[si + 1])

1539

99948

                    + u32::from(dst.data[di + 1]) * inv_sa / 255)

1540

99948

                    .min(255)) as u8;

1541

99948

                dst.data[di + 2] = ((u32::from(src[si + 2])

1542

99948

                    + u32::from(dst.data[di + 2]) * inv_sa / 255)

1543

99948

                    .min(255)) as u8;

1544

99948

                dst.data[di + 3] =

1545

99948

                    ((sa + u32::from(dst.data[di + 3]) * inv_sa / 255).min(255)) as u8;

1546

99948

1547

1548

1549

198

1550

1551

/// Alpha-blend one premultiplied-alpha RGBA buffer onto another at (dx, dy).

1552

#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1553

19

pub fn blit_buffer(dst: &mut AzulPixmap, src: &[u8], src_w: u32, src_h: u32, dx: i32, dy: i32) {

1554

19

    let dw = dst.width as i32;

1555

19

    let dh = dst.height as i32;

1556

1557

241

    for py in 0..src_h as i32 {

1558

        // saturating: see blit_pixmap — a saturated offset just fails the bounds check.

1559

241

        let ty = dy.saturating_add(py);

1560

241

        if ty < 0 || ty >= dh {

1561

7

            continue;

1562

234

1563

44031

        for px in 0..src_w as i32 {

1564

44031

            let tx = dx.saturating_add(px);

1565

44031

            if tx < 0 || tx >= dw {

1566

5

                continue;

1567

44026

1568

1569

44026

            let si = ((py as u32 * src_w + px as u32) * 4) as usize;

1570

44026

            let di = ((ty as u32 * dst.width + tx as u32) * 4) as usize;

1571

1572

44026

            if si + 3 >= src.len() || di + 3 >= dst.data.len() {

1573

18

                continue;

1574

44008

1575

1576

44008

            let sa = u32::from(src[si + 3]);

1577

44008

            if sa == 0 {

1578

42083

                continue;

1579

1925

1580

1925

            if sa == 255 {

1581

253

                dst.data[di] = src[si];

1582

253

                dst.data[di + 1] = src[si + 1];

1583

253

                dst.data[di + 2] = src[si + 2];

1584

253

                dst.data[di + 3] = 255;

1585

1672

            } else {

1586

1672

                // Premultiplied-alpha compositing: src RGB already premultiplied by AGG

1587

1672

                let inv_sa = 255 - sa;

1588

1672

                dst.data[di] =

1589

1672

                    ((u32::from(src[si]) + u32::from(dst.data[di]) * inv_sa / 255).min(255)) as u8;

1590

1672

                dst.data[di + 1] = ((u32::from(src[si + 1])

1591

1672

                    + u32::from(dst.data[di + 1]) * inv_sa / 255)

1592

1672

                    .min(255)) as u8;

1593

1672

                dst.data[di + 2] = ((u32::from(src[si + 2])

1594

1672

                    + u32::from(dst.data[di + 2]) * inv_sa / 255)

1595

1672

                    .min(255)) as u8;

1596

1672

                dst.data[di + 3] =

1597

1672

                    ((sa + u32::from(dst.data[di + 3]) * inv_sa / 255).min(255)) as u8;

1598

1672

1599

1600

1601

19

1602

1603

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

1604

// Image mask clipping

1605

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

1606

1607

/// Take a snapshot of a rectangular region of the pixmap.

1608

#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1609

#[must_use]

1610

202

pub fn snapshot_region(pixmap: &AzulPixmap, x: i32, y: i32, w: u32, h: u32) -> Vec<u8> {

1611

202

    let pw = pixmap.width as i32;

1612

202

    let ph = pixmap.height as i32;

1613

202

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

1614

1615

7949

    for py in 0..h as i32 {

1616

        // saturating: an extreme snapshot origin would overflow a plain `+`.

1617

7949

        let sy = y.saturating_add(py);

1618

7949

        if sy < 0 || sy >= ph {

1619

50

            continue;

1620

7899

1621

720037

        for px in 0..w as i32 {

1622

720037

            let sx = x.saturating_add(px);

1623

720037

            if sx < 0 || sx >= pw {

1624

10

                continue;

1625

720027

1626

720027

            let si = ((sy as u32 * pixmap.width + sx as u32) * 4) as usize;

1627

720027

            let di = ((py as u32 * w + px as u32) * 4) as usize;

1628

720027

            if si + 3 < pixmap.data.len() && di + 3 < snap.len() {

1629

720027

                snap[di] = pixmap.data[si];

1630

720027

                snap[di + 1] = pixmap.data[si + 1];

1631

720027

                snap[di + 2] = pixmap.data[si + 2];

1632

720027

                snap[di + 3] = pixmap.data[si + 3];

1633

720027

1634

1635

1636

202

    snap

1637

202

1638

1639

/// Overwrite (direct copy, no alpha blending) a `w`×`h` RGBA region of `dst` at

1640

/// `(x, y)` with the pixels in `src`.

1641

///

1642

/// Out-of-bounds pixels are skipped. This is the inverse of [`snapshot_region`]

1643

/// and is used to write a filtered backdrop copy back into the output buffer for

1644

/// `backdrop-filter`.

1645

// bounded image-dimension / non-negative-loop-index coordinate casts

1646

#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]

1647

12

pub fn write_region(dst: &mut AzulPixmap, src: &[u8], w: u32, h: u32, x: i32, y: i32) {

1648

12

    let dw = dst.width as i32;

1649

12

    let dh = dst.height as i32;

1650

119

    for py in 0..h as i32 {

1651

        // saturating: an extreme write-region origin would overflow a plain `+`.

1652

119

        let dy = y.saturating_add(py);

1653

119

        if dy < 0 || dy >= dh {

1654

6

            continue;

1655

113

1656

5036

        for px in 0..w as i32 {

1657

5036

            let dx = x.saturating_add(px);

1658

5036

            if dx < 0 || dx >= dw {

1659

6

                continue;

1660

5030

1661

5030

            let si = ((py as u32 * w + px as u32) * 4) as usize;

1662

5030

            let di = ((dy as u32 * dst.width + dx as u32) * 4) as usize;

1663

5030

            if si + 3 < src.len() && di + 3 < dst.data.len() {

1664

5015

                dst.data[di] = src[si];

1665

5015

                dst.data[di + 1] = src[si + 1];

1666

5015

                dst.data[di + 2] = src[si + 2];

1667

5015

                dst.data[di + 3] = src[si + 3];

1668

5015

1669

1670

1671

12

1672

1673

#[must_use]

1674

6912

pub fn union_rect(a: &LogicalRect, b: &LogicalRect) -> LogicalRect {

1675

6912

    let x = a.origin.x.min(b.origin.x);

1676

6912

    let y = a.origin.y.min(b.origin.y);

1677

6912

    let right = (a.origin.x + a.size.width).max(b.origin.x + b.size.width);

1678

6912

    let bottom = (a.origin.y + a.size.height).max(b.origin.y + b.size.height);

1679

6912

    LogicalRect {

1680

6912

        origin: LogicalPosition { x, y },

1681

6912

        size: LogicalSize {

1682

6912

            width: right - x,

1683

6912

            height: bottom - y,

1684

6912

},

1685

6912

1686

6912

1687

1688

#[must_use]

1689

16843

pub fn logical_rect_to_az_rect(bounds: &LogicalRect, dpi_factor: f32) -> Option<AzRect> {

1690

16843

    let x = bounds.origin.x * dpi_factor;

1691

16843

    let y = bounds.origin.y * dpi_factor;

1692

16843

    let width = bounds.size.width * dpi_factor;

1693

16843

    let height = bounds.size.height * dpi_factor;

1694

1695

16843

    AzRect::from_xywh(x, y, width, height)

1696

16843

1697

1698

#[cfg(test)]

1699

#[allow(clippy::many_single_char_names, clippy::float_cmp)]

1700

mod autotest_generated {

1701

    use agg_rust::span_gradient::GradientX;

1702

1703

    use super::*;

1704

1705

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

1706

    // helpers

1707

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

1708

1709

    const WHITE: [u8; 4] = [255, 255, 255, 255];

1710

    const CLEAR: [u8; 4] = [0, 0, 0, 0];

1711

1712

    fn pm(w: u32, h: u32) -> AzulPixmap {

1713

        AzulPixmap::new(w, h).expect("AzulPixmap::new failed for a valid size")

1714

1715

1716

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

1717

    // blit_pixmap_projective

1718

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

1719

1720

    fn opaque_run(dst: &AzulPixmap, row: u32) -> u32 {

1721

        (0..dst.width)

1722

            .filter(|&x| dst.data[((row * dst.width + x) * 4 + 3) as usize] > 128)

1723

            .count() as u32

1724

1725

1726

    #[test]

1727

    fn the_projective_blit_equals_the_affine_blit_for_an_affine_homography() {

1728

        let mut src = pm(6, 4);

1729

        src.fill(200, 40, 90, 255);

1730

        let m = TransAffine::new_custom(1.5, 0.2, -0.1, 0.8, 7.0, 5.0);

1731

        let mut a = pm(24, 16);

1732

        a.fill(0, 0, 0, 0);

1733

        blit_pixmap_affine(&src, &mut a, &m, 0.9);

1734

        let mut b = pm(24, 16);

1735

        b.fill(0, 0, 0, 0);

1736

        // agg: x' = x*sx + y*shx + tx ; y' = x*shy + y*sy + ty

1737

        let h = [m.sx, m.shx, m.tx, m.shy, m.sy, m.ty, 0.0, 0.0, 1.0];

1738

        blit_pixmap_projective(&src, &mut b, &h, 0.9);

1739

        assert_eq!(

1740

            a.data, b.data,

1741

            "with a trivial third row the two blits are the same blit"

1742

);

1743

1744

1745

    #[test]

1746

    fn a_perspective_homography_foreshortens_into_a_trapezoid() {

1747

        // w = 1 + 0.06 y: rows further down are divided more, so the square

1748

        // comes out narrower (and shorter) towards the bottom — a tilt.

1749

        let mut src = pm(20, 20);

1750

        src.fill(255, 255, 255, 255);

1751

        let mut dst = pm(40, 40);

1752

        dst.fill(0, 0, 0, 0);

1753

        let h = [1.0, 0.0, 10.0, 0.0, 1.0, 10.0, 0.0, 0.06, 1.0];

1754

        blit_pixmap_projective(&src, &mut dst, &h, 1.0);

1755

        let top = opaque_run(&dst, 10);

1756

        let painted_rows: Vec<u32> = (0..40).filter(|&r| opaque_run(&dst, r) > 0).collect();

1757

        let last = *painted_rows.last().expect("something was painted");

1758

        let bottom = opaque_run(&dst, last);

1759

        assert!(

1760

            top > bottom,

1761

            "top row {top} px wide must be wider than the last painted row {bottom} px"

1762

);

1763

        assert!(top >= 17 && bottom <= 14, "top {top}, bottom {bottom}");

1764

        assert!(

1765

            last < 20,

1766

            "the bottom edge moved UP (y' = 30 / 2.2): last painted row {last}"

1767

);

1768

        // nothing outside the destination and nothing behind the eye panics

1769

        let mut tiny = pm(2, 2);

1770

        blit_pixmap_projective(

1771

            &src,

1772

            &mut tiny,

1773

            &[1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0, 1.0],

1774

            1.0,

1775

);

1776

        blit_pixmap_projective(&src, &mut tiny, &[0.0; 9], 1.0);

1777

1778

1779

    fn filled(w: u32, h: u32, c: [u8; 4]) -> AzulPixmap {

1780

        let mut p = pm(w, h);

1781

        p.fill(c[0], c[1], c[2], c[3]);

1782

1783

1784

1785

    /// A pixmap whose R channel encodes `y * width + x` — makes shifts/copies verifiable.

1786

    fn marked(w: u32, h: u32) -> AzulPixmap {

1787

        let mut p = pm(w, h);

1788

        for y in 0..h {

1789

            for x in 0..w {

1790

                let idx = u8::try_from(y * w + x).expect("marker fits in u8");

1791

                set(&mut p, x, y, [idx, 0, 0, 255]);

1792

1793

1794

1795

1796

1797

    /// A pixmap with width == height == 0 (only reachable via `resize_reuse`, never `new`).

1798

    fn zero_sized() -> AzulPixmap {

1799

        let mut p = pm(2, 2);

1800

        p.resize_reuse(0, 0, 0, 0, 0, 0);

1801

1802

1803

1804

    /// Number of pixels that are no longer opaque white.

1805

    fn painted_count(p: &AzulPixmap) -> usize {

1806

        p.data()

1807

            .chunks_exact(4)

1808

            .filter(|c| c[0] != 255 || c[1] != 255 || c[2] != 255 || c[3] != 255)

1809

            .count()

1810

1811

1812

    fn get(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

1813

        let i = ((y * p.width() + x) * 4) as usize;

1814

        let d = p.data();

1815

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

1816

1817

1818

    fn set(p: &mut AzulPixmap, x: u32, y: u32, c: [u8; 4]) {

1819

        let i = ((y * p.width() + x) * 4) as usize;

1820

        p.data_mut()[i..i + 4].copy_from_slice(&c);

1821

1822

1823

    fn lrect(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

1824

        LogicalRect {

1825

            origin: LogicalPosition { x, y },

1826

            size: LogicalSize {

1827

                width: w,

1828

                height: h,

1829

},

1830

1831

1832

1833

    fn approx(a: f32, b: f32) -> bool {

1834

        (a - b).abs() < 1e-4

1835

1836

1837

    fn rect_path(x: f64, y: f64, w: f64, h: f64) -> PathStorage {

1838

        let mut p = PathStorage::new();

1839

        p.move_to(x, y);

1840

        p.line_to(x + w, y);

1841

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

1842

        p.line_to(x, y + h);

1843

        p.close_polygon(0);

1844

1845

1846

1847

    fn red() -> Rgba8 {

1848

        Rgba8::new(255, 0, 0, 255)

1849

1850

1851

    fn two_stop_lut() -> GradientLut {

1852

        let mut lut = GradientLut::new(256);

1853

        lut.add_color(0.0, Rgba8::new(255, 0, 0, 255));

1854

        lut.add_color(1.0, Rgba8::new(0, 0, 255, 255));

1855

        lut.build_lut();

1856

lut

1857

1858

1859

    /// Encode a PNG with an arbitrary colour type, so `decode_png`'s non-RGBA

1860

    /// branches get a positive (and a negative) control.

1861

    fn encode_custom_png(w: u32, h: u32, ct: png::ColorType, data: &[u8]) -> Vec<u8> {

1862

        let mut buf = Vec::new();

1863

1864

            let mut enc = png::Encoder::new(&mut buf, w, h);

1865

            enc.set_color(ct);

1866

            enc.set_depth(png::BitDepth::Eight);

1867

            let mut wr = enc.write_header().expect("test PNG header");

1868

            wr.write_image_data(data).expect("test PNG data");

1869

1870

buf

1871

1872

1873

    fn temp_path(tag: &str) -> std::path::PathBuf {

1874

        std::env::temp_dir().join(format!(

1875

            "azul_autotest_pixmap_{}_{tag}.bin",

1876

            std::process::id()

1877

))

1878

1879

1880

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

1881

    // rect_intersection (numeric)

1882

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

1883

1884

    #[test]

1885

    fn rect_intersection_overlap_is_the_common_area() {

1886

        let a = lrect(0.0, 0.0, 10.0, 10.0);

1887

        let b = lrect(5.0, 5.0, 10.0, 10.0);

1888

        let i = rect_intersection(&a, &b).expect("rects overlap");

1889

        assert!(approx(i.origin.x, 5.0));

1890

        assert!(approx(i.origin.y, 5.0));

1891

        assert!(approx(i.size.width, 5.0));

1892

        assert!(approx(i.size.height, 5.0));

1893

1894

1895

    #[test]

1896

    fn rect_intersection_is_commutative() {

1897

        let a = lrect(-3.0, 2.0, 8.0, 4.0);

1898

        let b = lrect(1.0, 1.0, 9.0, 9.0);

1899

        let ab = rect_intersection(&a, &b).expect("overlap");

1900

        let ba = rect_intersection(&b, &a).expect("overlap");

1901

        assert!(approx(ab.origin.x, ba.origin.x));

1902

        assert!(approx(ab.origin.y, ba.origin.y));

1903

        assert!(approx(ab.size.width, ba.size.width));

1904

        assert!(approx(ab.size.height, ba.size.height));

1905

1906

1907

    #[test]

1908

    fn rect_intersection_zero_sized_rect_is_none() {

1909

        let a = lrect(0.0, 0.0, 0.0, 0.0);

1910

        let b = lrect(0.0, 0.0, 10.0, 10.0);

1911

        // A zero-area rect can never satisfy `x2 > x1 && y2 > y1`.

1912

        assert!(rect_intersection(&a, &b).is_none());

1913

        assert!(rect_intersection(&b, &a).is_none());

1914

1915

1916

    #[test]

1917

    fn rect_intersection_touching_edges_is_none() {

1918

        // a's right edge == b's left edge: zero-width overlap, not an intersection.

1919

        let a = lrect(0.0, 0.0, 5.0, 5.0);

1920

        let b = lrect(5.0, 0.0, 5.0, 5.0);

1921

        assert!(rect_intersection(&a, &b).is_none());

1922

1923

1924

    #[test]

1925

    fn rect_intersection_disjoint_is_none() {

1926

        let a = lrect(0.0, 0.0, 1.0, 1.0);

1927

        let b = lrect(100.0, 100.0, 1.0, 1.0);

1928

        assert!(rect_intersection(&a, &b).is_none());

1929

1930

1931

    #[test]

1932

    fn rect_intersection_negative_coordinates() {

1933

        let a = lrect(-10.0, -10.0, 5.0, 5.0);

1934

        let b = lrect(-7.0, -7.0, 5.0, 5.0);

1935

        let i = rect_intersection(&a, &b).expect("overlap in negative quadrant");

1936

        assert!(approx(i.origin.x, -7.0));

1937

        assert!(approx(i.origin.y, -7.0));

1938

        assert!(approx(i.size.width, 2.0));

1939

        assert!(approx(i.size.height, 2.0));

1940

1941

1942

    #[test]

1943

    fn rect_intersection_result_never_exceeds_either_input() {

1944

        let a = lrect(-1.0, -1.0, 3.0, 100.0);

1945

        let b = lrect(0.0, 0.0, 100.0, 3.0);

1946

        let i = rect_intersection(&a, &b).expect("overlap");

1947

        assert!(i.size.width <= a.size.width && i.size.width <= b.size.width);

1948

        assert!(i.size.height <= a.size.height && i.size.height <= b.size.height);

1949

1950

1951

    #[test]

1952

    fn rect_intersection_f32_max_does_not_panic() {

1953

        let a = lrect(0.0, 0.0, f32::MAX, f32::MAX);

1954

        let b = lrect(0.0, 0.0, f32::MAX, f32::MAX);

1955

        let i = rect_intersection(&a, &b).expect("both cover the same huge area");

1956

        assert!(i.size.width > 0.0 && i.size.height > 0.0);

1957

1958

1959

    #[test]

1960

    fn rect_intersection_nan_does_not_panic_and_stays_finite() {

1961

        let nan = lrect(f32::NAN, f32::NAN, f32::NAN, f32::NAN);

1962

        let ok = lrect(0.0, 0.0, 10.0, 10.0);

1963

        // f32::max/min ignore NaN, so the NaN rect degrades to "the other rect".

1964

        // The only hard requirement: no panic, and no NaN leaking into the result.

1965

        for r in [

1966

            rect_intersection(&nan, &ok),

1967

            rect_intersection(&ok, &nan),

1968

            rect_intersection(&nan, &nan),

1969

1970

        .into_iter()

1971

        .flatten()

1972

1973

            assert!(!r.size.width.is_nan(), "NaN width leaked out: {r:?}");

1974

            assert!(!r.size.height.is_nan(), "NaN height leaked out: {r:?}");

1975

            assert!(r.size.width >= 0.0 && r.size.height >= 0.0);

1976

1977

1978

1979

    #[test]

1980

    fn rect_intersection_infinite_size_does_not_panic() {

1981

        let inf = lrect(0.0, 0.0, f32::INFINITY, f32::INFINITY);

1982

        let ok = lrect(2.0, 2.0, 4.0, 4.0);

1983

        let i = rect_intersection(&inf, &ok).expect("infinite rect contains the finite one");

1984

        assert!(approx(i.size.width, 4.0));

1985

        assert!(approx(i.size.height, 4.0));

1986

1987

1988

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

1989

    // union_rect (numeric)

1990

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

1991

1992

    #[test]

1993

    fn union_rect_covers_both_inputs() {

1994

        let a = lrect(0.0, 0.0, 2.0, 2.0);

1995

        let b = lrect(8.0, 8.0, 2.0, 2.0);

1996

        let u = union_rect(&a, &b);

1997

        assert!(approx(u.origin.x, 0.0));

1998

        assert!(approx(u.origin.y, 0.0));

1999

        assert!(approx(u.size.width, 10.0));

2000

        assert!(approx(u.size.height, 10.0));

2001

2002

2003

    #[test]

2004

    fn union_rect_with_self_is_identity() {

2005

        let a = lrect(3.0, 4.0, 5.0, 6.0);

2006

        let u = union_rect(&a, &a);

2007

        assert!(approx(u.origin.x, 3.0) && approx(u.origin.y, 4.0));

2008

        assert!(approx(u.size.width, 5.0) && approx(u.size.height, 6.0));

2009

2010

2011

    #[test]

2012

    fn union_rect_negative_origins() {

2013

        let a = lrect(-5.0, -5.0, 1.0, 1.0);

2014

        let b = lrect(5.0, 5.0, 1.0, 1.0);

2015

        let u = union_rect(&a, &b);

2016

        assert!(approx(u.origin.x, -5.0));

2017

        assert!(approx(u.size.width, 11.0));

2018

        assert!(approx(u.size.height, 11.0));

2019

2020

2021

    #[test]

2022

    fn union_rect_zero_size_still_extends_bounds() {

2023

        // A zero-area rect at (20, 20) must still push the union's extent out to 20.

2024

        let a = lrect(0.0, 0.0, 1.0, 1.0);

2025

        let b = lrect(20.0, 20.0, 0.0, 0.0);

2026

        let u = union_rect(&a, &b);

2027

        assert!(approx(u.size.width, 20.0));

2028

        assert!(approx(u.size.height, 20.0));

2029

2030

2031

    #[test]

2032

    fn union_rect_never_shrinks_below_its_inputs() {

2033

        let a = lrect(1.0, 1.0, 4.0, 4.0);

2034

        let b = lrect(2.0, 2.0, 1.0, 1.0); // fully inside a

2035

        let u = union_rect(&a, &b);

2036

        assert!(u.size.width >= a.size.width);

2037

        assert!(u.size.height >= a.size.height);

2038

2039

2040

    #[test]

2041

    fn union_rect_infinite_inputs_do_not_panic() {

2042

        let a = lrect(0.0, 0.0, f32::INFINITY, f32::INFINITY);

2043

        let b = lrect(1.0, 1.0, 1.0, 1.0);

2044

        let u = union_rect(&a, &b);

2045

        assert!(u.size.width.is_infinite());

2046

        assert!(u.size.height.is_infinite());

2047

2048

2049

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

2050

    // logical_rect_to_az_rect + AzRect::from_xywh (constructor / numeric)

2051

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

2052

2053

    #[test]

2054

    fn logical_rect_to_az_rect_scales_by_dpi() {

2055

        let r = lrect(1.0, 2.0, 3.0, 4.0);

2056

        let a = logical_rect_to_az_rect(&r, 2.0).expect("positive size");

2057

        assert!(approx(a.x, 2.0));

2058

        assert!(approx(a.y, 4.0));

2059

        assert!(approx(a.width, 6.0));

2060

        assert!(approx(a.height, 8.0));

2061

2062

2063

    #[test]

2064

    fn logical_rect_to_az_rect_zero_dpi_is_none() {

2065

        // dpi 0 collapses the rect to zero area -> from_xywh rejects it.

2066

        let r = lrect(1.0, 2.0, 3.0, 4.0);

2067

        assert!(logical_rect_to_az_rect(&r, 0.0).is_none());

2068

2069

2070

    #[test]

2071

    fn logical_rect_to_az_rect_negative_dpi_is_none() {

2072

        let r = lrect(1.0, 2.0, 3.0, 4.0);

2073

        assert!(logical_rect_to_az_rect(&r, -1.0).is_none());

2074

2075

2076

    #[test]

2077

    fn logical_rect_to_az_rect_zero_size_is_none() {

2078

        assert!(logical_rect_to_az_rect(&lrect(0.0, 0.0, 0.0, 10.0), 1.0).is_none());

2079

        assert!(logical_rect_to_az_rect(&lrect(0.0, 0.0, 10.0, 0.0), 1.0).is_none());

2080

2081

2082

    #[test]

2083

    fn logical_rect_to_az_rect_nan_dpi_is_none() {

2084

        let r = lrect(1.0, 2.0, 3.0, 4.0);

2085

        assert!(logical_rect_to_az_rect(&r, f32::NAN).is_none());

2086

2087

2088

    #[test]

2089

    fn logical_rect_to_az_rect_infinite_dpi_is_none() {

2090

        let r = lrect(1.0, 2.0, 3.0, 4.0);

2091

        assert!(logical_rect_to_az_rect(&r, f32::INFINITY).is_none());

2092

        assert!(logical_rect_to_az_rect(&r, f32::NEG_INFINITY).is_none());

2093

2094

2095

    #[test]

2096

    fn logical_rect_to_az_rect_overflow_to_inf_is_none() {

2097

        // f32::MAX * 2.0 saturates to +inf, which from_xywh must reject.

2098

        let r = lrect(0.0, 0.0, f32::MAX, f32::MAX);

2099

        assert!(logical_rect_to_az_rect(&r, 2.0).is_none());

2100

2101

2102

    #[test]

2103

    fn logical_rect_to_az_rect_nan_bounds_is_none() {

2104

        let r = lrect(f32::NAN, 0.0, 10.0, 10.0);

2105

        assert!(logical_rect_to_az_rect(&r, 1.0).is_none());

2106

2107

2108

    #[test]

2109

    fn az_rect_from_xywh_rejects_nonpositive_size() {

2110

        assert!(AzRect::from_xywh(0.0, 0.0, 0.0, 1.0).is_none());

2111

        assert!(AzRect::from_xywh(0.0, 0.0, 1.0, 0.0).is_none());

2112

        assert!(AzRect::from_xywh(0.0, 0.0, -1.0, 1.0).is_none());

2113

        assert!(AzRect::from_xywh(0.0, 0.0, 1.0, -1.0).is_none());

2114

2115

2116

    #[test]

2117

    fn az_rect_from_xywh_rejects_nonfinite() {

2118

        for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {

2119

            assert!(AzRect::from_xywh(bad, 0.0, 1.0, 1.0).is_none(), "x={bad}");

2120

            assert!(AzRect::from_xywh(0.0, bad, 1.0, 1.0).is_none(), "y={bad}");

2121

            assert!(AzRect::from_xywh(0.0, 0.0, bad, 1.0).is_none(), "w={bad}");

2122

            assert!(AzRect::from_xywh(0.0, 0.0, 1.0, bad).is_none(), "h={bad}");

2123

2124

2125

2126

    #[test]

2127

    fn az_rect_from_xywh_keeps_fields_verbatim() {

2128

        let r = AzRect::from_xywh(-3.5, 7.25, 1.5, 2.5).expect("valid");

2129

        assert!(approx(r.x, -3.5));

2130

        assert!(approx(r.y, 7.25));

2131

        assert!(approx(r.width, 1.5));

2132

        assert!(approx(r.height, 2.5));

2133

2134

2135

    #[test]

2136

    fn az_rect_from_xywh_smallest_positive_size_is_accepted() {

2137

        assert!(AzRect::from_xywh(0.0, 0.0, f32::MIN_POSITIVE, f32::MIN_POSITIVE).is_some());

2138

2139

2140

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

2141

    // AzRect::clip (other)

2142

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

2143

2144

    #[test]

2145

    fn az_rect_clip_contained_returns_self() {

2146

        let inner = AzRect::from_xywh(2.0, 2.0, 2.0, 2.0).expect("valid");

2147

        let outer = AzRect::from_xywh(0.0, 0.0, 10.0, 10.0).expect("valid");

2148

        let c = inner.clip(&outer).expect("inner is fully inside outer");

2149

        assert!(approx(c.x, 2.0) && approx(c.y, 2.0));

2150

        assert!(approx(c.width, 2.0) && approx(c.height, 2.0));

2151

2152

2153

    #[test]

2154

    fn az_rect_clip_partial_overlap() {

2155

        let a = AzRect::from_xywh(0.0, 0.0, 10.0, 10.0).expect("valid");

2156

        let b = AzRect::from_xywh(5.0, 5.0, 10.0, 10.0).expect("valid");

2157

        let c = a.clip(&b).expect("overlap");

2158

        assert!(approx(c.x, 5.0) && approx(c.width, 5.0));

2159

2160

2161

    #[test]

2162

    fn az_rect_clip_disjoint_is_none() {

2163

        let a = AzRect::from_xywh(0.0, 0.0, 1.0, 1.0).expect("valid");

2164

        let b = AzRect::from_xywh(50.0, 50.0, 1.0, 1.0).expect("valid");

2165

        assert!(a.clip(&b).is_none());

2166

2167

2168

    #[test]

2169

    fn az_rect_clip_touching_edge_is_none() {

2170

        let a = AzRect::from_xywh(0.0, 0.0, 5.0, 5.0).expect("valid");

2171

        let b = AzRect::from_xywh(5.0, 0.0, 5.0, 5.0).expect("valid");

2172

        assert!(a.clip(&b).is_none());

2173

2174

2175

    #[test]

2176

    fn az_rect_clip_huge_rect_does_not_panic() {

2177

        let a = AzRect::from_xywh(0.0, 0.0, f32::MAX, f32::MAX).expect("valid");

2178

        let b = AzRect::from_xywh(1.0, 1.0, 2.0, 2.0).expect("valid");

2179

        let c = a.clip(&b).expect("b is inside a");

2180

        assert!(approx(c.width, 2.0) && approx(c.height, 2.0));

2181

2182

2183

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

2184

    // intersect_clips (numeric) — the "empty clip must not become unclipped" contract

2185

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

2186

2187

    #[test]

2188

    fn intersect_clips_none_none_is_none() {

2189

        assert!(intersect_clips(None, None).is_none());

2190

2191

2192

    #[test]

2193

    fn intersect_clips_none_current_adopts_new() {

2194

        let new = AzRect::from_xywh(1.0, 2.0, 3.0, 4.0).expect("valid");

2195

        let r = intersect_clips(None, Some(new)).expect("adopts new");

2196

        assert!(approx(r.x, 1.0) && approx(r.width, 3.0));

2197

2198

2199

    #[test]

2200

    fn intersect_clips_none_new_keeps_current() {

2201

        let cur = AzRect::from_xywh(1.0, 2.0, 3.0, 4.0).expect("valid");

2202

        let r = intersect_clips(Some(cur), None).expect("keeps current");

2203

        assert!(approx(r.x, 1.0) && approx(r.width, 3.0));

2204

2205

2206

    #[test]

2207

    fn intersect_clips_nested_shrinks_to_inner() {

2208

        let outer = AzRect::from_xywh(0.0, 0.0, 10.0, 10.0).expect("valid");

2209

        let inner = AzRect::from_xywh(2.0, 2.0, 3.0, 3.0).expect("valid");

2210

        let r = intersect_clips(Some(outer), Some(inner)).expect("overlap");

2211

        assert!(approx(r.x, 2.0) && approx(r.y, 2.0));

2212

        assert!(approx(r.width, 3.0) && approx(r.height, 3.0));

2213

2214

2215

    #[test]

2216

    fn intersect_clips_never_grows() {

2217

        let a = AzRect::from_xywh(0.0, 0.0, 10.0, 4.0).expect("valid");

2218

        let b = AzRect::from_xywh(3.0, 0.0, 10.0, 10.0).expect("valid");

2219

        let r = intersect_clips(Some(a), Some(b)).expect("overlap");

2220

        assert!(r.width <= a.width && r.width <= b.width);

2221

        assert!(r.height <= a.height && r.height <= b.height);

2222

2223

2224

    #[test]

2225

    fn intersect_clips_disjoint_is_some_zero_area_not_none() {

2226

        // Documented invariant: an EMPTY intersection clips everything and must

2227

        // NOT degrade to `None` (which means "unclipped").

2228

        let a = AzRect::from_xywh(0.0, 0.0, 4.0, 4.0).expect("valid");

2229

        let b = AzRect::from_xywh(10.0, 10.0, 4.0, 4.0).expect("valid");

2230

        let r = intersect_clips(Some(a), Some(b)).expect("must stay Some, not unclipped");

2231

        assert!(approx(r.width, 0.0), "empty clip must have zero width");

2232

        assert!(approx(r.height, 0.0), "empty clip must have zero height");

2233

2234

2235

    #[test]

2236

    fn intersect_clips_never_yields_negative_extent() {

2237

        let a = AzRect::from_xywh(0.0, 0.0, 1.0, 1.0).expect("valid");

2238

        let b = AzRect::from_xywh(100.0, 100.0, 1.0, 1.0).expect("valid");

2239

        let r = intersect_clips(Some(a), Some(b)).expect("some");

2240

        assert!(r.width >= 0.0 && r.height >= 0.0);

2241

2242

2243

    #[test]

2244

    fn intersect_clips_with_self_is_idempotent() {

2245

        let a = AzRect::from_xywh(2.0, 3.0, 4.0, 5.0).expect("valid");

2246

        let r = intersect_clips(Some(a), Some(a)).expect("some");

2247

        assert!(approx(r.x, 2.0) && approx(r.y, 3.0));

2248

        assert!(approx(r.width, 4.0) && approx(r.height, 5.0));

2249

2250

2251

    #[test]

2252

    fn intersect_clips_huge_rects_do_not_panic() {

2253

        let a = AzRect::from_xywh(0.0, 0.0, f32::MAX, f32::MAX).expect("valid");

2254

        let b = AzRect::from_xywh(-1.0e30, -1.0e30, f32::MAX, f32::MAX).expect("valid");

2255

        let r = intersect_clips(Some(a), Some(b)).expect("some");

2256

        assert!(!r.width.is_nan() && !r.height.is_nan());

2257

        assert!(r.width >= 0.0 && r.height >= 0.0);

2258

2259

2260

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

2261

    // AzulPixmap::new (constructor) + getters

2262

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

2263

2264

    #[test]

2265

    fn pixmap_new_zero_dimension_is_none() {

2266

        assert!(AzulPixmap::new(0, 0).is_none());

2267

        assert!(AzulPixmap::new(0, 16).is_none());

2268

        assert!(AzulPixmap::new(16, 0).is_none());

2269

2270

2271

    #[test]

2272

    fn pixmap_new_invariants_hold() {

2273

        let p = pm(3, 5);

2274

        assert_eq!(p.width(), 3);

2275

        assert_eq!(p.height(), 5);

2276

        assert_eq!(p.data().len(), 3 * 5 * 4);

2277

        assert!(

2278

            p.data().iter().all(|&b| b == 255),

2279

            "new() is documented to be opaque white"

2280

);

2281

2282

2283

    #[test]

2284

    fn pixmap_new_1x1_is_a_single_white_pixel() {

2285

        let p = pm(1, 1);

2286

        assert_eq!(p.data(), &WHITE);

2287

2288

2289

    #[test]

2290

    fn pixmap_new_absurd_dimensions_return_none_instead_of_aborting() {

2291

        // `new` returns Option, so the documented failure mode for a size that

2292

        // cannot be allocated is None — not a `capacity overflow` panic.

2293

        assert!(AzulPixmap::new(u32::MAX, u32::MAX).is_none());

2294

2295

2296

    #[test]

2297

    fn pixmap_getters_on_zero_sized_instance_do_not_panic() {

2298

        let p = zero_sized();

2299

        assert_eq!(p.width(), 0);

2300

        assert_eq!(p.height(), 0);

2301

        assert!(p.data().is_empty());

2302

2303

2304

    #[test]

2305

    fn data_mut_writes_are_visible_through_data() {

2306

        let mut p = pm(2, 1);

2307

        p.data_mut()[0] = 7;

2308

        assert_eq!(p.data()[0], 7);

2309

        assert_eq!(p.data().len(), 8);

2310

2311

2312

    #[test]

2313

    fn data_mut_on_zero_sized_instance_is_empty_not_panic() {

2314

        let mut p = zero_sized();

2315

        assert!(p.data_mut().is_empty());

2316

2317

2318

    #[test]

2319

    fn clone_pixmap_is_a_deep_copy() {

2320

        let src = filled(2, 2, [1, 2, 3, 4]);

2321

        let mut cloned = src.clone_pixmap();

2322

        assert_eq!(cloned.width(), src.width());

2323

        assert_eq!(cloned.height(), src.height());

2324

        assert_eq!(cloned.data(), src.data());

2325

2326

        set(&mut cloned, 0, 0, [9, 9, 9, 9]);

2327

        assert_eq!(get(&src, 0, 0), [1, 2, 3, 4], "clone must not alias source");

2328

2329

2330

    #[test]

2331

    fn clone_pixmap_of_zero_sized_instance_does_not_panic() {

2332

        let p = zero_sized();

2333

        let c = p.clone_pixmap();

2334

        assert_eq!(c.width(), 0);

2335

        assert!(c.data().is_empty());

2336

2337

2338

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

2339

    // AzulPixmap::fill (numeric)

2340

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

2341

2342

    #[test]

2343

    fn fill_sets_every_channel_of_every_pixel() {

2344

        let p = filled(4, 3, [10, 20, 30, 40]);

2345

        for y in 0..3 {

2346

            for x in 0..4 {

2347

                assert_eq!(get(&p, x, y), [10, 20, 30, 40]);

2348

2349

2350

2351

2352

    #[test]

2353

    fn fill_with_u8_extremes() {

2354

        let p = filled(2, 2, [0, 0, 0, 0]);

2355

        assert!(p.data().iter().all(|&b| b == 0));

2356

        let p = filled(2, 2, [255, 255, 255, 255]);

2357

        assert!(p.data().iter().all(|&b| b == 255));

2358

2359

2360

    #[test]

2361

    fn fill_on_zero_sized_pixmap_does_not_panic() {

2362

        let mut p = zero_sized();

2363

        p.fill(1, 2, 3, 4);

2364

        assert!(p.data().is_empty());

2365

2366

2367

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

2368

    // AzulPixmap::fill_rect (numeric)

2369

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

2370

2371

    #[test]

2372

    fn fill_rect_fills_exactly_the_requested_box() {

2373

        let mut p = filled(5, 5, CLEAR);

2374

        p.fill_rect(1, 1, 2, 2, 1, 2, 3, 4);

2375

        assert_eq!(get(&p, 1, 1), [1, 2, 3, 4]);

2376

        assert_eq!(get(&p, 2, 2), [1, 2, 3, 4]);

2377

        assert_eq!(get(&p, 0, 0), CLEAR, "outside the box must be untouched");

2378

        assert_eq!(get(&p, 3, 3), CLEAR, "x1/y1 are exclusive");

2379

2380

2381

    #[test]

2382

    fn fill_rect_zero_size_is_a_noop() {

2383

        let mut p = filled(4, 4, CLEAR);

2384

        p.fill_rect(1, 1, 0, 0, 255, 0, 0, 255);

2385

        assert!(p.data().iter().all(|&b| b == 0));

2386

2387

2388

    #[test]

2389

    fn fill_rect_negative_origin_clips_to_the_pixmap() {

2390

        let mut p = filled(4, 4, CLEAR);

2391

        p.fill_rect(-2, -2, 4, 4, 9, 9, 9, 9);

2392

        // Only the on-screen quadrant (0..2, 0..2) is written.

2393

        assert_eq!(get(&p, 0, 0), [9, 9, 9, 9]);

2394

        assert_eq!(get(&p, 1, 1), [9, 9, 9, 9]);

2395

        assert_eq!(get(&p, 2, 2), CLEAR);

2396

2397

2398

    #[test]

2399

    fn fill_rect_fully_offscreen_is_a_noop() {

2400

        let mut p = filled(4, 4, CLEAR);

2401

        p.fill_rect(100, 100, 10, 10, 255, 0, 0, 255);

2402

        p.fill_rect(-100, -100, 10, 10, 255, 0, 0, 255);

2403

        assert!(p.data().iter().all(|&b| b == 0));

2404

2405

2406

    #[test]

2407

    fn fill_rect_negative_width_does_not_panic() {

2408

        // A negative width must be treated as an empty rect (a no-op), not turned

2409

        // into a reversed slice range.

2410

        let mut p = filled(8, 8, CLEAR);

2411

        p.fill_rect(3, 0, -5, 2, 255, 0, 0, 255);

2412

        assert!(

2413

            p.data().iter().all(|&b| b == 0),

2414

            "a negative-width rect must paint nothing"

2415

);

2416

2417

2418

    #[test]

2419

    fn fill_rect_negative_height_is_a_noop() {

2420

        let mut p = filled(8, 8, CLEAR);

2421

        p.fill_rect(0, 3, 2, -5, 255, 0, 0, 255);

2422

        assert!(p.data().iter().all(|&b| b == 0));

2423

2424

2425

    #[test]

2426

    fn fill_rect_i32_extremes_do_not_panic() {

2427

        let mut p = filled(4, 4, CLEAR);

2428

        p.fill_rect(i32::MIN, i32::MIN, i32::MAX, i32::MAX, 1, 1, 1, 1);

2429

        p.fill_rect(i32::MAX, i32::MAX, i32::MAX, i32::MAX, 2, 2, 2, 2);

2430

        p.fill_rect(0, 0, i32::MAX, i32::MAX, 3, 3, 3, 3);

2431

        // The last call saturates to the full pixmap.

2432

        assert_eq!(get(&p, 0, 0), [3, 3, 3, 3]);

2433

        assert_eq!(get(&p, 3, 3), [3, 3, 3, 3]);

2434

2435

2436

    #[test]

2437

    fn fill_rect_on_zero_sized_pixmap_does_not_panic() {

2438

        let mut p = zero_sized();

2439

        p.fill_rect(0, 0, 10, 10, 1, 2, 3, 4);

2440

        assert!(p.data().is_empty());

2441

2442

2443

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

2444

    // resize_grow_only (numeric)

2445

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

2446

2447

    #[test]

2448

    fn resize_grow_only_rejects_shrinking() {

2449

        let mut p = filled(4, 4, [1, 2, 3, 4]);

2450

        assert!(p.resize_grow_only(2, 4, 0, 0, 0, 0).is_none());

2451

        assert!(p.resize_grow_only(4, 2, 0, 0, 0, 0).is_none());

2452

        assert!(p.resize_grow_only(2, 2, 0, 0, 0, 0).is_none());

2453

        // Mixed grow/shrink is still a rejection.

2454

        assert!(p.resize_grow_only(8, 2, 0, 0, 0, 0).is_none());

2455

        assert_eq!(p.width(), 4, "a rejected resize must not mutate");

2456

        assert_eq!(p.height(), 4);

2457

        assert_eq!(p.data().len(), 4 * 4 * 4);

2458

2459

2460

    #[test]

2461

    fn resize_grow_only_same_dimensions_is_a_noop_some() {

2462

        let mut p = filled(3, 3, [7, 7, 7, 7]);

2463

        assert!(p.resize_grow_only(3, 3, 0, 0, 0, 0).is_some());

2464

        assert_eq!(p.width(), 3);

2465

        assert!(p.data().iter().all(|&b| b == 7));

2466

2467

2468

    #[test]

2469

    fn resize_grow_only_preserves_topleft_and_fills_the_new_strips() {

2470

        let mut p = marked(2, 2);

2471

        p.resize_grow_only(4, 4, 9, 8, 7, 6)

2472

            .expect("growing is allowed");

2473

        assert_eq!(p.width(), 4);

2474

        assert_eq!(p.height(), 4);

2475

        assert_eq!(p.data().len(), 4 * 4 * 4);

2476

        // old content stays in the top-left

2477

        assert_eq!(get(&p, 0, 0), [0, 0, 0, 255]);

2478

        assert_eq!(get(&p, 1, 0), [1, 0, 0, 255]);

2479

        assert_eq!(get(&p, 0, 1), [2, 0, 0, 255]);

2480

        assert_eq!(get(&p, 1, 1), [3, 0, 0, 255]);

2481

        // new right/bottom strips carry the fill colour

2482

        assert_eq!(get(&p, 3, 0), [9, 8, 7, 6]);

2483

        assert_eq!(get(&p, 0, 3), [9, 8, 7, 6]);

2484

        assert_eq!(get(&p, 3, 3), [9, 8, 7, 6]);

2485

2486

2487

    #[test]

2488

    fn resize_grow_only_grow_one_axis_only() {

2489

        let mut p = marked(2, 2);

2490

        p.resize_grow_only(2, 4, 1, 1, 1, 1)

2491

            .expect("height-only growth");

2492

        assert_eq!(p.width(), 2);

2493

        assert_eq!(p.height(), 4);

2494

        assert_eq!(get(&p, 1, 1), [3, 0, 0, 255]);

2495

        assert_eq!(get(&p, 0, 3), [1, 1, 1, 1]);

2496

2497

2498

    #[test]

2499

    fn resize_grow_only_from_zero_sized_pixmap_does_not_panic() {

2500

        let mut p = zero_sized();

2501

        p.resize_grow_only(2, 2, 5, 5, 5, 5)

2502

            .expect("0x0 -> 2x2 is a growth");

2503

        assert_eq!(p.width(), 2);

2504

        assert_eq!(p.data().len(), 16);

2505

        assert_eq!(get(&p, 0, 0), [5, 5, 5, 5]);

2506

2507

2508

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

2509

    // resize_reuse (numeric)

2510

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

2511

2512

    #[test]

2513

    fn resize_reuse_same_dimensions_is_a_noop() {

2514

        let mut p = filled(3, 3, [4, 4, 4, 4]);

2515

        p.resize_reuse(3, 3, 0, 0, 0, 0);

2516

        assert!(p.data().iter().all(|&b| b == 4));

2517

2518

2519

    #[test]

2520

    fn resize_reuse_grow_preserves_overlap_and_fills_the_rest() {

2521

        let mut p = marked(2, 2);

2522

        p.resize_reuse(4, 3, 1, 2, 3, 4);

2523

        assert_eq!(p.width(), 4);

2524

        assert_eq!(p.height(), 3);

2525

        assert_eq!(p.data().len(), 4 * 3 * 4);

2526

        assert_eq!(get(&p, 0, 0), [0, 0, 0, 255]);

2527

        assert_eq!(get(&p, 1, 1), [3, 0, 0, 255]);

2528

        assert_eq!(get(&p, 3, 0), [1, 2, 3, 4]);

2529

        assert_eq!(get(&p, 0, 2), [1, 2, 3, 4]);

2530

2531

2532

    #[test]

2533

    fn resize_reuse_shrink_crops_to_the_topleft() {

2534

        let mut p = marked(4, 4);

2535

        p.resize_reuse(2, 2, 0, 0, 0, 0);

2536

        assert_eq!(p.width(), 2);

2537

        assert_eq!(p.height(), 2);

2538

        assert_eq!(p.data().len(), 2 * 2 * 4);

2539

        // markers were y*4 + x on the old 4x4 grid

2540

        assert_eq!(get(&p, 0, 0), [0, 0, 0, 255]);

2541

        assert_eq!(get(&p, 1, 0), [1, 0, 0, 255]);

2542

        assert_eq!(get(&p, 0, 1), [4, 0, 0, 255]);

2543

        assert_eq!(get(&p, 1, 1), [5, 0, 0, 255]);

2544

2545

2546

    #[test]

2547

    fn resize_reuse_shrink_width_only_keeps_rows_aligned() {

2548

        let mut p = marked(4, 2);

2549

        p.resize_reuse(2, 2, 0, 0, 0, 0);

2550

        assert_eq!(get(&p, 0, 1), [4, 0, 0, 255], "row 1 must not be smeared");

2551

        assert_eq!(get(&p, 1, 1), [5, 0, 0, 255]);

2552

2553

2554

    #[test]

2555

    fn resize_reuse_to_zero_yields_an_empty_buffer() {

2556

        let mut p = filled(4, 4, [1, 1, 1, 1]);

2557

        p.resize_reuse(0, 0, 2, 2, 2, 2);

2558

        assert_eq!(p.width(), 0);

2559

        assert_eq!(p.height(), 0);

2560

        assert!(p.data().is_empty());

2561

2562

2563

    #[test]

2564

    fn resize_reuse_from_zero_sized_pixmap_does_not_panic() {

2565

        let mut p = zero_sized();

2566

        p.resize_reuse(2, 2, 3, 3, 3, 3);

2567

        assert_eq!(p.width(), 2);

2568

        assert_eq!(get(&p, 0, 0), [3, 3, 3, 3]);

2569

2570

2571

    #[test]

2572

    fn resize_reuse_data_len_always_matches_the_new_dimensions() {

2573

        let mut p = marked(3, 3);

2574

        for (w, h) in [(1u32, 1u32), (5, 2), (2, 5), (7, 7), (1, 9)] {

2575

            p.resize_reuse(w, h, 0, 0, 0, 0);

2576

            assert_eq!(p.width(), w);

2577

            assert_eq!(p.height(), h);

2578

            assert_eq!(p.data().len(), (w as usize) * (h as usize) * 4);

2579

2580

2581

2582

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

2583

    // encode_png / decode_png (round-trip + parser)

2584

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

2585

2586

    #[test]

2587

    fn png_round_trip_preserves_dimensions_and_pixels() {

2588

        let src = marked(5, 3);

2589

        let bytes = src.encode_png().expect("encode");

2590

        let back = AzulPixmap::decode_png(&bytes).expect("decode");

2591

        assert_eq!(back.width(), src.width());

2592

        assert_eq!(back.height(), src.height());

2593

        assert_eq!(back.data(), src.data());

2594

2595

2596

    #[test]

2597

    fn png_round_trip_1x1() {

2598

        let mut src = pm(1, 1);

2599

        set(&mut src, 0, 0, [1, 2, 3, 4]);

2600

        let bytes = src.encode_png().expect("encode");

2601

        let back = AzulPixmap::decode_png(&bytes).expect("decode");

2602

        assert_eq!(back.data(), &[1, 2, 3, 4]);

2603

2604

2605

    #[test]

2606

    fn png_round_trip_preserves_full_alpha_range() {

2607

        let mut src = pm(4, 1);

2608

        set(&mut src, 0, 0, [0, 0, 0, 0]);

2609

        set(&mut src, 1, 0, [255, 255, 255, 255]);

2610

        set(&mut src, 2, 0, [255, 0, 0, 1]);

2611

        set(&mut src, 3, 0, [0, 255, 0, 254]);

2612

        let bytes = src.encode_png().expect("encode");

2613

        let back = AzulPixmap::decode_png(&bytes).expect("decode");

2614

        assert_eq!(back.data(), src.data(), "PNG must not premultiply alpha");

2615

2616

2617

    #[test]

2618

    fn encode_png_starts_with_the_png_signature() {

2619

        let bytes = pm(2, 2).encode_png().expect("encode");

2620

        assert_eq!(

2621

            &bytes[..8],

2622

            &[0x89, b'P', b'N', b'G', 0x0d, 0x0a, 0x1a, 0x0a]

2623

);

2624

2625

2626

    #[test]

2627

    fn encode_png_of_a_zero_sized_pixmap_is_err_not_panic() {

2628

        let p = zero_sized();

2629

        let e = p.encode_png().expect_err("PNG forbids zero dimensions");

2630

        assert!(e.contains("PNG header error"), "unexpected message: {e}");

2631

2632

2633

    #[test]

2634

    fn decode_png_empty_input_is_err() {

2635

        assert!(AzulPixmap::decode_png(&[]).is_err());

2636

2637

2638

    #[test]

2639

    fn decode_png_whitespace_only_is_err() {

2640

        assert!(AzulPixmap::decode_png(b"   ").is_err());

2641

        assert!(AzulPixmap::decode_png(b"\t\n\r\n").is_err());

2642

2643

2644

    #[test]

2645

    fn decode_png_garbage_is_err() {

2646

        assert!(AzulPixmap::decode_png(b"not a png at all").is_err());

2647

        assert!(AzulPixmap::decode_png(&[0x00, 0x01, 0x02, 0x03]).is_err());

2648

2649

2650

    #[test]

2651

    fn decode_png_invalid_utf8_bytes_are_err() {

2652

        assert!(AzulPixmap::decode_png(&[0xFF, 0xFE, 0x00]).is_err());

2653

        assert!(AzulPixmap::decode_png(&[0xC0, 0x80, 0xED, 0xA0, 0x80]).is_err());

2654

2655

2656

    #[test]

2657

    fn decode_png_unicode_text_is_err() {

2658

        assert!(AzulPixmap::decode_png("\u{1F600} héllo n\u{0303}".as_bytes()).is_err());

2659

2660

2661

    #[test]

2662

    fn decode_png_boundary_number_strings_are_err() {

2663

        for s in [

2664

            "0",

2665

            "-0",

2666

            "9223372036854775807",

2667

            "NaN",

2668

            "inf",

2669

            "-inf",

2670

            "1e999",

2671

] {

2672

            assert!(

2673

                AzulPixmap::decode_png(s.as_bytes()).is_err(),

2674

                "{s:?} is not a PNG"

2675

);

2676

2677

2678

2679

    #[test]

2680

    fn decode_png_extremely_long_garbage_is_err_and_terminates() {

2681

        let junk = vec![0x41u8; 1_000_000];

2682

        assert!(AzulPixmap::decode_png(&junk).is_err());

2683

2684

2685

    #[test]

2686

    fn decode_png_deeply_nested_brackets_is_err() {

2687

        let mut nested = vec![b'['; 10_000];

2688

        nested.extend(std::iter::repeat_n(b']', 10_000));

2689

        assert!(AzulPixmap::decode_png(&nested).is_err());

2690

2691

2692

    #[test]

2693

    fn decode_png_signature_without_chunks_is_err() {

2694

        let sig = [0x89u8, b'P', b'N', b'G', 0x0d, 0x0a, 0x1a, 0x0a];

2695

        assert!(AzulPixmap::decode_png(&sig).is_err());

2696

2697

2698

    #[test]

2699

    fn decode_png_truncated_valid_png_is_err() {

2700

        let full = pm(4, 4).encode_png().expect("encode");

2701

        for cut in [9, full.len() / 2, full.len() - 1] {

2702

            assert!(

2703

                AzulPixmap::decode_png(&full[..cut]).is_err(),

2704

                "a PNG truncated to {cut} bytes must not decode"

2705

);

2706

2707

2708

2709

    #[test]

2710

    fn decode_png_leading_junk_is_rejected() {

2711

        let full = pm(2, 2).encode_png().expect("encode");

2712

        let mut with_junk = b"garbage".to_vec();

2713

        with_junk.extend_from_slice(&full);

2714

        assert!(

2715

            AzulPixmap::decode_png(&with_junk).is_err(),

2716

            "the decoder must not scan forward for a signature"

2717

);

2718

2719

2720

    #[test]

2721

    fn decode_png_trailing_junk_after_iend_still_decodes() {

2722

        let src = marked(2, 2);

2723

        let mut bytes = src.encode_png().expect("encode");

2724

        bytes.extend_from_slice(b"garbage;after;iend");

2725

        let back = AzulPixmap::decode_png(&bytes).expect("bytes past IEND are outside the stream");

2726

        assert_eq!(back.data(), src.data());

2727

2728

2729

    #[test]

2730

    fn decode_png_rgb_expands_to_opaque_rgba() {

2731

        let bytes = encode_custom_png(2, 1, png::ColorType::Rgb, &[10, 20, 30, 40, 50, 60]);

2732

        let p = AzulPixmap::decode_png(&bytes).expect("RGB is supported");

2733

        assert_eq!(p.width(), 2);

2734

        assert_eq!(p.height(), 1);

2735

        assert_eq!(p.data(), &[10, 20, 30, 255, 40, 50, 60, 255]);

2736

2737

2738

    #[test]

2739

    fn decode_png_grayscale_expands_to_rgba() {

2740

        let bytes = encode_custom_png(2, 1, png::ColorType::Grayscale, &[7, 9]);

2741

        let p = AzulPixmap::decode_png(&bytes).expect("grayscale is supported");

2742

        assert_eq!(p.data(), &[7, 7, 7, 255, 9, 9, 9, 255]);

2743

2744

2745

    #[test]

2746

    fn decode_png_unsupported_color_type_is_err_not_panic() {

2747

        let bytes = encode_custom_png(1, 1, png::ColorType::GrayscaleAlpha, &[7, 128]);

2748

        let e = AzulPixmap::decode_png(&bytes).expect_err("gray+alpha is not handled");

2749

        assert!(

2750

            e.contains("Unsupported PNG color type"),

2751

            "unexpected message: {e}"

2752

);

2753

2754

2755

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

2756

    // PixelDiffResult (predicate + getter)

2757

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

2758

2759

    fn diff_result(diff_count: u64, total_pixels: u64, dimensions_match: bool) -> PixelDiffResult {

2760

        PixelDiffResult {

2761

            diff_count,

2762

            total_pixels,

2763

            max_delta: 0,

2764

            dimensions_match,

2765

            ref_width: 1,

2766

            ref_height: 1,

2767

            test_width: 1,

2768

            test_height: 1,

2769

2770

2771

2772

    #[test]

2773

    fn is_match_is_true_only_when_dimensions_match_and_no_pixel_differs() {

2774

        assert!(diff_result(0, 100, true).is_match());

2775

        assert!(!diff_result(1, 100, true).is_match());

2776

        assert!(!diff_result(0, 100, false).is_match());

2777

        assert!(!diff_result(u64::MAX, 100, true).is_match());

2778

2779

2780

    #[test]

2781

    fn is_match_on_an_empty_comparison_is_deterministic() {

2782

        // Zero pixels compared but dimensions agree -> vacuously a match.

2783

        assert!(diff_result(0, 0, true).is_match());

2784

        assert!(!diff_result(0, 0, false).is_match());

2785

2786

2787

    #[test]

2788

    fn diff_ratio_of_zero_total_is_zero_not_nan() {

2789

        let r = diff_result(0, 0, true).diff_ratio();

2790

        assert!(r.is_finite() && r == 0.0, "0/0 must not become NaN");

2791

2792

2793

    #[test]

2794

    fn diff_ratio_basic_values() {

2795

        assert!((diff_result(0, 100, true).diff_ratio() - 0.0).abs() < 1e-12);

2796

        assert!((diff_result(50, 100, true).diff_ratio() - 0.5).abs() < 1e-12);

2797

        assert!((diff_result(100, 100, true).diff_ratio() - 1.0).abs() < 1e-12);

2798

2799

2800

    #[test]

2801

    fn diff_ratio_at_u64_max_stays_finite() {

2802

        let r = diff_result(u64::MAX, u64::MAX, true).diff_ratio();

2803

        assert!(r.is_finite(), "u64::MAX/u64::MAX must not overflow to inf");

2804

        assert!((r - 1.0).abs() < 1e-9);

2805

2806

2807

    #[test]

2808

    fn diff_ratio_on_a_dimension_mismatch_is_zero_yet_not_a_match() {

2809

        // A caller that only checks diff_ratio() would think a size mismatch is

2810

        // a perfect match — pin the (surprising but documented) behaviour down.

2811

        let r = diff_result(0, 0, false);

2812

        assert!((r.diff_ratio() - 0.0).abs() < 1e-12);

2813

        assert!(!r.is_match());

2814

2815

2816

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

2817

    // pixel_diff (numeric)

2818

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

2819

2820

    #[test]

2821

    fn pixel_diff_identical_images_match() {

2822

        let a = filled(4, 4, [1, 2, 3, 4]);

2823

        let b = filled(4, 4, [1, 2, 3, 4]);

2824

        let r = pixel_diff(&a, &b, 0);

2825

        assert!(r.is_match());

2826

        assert_eq!(r.diff_count, 0);

2827

        assert_eq!(r.max_delta, 0);

2828

        assert_eq!(r.total_pixels, 16);

2829

2830

2831

    #[test]

2832

    fn pixel_diff_threshold_is_exclusive_at_the_boundary() {

2833

        let a = filled(2, 2, [10, 10, 10, 255]);

2834

        let b = filled(2, 2, [13, 10, 10, 255]); // delta of exactly 3 on R

2835

        assert!(

2836

            pixel_diff(&a, &b, 3).is_match(),

2837

            "delta == threshold is within tolerance"

2838

);

2839

        assert!(

2840

            !pixel_diff(&a, &b, 2).is_match(),

2841

            "delta > threshold must be reported"

2842

);

2843

        assert_eq!(pixel_diff(&a, &b, 2).diff_count, 4);

2844

        assert_eq!(

2845

            pixel_diff(&a, &b, 3).max_delta,

2846

3,

2847

            "max_delta ignores the threshold"

2848

);

2849

2850

2851

    #[test]

2852

    fn pixel_diff_threshold_zero_catches_a_single_bit() {

2853

        let a = filled(2, 2, [0, 0, 0, 0]);

2854

        let mut b = filled(2, 2, [0, 0, 0, 0]);

2855

        set(&mut b, 1, 1, [0, 0, 0, 1]);

2856

        let r = pixel_diff(&a, &b, 0);

2857

        assert!(!r.is_match());

2858

        assert_eq!(r.diff_count, 1);

2859

        assert_eq!(r.max_delta, 1);

2860

2861

2862

    #[test]

2863

    fn pixel_diff_threshold_255_always_matches() {

2864

        // The largest possible per-channel delta is 255, and the check is `>`.

2865

        let a = filled(3, 3, [0, 0, 0, 0]);

2866

        let b = filled(3, 3, [255, 255, 255, 255]);

2867

        let r = pixel_diff(&a, &b, 255);

2868

        assert!(r.is_match(), "threshold 255 tolerates every possible delta");

2869

        assert_eq!(r.diff_count, 0);

2870

        assert_eq!(r.max_delta, 255);

2871

2872

2873

    #[test]

2874

    fn pixel_diff_max_delta_is_unsigned_and_direction_independent() {

2875

        let a = filled(1, 1, [0, 0, 0, 0]);

2876

        let b = filled(1, 1, [255, 0, 0, 0]);

2877

        assert_eq!(pixel_diff(&a, &b, 0).max_delta, 255, "no wraparound");

2878

        assert_eq!(

2879

            pixel_diff(&b, &a, 0).max_delta,

2880

            255,

2881

            "reference/test order must not change |delta|"

2882

);

2883

2884

2885

    #[test]

2886

    fn pixel_diff_all_pixels_different_ratio_is_one() {

2887

        let a = filled(4, 4, [0, 0, 0, 0]);

2888

        let b = filled(4, 4, [255, 255, 255, 255]);

2889

        let r = pixel_diff(&a, &b, 0);

2890

        assert_eq!(r.diff_count, r.total_pixels);

2891

        assert!((r.diff_ratio() - 1.0).abs() < 1e-12);

2892

2893

2894

    #[test]

2895

    fn pixel_diff_dimension_mismatch_reports_both_sizes_and_no_match() {

2896

        let a = filled(4, 4, CLEAR);

2897

        let b = filled(2, 8, CLEAR);

2898

        let r = pixel_diff(&a, &b, 0);

2899

        assert!(!r.is_match());

2900

        assert!(!r.dimensions_match);

2901

        assert_eq!(r.total_pixels, 0);

2902

        assert_eq!(r.diff_count, 0);

2903

        assert_eq!((r.ref_width, r.ref_height), (4, 4));

2904

        assert_eq!((r.test_width, r.test_height), (2, 8));

2905

2906

2907

    #[test]

2908

    fn pixel_diff_ratio_is_always_within_0_and_1() {

2909

        let a = marked(4, 4);

2910

        let b = filled(4, 4, [0, 0, 0, 0]);

2911

        for t in [0u8, 1, 127, 254, 255] {

2912

            let r = pixel_diff(&a, &b, t);

2913

            let ratio = r.diff_ratio();

2914

            assert!(

2915

                (0.0..=1.0).contains(&ratio),

2916

                "ratio {ratio} out of range at t={t}"

2917

);

2918

            assert!(r.diff_count <= r.total_pixels);

2919

2920

2921

2922

    #[test]

2923

    fn pixel_diff_on_zero_sized_pixmaps_does_not_panic() {

2924

        let a = zero_sized();

2925

        let b = zero_sized();

2926

        let r = pixel_diff(&a, &b, 0);

2927

        assert!(r.is_match());

2928

        assert_eq!(r.total_pixels, 0);

2929

        assert!((r.diff_ratio() - 0.0).abs() < 1e-12);

2930

2931

2932

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

2933

    // compare_against_reference (parser / IO)

2934

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

2935

2936

    #[test]

2937

    fn compare_against_reference_missing_file_is_err() {

2938

        let p = pm(2, 2);

2939

        let e = compare_against_reference(&p, "/nonexistent/azul/does_not_exist.png", 0)

2940

            .expect_err("missing file");

2941

        assert!(e.contains("Cannot read reference image"), "got: {e}");

2942

2943

2944

    #[test]

2945

    fn compare_against_reference_empty_path_is_err() {

2946

        let p = pm(2, 2);

2947

        assert!(compare_against_reference(&p, "", 0).is_err());

2948

2949

2950

    #[test]

2951

    fn compare_against_reference_whitespace_path_is_err() {

2952

        let p = pm(2, 2);

2953

        assert!(compare_against_reference(&p, "   ", 0).is_err());

2954

        assert!(compare_against_reference(&p, "\t\n", 0).is_err());

2955

2956

2957

    #[test]

2958

    fn compare_against_reference_nul_byte_path_is_err_not_panic() {

2959

        let p = pm(2, 2);

2960

        assert!(compare_against_reference(&p, "bad\0path.png", 0).is_err());

2961

2962

2963

    #[test]

2964

    fn compare_against_reference_unicode_path_is_err() {

2965

        let p = pm(2, 2);

2966

        assert!(compare_against_reference(&p, "/tmp/\u{1F600}/nope.png", 0).is_err());

2967

2968

2969

    #[test]

2970

    fn compare_against_reference_extremely_long_path_is_err_not_panic() {

2971

        let p = pm(2, 2);

2972

        let long = format!("/tmp/{}.png", "a".repeat(100_000));

2973

        assert!(compare_against_reference(&p, &long, 0).is_err());

2974

2975

2976

    #[test]

2977

    fn compare_against_reference_boundary_number_paths_are_err() {

2978

        let p = pm(2, 2);

2979

        for s in ["0", "-0", "NaN", "inf", "9223372036854775807"] {

2980

            assert!(compare_against_reference(&p, s, 0).is_err(), "{s:?}");

2981

2982

2983

2984

    #[test]

2985

    fn compare_against_reference_non_png_file_is_err() {

2986

        let path = temp_path("not_a_png");

2987

        std::fs::write(&path, b"definitely not a png").expect("write temp file");

2988

        let p = pm(2, 2);

2989

        let res = compare_against_reference(&p, path.to_str().expect("utf8 path"), 0);

2990

        let _ = std::fs::remove_file(&path);

2991

        let e = res.expect_err("a non-PNG file must not decode");

2992

        assert!(e.contains("PNG decode error"), "got: {e}");

2993

2994

2995

    #[test]

2996

    fn compare_against_reference_valid_png_matches_itself() {

2997

        let src = marked(3, 2);

2998

        let path = temp_path("valid_ref");

2999

        std::fs::write(&path, src.encode_png().expect("encode")).expect("write temp file");

3000

        let res = compare_against_reference(&src, path.to_str().expect("utf8 path"), 0);

3001

        let _ = std::fs::remove_file(&path);

3002

        let r = res.expect("a freshly written reference must decode");

3003

        assert!(r.is_match(), "an image must match its own PNG: {r:?}");

3004

        assert_eq!(r.total_pixels, 6);

3005

3006

3007

    #[test]

3008

    fn compare_against_reference_size_mismatch_is_ok_but_not_a_match() {

3009

        let src = marked(3, 2);

3010

        let path = temp_path("size_mismatch");

3011

        std::fs::write(&path, src.encode_png().expect("encode")).expect("write temp file");

3012

        let other = pm(4, 4);

3013

        let res = compare_against_reference(&other, path.to_str().expect("utf8 path"), 0);

3014

        let _ = std::fs::remove_file(&path);

3015

        let r = res.expect("decoding succeeds; only the comparison fails");

3016

        assert!(!r.is_match());

3017

        assert!(!r.dimensions_match);

3018

3019

3020

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

3021

    // blit_pixmap (numeric)

3022

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

3023

3024

    #[test]

3025

    fn blit_pixmap_full_opacity_opaque_src_overwrites_dst() {

3026

        let src = filled(2, 2, [10, 20, 30, 255]);

3027

        let mut dst = filled(4, 4, CLEAR);

3028

        blit_pixmap(&src, &mut dst, 1, 1, 1.0);

3029

        assert_eq!(get(&dst, 1, 1), [10, 20, 30, 255]);

3030

        assert_eq!(get(&dst, 2, 2), [10, 20, 30, 255]);

3031

        assert_eq!(get(&dst, 0, 0), CLEAR);

3032

        assert_eq!(get(&dst, 3, 3), CLEAR);

3033

3034

3035

    #[test]

3036

    fn blit_pixmap_zero_opacity_leaves_dst_untouched() {

3037

        let src = filled(2, 2, [10, 20, 30, 255]);

3038

        let mut dst = filled(2, 2, WHITE);

3039

        blit_pixmap(&src, &mut dst, 0, 0, 0.0);

3040

        assert!(dst.data().iter().all(|&b| b == 255));

3041

3042

3043

    #[test]

3044

    fn blit_pixmap_transparent_src_leaves_dst_untouched() {

3045

        let src = filled(2, 2, [10, 20, 30, 0]);

3046

        let mut dst = filled(2, 2, WHITE);

3047

        blit_pixmap(&src, &mut dst, 0, 0, 1.0);

3048

        assert!(dst.data().iter().all(|&b| b == 255));

3049

3050

3051

    #[test]

3052

    fn blit_pixmap_nan_opacity_does_not_panic_and_blits_nothing() {

3053

        // (NaN * 255).clamp(..) is NaN, and `NaN as u32` saturates to 0.

3054

        let src = filled(2, 2, [10, 20, 30, 255]);

3055

        let mut dst = filled(2, 2, WHITE);

3056

        blit_pixmap(&src, &mut dst, 0, 0, f32::NAN);

3057

        assert!(

3058

            dst.data().iter().all(|&b| b == 255),

3059

            "a NaN opacity must not paint anything"

3060

);

3061

3062

3063

    #[test]

3064

    fn blit_pixmap_infinite_opacity_clamps_to_fully_opaque() {

3065

        let src = filled(1, 1, [10, 20, 30, 255]);

3066

        let mut dst = filled(1, 1, WHITE);

3067

        blit_pixmap(&src, &mut dst, 0, 0, f32::INFINITY);

3068

        assert_eq!(get(&dst, 0, 0), [10, 20, 30, 255]);

3069

3070

3071

    #[test]

3072

    fn blit_pixmap_negative_infinite_opacity_clamps_to_transparent() {

3073

        let src = filled(1, 1, [10, 20, 30, 255]);

3074

        let mut dst = filled(1, 1, WHITE);

3075

        blit_pixmap(&src, &mut dst, 0, 0, f32::NEG_INFINITY);

3076

        assert_eq!(get(&dst, 0, 0), WHITE);

3077

3078

3079

    #[test]

3080

    fn blit_pixmap_opacity_above_one_clamps_to_one() {

3081

        let src = filled(1, 1, [10, 20, 30, 255]);

3082

        let mut a = filled(1, 1, CLEAR);

3083

        let mut b = filled(1, 1, CLEAR);

3084

        blit_pixmap(&src, &mut a, 0, 0, 1.0);

3085

        blit_pixmap(&src, &mut b, 0, 0, 1.0e30);

3086

        assert_eq!(a.data(), b.data(), "opacity is clamped to [0, 1]");

3087

3088

3089

    #[test]

3090

    fn blit_pixmap_half_alpha_blend_is_exact() {

3091

        let src = filled(1, 1, [200, 100, 50, 128]);

3092

        let mut dst = filled(1, 1, CLEAR);

3093

        blit_pixmap(&src, &mut dst, 0, 0, 1.0);

3094

        // sa = 128, inv = 127, dst starts at 0 => (c * 128) / 255

3095

        assert_eq!(get(&dst, 0, 0), [100, 50, 25, 128]);

3096

3097

3098

    #[test]

3099

    fn blit_pixmap_negative_position_clips_to_dst() {

3100

        let src = marked(2, 2);

3101

        let mut dst = filled(4, 4, CLEAR);

3102

        blit_pixmap(&src, &mut dst, -1, -1, 1.0);

3103

        // Only src(1,1) (marker 3) lands on dst(0,0).

3104

        assert_eq!(get(&dst, 0, 0), [3, 0, 0, 255]);

3105

        assert_eq!(get(&dst, 1, 1), CLEAR);

3106

3107

3108

    #[test]

3109

    fn blit_pixmap_fully_offscreen_is_a_noop() {

3110

        let src = filled(2, 2, [1, 2, 3, 255]);

3111

        let mut dst = filled(4, 4, CLEAR);

3112

        blit_pixmap(&src, &mut dst, 100, 100, 1.0);

3113

        blit_pixmap(&src, &mut dst, -100, -100, 1.0);

3114

        assert!(dst.data().iter().all(|&b| b == 0));

3115

3116

3117

    #[test]

3118

    fn blit_pixmap_into_smaller_dst_clips_instead_of_panicking() {

3119

        let src = filled(8, 8, [1, 2, 3, 255]);

3120

        let mut dst = filled(2, 2, CLEAR);

3121

        blit_pixmap(&src, &mut dst, 0, 0, 1.0);

3122

        assert_eq!(get(&dst, 1, 1), [1, 2, 3, 255]);

3123

3124

3125

    #[test]

3126

    fn blit_pixmap_extreme_positions_do_not_panic() {

3127

        // Every source pixel is off-screen, so this must be a no-op — not an

3128

        // `px_x + sx` overflow.

3129

        let src = filled(2, 2, [1, 2, 3, 255]);

3130

        let mut dst = filled(4, 4, CLEAR);

3131

        blit_pixmap(&src, &mut dst, i32::MAX, 0, 1.0);

3132

        blit_pixmap(&src, &mut dst, 0, i32::MAX, 1.0);

3133

        blit_pixmap(&src, &mut dst, i32::MIN, i32::MIN, 1.0);

3134

        assert!(dst.data().iter().all(|&b| b == 0));

3135

3136

3137

    #[test]

3138

    fn blit_pixmap_zero_sized_src_is_a_noop() {

3139

        let src = zero_sized();

3140

        let mut dst = filled(2, 2, WHITE);

3141

        blit_pixmap(&src, &mut dst, 0, 0, 1.0);

3142

        assert!(dst.data().iter().all(|&b| b == 255));

3143

3144

3145

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

3146

    // shift_pixbuf (numeric)

3147

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

3148

3149

    #[test]

3150

    fn shift_pixbuf_zero_delta_is_a_noop() {

3151

        let mut p = marked(3, 3);

3152

        let before = p.data().to_vec();

3153

        shift_pixbuf(&mut p, 0, 0);

3154

        assert_eq!(p.data(), &before[..]);

3155

3156

3157

    #[test]

3158

    fn shift_pixbuf_right_moves_columns_and_clears_the_left() {

3159

        let mut p = marked(3, 3);

3160

        shift_pixbuf(&mut p, 1, 0);

3161

        assert_eq!(get(&p, 0, 0), CLEAR, "the exposed column must be cleared");

3162

        assert_eq!(get(&p, 1, 0), [0, 0, 0, 255]);

3163

        assert_eq!(get(&p, 2, 0), [1, 0, 0, 255]);

3164

        assert_eq!(get(&p, 1, 2), [6, 0, 0, 255]);

3165

3166

3167

    #[test]

3168

    fn shift_pixbuf_left_moves_columns_and_clears_the_right() {

3169

        let mut p = marked(3, 3);

3170

        shift_pixbuf(&mut p, -1, 0);

3171

        assert_eq!(get(&p, 0, 0), [1, 0, 0, 255]);

3172

        assert_eq!(get(&p, 1, 0), [2, 0, 0, 255]);

3173

        assert_eq!(get(&p, 2, 0), CLEAR);

3174

        assert_eq!(get(&p, 0, 2), [7, 0, 0, 255]);

3175

3176

3177

    #[test]

3178

    fn shift_pixbuf_down_moves_rows_and_clears_the_top() {

3179

        let mut p = marked(3, 3);

3180

        shift_pixbuf(&mut p, 0, 1);

3181

        assert_eq!(get(&p, 0, 0), CLEAR);

3182

        assert_eq!(get(&p, 0, 1), [0, 0, 0, 255]);

3183

        assert_eq!(get(&p, 1, 1), [1, 0, 0, 255]);

3184

        assert_eq!(get(&p, 0, 2), [3, 0, 0, 255]);

3185

3186

3187

    #[test]

3188

    fn shift_pixbuf_up_moves_rows_and_clears_the_bottom() {

3189

        let mut p = marked(3, 3);

3190

        shift_pixbuf(&mut p, 0, -1);

3191

        assert_eq!(get(&p, 0, 0), [3, 0, 0, 255]);

3192

        assert_eq!(get(&p, 0, 1), [6, 0, 0, 255]);

3193

        assert_eq!(get(&p, 0, 2), CLEAR);

3194

        assert_eq!(get(&p, 2, 2), CLEAR);

3195

3196

3197

    #[test]

3198

    fn shift_pixbuf_diagonal_composes_both_axes() {

3199

        let mut p = marked(3, 3);

3200

        shift_pixbuf(&mut p, 1, 1);

3201

        assert_eq!(get(&p, 1, 1), [0, 0, 0, 255]);

3202

        assert_eq!(get(&p, 2, 2), [4, 0, 0, 255]);

3203

        assert_eq!(get(&p, 0, 0), CLEAR);

3204

        assert_eq!(get(&p, 2, 0), CLEAR);

3205

        assert_eq!(get(&p, 0, 2), CLEAR);

3206

3207

3208

    #[test]

3209

    fn shift_pixbuf_by_exactly_the_size_clears_everything() {

3210

        let mut p = marked(3, 3);

3211

        shift_pixbuf(&mut p, 3, 0);

3212

        assert!(p.data().iter().all(|&b| b == 0));

3213

3214

        let mut p = marked(3, 3);

3215

        shift_pixbuf(&mut p, 0, -3);

3216

        assert!(p.data().iter().all(|&b| b == 0));

3217

3218

3219

    #[test]

3220

    fn shift_pixbuf_beyond_the_size_clears_everything() {

3221

        let mut p = marked(3, 3);

3222

        shift_pixbuf(&mut p, 100, 100);

3223

        assert!(p.data().iter().all(|&b| b == 0));

3224

3225

3226

    #[test]

3227

    fn shift_pixbuf_i32_max_clears_everything() {

3228

        let mut p = marked(3, 3);

3229

        shift_pixbuf(&mut p, i32::MAX, i32::MAX);

3230

        assert!(p.data().iter().all(|&b| b == 0));

3231

3232

3233

    #[test]

3234

    fn shift_pixbuf_i32_min_does_not_panic() {

3235

        // `dx.abs()` on i32::MIN overflows; the buffer is entirely exposed, so

3236

        // the documented outcome is "clear everything".

3237

        let mut p = marked(3, 3);

3238

        shift_pixbuf(&mut p, i32::MIN, 0);

3239

        assert!(p.data().iter().all(|&b| b == 0));

3240

3241

3242

    #[test]

3243

    fn shift_pixbuf_i32_min_dy_does_not_panic() {

3244

        let mut p = marked(3, 3);

3245

        shift_pixbuf(&mut p, 0, i32::MIN);

3246

        assert!(p.data().iter().all(|&b| b == 0));

3247

3248

3249

    #[test]

3250

    fn shift_pixbuf_on_zero_sized_pixmap_does_not_panic() {

3251

        let mut p = zero_sized();

3252

        shift_pixbuf(&mut p, 1, 1);

3253

        assert!(p.data().is_empty());

3254

3255

3256

    #[test]

3257

    fn shift_pixbuf_preserves_the_buffer_length() {

3258

        let mut p = marked(4, 4);

3259

        for (dx, dy) in [(1, 0), (-1, 0), (0, 1), (0, -1), (3, 3), (-3, -3)] {

3260

            shift_pixbuf(&mut p, dx, dy);

3261

            assert_eq!(p.data().len(), 4 * 4 * 4);

3262

3263

3264

3265

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

3266

    // blit_buffer (numeric)

3267

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

3268

3269

    #[test]

3270

    fn blit_buffer_opaque_src_overwrites_dst() {

3271

        let src = vec![10u8, 20, 30, 255, 40, 50, 60, 255];

3272

        let mut dst = filled(4, 1, CLEAR);

3273

        blit_buffer(&mut dst, &src, 2, 1, 1, 0);

3274

        assert_eq!(get(&dst, 0, 0), CLEAR);

3275

        assert_eq!(get(&dst, 1, 0), [10, 20, 30, 255]);

3276

        assert_eq!(get(&dst, 2, 0), [40, 50, 60, 255]);

3277

        assert_eq!(get(&dst, 3, 0), CLEAR);

3278

3279

3280

    #[test]

3281

    fn blit_buffer_transparent_src_is_a_noop() {

3282

        let src = vec![10u8, 20, 30, 0];

3283

        let mut dst = filled(1, 1, WHITE);

3284

        blit_buffer(&mut dst, &src, 1, 1, 0, 0);

3285

        assert_eq!(get(&dst, 0, 0), WHITE);

3286

3287

3288

    #[test]

3289

    fn blit_buffer_premultiplied_half_alpha_blend_is_exact() {

3290

        // src RGB is already premultiplied, so dst = src + dst * (255 - sa) / 255.

3291

        let src = vec![100u8, 50, 25, 128];

3292

        let mut dst = filled(1, 1, CLEAR);

3293

        blit_buffer(&mut dst, &src, 1, 1, 0, 0);

3294

        assert_eq!(get(&dst, 0, 0), [100, 50, 25, 128]);

3295

3296

3297

    #[test]

3298

    fn blit_buffer_premultiplied_blend_saturates_instead_of_wrapping() {

3299

        // src is (illegally) not premultiplied: 255 + white*127/255 would exceed

3300

        // u8 — it must clamp to 255, not wrap to a dark pixel.

3301

        let src = vec![255u8, 255, 255, 128];

3302

        let mut dst = filled(1, 1, WHITE);

3303

        blit_buffer(&mut dst, &src, 1, 1, 0, 0);

3304

        assert_eq!(get(&dst, 0, 0), WHITE);

3305

3306

3307

    #[test]

3308

    fn blit_buffer_negative_offset_clips() {

3309

        let src = vec![1u8, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255, 4, 4, 4, 255];

3310

        let mut dst = filled(2, 2, CLEAR);

3311

        blit_buffer(&mut dst, &src, 2, 2, -1, -1);

3312

        // Only src(1,1) lands on dst(0,0).

3313

        assert_eq!(get(&dst, 0, 0), [4, 4, 4, 255]);

3314

        assert_eq!(get(&dst, 1, 1), CLEAR);

3315

3316

3317

    #[test]

3318

    fn blit_buffer_fully_offscreen_is_a_noop() {

3319

        let src = vec![9u8, 9, 9, 255];

3320

        let mut dst = filled(2, 2, CLEAR);

3321

        blit_buffer(&mut dst, &src, 1, 1, 50, 50);

3322

        blit_buffer(&mut dst, &src, 1, 1, -50, -50);

3323

        assert!(dst.data().iter().all(|&b| b == 0));

3324

3325

3326

    #[test]

3327

    fn blit_buffer_src_shorter_than_its_declared_size_is_skipped_not_panic() {

3328

        // Claims 4x4 but only carries 2 pixels — the bounds guard must skip the rest.

3329

        let src = vec![7u8, 7, 7, 255, 8, 8, 8, 255];

3330

        let mut dst = filled(4, 4, CLEAR);

3331

        blit_buffer(&mut dst, &src, 4, 4, 0, 0);

3332

        assert_eq!(get(&dst, 0, 0), [7, 7, 7, 255]);

3333

        assert_eq!(get(&dst, 1, 0), [8, 8, 8, 255]);

3334

        assert_eq!(get(&dst, 2, 0), CLEAR);

3335

        assert_eq!(get(&dst, 3, 3), CLEAR);

3336

3337

3338

    #[test]

3339

    fn blit_buffer_empty_src_is_a_noop() {

3340

        let mut dst = filled(2, 2, WHITE);

3341

        blit_buffer(&mut dst, &[], 2, 2, 0, 0);

3342

        assert!(dst.data().iter().all(|&b| b == 255));

3343

3344

3345

    #[test]

3346

    fn blit_buffer_zero_src_dimensions_are_a_noop() {

3347

        let src = vec![9u8, 9, 9, 255];

3348

        let mut dst = filled(2, 2, WHITE);

3349

        blit_buffer(&mut dst, &src, 0, 0, 0, 0);

3350

        blit_buffer(&mut dst, &src, 0, 1, 0, 0);

3351

        blit_buffer(&mut dst, &src, 1, 0, 0, 0);

3352

        assert!(dst.data().iter().all(|&b| b == 255));

3353

3354

3355

    #[test]

3356

    fn blit_buffer_u32_max_src_dimensions_are_a_noop() {

3357

        // `src_w as i32` is -1, so both loops are empty.

3358

        let src = vec![9u8, 9, 9, 255];

3359

        let mut dst = filled(2, 2, WHITE);

3360

        blit_buffer(&mut dst, &src, u32::MAX, u32::MAX, 0, 0);

3361

        assert!(dst.data().iter().all(|&b| b == 255));

3362

3363

3364

    #[test]

3365

    fn blit_buffer_extreme_offsets_do_not_panic() {

3366

        let src = vec![9u8; 2 * 2 * 4];

3367

        let mut dst = filled(4, 4, CLEAR);

3368

        blit_buffer(&mut dst, &src, 2, 2, i32::MAX, 0);

3369

        blit_buffer(&mut dst, &src, 2, 2, 0, i32::MAX);

3370

        blit_buffer(&mut dst, &src, 2, 2, i32::MIN, i32::MIN);

3371

        assert!(dst.data().iter().all(|&b| b == 0));

3372

3373

3374

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

3375

    // snapshot_region / write_region (numeric + round-trip)

3376

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

3377

3378

    #[test]

3379

    fn snapshot_region_copies_the_requested_box() {

3380

        let p = marked(4, 4);

3381

        let snap = snapshot_region(&p, 1, 1, 2, 2);

3382

        assert_eq!(snap.len(), 2 * 2 * 4);

3383

        assert_eq!(&snap[0..4], &[5, 0, 0, 255]); // (1,1)

3384

        assert_eq!(&snap[4..8], &[6, 0, 0, 255]); // (2,1)

3385

        assert_eq!(&snap[8..12], &[9, 0, 0, 255]); // (1,2)

3386

        assert_eq!(&snap[12..16], &[10, 0, 0, 255]); // (2,2)

3387

3388

3389

    #[test]

3390

    fn snapshot_region_zero_size_is_an_empty_vec() {

3391

        let p = marked(4, 4);

3392

        assert!(snapshot_region(&p, 0, 0, 0, 0).is_empty());

3393

        assert!(snapshot_region(&p, 0, 0, 4, 0).is_empty());

3394

        assert!(snapshot_region(&p, 0, 0, 0, 4).is_empty());

3395

3396

3397

    #[test]

3398

    fn snapshot_region_out_of_bounds_pixels_are_zero_filled() {

3399

        let p = filled(2, 2, WHITE);

3400

        let snap = snapshot_region(&p, 1, 1, 2, 2);

3401

        assert_eq!(snap.len(), 16);

3402

        assert_eq!(&snap[0..4], &WHITE, "only (1,1) is inside the pixmap");

3403

        assert_eq!(&snap[4..8], &CLEAR);

3404

        assert_eq!(&snap[8..12], &CLEAR);

3405

        assert_eq!(&snap[12..16], &CLEAR);

3406

3407

3408

    #[test]

3409

    fn snapshot_region_negative_origin_is_partially_zero_filled() {

3410

        let p = marked(2, 2);

3411

        let snap = snapshot_region(&p, -1, -1, 2, 2);

3412

        assert_eq!(&snap[0..4], &CLEAR);

3413

        assert_eq!(&snap[4..8], &CLEAR);

3414

        assert_eq!(&snap[8..12], &CLEAR);

3415

        assert_eq!(&snap[12..16], &[0, 0, 0, 255], "pixel (0,0) of the source");

3416

3417

3418

    #[test]

3419

    fn snapshot_region_fully_offscreen_is_all_zeroes() {

3420

        let p = filled(4, 4, WHITE);

3421

        let snap = snapshot_region(&p, 100, 100, 2, 2);

3422

        assert!(snap.iter().all(|&b| b == 0));

3423

3424

3425

    #[test]

3426

    fn snapshot_region_extreme_origin_does_not_panic() {

3427

        // Every sampled pixel is off-screen, so the result must be all zeroes —

3428

        // not an `x + px` overflow.

3429

        let p = filled(4, 4, WHITE);

3430

        let snap = snapshot_region(&p, i32::MAX, 0, 2, 2);

3431

        assert!(snap.iter().all(|&b| b == 0));

3432

        let snap = snapshot_region(&p, 0, i32::MAX, 2, 2);

3433

        assert!(snap.iter().all(|&b| b == 0));

3434

        let snap = snapshot_region(&p, i32::MIN, i32::MIN, 2, 2);

3435

        assert!(snap.iter().all(|&b| b == 0));

3436

3437

3438

    #[test]

3439

    fn write_region_overwrites_without_blending() {

3440

        // Unlike blit_buffer, a fully transparent src must still clobber dst.

3441

        let src = vec![0u8; 4];

3442

        let mut dst = filled(2, 2, WHITE);

3443

        write_region(&mut dst, &src, 1, 1, 0, 0);

3444

        assert_eq!(get(&dst, 0, 0), CLEAR, "write_region is a direct copy");

3445

        assert_eq!(get(&dst, 1, 1), WHITE);

3446

3447

3448

    #[test]

3449

    fn write_region_places_pixels_at_the_offset() {

3450

        let src = vec![1u8, 2, 3, 4, 5, 6, 7, 8];

3451

        let mut dst = filled(4, 1, CLEAR);

3452

        write_region(&mut dst, &src, 2, 1, 2, 0);

3453

        assert_eq!(get(&dst, 2, 0), [1, 2, 3, 4]);

3454

        assert_eq!(get(&dst, 3, 0), [5, 6, 7, 8]);

3455

        assert_eq!(get(&dst, 0, 0), CLEAR);

3456

3457

3458

    #[test]

3459

    fn write_region_out_of_bounds_pixels_are_skipped() {

3460

        let src = vec![9u8; 2 * 2 * 4];

3461

        let mut dst = filled(2, 2, CLEAR);

3462

        write_region(&mut dst, &src, 2, 2, 1, 1);

3463

        assert_eq!(get(&dst, 1, 1), [9, 9, 9, 9]);

3464

        assert_eq!(get(&dst, 0, 0), CLEAR);

3465

3466

3467

    #[test]

3468

    fn write_region_negative_coords_clip() {

3469

        let src = vec![1u8, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4];

3470

        let mut dst = filled(2, 2, CLEAR);

3471

        write_region(&mut dst, &src, 2, 2, -1, -1);

3472

        assert_eq!(get(&dst, 0, 0), [4, 4, 4, 4]);

3473

        assert_eq!(get(&dst, 1, 1), CLEAR);

3474

3475

3476

    #[test]

3477

    fn write_region_short_src_is_skipped_not_panic() {

3478

        let src = vec![7u8, 7, 7, 7];

3479

        let mut dst = filled(4, 4, CLEAR);

3480

        write_region(&mut dst, &src, 4, 4, 0, 0);

3481

        assert_eq!(get(&dst, 0, 0), [7, 7, 7, 7]);

3482

        assert_eq!(get(&dst, 1, 0), CLEAR);

3483

3484

3485

    #[test]

3486

    fn write_region_zero_dimensions_are_a_noop() {

3487

        let src = vec![9u8; 16];

3488

        let mut dst = filled(2, 2, WHITE);

3489

        write_region(&mut dst, &src, 0, 0, 0, 0);

3490

        assert!(dst.data().iter().all(|&b| b == 255));

3491

3492

3493

    #[test]

3494

    fn write_region_u32_max_dimensions_are_a_noop() {

3495

        let src = vec![9u8; 16];

3496

        let mut dst = filled(2, 2, WHITE);

3497

        write_region(&mut dst, &src, u32::MAX, u32::MAX, 0, 0);

3498

        assert!(dst.data().iter().all(|&b| b == 255));

3499

3500

3501

    #[test]

3502

    fn write_region_extreme_coords_do_not_panic() {

3503

        let src = vec![9u8; 2 * 2 * 4];

3504

        let mut dst = filled(4, 4, CLEAR);

3505

        write_region(&mut dst, &src, 2, 2, i32::MAX, 0);

3506

        write_region(&mut dst, &src, 2, 2, 0, i32::MAX);

3507

        write_region(&mut dst, &src, 2, 2, i32::MIN, i32::MIN);

3508

        assert!(dst.data().iter().all(|&b| b == 0));

3509

3510

3511

    #[test]

3512

    fn snapshot_region_then_write_region_round_trips() {

3513

        let mut p = marked(6, 6);

3514

        let snap = snapshot_region(&p, 1, 1, 3, 3);

3515

        let expected = p.data().to_vec();

3516

        p.fill_rect(1, 1, 3, 3, 0, 0, 0, 0); // destroy the region

3517

        assert_eq!(get(&p, 2, 2), CLEAR);

3518

        write_region(&mut p, &snap, 3, 3, 1, 1); // restore it

3519

        assert_eq!(

3520

            p.data(),

3521

            &expected[..],

3522

            "write_region must invert snapshot_region"

3523

);

3524

3525

3526

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

3527

    // agg_fill_path / agg_fill_path_clipped (other + numeric)

3528

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

3529

3530

    #[test]

3531

    fn agg_fill_path_paints_the_path_interior_only() {

3532

        let mut p = filled(10, 10, WHITE);

3533

        let mut path = rect_path(2.0, 2.0, 6.0, 6.0);

3534

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3535

        assert_eq!(get(&p, 5, 5), [255, 0, 0, 255], "interior is fully covered");

3536

        assert_eq!(get(&p, 0, 0), WHITE, "outside the path is untouched");

3537

        assert_eq!(get(&p, 9, 9), WHITE);

3538

3539

3540

    #[test]

3541

    fn agg_fill_path_empty_path_paints_nothing() {

3542

        let mut p = filled(8, 8, WHITE);

3543

        let mut path = PathStorage::new();

3544

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3545

        assert!(p.data().iter().all(|&b| b == 255));

3546

3547

3548

    #[test]

3549

    fn agg_fill_path_on_a_1x1_pixmap_does_not_panic() {

3550

        let mut p = filled(1, 1, WHITE);

3551

        let mut path = rect_path(0.0, 0.0, 1.0, 1.0);

3552

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3553

        assert_eq!(get(&p, 0, 0), [255, 0, 0, 255]);

3554

3555

3556

    #[test]

3557

    fn agg_fill_path_offscreen_path_paints_nothing() {

3558

        let mut p = filled(8, 8, WHITE);

3559

        let mut path = rect_path(100.0, 100.0, 10.0, 10.0);

3560

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3561

        assert!(p.data().iter().all(|&b| b == 255));

3562

3563

3564

    #[test]

3565

    fn agg_fill_path_nan_coordinates_do_not_panic() {

3566

        let mut p = filled(8, 8, WHITE);

3567

        let mut path = PathStorage::new();

3568

        path.move_to(f64::NAN, f64::NAN);

3569

        path.line_to(4.0, f64::NAN);

3570

        path.line_to(f64::NAN, 4.0);

3571

        path.close_polygon(0);

3572

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3573

        assert_eq!(p.data().len(), 8 * 8 * 4, "the buffer must stay intact");

3574

3575

3576

    #[test]

3577

    fn agg_fill_path_huge_coordinates_do_not_panic() {

3578

        let mut p = filled(8, 8, WHITE);

3579

        let mut path = rect_path(-1.0e30, -1.0e30, 2.0e30, 2.0e30);

3580

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3581

        assert_eq!(p.data().len(), 8 * 8 * 4);

3582

3583

3584

    #[test]

3585

    fn agg_fill_path_infinite_coordinates_do_not_panic() {

3586

        let mut p = filled(8, 8, WHITE);

3587

        let mut path = PathStorage::new();

3588

        path.move_to(f64::NEG_INFINITY, f64::NEG_INFINITY);

3589

        path.line_to(f64::INFINITY, f64::NEG_INFINITY);

3590

        path.line_to(f64::INFINITY, f64::INFINITY);

3591

        path.close_polygon(0);

3592

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::NonZero);

3593

        assert_eq!(p.data().len(), 8 * 8 * 4);

3594

3595

3596

    #[test]

3597

    fn agg_fill_path_clipped_none_clip_equals_unclipped() {

3598

        let mut a = filled(10, 10, WHITE);

3599

        let mut b = filled(10, 10, WHITE);

3600

        let mut pa = rect_path(1.0, 1.0, 5.0, 5.0);

3601

        let mut pb = rect_path(1.0, 1.0, 5.0, 5.0);

3602

        agg_fill_path(&mut a, &mut pa, &red(), FillingRule::NonZero);

3603

        agg_fill_path_clipped(&mut b, &mut pb, &red(), FillingRule::NonZero, None);

3604

        assert_eq!(a.data(), b.data());

3605

3606

3607

    #[test]

3608

    fn agg_fill_path_clipped_restricts_output_to_the_clip_box() {

3609

        let mut p = filled(10, 10, WHITE);

3610

        let mut path = rect_path(0.0, 0.0, 10.0, 10.0); // the whole canvas

3611

        let clip = AzRect::from_xywh(2.0, 2.0, 3.0, 3.0).expect("valid");

3612

        agg_fill_path_clipped(&mut p, &mut path, &red(), FillingRule::NonZero, Some(clip));

3613

        assert_eq!(get(&p, 3, 3), [255, 0, 0, 255], "inside the clip");

3614

        assert_eq!(get(&p, 6, 6), WHITE, "outside the clip");

3615

        assert_eq!(get(&p, 0, 0), WHITE);

3616

3617

3618

    #[test]

3619

    fn agg_fill_path_clipped_offscreen_clip_paints_nothing() {

3620

        let mut p = filled(10, 10, WHITE);

3621

        let mut path = rect_path(0.0, 0.0, 10.0, 10.0);

3622

        let clip = AzRect::from_xywh(100.0, 100.0, 5.0, 5.0).expect("valid");

3623

        agg_fill_path_clipped(&mut p, &mut path, &red(), FillingRule::NonZero, Some(clip));

3624

        assert!(

3625

            p.data().iter().all(|&b| b == 255),

3626

            "a clip box outside the buffer must reject everything"

3627

);

3628

3629

3630

    #[test]

3631

    fn agg_fill_path_clipped_empty_clip_paints_nothing() {

3632

        // `intersect_clips` returns a zero-area rect for non-overlapping nested

3633

        // clips, and documents that it must clip EVERYTHING. Nothing may leak.

3634

        let outer = AzRect::from_xywh(0.0, 0.0, 4.0, 4.0).expect("valid");

3635

        let inner = AzRect::from_xywh(10.0, 10.0, 4.0, 4.0).expect("valid");

3636

        let empty = intersect_clips(Some(outer), Some(inner)).expect("stays Some");

3637

        assert!(approx(empty.width, 0.0) && approx(empty.height, 0.0));

3638

3639

        let mut p = filled(20, 20, WHITE);

3640

        let mut path = rect_path(0.0, 0.0, 20.0, 20.0);

3641

        agg_fill_path_clipped(&mut p, &mut path, &red(), FillingRule::NonZero, Some(empty));

3642

        let painted = painted_count(&p);

3643

        assert_eq!(

3644

            painted, 0,

3645

            "an empty clip leaked {painted} painted pixel(s)"

3646

);

3647

3648

3649

    #[test]

3650

    fn agg_fill_path_evenodd_leaves_the_hole_of_a_donut_unpainted() {

3651

        let mut p = filled(12, 12, WHITE);

3652

        let mut path = PathStorage::new();

3653

        // outer ring

3654

        path.move_to(1.0, 1.0);

3655

        path.line_to(11.0, 1.0);

3656

        path.line_to(11.0, 11.0);

3657

        path.line_to(1.0, 11.0);

3658

        path.close_polygon(0);

3659

        // inner ring (same winding — only EvenOdd punches a hole)

3660

        path.move_to(4.0, 4.0);

3661

        path.line_to(8.0, 4.0);

3662

        path.line_to(8.0, 8.0);

3663

        path.line_to(4.0, 8.0);

3664

        path.close_polygon(0);

3665

        agg_fill_path(&mut p, &mut path, &red(), FillingRule::EvenOdd);

3666

        assert_eq!(get(&p, 2, 2), [255, 0, 0, 255], "the ring is painted");

3667

        assert_eq!(get(&p, 6, 6), WHITE, "the hole is not");

3668

3669

3670

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

3671

    // agg_fill_transformed_path / _clipped (other + numeric)

3672

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

3673

3674

    #[test]

3675

    fn agg_fill_transformed_path_identity_matches_the_untransformed_fill() {

3676

        let mut a = filled(10, 10, WHITE);

3677

        let mut b = filled(10, 10, WHITE);

3678

        let mut pa = rect_path(2.0, 2.0, 4.0, 4.0);

3679

        let mut pb = rect_path(2.0, 2.0, 4.0, 4.0);

3680

        agg_fill_path(&mut a, &mut pa, &red(), FillingRule::NonZero);

3681

        agg_fill_transformed_path(

3682

            &mut b,

3683

            &mut pb,

3684

            &red(),

3685

            FillingRule::NonZero,

3686

            &TransAffine::new(),

3687

);

3688

        assert_eq!(a.data(), b.data(), "an identity transform must be a no-op");

3689

3690

3691

    #[test]

3692

    fn agg_fill_transformed_path_translation_moves_the_output() {

3693

        let mut p = filled(12, 12, WHITE);

3694

        let mut path = rect_path(0.0, 0.0, 3.0, 3.0);

3695

        let t = TransAffine::new_translation(6.0, 0.0);

3696

        agg_fill_transformed_path(&mut p, &mut path, &red(), FillingRule::NonZero, &t);

3697

        assert_eq!(get(&p, 7, 1), [255, 0, 0, 255], "moved right by 6");

3698

        assert_eq!(get(&p, 1, 1), WHITE, "the original position is empty");

3699

3700

3701

    #[test]

3702

    fn agg_fill_transformed_path_zero_scale_does_not_panic() {

3703

        let mut p = filled(8, 8, WHITE);

3704

        let mut path = rect_path(1.0, 1.0, 4.0, 4.0);

3705

        let t = TransAffine::new_scaling(0.0, 0.0);

3706

        agg_fill_transformed_path(&mut p, &mut path, &red(), FillingRule::NonZero, &t);

3707

        assert!(

3708

            p.data().iter().all(|&b| b == 255),

3709

            "a degenerate transform collapses the path to a point"

3710

);

3711

3712

3713

    #[test]

3714

    fn agg_fill_transformed_path_nan_transform_does_not_panic() {

3715

        let mut p = filled(8, 8, WHITE);

3716

        let mut path = rect_path(1.0, 1.0, 4.0, 4.0);

3717

        let t = TransAffine::new_scaling(f64::NAN, 1.0);

3718

        agg_fill_transformed_path(&mut p, &mut path, &red(), FillingRule::NonZero, &t);

3719

        assert_eq!(p.data().len(), 8 * 8 * 4);

3720

3721

3722

    #[test]

3723

    fn agg_fill_transformed_path_clipped_applies_the_clip_after_the_transform() {

3724

        let mut p = filled(12, 12, WHITE);

3725

        let mut path = rect_path(0.0, 0.0, 3.0, 3.0);

3726

        let t = TransAffine::new_translation(6.0, 0.0);

3727

        // The clip box covers the ORIGINAL position, not the transformed one.

3728

        let clip = AzRect::from_xywh(0.0, 0.0, 3.0, 3.0).expect("valid");

3729

        agg_fill_transformed_path_clipped(

3730

            &mut p,

3731

            &mut path,

3732

            &red(),

3733

            FillingRule::NonZero,

3734

&t,

3735

            Some(clip),

3736

);

3737

        assert!(

3738

            p.data().iter().all(|&b| b == 255),

3739

            "the translated path lies outside the clip box"

3740

);

3741

3742

3743

    #[test]

3744

    fn agg_fill_transformed_path_clipped_empty_clip_paints_nothing() {

3745

        let outer = AzRect::from_xywh(0.0, 0.0, 4.0, 4.0).expect("valid");

3746

        let inner = AzRect::from_xywh(10.0, 10.0, 4.0, 4.0).expect("valid");

3747

        let empty = intersect_clips(Some(outer), Some(inner)).expect("stays Some");

3748

3749

        let mut p = filled(20, 20, WHITE);

3750

        let mut path = rect_path(0.0, 0.0, 20.0, 20.0);

3751

        agg_fill_transformed_path_clipped(

3752

            &mut p,

3753

            &mut path,

3754

            &red(),

3755

            FillingRule::NonZero,

3756

            &TransAffine::new(),

3757

            Some(empty),

3758

);

3759

        assert!(

3760

            p.data().iter().all(|&b| b == 255),

3761

            "an empty clip must clip everything, even on the identity fast path"

3762

);

3763

3764

3765

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

3766

    // agg_fill_gradient / agg_fill_gradient_clipped (numeric)

3767

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

3768

3769

    #[test]

3770

    fn agg_fill_gradient_paints_the_path() {

3771

        let mut p = filled(10, 10, WHITE);

3772

        let mut path = rect_path(0.0, 0.0, 10.0, 10.0);

3773

        let lut = two_stop_lut();

3774

        agg_fill_gradient(

3775

            &mut p,

3776

            &mut path,

3777

            &lut,

3778

            GradientX,

3779

            TransAffine::new(),

3780

            0.0,

3781

            10.0,

3782

);

3783

        assert_ne!(get(&p, 5, 5), WHITE, "the gradient must paint something");

3784

        assert_eq!(get(&p, 5, 5)[3], 255, "opaque stops produce opaque pixels");

3785

3786

3787

    #[test]

3788

    fn agg_fill_gradient_empty_path_paints_nothing() {

3789

        let mut p = filled(8, 8, WHITE);

3790

        let mut path = PathStorage::new();

3791

        let lut = two_stop_lut();

3792

        agg_fill_gradient(

3793

            &mut p,

3794

            &mut path,

3795

            &lut,

3796

            GradientX,

3797

            TransAffine::new(),

3798

            0.0,

3799

            8.0,

3800

);

3801

        assert!(p.data().iter().all(|&b| b == 255));

3802

3803

3804

    #[test]

3805

    fn agg_fill_gradient_zero_length_d1_eq_d2_does_not_panic() {

3806

        // d2 - d1 == 0 must not divide by zero.

3807

        let mut p = filled(8, 8, WHITE);

3808

        let mut path = rect_path(0.0, 0.0, 8.0, 8.0);

3809

        let lut = two_stop_lut();

3810

        agg_fill_gradient_clipped(

3811

            &mut p,

3812

            &mut path,

3813

            &lut,

3814

            GradientX,

3815

            TransAffine::new(),

3816

            5.0,

3817

            5.0,

3818

            None,

3819

);

3820

        assert_eq!(p.data().len(), 8 * 8 * 4);

3821

3822

3823

    #[test]

3824

    fn agg_fill_gradient_reversed_d2_lt_d1_does_not_panic() {

3825

        let mut p = filled(8, 8, WHITE);

3826

        let mut path = rect_path(0.0, 0.0, 8.0, 8.0);

3827

        let lut = two_stop_lut();

3828

        agg_fill_gradient_clipped(

3829

            &mut p,

3830

            &mut path,

3831

            &lut,

3832

            GradientX,

3833

            TransAffine::new(),

3834

            8.0,

3835

            0.0,

3836

            None,

3837

);

3838

        assert_eq!(p.data().len(), 8 * 8 * 4);

3839

3840

3841

    #[test]

3842

    fn agg_fill_gradient_nan_and_inf_distances_do_not_panic() {

3843

        let lut = two_stop_lut();

3844

        for (d1, d2) in [

3845

            (f64::NAN, f64::NAN),

3846

            (0.0, f64::NAN),

3847

            (f64::NEG_INFINITY, f64::INFINITY),

3848

            (0.0, f64::MAX),

3849

            (f64::MIN, f64::MAX),

3850

] {

3851

            let mut p = filled(8, 8, WHITE);

3852

            let mut path = rect_path(0.0, 0.0, 8.0, 8.0);

3853

            agg_fill_gradient_clipped(

3854

                &mut p,

3855

                &mut path,

3856

                &lut,

3857

                GradientX,

3858

                TransAffine::new(),

3859

d1,

3860

d2,

3861

                None,

3862

);

3863

            assert_eq!(p.data().len(), 8 * 8 * 4, "d1={d1}, d2={d2}");

3864

3865

3866

3867

    #[test]

3868

    fn agg_fill_gradient_nan_transform_does_not_panic() {

3869

        let mut p = filled(8, 8, WHITE);

3870

        let mut path = rect_path(0.0, 0.0, 8.0, 8.0);

3871

        let lut = two_stop_lut();

3872

        agg_fill_gradient_clipped(

3873

            &mut p,

3874

            &mut path,

3875

            &lut,

3876

            GradientX,

3877

            TransAffine::new_scaling(f64::NAN, f64::NAN),

3878

            0.0,

3879

            8.0,

3880

            None,

3881

);

3882

        assert_eq!(p.data().len(), 8 * 8 * 4);

3883

3884

3885

    #[test]

3886

    fn agg_fill_gradient_clipped_restricts_output_to_the_clip_box() {

3887

        let mut p = filled(10, 10, WHITE);

3888

        let mut path = rect_path(0.0, 0.0, 10.0, 10.0);

3889

        let lut = two_stop_lut();

3890

        let clip = AzRect::from_xywh(0.0, 0.0, 3.0, 3.0).expect("valid");

3891

        agg_fill_gradient_clipped(

3892

            &mut p,

3893

            &mut path,

3894

            &lut,

3895

            GradientX,

3896

            TransAffine::new(),

3897

            0.0,

3898

            10.0,

3899

            Some(clip),

3900

);

3901

        assert_ne!(get(&p, 1, 1), WHITE, "inside the clip");

3902

        assert_eq!(get(&p, 8, 8), WHITE, "outside the clip");

3903

3904

3905

    #[test]

3906

    fn agg_fill_gradient_clipped_empty_clip_paints_nothing() {

3907

        let outer = AzRect::from_xywh(0.0, 0.0, 4.0, 4.0).expect("valid");

3908

        let inner = AzRect::from_xywh(10.0, 10.0, 4.0, 4.0).expect("valid");

3909

        let empty = intersect_clips(Some(outer), Some(inner)).expect("stays Some");

3910

3911

        let mut p = filled(20, 20, WHITE);

3912

        let mut path = rect_path(0.0, 0.0, 20.0, 20.0);

3913

        let lut = two_stop_lut();

3914

        agg_fill_gradient_clipped(

3915

            &mut p,

3916

            &mut path,

3917

            &lut,

3918

            GradientX,

3919

            TransAffine::new(),

3920

            0.0,

3921

            20.0,

3922

            Some(empty),

3923

);

3924

        let painted = painted_count(&p);

3925

        assert_eq!(

3926

            painted, 0,

3927

            "an empty clip leaked {painted} painted pixel(s)"

3928

);

3929

3930

3931

    #[test]

3932

    fn agg_fill_gradient_on_a_1x1_pixmap_does_not_panic() {

3933

        let mut p = filled(1, 1, WHITE);

3934

        let mut path = rect_path(0.0, 0.0, 1.0, 1.0);

3935

        let lut = two_stop_lut();

3936

        agg_fill_gradient(

3937

            &mut p,

3938

            &mut path,

3939

            &lut,

3940

            GradientX,

3941

            TransAffine::new(),

3942

            0.0,

3943

            1.0,

3944

);

3945

        assert_eq!(p.data().len(), 4);

3946

3947

3948

3949

#[cfg(test)]

3950

mod pixbuf_tests {

3951

    use super::*;

3952

3953

    #[test]

3954

1

    fn external_pixmap_reads_and_writes_the_callers_memory_and_never_frees_it() {

3955

1

        let mut backing = vec![7u8; 4 * 2 * 4];

3956

1

        let ptr = backing.as_mut_ptr();

3957

3958

1

            let mut p = unsafe { AzulPixmap::from_external(ptr, 4, 2) }.unwrap();

3959

1

            assert!(p.is_external());

3960

1

            assert_eq!(p.data.len(), 32);

3961

32

            assert!(p.data.iter().all(|&b| b == 7), "reads the caller's bytes");

3962

1

            p.data[0] = 42;

3963

            // Clone SNAPSHOTS to owned — must not alias the backing.

3964

1

            let mut c = AzulPixmap {

3965

1

                data: p.data.clone(),

3966

1

                width: p.width,

3967

1

                height: p.height,

3968

1

};

3969

1

            assert!(!c.is_external());

3970

1

            c.data[1] = 99;

3971

1

            assert_ne!(backing[1], 99, "clone must not write through");

3972

        } // drop of the borrowed pixmap must NOT free `backing`

3973

1

        assert_eq!(backing[0], 42, "writes went to the caller's memory");

3974

1

        assert_eq!(backing[1], 7);

3975

1

        drop(backing); // and the Vec is still validly ours to free

3976

1

3977

3978

    #[test]

3979

1

    fn into_vec_copies_out_of_borrowed_storage() {

3980

1

        let mut backing = vec![3u8; 16];

3981

1

        let p = unsafe { AzulPixmap::from_external(backing.as_mut_ptr(), 2, 2) }.unwrap();

3982

1

        let v = p.data.into_vec();

3983

1

        assert_eq!(v, vec![3u8; 16]);

3984

1

        backing[0] = 9; // backing untouched and still alive

3985

1

        assert_eq!(v[0], 3);

3986

1

3987

3988

    #[test]

3989

1

    fn from_external_rejects_null_and_zero_dims() {

3990

1

        assert!(unsafe { AzulPixmap::from_external(core::ptr::null_mut(), 4, 4) }.is_none());

3991

1

        let mut b = [0u8; 16];

3992

1

        assert!(unsafe { AzulPixmap::from_external(b.as_mut_ptr(), 0, 2) }.is_none());

3993

1

        assert!(unsafe { AzulPixmap::from_external(b.as_mut_ptr(), 2, 0) }.is_none());

3994

1

3995