crystal-api 0.0.6

Crystal API is a unified GPU API's wrapper
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::{marker::PhantomData, sync::Arc};

use crate::{
    GpuSamplerSet,
    mesh::{AttributeDescriptor, MeshBuffer},
    object::Object,
    proxies::PipelineProxy,
};

/// Empty struct used for compute pipeline as a template
pub struct ComputeDescriptor {}

impl AttributeDescriptor for ComputeDescriptor {
    fn get_attributes() -> &'static [crate::mesh::Attribute] {
        &[]
    }
}

/// Used to setup render or compute pipeline
pub struct Pipeline<V: AttributeDescriptor> {
    pub(crate) inner: Arc<dyn PipelineProxy>,
    _ty: PhantomData<V>,
}

impl<V: AttributeDescriptor> Pipeline<V> {
    pub(crate) fn new(proxy: Arc<dyn PipelineProxy>) -> Self {
        Self {
            inner: proxy,
            _ty: PhantomData,
        }
    }

    /// Creates graphics object with mesh only
    pub fn create_object_with_mesh<I>(&self, index: u32, mesh: &MeshBuffer<V, I>) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: Some(mesh.inner.clone()),
            sampler: None,
            groups: None,
            index,
            array: 1,
        }
    }

    /// Creates graphics object with mesh and textures
    pub fn create_object_with_mesh_sampled<I>(
        &self,
        index: u32,
        mesh: &MeshBuffer<V, I>,
        sampler: Arc<GpuSamplerSet>,
    ) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: Some(mesh.inner.clone()),
            sampler: Some(sampler),
            groups: None,
            index,
            array: 1,
        }
    }

    /// Creates array of graphics objects with mesh
    pub fn create_object_with_mesh_array<I>(
        &self,
        index: u32,
        mesh: &MeshBuffer<V, I>,
        array: u32,
    ) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: Some(mesh.inner.clone()),
            sampler: None,
            groups: None,
            index,
            array,
        }
    }

    /// Creates array of graphics objects with mesh and textures
    pub fn create_object_with_mesh_sampled_array<I>(
        &self,
        index: u32,
        mesh: &MeshBuffer<V, I>,
        sampler: Arc<GpuSamplerSet>,
        array: u32,
    ) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: Some(mesh.inner.clone()),
            sampler: Some(sampler),
            groups: None,
            index,
            array,
        }
    }
}

impl Pipeline<ComputeDescriptor> {
    /// Creates compute object. Need to specify compute groups
    pub fn create_object_compute(&self, groups: [u32; 3]) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: None,
            sampler: None,
            groups: Some(groups),
            index: 0,
            array: 0,
        }
    }

    /// Creates compute object with samplers
    pub fn create_object_compute_with_samplers(
        &self,
        groups: [u32; 3],
        sampler: Arc<GpuSamplerSet>,
    ) -> Object {
        Object {
            pipeline: self.inner.clone(),
            mesh_buffer: None,
            sampler: Some(sampler),
            groups: Some(groups),
            index: 0,
            array: 0,
        }
    }
}