kahlo 0.0.3

Optimized software rendering library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::{
    bitmap::{BitmapAccess, BitmapRawDataMut},
    colour::{read_from_bytes, write_as_bytes, BlendMode, Colour},
    formats::{PixelFormatSpec, Rgba32, A8},
    math::{PixelBox, PixelPoint},
    op::binary_map_pixel_data_with,
};

use super::{
    dispatch::{GenericUnary, UnaryDispatch},
    UnaryOpSpec,
};

#[cfg(target_arch = "x86_64")]
mod x86_64;

pub struct FillRegionMaskedOp;

type OpParams<'l> = (
    &'l dyn BitmapAccess<A8>,
    PixelBox,
    PixelPoint,
    Colour,
    BlendMode,
);

#[cfg(any(test, feature = "benchmark"))]
const _: () = {
    use super::generate;
    impl generate::UnaryInputSpec for FillRegionMaskedOp {
        fn gen<'l>() -> impl generate::ValueGeneratorList<'l, OutputTuple = Self::Params<'l>> {
            (
                generate::alphamap,
                generate::alphamap_area,
                generate::dst_point,
                generate::random_colour,
                generate::blend_mode,
            )
        }
    }
};

impl<'l> GenericUnary<OpParams<'l>> for FillRegionMaskedOp {
    fn perform<Format: PixelFormatSpec>(
        write_data: &mut dyn BitmapRawDataMut,
        params: &OpParams<'l>,
    ) {
        let (read_alphamap, read_box, dst, colour, blend) = params;

        binary_map_pixel_data_with::<0usize, Format, A8>(
            write_data,
            *read_alphamap,
            read_box.size(),
            *dst,
            read_box.min,
            |dst_slice, src_slice| {
                let mut dx = 0;
                let mut sx = 0;
                while dx < dst_slice.len() {
                    let existing = read_from_bytes::<Format>(&dst_slice[dx..]);
                    let new_alpha = src_slice[sx];

                    let new_colour = blend.blend(
                        &Colour {
                            a: new_alpha,
                            ..*colour
                        },
                        &existing,
                    );

                    write_as_bytes::<Format>(&new_colour, &mut dst_slice[dx..]);

                    dx += Format::PIXEL_STRIDE;
                    sx += A8::PIXEL_STRIDE;
                }
            },
        );
    }
}

impl UnaryOpSpec for FillRegionMaskedOp {
    type Params<'l> = OpParams<'l>;
    fn build<'l>() -> UnaryDispatch<Self::Params<'l>> {
        UnaryDispatch::from_generic::<Self>().with_avx::<Rgba32>(x86_64::avx_rbga32)
    }
}