spirv-cross2 0.4.5

Safe Rust bindings to SPIRV-Cross
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

# spirv-cross2


Safe and sound Rust bindings to [SPIRV-Cross](https://github.com/KhronosGroup/SPIRV-Cross).

[![Latest Version](https://img.shields.io/crates/v/spirv-cross2.svg)](https://crates.io/crates/spirv-cross2) [![Docs](https://docs.rs/spirv-cross2/badge.svg)](https://docs.rs/spirv-cross2)
![Crates.io MSRV](https://img.shields.io/crates/msrv/spirv-cross2)
![License](https://img.shields.io/crates/l/spirv-cross2)

 All backends exposed by the SPIRV-Cross C API are fully supported, including

 * GLSL
 * HLSL
 * MSL
 * JSON
 * C++
 * Reflection Only

 The API provided is roughly similar to the SPIRV-Cross [`Compiler`](https://github.com/KhronosGroup/SPIRV-Cross/blob/main/spirv_cross.hpp) C++ API,
 with some inspiration from [naga](https://docs.rs/naga/latest/naga/index.html). A best effort has been
 made to ensure that these bindings are sound, and that mutations occur strictly within Rust's borrow rules.

 ## Usage
 Here is an example of using the API to do some reflection and compile to GLSL.

 ```rust
 use spirv_cross2::compile::{CompilableTarget, CompiledArtifact};
 use spirv_cross2::{Module, SpirvCrossContext, SpirvCrossError};
 use spirv_cross2::compile::glsl::GlslVersion;
 use spirv_cross2::reflect::{DecorationValue, ResourceType};
 use spirv_cross2::spirv;
 use spirv_cross2::targets::Glsl;

 fn compile_spirv(words: &[u32]) -> Result<CompiledArtifact<'static, Glsl>, SpirvCrossError> {
     let module = Module::from_words(words);
     let context = SpirvCrossContext::new()?;

     let mut compiler = context.into_compiler::<Glsl>(module)?;

     let resources = compiler.shader_resources()?;

     for resource in resources.resources_for_type(ResourceType::SampledImage)? {
         let Some(DecorationValue::Literal(set)) =
                 compiler.decoration(resource.id,  spirv::Decoration::DescriptorSet)? else {
             continue;
         };
         let Some(DecorationValue::Literal(binding)) =
             compiler.decoration(resource.id,  spirv::Decoration::Binding)? else {
             continue;
         };

         println!("Image {} at set = {}, binding = {}", resource.name, set, binding);

         // Modify the decoration to prepare it for GLSL.
         compiler.set_decoration(resource.id, spirv::Decoration::DescriptorSet,
                 DecorationValue::unset())?;

         // Some arbitrary remapping if we want.
         compiler.set_decoration(resource.id, spirv::Decoration::Binding,
             Some(set * 16 + binding))?;
     }

     let mut options = Glsl::options();
     options.version = GlslVersion::Glsl300Es;

     compiler.compile(&options)
 }
 ```

## Features

By default, the `glsl`, `hlsl`, and `msl` features are enabled by default. The `cpp` and `json` targets can be enabled
in Cargo.toml

```toml
 [dependencies]
 spirv-cross2 = { features = ["cpp", "json"] }
```

SPIRV-Cross will only be built with support for enabled targets. If you want to only perform reflection and shrink the binary size,
you can disable all but the `None` target.

```toml
 [dependencies]
 spirv-cross2 = { default-features = false }
```

To enable all features, including `f16` and vector constant support, use the `full` feature.

```toml
 [dependencies]
 spirv-cross2 = { features = ["full"] }
```

### `f16` and vector specialization constants support

When querying specialization constants, spirv-cross2 includes optional support for `f16` via [half](https://crates.io/crates/half) and vector and matrix types
via [glam](https://crates.io/crates/glam) and [gfx-maths](https://crates.io/crates/gfx-maths).

```toml
 [dependencies]
 spirv-cross2 = { features = ["f16", "gfx-maths-types", "glam-types"] }
```

## License

This project is licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or [MIT license](LICENSE-MIT), at your option.

## Contributing 


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed under the terms of both the Apache License, Version 2.0 and the MIT license without any additional terms or conditions.