shaderc_sys_dyn/

lib.rs

// Copyright 2016 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! Shaderc system library FFI with runtime dynamic loading
//!
//! This crate contains the lower-level C interface for the Shaderc library.
//! For the higher-level Rust-friendly interface, please see the
//! [shaderc](https://docs.rs/shaderc) crate.
//!
//! The [Shaderc](https://github.com/google/shaderc) library provides an API
//! for compiling GLSL/HLSL source code to SPIRV modules. It has been shipping
//! in the Android NDK since version r12b.
//!
//! This crate loads the shaderc shared library (`libshaderc_shared`) at runtime
//! using `libloading` instead of statically linking at build time. The shared
//! library must be installed and available on the system library search path,
//! or its location can be specified via the `SHADERC_LIB_PATH` environment
//! variable.

#![allow(non_camel_case_types)]
#![allow(clippy::missing_safety_doc)]

use std::ffi::{c_char, c_int, c_void};
use std::sync::OnceLock;

// ---------------------------------------------------------------------------
// Opaque C types (identical to upstream shaderc-sys)
// ---------------------------------------------------------------------------

pub enum ShadercCompiler {}
pub enum ShadercCompileOptions {}
pub enum ShadercCompilationResult {}

// ---------------------------------------------------------------------------
// Include callback types (identical to upstream shaderc-sys)
// ---------------------------------------------------------------------------

#[repr(C)]
pub struct shaderc_include_result {
    pub source_name: *const c_char,
    pub source_name_length: usize,
    pub content: *const c_char,
    pub content_length: usize,
    pub user_data: *mut c_void,
}

pub type shaderc_include_resolve_fn = extern "C" fn(
    user_data: *mut c_void,
    requested_source: *const c_char,
    type_: c_int,
    requesting_source: *const c_char,
    include_depth: usize,
) -> *mut shaderc_include_result;

pub type shaderc_include_result_release_fn =
    extern "C" fn(user_data: *mut c_void, include_result: *mut shaderc_include_result);

// ---------------------------------------------------------------------------
// Library loading
// ---------------------------------------------------------------------------

struct ShadercLibrary {
    _lib: libloading::Library,
    fns: ShadercFunctions,
}

/// All shaderc C function pointers loaded from the shared library.
struct ShadercFunctions {
    // Compiler
    compiler_initialize: unsafe extern "C" fn() -> *mut ShadercCompiler,
    compiler_release: unsafe extern "C" fn(*mut ShadercCompiler),

    // Compilation
    compile_into_spv: unsafe extern "C" fn(
        *const ShadercCompiler,
        *const c_char,
        usize,
        i32,
        *const c_char,
        *const c_char,
        *const ShadercCompileOptions,
    ) -> *mut ShadercCompilationResult,
    compile_into_spv_assembly: unsafe extern "C" fn(
        *const ShadercCompiler,
        *const c_char,
        usize,
        i32,
        *const c_char,
        *const c_char,
        *const ShadercCompileOptions,
    ) -> *mut ShadercCompilationResult,
    compile_into_preprocessed_text: unsafe extern "C" fn(
        *const ShadercCompiler,
        *const c_char,
        usize,
        i32,
        *const c_char,
        *const c_char,
        *const ShadercCompileOptions,
    ) -> *mut ShadercCompilationResult,
    assemble_into_spv: unsafe extern "C" fn(
        *const ShadercCompiler,
        *const c_char,
        usize,
        *const ShadercCompileOptions,
    ) -> *mut ShadercCompilationResult,

