rafx-plugins 0.0.16

// This code is auto-generated by the shader processor.

#[allow(unused_imports)]
use rafx::RafxResult;

#[allow(unused_imports)]
use rafx::framework::{
    DescriptorSetAllocator, DescriptorSetArc, DescriptorSetBindings, DescriptorSetInitializer,
    DescriptorSetWriter, DescriptorSetWriterContext, DynDescriptorSet, ImageViewResource,
    ResourceArc,
};

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct AverageHistogramConfigStd140 {
    pub pixel_count: u32,        // +0 (size: 4)
    pub min_log_luma: f32,       // +4 (size: 4)
    pub log_luma_range: f32,     // +8 (size: 4)
    pub dt: f32,                 // +12 (size: 4)
    pub low_percentile: f32,     // +16 (size: 4)
    pub high_percentile: f32,    // +20 (size: 4)
    pub low_adjust_speed: f32,   // +24 (size: 4)
    pub high_adjust_speed: f32,  // +28 (size: 4)
    pub write_debug_output: u32, // +32 (size: 4)
    pub _padding0: [u8; 12],     // +36 (size: 12)
} // 48 bytes

impl Default for AverageHistogramConfigStd140 {
    fn default() -> Self {
        AverageHistogramConfigStd140 {
            pixel_count: <u32>::default(),
            min_log_luma: <f32>::default(),
            log_luma_range: <f32>::default(),
            dt: <f32>::default(),
            low_percentile: <f32>::default(),
            high_percentile: <f32>::default(),
            low_adjust_speed: <f32>::default(),
            high_adjust_speed: <f32>::default(),
            write_debug_output: <u32>::default(),
            _padding0: [u8::default(); 12],
        }
    }
}

pub type AverageHistogramConfigUniform = AverageHistogramConfigStd140;

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct HistogramDataStd430 {
    pub data: [u32; 256], // +0 (size: 1024)
} // 1024 bytes

pub type HistogramDataBuffer = HistogramDataStd430;

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct HistogramResultStd430 {
    pub average_luminosity_interpolated: f32, // +0 (size: 4)
    pub average_luminosity_this_frame: f32,   // +4 (size: 4)
    pub average_luminosity_last_frame: f32,   // +8 (size: 4)
    pub min_luminosity_interpolated: f32,     // +12 (size: 4)
    pub min_luminosity_this_frame: f32,       // +16 (size: 4)
    pub min_luminosity_last_frame: f32,       // +20 (size: 4)
    pub max_luminosity_interpolated: f32,     // +24 (size: 4)
    pub max_luminosity_this_frame: f32,       // +28 (size: 4)
    pub max_luminosity_last_frame: f32,       // +32 (size: 4)
    pub low_luminosity_interpolated: f32,     // +36 (size: 4)
    pub low_luminosity_this_frame: f32,       // +40 (size: 4)
    pub low_luminosity_last_frame: f32,       // +44 (size: 4)
    pub high_luminosity_interpolated: f32,    // +48 (size: 4)
    pub high_luminosity_this_frame: f32,      // +52 (size: 4)
    pub high_luminosity_last_frame: f32,      // +56 (size: 4)
    pub average_bin_include_zero: f32,        // +60 (size: 4)
    pub average_bin_non_zero: f32,            // +64 (size: 4)
    pub min_bin: u32,                         // +68 (size: 4)
    pub max_bin: u32,                         // +72 (size: 4)
    pub low_bin: u32,                         // +76 (size: 4)
    pub high_bin: u32,                        // +80 (size: 4)
} // 84 bytes

pub type HistogramResultBuffer = HistogramResultStd430;

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct DebugOutputStd430 {
    pub result: HistogramResultStd430, // +0 (size: 84)
    pub data: [u32; 256],              // +84 (size: 1024)
} // 1108 bytes

pub type DebugOutputBuffer = DebugOutputStd430;

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct HistogramResultBufferStd430 {
    pub result: HistogramResultStd430, // +0 (size: 84)
} // 84 bytes

pub type HistogramResultBufferBuffer = HistogramResultBufferStd430;

