Method rebuild_pipelines

examples/runners/ash/src/main.rs:743–826

(&mut self, pipeline_cache: vk::PipelineCache)

    }

    pub fn rebuild_pipelines(&mut self, pipeline_cache: vk::PipelineCache) {
        // NOTE(eddyb) this acts like an integration test for specialization constants.
        let spec_const_entries = [vk::SpecializationMapEntry::builder()
            .constant_id(0x5007)
            .offset(0)
            .size(4)
            .build()];
        let spec_const_data =
            u32::to_le_bytes(self.sky_fs_spec_id_0x5007_sun_intensity_extra_spec_const_factor);
        let specialization_info = vk::SpecializationInfo::builder()
            .map_entries(&spec_const_entries)
            .data(&spec_const_data);

        self.cleanup_pipelines();
        let pipeline_layout = self.create_pipeline_layout();
        let viewport = vk::PipelineViewportStateCreateInfo::builder()
            .scissor_count(1)
            .viewport_count(1);
        let modules_names = self
            .shader_set
            .iter()
            .map(|(vert, frag)| {
                let vert_module = *self.shader_modules.get(&vert.module).unwrap();
                let vert_name = CString::new(vert.entry_point.clone()).unwrap();
                let frag_module = *self.shader_modules.get(&frag.module).unwrap();
                let frag_name = CString::new(frag.entry_point.clone()).unwrap();
                ((frag_module, frag_name), (vert_module, vert_name))
            })
            .collect::<Vec<_>>();
        let descs = modules_names
            .iter()
            .map(|((frag_module, frag_name), (vert_module, vert_name))| {
                PipelineDescriptor::new(Box::new([
                    vk::PipelineShaderStageCreateInfo {
                        module: *vert_module,
                        p_name: (*vert_name).as_ptr(),
                        stage: vk::ShaderStageFlags::VERTEX,
                        ..Default::default()
                    },
                    vk::PipelineShaderStageCreateInfo {
                        s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
                        module: *frag_module,
                        p_name: (*frag_name).as_ptr(),
                        stage: vk::ShaderStageFlags::FRAGMENT,
                        p_specialization_info: &*specialization_info,
                        ..Default::default()
                    },
                ]))
            })
            .collect::<Vec<_>>();
        let pipeline_info = descs
            .iter()
            .map(|desc| {
                vk::GraphicsPipelineCreateInfo::builder()
                    .stages(&desc.shader_stages)
                    .vertex_input_state(&desc.vertex_input)
                    .input_assembly_state(&desc.input_assembly)
                    .rasterization_state(&desc.rasterization)