let-engine 0.10.0

game engine
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

//! Default shaders.

use std::sync::Arc;

use anyhow::{Context, Result};
use vulkano::{
    device::Device,
    shader::{spirv::bytes_to_words, ShaderModule, ShaderModuleCreateInfo},
};

fn from_bytes(bytes: &[u8], device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    let code = bytes_to_words(bytes)?;
    Ok(unsafe { ShaderModule::new(device, ShaderModuleCreateInfo::new(&code))? })
}

pub fn vertex_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/default_vert.spv"), device)
        .context("There was a problem making the default vertex shader.")
}

pub fn fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/default_frag.spv"), device)
        .context("There was a problem making the default fragment shader.")
}

pub fn instanced_vertex_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/instance_vert.spv"), device)
        .context("There was a problem making the default instanced vertex shader.")
}

pub fn instanced_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/instance_frag.spv"), device)
        .context("There was a problem making the default instanced fragment shader.")
}

pub fn textured_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/textured_frag.spv"), device)
        .context("There was a problem making the default textured fragment shader.")
}

pub fn texture_array_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/texture_array_frag.spv"), device)
        .context("There was a problem making the default texture array fragment shader.")
}

pub fn instanced_textured_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/textured_instance_frag.spv"), device)
        .context("There was a problem making the default instanced texture fragment shader.")
}

pub fn instanced_texture_array_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(
        include_bytes!("shaders/texture_array_instance_frag.spv"),
        device,
    )
    .context("There was a problem making the default instanced texture array fragment shader.")
}

#[cfg(feature = "labels")]
pub fn text_fragment_shader(device: Arc<Device>) -> Result<Arc<ShaderModule>> {
    from_bytes(include_bytes!("shaders/text_frag.spv"), device)
        .context("There was a problem making the labels fragment shader.")
}