pub const HISTOGRAM_DATA_DESCRIPTOR_SET_INDEX: usize = 0;
pub const HISTOGRAM_DATA_DESCRIPTOR_BINDING_INDEX: usize = 0;
pub const CONFIG_DESCRIPTOR_SET_INDEX: usize = 0;
pub const CONFIG_DESCRIPTOR_BINDING_INDEX: usize = 1;
pub const HISTOGRAM_RESULT_DESCRIPTOR_SET_INDEX: usize = 0;
pub const HISTOGRAM_RESULT_DESCRIPTOR_BINDING_INDEX: usize = 2;
pub const DEBUG_OUTPUT_DESCRIPTOR_SET_INDEX: usize = 0;
pub const DEBUG_OUTPUT_DESCRIPTOR_BINDING_INDEX: usize = 3;

pub struct DescriptorSet0Args<'a> {
    pub histogram_data: &'a HistogramDataBuffer,
    pub config: &'a AverageHistogramConfigUniform,
    pub histogram_result: &'a HistogramResultBufferBuffer,
    pub debug_output: &'a DebugOutputBuffer,
}

impl<'a> DescriptorSetInitializer<'a> for DescriptorSet0Args<'a> {
    type Output = DescriptorSet0;

    fn create_dyn_descriptor_set(
        descriptor_set: DynDescriptorSet,
        args: Self,
    ) -> Self::Output {
        let mut descriptor = DescriptorSet0(descriptor_set);
        descriptor.set_args(args);
        descriptor
    }

    fn create_descriptor_set(
        descriptor_set_allocator: &mut DescriptorSetAllocator,
        descriptor_set: DynDescriptorSet,
        args: Self,
    ) -> RafxResult<DescriptorSetArc> {
        let mut descriptor = Self::create_dyn_descriptor_set(descriptor_set, args);
        descriptor.0.flush(descriptor_set_allocator)?;
        Ok(descriptor.0.descriptor_set().clone())
    }
}

impl<'a> DescriptorSetWriter<'a> for DescriptorSet0Args<'a> {
    fn write_to(
        descriptor_set: &mut DescriptorSetWriterContext,
        args: Self,
    ) {
        descriptor_set.set_buffer_data(
            HISTOGRAM_DATA_DESCRIPTOR_BINDING_INDEX as u32,
            args.histogram_data,
        );
        descriptor_set.set_buffer_data(CONFIG_DESCRIPTOR_BINDING_INDEX as u32, args.config);
        descriptor_set.set_buffer_data(
            HISTOGRAM_RESULT_DESCRIPTOR_BINDING_INDEX as u32,
            args.histogram_result,
        );
        descriptor_set.set_buffer_data(
            DEBUG_OUTPUT_DESCRIPTOR_BINDING_INDEX as u32,
            args.debug_output,
        );
    }
}

pub struct DescriptorSet0(pub DynDescriptorSet);

impl DescriptorSet0 {
    pub fn set_args_static(
        descriptor_set: &mut DynDescriptorSet,
        args: DescriptorSet0Args,
    ) {
        descriptor_set.set_buffer_data(
            HISTOGRAM_DATA_DESCRIPTOR_BINDING_INDEX as u32,
            args.histogram_data,
        );
        descriptor_set.set_buffer_data(CONFIG_DESCRIPTOR_BINDING_INDEX as u32, args.config);
        descriptor_set.set_buffer_data(
            HISTOGRAM_RESULT_DESCRIPTOR_BINDING_INDEX as u32,
            args.histogram_result,
        );
        descriptor_set.set_buffer_data(
            DEBUG_OUTPUT_DESCRIPTOR_BINDING_INDEX as u32,
            args.debug_output,
        );
    }

    pub fn set_args(
        &mut self,
        args: DescriptorSet0Args,
    ) {
        self.set_histogram_data(args.histogram_data);
        self.set_config(args.config);
        self.set_histogram_result(args.histogram_result);
        self.set_debug_output(args.debug_output);
    }

    pub fn set_histogram_data(
        &mut self,
        histogram_data: &HistogramDataBuffer,
    ) {
        self.0.set_buffer_data(
            HISTOGRAM_DATA_DESCRIPTOR_BINDING_INDEX as u32,
            histogram_data,
        );
    }

    pub fn set_config(
        &mut self,
        config: &AverageHistogramConfigUniform,
    ) {
        self.0
            .set_buffer_data(CONFIG_DESCRIPTOR_BINDING_INDEX as u32, config);
    }

    pub fn set_histogram_result(
        &mut self,
        histogram_result: &HistogramResultBufferBuffer,
    ) {
        self.0.set_buffer_data(
            HISTOGRAM_RESULT_DESCRIPTOR_BINDING_INDEX as u32,
            histogram_result,
        );
    }