    // Options
    compile_options_initialize: unsafe extern "C" fn() -> *mut ShadercCompileOptions,
    compile_options_clone:
        unsafe extern "C" fn(*const ShadercCompileOptions) -> *mut ShadercCompileOptions,
    compile_options_release: unsafe extern "C" fn(*mut ShadercCompileOptions),
    compile_options_add_macro_definition: unsafe extern "C" fn(
        *mut ShadercCompileOptions,
        *const c_char,
        usize,
        *const c_char,
        usize,
    ),
    compile_options_set_source_language: unsafe extern "C" fn(*mut ShadercCompileOptions, i32),
    compile_options_set_generate_debug_info: unsafe extern "C" fn(*mut ShadercCompileOptions),
    compile_options_set_optimization_level: unsafe extern "C" fn(*mut ShadercCompileOptions, i32),
    compile_options_set_forced_version_profile:
        unsafe extern "C" fn(*mut ShadercCompileOptions, c_int, i32),
    compile_options_set_include_callbacks: unsafe extern "C" fn(
        *mut ShadercCompileOptions,
        shaderc_include_resolve_fn,
        shaderc_include_result_release_fn,
        *mut c_void,
    ),
    compile_options_set_suppress_warnings: unsafe extern "C" fn(*mut ShadercCompileOptions),
    compile_options_set_warnings_as_errors: unsafe extern "C" fn(*mut ShadercCompileOptions),
    compile_options_set_target_env: unsafe extern "C" fn(*mut ShadercCompileOptions, i32, u32),
    compile_options_set_target_spirv: unsafe extern "C" fn(*mut ShadercCompileOptions, i32),
    compile_options_set_limit: unsafe extern "C" fn(*mut ShadercCompileOptions, i32, c_int),
    compile_options_set_auto_bind_uniforms: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_auto_combined_image_sampler:
        unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_hlsl_io_mapping: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_hlsl_offsets: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_binding_base: unsafe extern "C" fn(*mut ShadercCompileOptions, c_int, u32),
    compile_options_set_binding_base_for_stage:
        unsafe extern "C" fn(*mut ShadercCompileOptions, c_int, c_int, u32),
    compile_options_set_hlsl_register_set_and_binding: unsafe extern "C" fn(
        *mut ShadercCompileOptions,
        *const c_char,
        *const c_char,
        *const c_char,
    ),
    compile_options_set_auto_map_locations: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_hlsl_register_set_and_binding_for_stage: unsafe extern "C" fn(
        *mut ShadercCompileOptions,
        c_int,
        *const c_char,
        *const c_char,
        *const c_char,
    ),
    compile_options_set_hlsl_functionality1: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_invert_y: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),
    compile_options_set_nan_clamp: unsafe extern "C" fn(*mut ShadercCompileOptions, bool),

    // Results
    result_release: unsafe extern "C" fn(*mut ShadercCompilationResult),
    result_get_compilation_status: unsafe extern "C" fn(*const ShadercCompilationResult) -> i32,
    result_get_num_errors: unsafe extern "C" fn(*const ShadercCompilationResult) -> usize,
    result_get_num_warnings: unsafe extern "C" fn(*const ShadercCompilationResult) -> usize,
    result_get_error_message:
        unsafe extern "C" fn(*const ShadercCompilationResult) -> *const c_char,
    result_get_length: unsafe extern "C" fn(*const ShadercCompilationResult) -> usize,
    result_get_bytes: unsafe extern "C" fn(*const ShadercCompilationResult) -> *const c_char,

    // Utility
    get_spv_version: unsafe extern "C" fn(*mut c_int, *mut c_int),
    parse_version_profile: unsafe extern "C" fn(*const c_char, *mut c_int, *mut i32) -> bool,
}

