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
use super::ShaderLayout;
use bevy_asset::Handle;
use bevy_glsl_to_spirv::compile;
use std::{io::Read, marker::Copy};
#[derive(Hash, Eq, PartialEq, Copy, Clone, Debug)]
pub enum ShaderStage {
Vertex,
Fragment,
Compute,
}
impl Into<bevy_glsl_to_spirv::ShaderType> for ShaderStage {
fn into(self) -> bevy_glsl_to_spirv::ShaderType {
match self {
ShaderStage::Vertex => bevy_glsl_to_spirv::ShaderType::Vertex,
ShaderStage::Fragment => bevy_glsl_to_spirv::ShaderType::Fragment,
ShaderStage::Compute => bevy_glsl_to_spirv::ShaderType::Compute,
}
}
}
fn glsl_to_spirv(
glsl_source: &str,
stage: ShaderStage,
shader_defs: Option<&[String]>,
) -> Vec<u32> {
let mut output = compile(glsl_source, stage.into(), shader_defs).unwrap();
let mut spv_bytes = Vec::new();
output.read_to_end(&mut spv_bytes).unwrap();
bytes_to_words(&spv_bytes)
}
fn bytes_to_words(bytes: &[u8]) -> Vec<u32> {
let mut words = Vec::new();
for bytes4 in bytes.chunks(4) {
words.push(u32::from_le_bytes([
bytes4[0], bytes4[1], bytes4[2], bytes4[3],
]));
}
words
}
#[derive(Clone, Debug, Hash, Eq, PartialEq)]
pub enum ShaderSource {
Spirv(Vec<u32>),
Glsl(String),
}
impl ShaderSource {
pub fn spirv_from_bytes(bytes: &[u8]) -> ShaderSource {
ShaderSource::Spirv(bytes_to_words(bytes))
}
}
#[derive(Clone, Debug)]
pub struct Shader {
pub source: ShaderSource,
pub stage: ShaderStage,
}
impl Shader {
pub fn new(stage: ShaderStage, source: ShaderSource) -> Shader {
Shader { stage, source }
}
pub fn from_glsl(stage: ShaderStage, glsl: &str) -> Shader {
Shader {
source: ShaderSource::Glsl(glsl.to_string()),
stage,
}
}
pub fn get_spirv(&self, macros: Option<&[String]>) -> Vec<u32> {
match self.source {
ShaderSource::Spirv(ref bytes) => bytes.clone(),
ShaderSource::Glsl(ref source) => glsl_to_spirv(&source, self.stage, macros),
}
}
pub fn get_spirv_shader(&self, macros: Option<&[String]>) -> Shader {
Shader {
source: ShaderSource::Spirv(self.get_spirv(macros)),
stage: self.stage,
}
}
pub fn reflect_layout(&self, enforce_bevy_conventions: bool) -> Option<ShaderLayout> {
if let ShaderSource::Spirv(ref spirv) = self.source {
Some(ShaderLayout::from_spirv(
spirv.as_slice(),
enforce_bevy_conventions,
))
} else {
panic!("Cannot reflect layout of non-SpirV shader. Try compiling this shader to SpirV first using self.get_spirv_shader()");
}
}
}
#[derive(Clone, Debug)]
pub struct ShaderStages {
pub vertex: Handle<Shader>,
pub fragment: Option<Handle<Shader>>,
}
impl ShaderStages {
pub fn new(vertex_shader: Handle<Shader>) -> Self {
ShaderStages {
vertex: vertex_shader,
fragment: None,
}
}
}