skia

// Generated by mix skia.codegen. Do not edit by hand.

fn draw_image<'a>(canvas: &skia_safe::Canvas, command: Term<'a>) -> NifResult<()> {
    let args = decode_args(command)?;
    let opts = decode_opts(command)?;
    let decoded_opts = generated_opts::decode_image_opts(&opts)?;
    draw_image_impl(canvas, args, decoded_opts, &opts)
}
fn draw_image_impl<'a>(
    canvas: &skia_safe::Canvas,
    args: Vec<Term<'a>>,
    opts: generated_opts::ImageOpts<'a>,
    raw_opts: &[(Atom, Term<'a>)],
) -> NifResult<()> {
    let image = image_from_term(*args.first().ok_or(rustler::Error::BadArg)?)?;
    let mut paint = Paint::default();
    paint.set_anti_alias(true);
    if let Some(opacity) = opts.opacity {
        let alpha = (opacity.clamp(0.0, 1.0) * 255.0).round() as u8;
        paint.set_alpha(alpha);
    }
    apply_blend_mode(&mut paint, raw_opts)?;
    let sampling = opt_sampling(raw_opts, atoms::sampling())?;
    let source = match opts.source {
        Some(term) => Some(rect_from_term(term)?),
        None => None,
    };
    match opts.width {
        Some(width) => {
            match opts.height {
                Some(height) => {
                    let src = source
                        .as_ref()
                        .map(|rect| (rect, SrcRectConstraint::Strict));
                    canvas
                        .draw_image_rect_with_sampling_options(
                            image,
                            src,
                            Rect::from_xywh(opts.x, opts.y, width, height),
                            sampling,
                            &paint,
                        );
                }
                None => {
                    draw_image_source_or_default(
                        canvas,
                        image,
                        source,
                        opts,
                        sampling,
                        &paint,
                    );
                }
            };
        }
        None => {
            draw_image_source_or_default(canvas, image, source, opts, sampling, &paint);
        }
    };
    Ok(())
}
fn draw_picture<'a>(canvas: &skia_safe::Canvas, command: Term<'a>) -> NifResult<()> {
    let args = decode_args(command)?;
    let opts = decode_opts(command)?;
    let decoded_opts = generated_opts::decode_picture_opts(&opts)?;
    draw_picture_impl(canvas, args, decoded_opts, &opts)
}
fn draw_picture_impl<'a>(
    canvas: &skia_safe::Canvas,
    args: Vec<Term<'a>>,
    opts: generated_opts::PictureOpts<'a>,
    raw_opts: &[(Atom, Term<'a>)],
) -> NifResult<()> {
    let picture = picture_from_term(*args.first().ok_or(rustler::Error::BadArg)?)?;
    let mut paint = Paint::default();
    paint.set_anti_alias(true);
    if let Some(opacity) = opts.opacity {
        let alpha = (opacity.clamp(0.0, 1.0) * 255.0).round() as u8;
        paint.set_alpha(alpha);
    }
    apply_blend_mode(&mut paint, raw_opts)?;
    canvas.save();
    canvas.translate((opts.x.unwrap_or(0.0), opts.y.unwrap_or(0.0)));
    canvas.draw_picture(picture, None, Some(&paint));
    canvas.restore();
    Ok(())
}
fn draw_image_source_or_default<'a>(
    canvas: &skia_safe::Canvas,
    image: Image,
    source: Option<Rect>,
    opts: generated_opts::ImageOpts<'a>,
    sampling: SamplingOptions,
    paint: &Paint,
) -> () {
    match source {
        Some(source) => {
            canvas
                .draw_image_rect_with_sampling_options(
                    image,
                    Some((&source, SrcRectConstraint::Strict)),
                    Rect::from_xywh(opts.x, opts.y, source.width(), source.height()),
                    sampling,
                    paint,
                );
        }
        None => {
            canvas
                .draw_image_with_sampling_options(
                    image,
                    (opts.x, opts.y),
                    sampling,
                    Some(paint),
                );
        }
    };
    ()
}