/// Attempts to load the shaderc shared library from the system.
fn load_library() -> Option<ShadercLibrary> {
    let lib_name = if let Ok(path) = std::env::var("SHADERC_LIB_PATH") {
        path
    } else if cfg!(target_os = "windows") {
        "shaderc_shared.dll".to_owned()
    } else if cfg!(target_os = "macos") {
        "libshaderc_shared.dylib".to_owned()
    } else {
        "libshaderc_shared.so".to_owned()
    };

    let lib = unsafe { libloading::Library::new(&lib_name) }.ok()?;

    /// Helper macro to load a symbol or return `None`.
    macro_rules! load {
        ($lib:expr, $name:literal) => {
            *unsafe { $lib.get::<_>($name) }.ok()?
        };
    }

    let fns = ShadercFunctions {
        compiler_initialize: load!(lib, b"shaderc_compiler_initialize\0"),
        compiler_release: load!(lib, b"shaderc_compiler_release\0"),
        compile_into_spv: load!(lib, b"shaderc_compile_into_spv\0"),
        compile_into_spv_assembly: load!(lib, b"shaderc_compile_into_spv_assembly\0"),
        compile_into_preprocessed_text: load!(lib, b"shaderc_compile_into_preprocessed_text\0"),
        assemble_into_spv: load!(lib, b"shaderc_assemble_into_spv\0"),
        compile_options_initialize: load!(lib, b"shaderc_compile_options_initialize\0"),
        compile_options_clone: load!(lib, b"shaderc_compile_options_clone\0"),
        compile_options_release: load!(lib, b"shaderc_compile_options_release\0"),
        compile_options_add_macro_definition: load!(
            lib,
            b"shaderc_compile_options_add_macro_definition\0"
        ),
        compile_options_set_source_language: load!(
            lib,
            b"shaderc_compile_options_set_source_language\0"
        ),
        compile_options_set_generate_debug_info: load!(
            lib,
            b"shaderc_compile_options_set_generate_debug_info\0"
        ),
        compile_options_set_optimization_level: load!(
            lib,
            b"shaderc_compile_options_set_optimization_level\0"
        ),
        compile_options_set_forced_version_profile: load!(
            lib,
            b"shaderc_compile_options_set_forced_version_profile\0"
        ),
        compile_options_set_include_callbacks: load!(
            lib,
            b"shaderc_compile_options_set_include_callbacks\0"
        ),
        compile_options_set_suppress_warnings: load!(
            lib,
            b"shaderc_compile_options_set_suppress_warnings\0"
        ),
        compile_options_set_warnings_as_errors: load!(
            lib,
            b"shaderc_compile_options_set_warnings_as_errors\0"
        ),
        compile_options_set_target_env: load!(lib, b"shaderc_compile_options_set_target_env\0"),
        compile_options_set_target_spirv: load!(lib, b"shaderc_compile_options_set_target_spirv\0"),
        compile_options_set_limit: load!(lib, b"shaderc_compile_options_set_limit\0"),
        compile_options_set_auto_bind_uniforms: load!(
            lib,
            b"shaderc_compile_options_set_auto_bind_uniforms\0"
        ),
        compile_options_set_auto_combined_image_sampler: load!(
            lib,
            b"shaderc_compile_options_set_auto_combined_image_sampler\0"
        ),
        compile_options_set_hlsl_io_mapping: load!(
            lib,
            b"shaderc_compile_options_set_hlsl_io_mapping\0"
        ),
        compile_options_set_hlsl_offsets: load!(lib, b"shaderc_compile_options_set_hlsl_offsets\0"),
        compile_options_set_binding_base: load!(lib, b"shaderc_compile_options_set_binding_base\0"),
        compile_options_set_binding_base_for_stage: load!(
            lib,
            b"shaderc_compile_options_set_binding_base_for_stage\0"
        ),
        compile_options_set_hlsl_register_set_and_binding: load!(
            lib,
            b"shaderc_compile_options_set_hlsl_register_set_and_binding\0"
        ),
        compile_options_set_auto_map_locations: load!(
            lib,
            b"shaderc_compile_options_set_auto_map_locations\0"
        ),
        compile_options_set_hlsl_register_set_and_binding_for_stage: load!(
            lib,
            b"shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage\0"
        ),
        compile_options_set_hlsl_functionality1: load!(
            lib,
            b"shaderc_compile_options_set_hlsl_functionality1\0"
        ),
        compile_options_set_invert_y: load!(lib, b"shaderc_compile_options_set_invert_y\0"),
        compile_options_set_nan_clamp: load!(lib, b"shaderc_compile_options_set_nan_clamp\0"),
        result_release: load!(lib, b"shaderc_result_release\0"),
        result_get_compilation_status: load!(lib, b"shaderc_result_get_compilation_status\0"),
        result_get_num_errors: load!(lib, b"shaderc_result_get_num_errors\0"),
        result_get_num_warnings: load!(lib, b"shaderc_result_get_num_warnings\0"),
        result_get_error_message: load!(lib, b"shaderc_result_get_error_message\0"),
        result_get_length: load!(lib, b"shaderc_result_get_length\0"),
        result_get_bytes: load!(lib, b"shaderc_result_get_bytes\0"),
        get_spv_version: load!(lib, b"shaderc_get_spv_version\0"),
        parse_version_profile: load!(lib, b"shaderc_parse_version_profile\0"),
    };

    Some(ShadercLibrary { _lib: lib, fns })
}