    pub fn set_debug_output(
        &mut self,
        debug_output: &DebugOutputBuffer,
    ) {
        self.0
            .set_buffer_data(DEBUG_OUTPUT_DESCRIPTOR_BINDING_INDEX as u32, debug_output);
    }

    pub fn flush(
        &mut self,
        descriptor_set_allocator: &mut DescriptorSetAllocator,
    ) -> RafxResult<()> {
        self.0.flush(descriptor_set_allocator)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_struct_average_histogram_config_std140() {
        assert_eq!(std::mem::size_of::<AverageHistogramConfigStd140>(), 48);
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, pixel_count),
            0
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, min_log_luma),
            4
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, log_luma_range),
            8
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(memoffset::offset_of!(AverageHistogramConfigStd140, dt), 12);
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, low_percentile),
            16
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, high_percentile),
            20
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, low_adjust_speed),
            24
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, high_adjust_speed),
            28
        );
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, write_debug_output),
            32
        );
        assert_eq!(std::mem::size_of::<[u8; 12]>(), 12);
        assert_eq!(std::mem::align_of::<[u8; 12]>(), 1);
        assert_eq!(
            memoffset::offset_of!(AverageHistogramConfigStd140, _padding0),
            36
        );
    }

    #[test]
    fn test_struct_histogram_data_std430() {
        assert_eq!(std::mem::size_of::<HistogramDataStd430>(), 1024);
        assert_eq!(std::mem::size_of::<[u32; 256]>(), 1024);
        assert_eq!(std::mem::align_of::<[u32; 256]>(), 4);
        assert_eq!(memoffset::offset_of!(HistogramDataStd430, data), 0);
    }

    #[test]
    fn test_struct_histogram_result_std430() {
        assert_eq!(std::mem::size_of::<HistogramResultStd430>(), 84);
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, average_luminosity_interpolated),
            0
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, average_luminosity_this_frame),
            4
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, average_luminosity_last_frame),
            8
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, min_luminosity_interpolated),
            12
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, min_luminosity_this_frame),
            16
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, min_luminosity_last_frame),
            20
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, max_luminosity_interpolated),
            24
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, max_luminosity_this_frame),
            28
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, max_luminosity_last_frame),
            32
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, low_luminosity_interpolated),
            36
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, low_luminosity_this_frame),
            40
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, low_luminosity_last_frame),
            44
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, high_luminosity_interpolated),
            48
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, high_luminosity_this_frame),
            52
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, high_luminosity_last_frame),
            56
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, average_bin_include_zero),
            60
        );
        assert_eq!(std::mem::size_of::<f32>(), 4);
        assert_eq!(std::mem::align_of::<f32>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultStd430, average_bin_non_zero),
            64
        );
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(memoffset::offset_of!(HistogramResultStd430, min_bin), 68);
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(memoffset::offset_of!(HistogramResultStd430, max_bin), 72);
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(memoffset::offset_of!(HistogramResultStd430, low_bin), 76);
        assert_eq!(std::mem::size_of::<u32>(), 4);
        assert_eq!(std::mem::align_of::<u32>(), 4);
        assert_eq!(memoffset::offset_of!(HistogramResultStd430, high_bin), 80);
    }

    #[test]
    fn test_struct_debug_output_std430() {
        assert_eq!(std::mem::size_of::<DebugOutputStd430>(), 1108);
        assert_eq!(std::mem::size_of::<HistogramResultStd430>(), 84);
        assert_eq!(std::mem::align_of::<HistogramResultStd430>(), 4);
        assert_eq!(memoffset::offset_of!(DebugOutputStd430, result), 0);
        assert_eq!(std::mem::size_of::<[u32; 256]>(), 1024);
        assert_eq!(std::mem::align_of::<[u32; 256]>(), 4);
        assert_eq!(memoffset::offset_of!(DebugOutputStd430, data), 84);
    }

    #[test]
    fn test_struct_histogram_result_buffer_std430() {
        assert_eq!(std::mem::size_of::<HistogramResultBufferStd430>(), 84);
        assert_eq!(std::mem::size_of::<HistogramResultStd430>(), 84);
        assert_eq!(std::mem::align_of::<HistogramResultStd430>(), 4);
        assert_eq!(
            memoffset::offset_of!(HistogramResultBufferStd430, result),
            0
        );
    }
}