Struct Compiler 

pub struct Compiler<R = ()> {
    pub options: CompileOptions,
    pub resolver: R,
}

The WESL compiler.

Basic Usage

let compiler = Compiler::default();
let wgsl_string = compiler
    .compile("path/to/shader.wgsl")
    .inspect_err(|e| eprintln!("{e}")) // pretty-print errors
    .unwrap()
    .to_string();

Fields

options: CompileOptions

resolver: R

Implementations

impl<R1> Compiler<R1>

pub fn with_resolver<R2>(self, resolver: R2) -> Compiler<R2>

Set the compilation crate::Resolver or crate::AsyncResolver.

impl<R> Compiler<R>

pub fn new_with_resolver(options: CompileOptions, resolver: R) -> Self

Shorthand for Compiler::new(options).with_resolver(resolver).

impl Compiler<()>

pub fn new(options: CompileOptions) -> Self

Create a new compiler.

By default, the compiler will use a StandardResolver when compiling.

impl Compiler<()>

pub fn compile(&self, path: impl AsRef<Path>) -> Result<CompileResult, Error>

Compile a WESL shader to WGSL.

path defines where to look for shader files. It can point to a wesl.toml file, a directory or a shader file.

The main module (which exposes entry points, bindings and overrides) is determined from path: It is the package root module if path points to a toml file or a directory, otherwise it is the file that path points to. See Self::compile_module to compile a different main module.

Path	Package root directory	Main module
wesl.toml	root field in wesl.toml	package.wesl in root dir
directory	the directory	package.wesl in root dir
.wesl file	the parent directory	the file specified

Note: .wgsl extensions are also supported, but .wesl takes priority.

pub fn compile_module( &self, pkg_root_dir: impl AsRef<Path>, main_path: &ModulePath, ) -> Result<CompileResult, Error>

Variant of Self::compile with a custom main module path.

pub async fn compile_async(&self, path: &Path) -> Result<CompileResult, Error>

Async version of Self::compile.

pub async fn compile_module_async( &self, pkg_root_dir: impl AsRef<Path>, main_path: &ModulePath, ) -> Result<CompileResult, Error>

Async version of Self::compile_module.

impl<R: Resolver> Compiler<R>

pub fn compile_root(&self) -> Result<CompileResult, Error>

Compile a WESL shader to WGSL.

The main module defaults to the package root module. See Self::compile_module to compile a different main module.

pub fn compile_module( &self, main_path: &ModulePath, ) -> Result<CompileResult, Error>

Variant of Self::compile with a custom main module path.

pub fn compile( &self, fs_main_path: impl AsRef<Path>, ) -> Result<CompileResult, Error>

Variant of Self::compile_root with a custom main module path.

fs_main_path defines the main module path according to the resolver’s file system mapping implemented in Resolver::module_path.

Warning

This function works best with filesystem resolvers which implement Resolver::module_path. If not, this function assumes that the package root directory is the current working directory.

Panics

Can panic if ModulePath::from_path fails.

pub async fn compile_root_async(&self) -> Result<CompileResult, Error>

Async version of Self::compile_root.

pub async fn compile_module_async( &self, main_path: &ModulePath, ) -> Result<CompileResult, Error>

Async version of Self::compile_module.

pub async fn compile_async( &self, fs_main_path: &impl AsRef<Path>, ) -> Result<CompileResult, Error>

Async version of Self::compile.

Trait Implementations

impl<R: Clone> Clone for Compiler<R>

fn clone(&self) -> Compiler<R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug> Debug for Compiler<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Compiler<()>

fn default() -> Self

Returns the “default value” for a type.