static LIB: OnceLock<Option<ShadercLibrary>> = OnceLock::new();

fn lib() -> Option<&'static ShadercLibrary> {
    LIB.get_or_init(load_library).as_ref()
}

fn expect_lib() -> &'static ShadercLibrary {
    lib().expect(
        "shaderc shared library not loaded. \
         Install libshaderc_shared (via Vulkan SDK, `brew install shaderc`, \
         or `apt install libshaderc-dev`) and ensure it is on the library search path, \
         or set SHADERC_LIB_PATH to the full path of the shared library.",
    )
}

// ---------------------------------------------------------------------------
// Public API — same signatures as upstream shaderc-sys extern "C" block
// ---------------------------------------------------------------------------

// -- Compiler ---------------------------------------------------------------

pub unsafe fn shaderc_compiler_initialize() -> *mut ShadercCompiler {
    match lib() {
        Some(l) => unsafe { (l.fns.compiler_initialize)() },
        None => std::ptr::null_mut(),
    }
}

pub unsafe fn shaderc_compiler_release(compiler: *mut ShadercCompiler) {
    unsafe { (expect_lib().fns.compiler_release)(compiler) };
}

// -- Compilation ------------------------------------------------------------

pub unsafe fn shaderc_compile_into_spv(
    compiler: *const ShadercCompiler,
    source_text: *const c_char,
    source_size: usize,
    shader_kind: i32,
    input_file_name: *const c_char,
    entry_point_name: *const c_char,
    additional_options: *const ShadercCompileOptions,
) -> *mut ShadercCompilationResult {
    unsafe {
        (expect_lib().fns.compile_into_spv)(
            compiler,
            source_text,
            source_size,
            shader_kind,
            input_file_name,
            entry_point_name,
            additional_options,
        )
    }
}

pub unsafe fn shaderc_compile_into_spv_assembly(
    compiler: *const ShadercCompiler,
    source_text: *const c_char,
    source_size: usize,
    shader_kind: i32,
    input_file_name: *const c_char,
    entry_point_name: *const c_char,
    additional_options: *const ShadercCompileOptions,
) -> *mut ShadercCompilationResult {
    unsafe {
        (expect_lib().fns.compile_into_spv_assembly)(
            compiler,
            source_text,
            source_size,
            shader_kind,
            input_file_name,
            entry_point_name,
            additional_options,
        )
    }
}

pub unsafe fn shaderc_compile_into_preprocessed_text(
    compiler: *const ShadercCompiler,
    source_text: *const c_char,
    source_size: usize,
    shader_kind: i32,
    input_file_name: *const c_char,
    entry_point_name: *const c_char,
    additional_options: *const ShadercCompileOptions,
) -> *mut ShadercCompilationResult {
    unsafe {
        (expect_lib().fns.compile_into_preprocessed_text)(
            compiler,
            source_text,
            source_size,
            shader_kind,
            input_file_name,
            entry_point_name,
            additional_options,
        )
    }
}

pub unsafe fn shaderc_assemble_into_spv(
    compiler: *const ShadercCompiler,
    source_assembly: *const c_char,
    source_size: usize,
    additional_options: *const ShadercCompileOptions,
) -> *mut ShadercCompilationResult {
    unsafe {
        (expect_lib().fns.assemble_into_spv)(
            compiler,
            source_assembly,
            source_size,
            additional_options,
        )
    }
}

// -- Options ----------------------------------------------------------------

pub unsafe fn shaderc_compile_options_initialize() -> *mut ShadercCompileOptions {
    match lib() {
        Some(l) => unsafe { (l.fns.compile_options_initialize)() },
        None => std::ptr::null_mut(),
    }
}

