kahlo 0.0.2

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

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

use super::{
    dispatch::{BinaryDispatch, GenericBinary},
    BinaryOpSpec,
};

pub struct CompositeOp;

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

impl<'l> GenericBinary<(PixelBox, PixelPoint, BlendMode)> for CompositeOp {
    fn perform<Format: PixelFormatSpec, SrcFormat: PixelFormatSpec>(
        write_data: &mut dyn BitmapRawDataMut,
        read_data: &dyn BitmapRawData,
        params: &(PixelBox, PixelPoint, BlendMode),
    ) {
        let (read_box, dst, bmode) = params;

        binary_map_pixel_data_with::<0usize, Format, SrcFormat>(
            write_data,
            read_data,
            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 source = read_from_bytes::<SrcFormat>(&src_slice[sx..]);
                    let blended = bmode.blend(&source, &existing);
                    write_as_bytes::<Format>(&blended, &mut dst_slice[dx..]);

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

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

impl BinaryOpSpec for CompositeOp {
    type Params<'l> = (PixelBox, PixelPoint, BlendMode);
    fn build<'l>() -> BinaryDispatch<Self::Params<'l>> {
        BinaryDispatch::from_generic::<Self>().with_avx::<Rgba32, Rgba32>(x86_64::avx_rgba32_rgba32)
    }
}