goldy 0.2.0

Fondaco Machine GPU runtime for Rust (Vulkan, DX12, Metal)
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Scheme render-pass helpers for integration and screenshot tests.
//!
//! Included from multiple integration test binaries; not every entry point is used in each crate.
#![allow(dead_code)]

use goldy::{
    Context, DepthFormat, Device, MemoryExchange, Parcel, Scheme, Submission, Texture, TextureFlags, TextureFormat,
    TextureKind, WithdrawTransaction,
};
use std::sync::Arc;

/// Acquire a texture parcel suitable as a copy destination and withdraw source.
pub fn acquire_readback_texture(
    pool: &mut goldy::RetainedPool,
    width: u32,
    height: u32,
    format: TextureFormat,
) -> Texture {
    pool.acquire_texture(
        width,
        height,
        format,
        TextureKind::Direct,
        TextureFlags::COPY_SRC | TextureFlags::COPY_DST,
        None,
    )
    .expect("acquire readback texture")
}

pub fn read_grant_texture(grant: &WithdrawTransaction, submission: &mut Submission) -> Vec<u8> {
    grant
        .claim(submission)
        .expect("claim")
        .consume()
        .expect("withdraw consume")
        .to_vec()
}

/// Record render pass → copy-to-texture → withdraw once on a new scheme.
pub fn scheme_record_readback(
    ctx: &Context,
    width: u32,
    height: u32,
    format: TextureFormat,
    depth_format: Option<DepthFormat>,
    readback: &Parcel,
    label: &'static str,
    color_load: goldy::TargetLoad,
    record: impl FnOnce(&mut goldy::SchemeRenderPassBuilder<'_>),
) -> (Scheme, WithdrawTransaction) {
    let mut scheme = Scheme::new(ctx);
    let rt = scheme
        .lease_render_target(width, height, format, depth_format)
        .expect("render target lease");
    {
        let mut pass = scheme.render_pass(label, &rt, color_load);
        record(&mut pass);
        pass.finish();
    }
    scheme.copy_to_texture(&rt, readback).expect("copy_to_texture");
    let grant = MemoryExchange::new(scheme.context())
        .bind_withdraw(&mut scheme, readback)
        .expect("withdraw");
    (scheme, grant)
}

/// Record once, submit once, consume withdraw claim, and return pixels.
pub fn scheme_render_and_readback(
    ctx: &Context,
    width: u32,
    height: u32,
    format: TextureFormat,
    depth_format: Option<DepthFormat>,
    readback: &Parcel,
    label: &'static str,
    color_load: goldy::TargetLoad,
    record: impl FnOnce(&mut goldy::SchemeRenderPassBuilder<'_>),
) -> Vec<u8> {
    let (mut scheme, grant) = scheme_record_readback(
        ctx,
        width,
        height,
        format,
        depth_format,
        readback,
        label,
        color_load,
        record,
    );
    let mut frame = scheme.submit().expect("submit");
    read_grant_texture(&grant, &mut frame)
}

pub fn make_device() -> Option<Device> {
    let instance = goldy::Instance::new().ok()?;
    instance
        .request_adapter(&goldy::RequestAdapterOptions::default())
        .ok()?
        .request_device(&goldy::DeviceDescriptor::default())
        .ok()
}

pub fn device_and_pool() -> Option<(Device, goldy::RetainedPool)> {
    let device = make_device()?;
    Some((device.clone(), goldy::RetainedPool::new(Arc::new(device))))
}