pub unsafe fn shaderc_compile_options_clone(
    options: *const ShadercCompileOptions,
) -> *mut ShadercCompileOptions {
    match lib() {
        Some(l) => unsafe { (l.fns.compile_options_clone)(options) },
        None => std::ptr::null_mut(),
    }
}

pub unsafe fn shaderc_compile_options_release(options: *mut ShadercCompileOptions) {
    unsafe { (expect_lib().fns.compile_options_release)(options) };
}

pub unsafe fn shaderc_compile_options_add_macro_definition(
    options: *mut ShadercCompileOptions,
    name: *const c_char,
    name_length: usize,
    value: *const c_char,
    value_length: usize,
) {
    unsafe {
        (expect_lib().fns.compile_options_add_macro_definition)(
            options,
            name,
            name_length,
            value,
            value_length,
        )
    };
}

pub unsafe fn shaderc_compile_options_set_source_language(
    options: *mut ShadercCompileOptions,
    language: i32,
) {
    unsafe { (expect_lib().fns.compile_options_set_source_language)(options, language) };
}

pub unsafe fn shaderc_compile_options_set_generate_debug_info(options: *mut ShadercCompileOptions) {
    unsafe { (expect_lib().fns.compile_options_set_generate_debug_info)(options) };
}

pub unsafe fn shaderc_compile_options_set_optimization_level(
    options: *mut ShadercCompileOptions,
    level: i32,
) {
    unsafe { (expect_lib().fns.compile_options_set_optimization_level)(options, level) };
}

pub unsafe fn shaderc_compile_options_set_forced_version_profile(
    options: *mut ShadercCompileOptions,
    version: c_int,
    profile: i32,
) {
    unsafe {
        (expect_lib().fns.compile_options_set_forced_version_profile)(options, version, profile)
    };
}

pub unsafe fn shaderc_compile_options_set_include_callbacks(
    options: *mut ShadercCompileOptions,
    resolver: shaderc_include_resolve_fn,
    result_releaser: shaderc_include_result_release_fn,
    user_data: *mut c_void,
) {
    unsafe {
        (expect_lib().fns.compile_options_set_include_callbacks)(
            options,
            resolver,
            result_releaser,
            user_data,
        )
    };
}

pub unsafe fn shaderc_compile_options_set_suppress_warnings(options: *mut ShadercCompileOptions) {
    unsafe { (expect_lib().fns.compile_options_set_suppress_warnings)(options) };
}

pub unsafe fn shaderc_compile_options_set_warnings_as_errors(options: *mut ShadercCompileOptions) {
    unsafe { (expect_lib().fns.compile_options_set_warnings_as_errors)(options) };
}

pub unsafe fn shaderc_compile_options_set_target_env(
    options: *mut ShadercCompileOptions,
    env: i32,
    version: u32,
) {
    unsafe { (expect_lib().fns.compile_options_set_target_env)(options, env, version) };
}

pub unsafe fn shaderc_compile_options_set_target_spirv(
    options: *mut ShadercCompileOptions,
    version: i32,
) {
    unsafe { (expect_lib().fns.compile_options_set_target_spirv)(options, version) };
}

pub unsafe fn shaderc_compile_options_set_limit(
    options: *mut ShadercCompileOptions,
    limit: i32,
    value: c_int,
) {
    unsafe { (expect_lib().fns.compile_options_set_limit)(options, limit, value) };
}

pub unsafe fn shaderc_compile_options_set_auto_bind_uniforms(
    options: *mut ShadercCompileOptions,
    auto_bind: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_auto_bind_uniforms)(options, auto_bind) };
}

pub unsafe fn shaderc_compile_options_set_auto_combined_image_sampler(
    options: *mut ShadercCompileOptions,
    auto_combine: bool,
) {
    unsafe {
        (expect_lib()
            .fns
            .compile_options_set_auto_combined_image_sampler)(options, auto_combine)
    };
}

pub unsafe fn shaderc_compile_options_set_hlsl_io_mapping(
    options: *mut ShadercCompileOptions,
    hlsl_iomap: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_hlsl_io_mapping)(options, hlsl_iomap) };
}

pub unsafe fn shaderc_compile_options_set_hlsl_offsets(
    options: *mut ShadercCompileOptions,
    hlsl_offsets: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_hlsl_offsets)(options, hlsl_offsets) };
}

