Crate nox_spirv 

Compact SPIR-V reflection library written in pure-Rust, with zero dependencies and minimal allocations.

Allocation policy

• Strings and arrays are just slices to the SPIR-V passed to Module.
• Only decorations and instructions streams with a result id are cached using an extra allocation.
• Parsing is mostly done on-demand.

Usage

use nox_spirv::op;
use nox_spirv::Module;
use nox_spirv::reflect::{Reflector, ResourceType};
 
let spirv: &[u32] = ...;
let module = Module::new(spirv);
let mut reflector = Reflector::new(module).unwrap();
// Must be set before reflecting resources.
reflector.set_entry_point(c"main", op::ExecutionModel::FRAGMENT).unwrap();
for ubo in reflector.resources_for_type(ResourceType::UniformBuffer).unwrap() {
    match ubo {
        Ok(ubo) => {
            let mut set = None;
            let mut binding = None;
            for dec in reflector.decorations(ubo.variable_id) {
                if let op::Decoration::DescriptorSet { descriptor_set } = dec.decoration {
                    set = Some(descriptor_set);
                } else if let op::Decoration::Binding { binding_point } = dec.decoration {
                    binding = Some(binding_point);
                }
            }
            println!("Uniform buffer (set {}, binding {}): {}",
                set.unwrap(), binding.unwrap(), ubo.name.unwrap_or_default(),
            );
        },
        Err(err) => eprintln!("parse error: {err}")
    }
}
for pc in reflector.resources_for_type(ResourceType::PushConstant).unwrap() {
    match pc {
        Ok(pc) => {
            let size = reflector
                .type_description(pc.base_type_id)
                .unwrap().size_hint.declared();
            println!("Push constant (size {size}): {}", pc.name.unwrap_or_default());
        },
        Err(err) => eprintln!("parse error: {err}"),
    }
}

Modules

op

SPIR-V Op-types and enumerations.

reflect

Contains everything reflection relevant.

stream

SPIR-V streams.

Structs

CompilerStr

Represents a string inside SPIR-V. Doesn’t do any extra allocations and is trivially copyable.

Module

ParseContext

ResultStorage

Enums

Literal

Specifies the value of a literal constant.

ParseError

Indicates that the SPIR-V code passed to a module is invalid.

Traits

Word

A trait for types, which can be trivially converted from and to u32.

WordExt

Type Aliases

ParseResult