starlight-renderer 0.0.1

WIP renderer framework
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
107
108
109
110

use std::sync::Arc;

use glam::Vec4;
use tokio::sync::RwLock;
use vulkano::{
    DeviceSize, Validated,
    buffer::{AllocateBufferError, BufferContents},
};

use crate::{
    Context,
    images::ImageRefData,
    materials::MaterialHandle,
    resource_manager::{ResourceHandle, ResourceManager},
    resources::{ReadOp, buffer::Bda, image::ImageReadOp},
};

#[derive(Debug, BufferContents, Clone, Copy)]
#[repr(C)]
struct PbrBufferData {
    color: Vec4,
    color_image: Option<Bda<'static, ImageRefData>>,
}
#[derive(Debug)]
pub struct PbrData {
    pub color: Vec4,
    pub color_image: Option<Arc<dyn ImageReadOp>>,
}
impl PbrData {
    fn to_buffer_data(&self) -> PbrBufferData {
        PbrBufferData {
            color: self.color,
            color_image: self
                .color_image
                .as_ref()
                // # Safety
                // a handle to this is held for as long as this is potentially accessed
                .map(|v| unsafe { v.image_ref().bda().to_static() }),
        }
    }
}

#[derive(Debug)]
pub struct PbrMaterial {
    data: RwLock<PbrData>,
    handle: ResourceHandle<PbrBufferData>,
}
impl MaterialHandle for PbrMaterial {
    unsafe fn get_device_ptr(&self) -> DeviceSize {
        // # Safety
        // this surrounding function has the same guarantees that this needs
        unsafe {
            self.handle
                .device_address()
                .unwrap()
                .to_static()
                .as_raw()
                .get()
        }
    }

    fn get_read_ops(&self) -> impl IntoIterator<Item = Arc<dyn ReadOp>> {
        // TODO: figure out how to make this lockless
        // TODO: make this work for both runtime flavors? maybe?
        let v = tokio::task::block_in_place(|| self.data.blocking_read());
        v.color_image.clone().map(|v| v as _)
    }
}
impl PbrMaterial {
    pub async fn update(&self, new_data: PbrData) {
        self.handle
            .new_wite_op()
            .write(|mut v| *v = new_data.to_buffer_data())
            .await
            .unwrap();
        *self.data.write().await = new_data;
    }
}

const MATERIAL_BUFFER_SIZE: u64 = 512;
pub struct PbrMaterialManager {
    manager: Arc<ResourceManager<PbrBufferData>>,
}
impl PbrMaterialManager {
    pub fn new() -> Self {
        Self {
            manager: ResourceManager::new(MATERIAL_BUFFER_SIZE),
        }
    }
    pub async fn alloc(
        &self,
        ctx: &Context,
        data: PbrData,
    ) -> Result<Arc<PbrMaterial>, Validated<AllocateBufferError>> {
        let handle = self.manager.alloc(ctx, data.to_buffer_data()).await?;
        Ok(Arc::new(PbrMaterial {
            handle,
            data: RwLock::new(data),
        }))
    }
}

pub mod fs {
    vulkano_shaders::shader! {
        vulkan_version: "1.3",
        ty: "fragment",
        path: "src/materials/simple_pbr.frag",
        include: ["src/materials/", "src/pipeline_pieces/"],
    }
}