pub unsafe fn shaderc_compile_options_set_binding_base(
    options: *mut ShadercCompileOptions,
    resource_kind: c_int,
    base: u32,
) {
    unsafe { (expect_lib().fns.compile_options_set_binding_base)(options, resource_kind, base) };
}

pub unsafe fn shaderc_compile_options_set_binding_base_for_stage(
    options: *mut ShadercCompileOptions,
    shader_kind: c_int,
    resource_kind: c_int,
    base: u32,
) {
    unsafe {
        (expect_lib().fns.compile_options_set_binding_base_for_stage)(
            options,
            shader_kind,
            resource_kind,
            base,
        )
    };
}

pub unsafe fn shaderc_compile_options_set_hlsl_register_set_and_binding(
    options: *mut ShadercCompileOptions,
    register: *const c_char,
    set: *const c_char,
    binding: *const c_char,
) {
    unsafe {
        (expect_lib()
            .fns
            .compile_options_set_hlsl_register_set_and_binding)(
            options, register, set, binding
        )
    };
}

pub unsafe fn shaderc_compile_options_set_auto_map_locations(
    options: *mut ShadercCompileOptions,
    auto_map: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_auto_map_locations)(options, auto_map) };
}

pub unsafe fn shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage(
    options: *mut ShadercCompileOptions,
    shader_kind: c_int,
    register: *const c_char,
    set: *const c_char,
    binding: *const c_char,
) {
    unsafe {
        (expect_lib()
            .fns
            .compile_options_set_hlsl_register_set_and_binding_for_stage)(
            options,
            shader_kind,
            register,
            set,
            binding,
        )
    };
}

pub unsafe fn shaderc_compile_options_set_hlsl_functionality1(
    options: *mut ShadercCompileOptions,
    enable: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_hlsl_functionality1)(options, enable) };
}

pub unsafe fn shaderc_compile_options_set_invert_y(
    options: *mut ShadercCompileOptions,
    enable: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_invert_y)(options, enable) };
}

pub unsafe fn shaderc_compile_options_set_nan_clamp(
    options: *mut ShadercCompileOptions,
    enable: bool,
) {
    unsafe { (expect_lib().fns.compile_options_set_nan_clamp)(options, enable) };
}

// -- Results ----------------------------------------------------------------

pub unsafe fn shaderc_result_release(result: *mut ShadercCompilationResult) {
    unsafe { (expect_lib().fns.result_release)(result) };
}

pub unsafe fn shaderc_result_get_compilation_status(
    result: *const ShadercCompilationResult,
) -> i32 {
    unsafe { (expect_lib().fns.result_get_compilation_status)(result) }
}

pub unsafe fn shaderc_result_get_num_errors(result: *const ShadercCompilationResult) -> usize {
    unsafe { (expect_lib().fns.result_get_num_errors)(result) }
}

pub unsafe fn shaderc_result_get_num_warnings(result: *const ShadercCompilationResult) -> usize {
    unsafe { (expect_lib().fns.result_get_num_warnings)(result) }
}

pub unsafe fn shaderc_result_get_error_message(
    result: *const ShadercCompilationResult,
) -> *const c_char {
    unsafe { (expect_lib().fns.result_get_error_message)(result) }
}

pub unsafe fn shaderc_result_get_length(result: *const ShadercCompilationResult) -> usize {
    unsafe { (expect_lib().fns.result_get_length)(result) }
}

pub unsafe fn shaderc_result_get_bytes(result: *const ShadercCompilationResult) -> *const c_char {
    unsafe { (expect_lib().fns.result_get_bytes)(result) }
}

// -- Utility ----------------------------------------------------------------

pub unsafe fn shaderc_get_spv_version(version: *mut c_int, revision: *mut c_int) {
    unsafe { (expect_lib().fns.get_spv_version)(version, revision) };
}

pub unsafe fn shaderc_parse_version_profile(
    str: *const c_char,
    version: *mut c_int,
    profile: *mut i32,
) -> bool {
    unsafe { (expect_lib().fns.parse_version_profile)(str, version, profile) }
}