shaderc-macro 0.1.0

use serde::Deserialize;
use serde::__private::Formatter;
use serde::de::Error;

#[derive(Deserialize)]
#[serde(remote = "shaderc::TargetEnv")]
pub enum TargetEnv {
    Vulkan,
    OpenGL,
    OpenGLCompat,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::EnvVersion")]
pub enum EnvVersion {
    Vulkan1_0 = 1 << 22,
    Vulkan1_1 = (1 << 22) | (1 << 12),
    Vulkan1_2 = (1 << 22) | (2 << 12),
    OpenGL4_5 = 450,
    WebGPU,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::GlslProfile")]
pub enum GlslProfile {
    None,
    Core,
    Compatibility,
    Es,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::Limit")]
pub enum Limit {
    MaxLights,
    MaxClipPlanes,
    MaxTextureUnits,
    MaxTextureCoords,
    MaxVertexAttribs,
    MaxVertexUniformComponents,
    MaxVaryingFloats,
    MaxVertexTextureImageUnits,
    MaxCombinedTextureImageUnits,
    MaxTextureImageUnits,
    MaxFragmentUniformComponents,
    MaxDrawBuffers,
    MaxVertexUniformVectors,
    MaxVaryingVectors,
    MaxFragmentUniformVectors,
    MaxVertexOutputVectors,
    MaxFragmentInputVectors,
    MinProgramTexelOffset,
    MaxProgramTexelOffset,
    MaxClipDistances,
    MaxComputeWorkGroupCountX,
    MaxComputeWorkGroupCountY,
    MaxComputeWorkGroupCountZ,
    MaxComputeWorkGroupSizeX,
    MaxComputeWorkGroupSizeY,
    MaxComputeWorkGroupSizeZ,
    MaxComputeUniformComponents,
    MaxComputeTextureImageUnits,
    MaxComputeImageUniforms,
    MaxComputeAtomicCounters,
    MaxComputeAtomicCounterBuffers,
    MaxVaryingComponents,
    MaxVertexOutputComponents,
    MaxGeometryInputComponents,
    MaxGeometryOutputComponents,
    MaxFragmentInputComponents,
    MaxImageUnits,
    MaxCombinedImageUnitsAndFragmentOutputs,
    MaxCombinedShaderOutputResources,
    MaxImageSamples,
    MaxVertexImageUniforms,
    MaxTessControlImageUniforms,
    MaxTessEvaluationImageUniforms,
    MaxGeometryImageUniforms,
    MaxFragmentImageUniforms,
    MaxCombinedImageUniforms,
    MaxGeometryTextureImageUnits,
    MaxGeometryOutputVertices,
    MaxGeometryTotalOutputComponents,
    MaxGeometryUniformComponents,
    MaxGeometryVaryingComponents,
    MaxTessControlInputComponents,
    MaxTessControlOutputComponents,
    MaxTessControlTextureImageUnits,
    MaxTessControlUniformComponents,
    MaxTessControlTotalOutputComponents,
    MaxTessEvaluationInputComponents,
    MaxTessEvaluationOutputComponents,
    MaxTessEvaluationTextureImageUnits,
    MaxTessEvaluationUniformComponents,
    MaxTessPatchComponents,
    MaxPatchVertices,
    MaxTessGenLevel,
    MaxViewports,
    MaxVertexAtomicCounters,
    MaxTessControlAtomicCounters,
    MaxTessEvaluationAtomicCounters,
    MaxGeometryAtomicCounters,
    MaxFragmentAtomicCounters,
    MaxCombinedAtomicCounters,
    MaxAtomicCounterBindings,
    MaxVertexAtomicCounterBuffers,
    MaxTessControlAtomicCounterBuffers,
    MaxTessEvaluationAtomicCounterBuffers,
    MaxGeometryAtomicCounterBuffers,
    MaxFragmentAtomicCounterBuffers,
    MaxCombinedAtomicCounterBuffers,
    MaxAtomicCounterBufferSize,
    MaxTransformFeedbackBuffers,
    MaxTransformFeedbackInterleavedComponents,
    MaxCullDistances,
    MaxCombinedClipAndCullDistances,
    MaxSamples,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::ResourceKind")]
pub enum ResourceKind {
    Image,
    Sampler,
    Texture,
    Buffer,
    StorageBuffer,
    UnorderedAccessView,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::ShaderKind")]
pub enum ShaderKind {
    Vertex,
    Fragment,
    Compute,
    Geometry,
    TessControl,
    TessEvaluation,
    InferFromSource,
    DefaultVertex,
    DefaultFragment,
    DefaultCompute,
    DefaultGeometry,
    DefaultTessControl,
    DefaultTessEvaluation,
    SpirvAssembly,
    RayGeneration,
    AnyHit,
    ClosestHit,
    Miss,
    Intersection,
    Callable,
    DefaultRayGeneration,
    DefaultAnyHit,
    DefaultClosestHit,
    DefaultMiss,
    DefaultIntersection,
    DefaultCallable,
    Task,
    Mesh,
    DefaultTask,
    DefaultMesh,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::SpirvVersion")]
pub enum SpirvVersion {
    V1_0 = 0x0001_0000,
    V1_1 = 0x0001_0100,
    V1_2 = 0x0001_0200,
    V1_3 = 0x0001_0300,
    V1_4 = 0x0001_0400,
    V1_5 = 0x0001_0500,
}

#[allow(clippy::upper_case_acronyms)]
#[derive(Deserialize)]
#[serde(remote = "shaderc::SourceLanguage")]
pub enum SourceLanguage {
    GLSL,
    HLSL,
}

#[derive(Deserialize)]
#[serde(remote = "shaderc::OptimizationLevel")]
pub enum OptimizationLevel {
    Zero,
    Size,
    Performance,
}

macro_rules! impl_de_opt {
    ($fn:ident , $remote:path , $with:ident) => {
        pub fn $fn<'de, D: serde::Deserializer<'de>>(de: D) -> Result<Option<$remote>, D::Error> {
            struct Visit();
            impl<'v> serde::de::Visitor<'v> for Visit {
                type Value = Option<$remote>;
                fn expecting(&self, fmt: &mut Formatter<'_>) -> std::fmt::Result {
                    write!(fmt, concat!("optional ", stringify!($remote)))
                }
                fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
                    Ok(None)
                }
                fn visit_some<D: serde::Deserializer<'v>>(
                    self,
                    de: D,
                ) -> Result<Self::Value, D::Error> {
                    Ok(Some($with::deserialize(de)?.into()))
                }
            }
            de.deserialize_option(Visit())
        }
    };
}

impl_de_opt!(de_opt_spirv_version, shaderc::SpirvVersion, SpirvVersion);
impl_de_opt!(
    de_opt_source_language,
    shaderc::SourceLanguage,
    SourceLanguage
);
impl_de_opt!(de_opt_shader_kind, shaderc::ShaderKind, ShaderKind);
impl_de_opt!(
    de_opt_optimization_level,
    shaderc::OptimizationLevel,
    OptimizationLevel
);
impl_de_opt!(de_opt_glsl_profile, shaderc::GlslProfile, GlslProfile);