erupt/generated/extensions/
ext_conservative_rasterization.rs1#[doc(alias = "VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION")]
4pub const EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION: u32 = 1;
5#[doc(alias = "VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME")]
7pub const EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8 "VK_EXT_conservative_rasterization"
9);
10bitflags::bitflags! {
11 #[doc =
12 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html) · Bitmask of [`PipelineRasterizationConservativeStateCreateFlagBitsEXT`]"]
13 #[doc(alias = "VkPipelineRasterizationConservativeStateCreateFlagsEXT")]
14 #[derive(Default)] #[repr(transparent)] pub struct
15 PipelineRasterizationConservativeStateCreateFlagsEXT : u32 {
16 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
17}
18#[doc(alias = "VkPipelineRasterizationConservativeStateCreateFlagBitsEXT")]
20#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
21#[repr(transparent)]
22pub struct PipelineRasterizationConservativeStateCreateFlagBitsEXT(pub u32);
23impl PipelineRasterizationConservativeStateCreateFlagBitsEXT {
24 #[inline]
25 pub const fn bitmask(&self) -> PipelineRasterizationConservativeStateCreateFlagsEXT {
27 PipelineRasterizationConservativeStateCreateFlagsEXT::from_bits_truncate(self.0)
28 }
29}
30impl std::fmt::Debug for PipelineRasterizationConservativeStateCreateFlagBitsEXT {
31 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
32 f.write_str(
33 match self {
34 _ => "(unknown variant)",
35 },
36 )
37 }
38}
39impl crate::vk1_0::StructureType {
41 pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(
42 1000101000,
43 );
44 pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(
45 1000101001,
46 );
47}
48#[doc(alias = "VkConservativeRasterizationModeEXT")]
50#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
51#[repr(transparent)]
52pub struct ConservativeRasterizationModeEXT(pub i32);
53impl std::fmt::Debug for ConservativeRasterizationModeEXT {
54 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
55 f.write_str(
56 match self {
57 &Self::DISABLED_EXT => "DISABLED_EXT",
58 &Self::OVERESTIMATE_EXT => "OVERESTIMATE_EXT",
59 &Self::UNDERESTIMATE_EXT => "UNDERESTIMATE_EXT",
60 _ => "(unknown variant)",
61 },
62 )
63 }
64}
65impl crate::extensions::ext_conservative_rasterization::ConservativeRasterizationModeEXT {
67 pub const DISABLED_EXT: Self = Self(0);
68 pub const OVERESTIMATE_EXT: Self = Self(1);
69 pub const UNDERESTIMATE_EXT: Self = Self(2);
70}
71impl<'a> crate::ExtendableFrom<'a, PipelineRasterizationConservativeStateCreateInfoEXT>
72for crate::vk1_0::PipelineRasterizationStateCreateInfoBuilder<'a> {}
73impl<
74 'a,
75> crate::ExtendableFrom<
76 'a,
77 PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>,
78> for crate::vk1_0::PipelineRasterizationStateCreateInfoBuilder<'a> {}
79impl<'a> crate::ExtendableFrom<'a, PhysicalDeviceConservativeRasterizationPropertiesEXT>
80for crate::vk1_1::PhysicalDeviceProperties2Builder<'a> {}
81impl<
82 'a,
83> crate::ExtendableFrom<
84 'a,
85 PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>,
86> for crate::vk1_1::PhysicalDeviceProperties2Builder<'a> {}
87#[doc(alias = "VkPhysicalDeviceConservativeRasterizationPropertiesEXT")]
89#[derive(Copy, Clone)]
90#[repr(C)]
91pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
92 pub s_type: crate::vk1_0::StructureType,
93 pub p_next: *mut std::ffi::c_void,
94 pub primitive_overestimation_size: std::os::raw::c_float,
95 pub max_extra_primitive_overestimation_size: std::os::raw::c_float,
96 pub extra_primitive_overestimation_size_granularity: std::os::raw::c_float,
97 pub primitive_underestimation: crate::vk1_0::Bool32,
98 pub conservative_point_and_line_rasterization: crate::vk1_0::Bool32,
99 pub degenerate_triangles_rasterized: crate::vk1_0::Bool32,
100 pub degenerate_lines_rasterized: crate::vk1_0::Bool32,
101 pub fully_covered_fragment_shader_input_variable: crate::vk1_0::Bool32,
102 pub conservative_rasterization_post_depth_coverage: crate::vk1_0::Bool32,
103}
104impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
105 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
106}
107impl Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
108 fn default() -> Self {
109 Self {
110 s_type: Self::STRUCTURE_TYPE,
111 p_next: std::ptr::null_mut(),
112 primitive_overestimation_size: Default::default(),
113 max_extra_primitive_overestimation_size: Default::default(),
114 extra_primitive_overestimation_size_granularity: Default::default(),
115 primitive_underestimation: Default::default(),
116 conservative_point_and_line_rasterization: Default::default(),
117 degenerate_triangles_rasterized: Default::default(),
118 degenerate_lines_rasterized: Default::default(),
119 fully_covered_fragment_shader_input_variable: Default::default(),
120 conservative_rasterization_post_depth_coverage: Default::default(),
121 }
122 }
123}
124impl std::fmt::Debug for PhysicalDeviceConservativeRasterizationPropertiesEXT {
125 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
126 f.debug_struct("PhysicalDeviceConservativeRasterizationPropertiesEXT")
127 .field("s_type", &self.s_type)
128 .field("p_next", &self.p_next)
129 .field("primitive_overestimation_size", &self.primitive_overestimation_size)
130 .field(
131 "max_extra_primitive_overestimation_size",
132 &self.max_extra_primitive_overestimation_size,
133 )
134 .field(
135 "extra_primitive_overestimation_size_granularity",
136 &self.extra_primitive_overestimation_size_granularity,
137 )
138 .field("primitive_underestimation", &(self.primitive_underestimation != 0))
139 .field(
140 "conservative_point_and_line_rasterization",
141 &(self.conservative_point_and_line_rasterization != 0),
142 )
143 .field(
144 "degenerate_triangles_rasterized",
145 &(self.degenerate_triangles_rasterized != 0),
146 )
147 .field(
148 "degenerate_lines_rasterized",
149 &(self.degenerate_lines_rasterized != 0),
150 )
151 .field(
152 "fully_covered_fragment_shader_input_variable",
153 &(self.fully_covered_fragment_shader_input_variable != 0),
154 )
155 .field(
156 "conservative_rasterization_post_depth_coverage",
157 &(self.conservative_rasterization_post_depth_coverage != 0),
158 )
159 .finish()
160 }
161}
162impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
163 #[inline]
164 pub fn into_builder<'a>(
165 self,
166 ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
167 PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder(
168 self,
169 std::marker::PhantomData,
170 )
171 }
172}
173#[derive(Copy, Clone)]
174#[repr(transparent)]
176pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>(
177 PhysicalDeviceConservativeRasterizationPropertiesEXT,
178 std::marker::PhantomData<&'a ()>,
179);
180impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
181 #[inline]
182 pub fn new() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
183 PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder(
184 Default::default(),
185 std::marker::PhantomData,
186 )
187 }
188 #[inline]
189 #[must_use]
190 pub fn primitive_overestimation_size(
191 mut self,
192 primitive_overestimation_size: std::os::raw::c_float,
193 ) -> Self {
194 self.0.primitive_overestimation_size = primitive_overestimation_size as _;
195 self
196 }
197 #[inline]
198 #[must_use]
199 pub fn max_extra_primitive_overestimation_size(
200 mut self,
201 max_extra_primitive_overestimation_size: std::os::raw::c_float,
202 ) -> Self {
203 self
204 .0
205 .max_extra_primitive_overestimation_size = max_extra_primitive_overestimation_size
206 as _;
207 self
208 }
209 #[inline]
210 #[must_use]
211 pub fn extra_primitive_overestimation_size_granularity(
212 mut self,
213 extra_primitive_overestimation_size_granularity: std::os::raw::c_float,
214 ) -> Self {
215 self
216 .0
217 .extra_primitive_overestimation_size_granularity = extra_primitive_overestimation_size_granularity
218 as _;
219 self
220 }
221 #[inline]
222 #[must_use]
223 pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self {
224 self.0.primitive_underestimation = primitive_underestimation as _;
225 self
226 }
227 #[inline]
228 #[must_use]
229 pub fn conservative_point_and_line_rasterization(
230 mut self,
231 conservative_point_and_line_rasterization: bool,
232 ) -> Self {
233 self
234 .0
235 .conservative_point_and_line_rasterization = conservative_point_and_line_rasterization
236 as _;
237 self
238 }
239 #[inline]
240 #[must_use]
241 pub fn degenerate_triangles_rasterized(
242 mut self,
243 degenerate_triangles_rasterized: bool,
244 ) -> Self {
245 self.0.degenerate_triangles_rasterized = degenerate_triangles_rasterized as _;
246 self
247 }
248 #[inline]
249 #[must_use]
250 pub fn degenerate_lines_rasterized(
251 mut self,
252 degenerate_lines_rasterized: bool,
253 ) -> Self {
254 self.0.degenerate_lines_rasterized = degenerate_lines_rasterized as _;
255 self
256 }
257 #[inline]
258 #[must_use]
259 pub fn fully_covered_fragment_shader_input_variable(
260 mut self,
261 fully_covered_fragment_shader_input_variable: bool,
262 ) -> Self {
263 self
264 .0
265 .fully_covered_fragment_shader_input_variable = fully_covered_fragment_shader_input_variable
266 as _;
267 self
268 }
269 #[inline]
270 #[must_use]
271 pub fn conservative_rasterization_post_depth_coverage(
272 mut self,
273 conservative_rasterization_post_depth_coverage: bool,
274 ) -> Self {
275 self
276 .0
277 .conservative_rasterization_post_depth_coverage = conservative_rasterization_post_depth_coverage
278 as _;
279 self
280 }
281 #[inline]
282 pub fn build_dangling(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
285 self.0
286 }
287}
288impl<'a> std::default::Default
289for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
290 fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
291 Self::new()
292 }
293}
294impl<'a> std::fmt::Debug
295for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
296 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
297 std::fmt::Debug::fmt(&self.0, f)
298 }
299}
300impl<'a> std::ops::Deref
301for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
302 type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
303 fn deref(&self) -> &Self::Target {
304 &self.0
305 }
306}
307impl<'a> std::ops::DerefMut
308for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
309 fn deref_mut(&mut self) -> &mut Self::Target {
310 &mut self.0
311 }
312}
313#[doc(alias = "VkPipelineRasterizationConservativeStateCreateInfoEXT")]
315#[derive(Copy, Clone)]
316#[repr(C)]
317pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
318 pub s_type: crate::vk1_0::StructureType,
319 pub p_next: *const std::ffi::c_void,
320 pub flags: crate::extensions::ext_conservative_rasterization::PipelineRasterizationConservativeStateCreateFlagsEXT,
321 pub conservative_rasterization_mode: crate::extensions::ext_conservative_rasterization::ConservativeRasterizationModeEXT,
322 pub extra_primitive_overestimation_size: std::os::raw::c_float,
323}
324impl PipelineRasterizationConservativeStateCreateInfoEXT {
325 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
326}
327impl Default for PipelineRasterizationConservativeStateCreateInfoEXT {
328 fn default() -> Self {
329 Self {
330 s_type: Self::STRUCTURE_TYPE,
331 p_next: std::ptr::null(),
332 flags: Default::default(),
333 conservative_rasterization_mode: Default::default(),
334 extra_primitive_overestimation_size: Default::default(),
335 }
336 }
337}
338impl std::fmt::Debug for PipelineRasterizationConservativeStateCreateInfoEXT {
339 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
340 f.debug_struct("PipelineRasterizationConservativeStateCreateInfoEXT")
341 .field("s_type", &self.s_type)
342 .field("p_next", &self.p_next)
343 .field("flags", &self.flags)
344 .field(
345 "conservative_rasterization_mode",
346 &self.conservative_rasterization_mode,
347 )
348 .field(
349 "extra_primitive_overestimation_size",
350 &self.extra_primitive_overestimation_size,
351 )
352 .finish()
353 }
354}
355impl PipelineRasterizationConservativeStateCreateInfoEXT {
356 #[inline]
357 pub fn into_builder<'a>(
358 self,
359 ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
360 PipelineRasterizationConservativeStateCreateInfoEXTBuilder(
361 self,
362 std::marker::PhantomData,
363 )
364 }
365}
366#[derive(Copy, Clone)]
367#[repr(transparent)]
369pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>(
370 PipelineRasterizationConservativeStateCreateInfoEXT,
371 std::marker::PhantomData<&'a ()>,
372);
373impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
374 #[inline]
375 pub fn new() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
376 PipelineRasterizationConservativeStateCreateInfoEXTBuilder(
377 Default::default(),
378 std::marker::PhantomData,
379 )
380 }
381 #[inline]
382 #[must_use]
383 pub fn flags(
384 mut self,
385 flags: crate::extensions::ext_conservative_rasterization::PipelineRasterizationConservativeStateCreateFlagsEXT,
386 ) -> Self {
387 self.0.flags = flags as _;
388 self
389 }
390 #[inline]
391 #[must_use]
392 pub fn conservative_rasterization_mode(
393 mut self,
394 conservative_rasterization_mode: crate::extensions::ext_conservative_rasterization::ConservativeRasterizationModeEXT,
395 ) -> Self {
396 self.0.conservative_rasterization_mode = conservative_rasterization_mode as _;
397 self
398 }
399 #[inline]
400 #[must_use]
401 pub fn extra_primitive_overestimation_size(
402 mut self,
403 extra_primitive_overestimation_size: std::os::raw::c_float,
404 ) -> Self {
405 self
406 .0
407 .extra_primitive_overestimation_size = extra_primitive_overestimation_size
408 as _;
409 self
410 }
411 #[inline]
412 pub fn build_dangling(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
415 self.0
416 }
417}
418impl<'a> std::default::Default
419for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
420 fn default() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
421 Self::new()
422 }
423}
424impl<'a> std::fmt::Debug
425for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
426 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
427 std::fmt::Debug::fmt(&self.0, f)
428 }
429}
430impl<'a> std::ops::Deref
431for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
432 type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
433 fn deref(&self) -> &Self::Target {
434 &self.0
435 }
436}
437impl<'a> std::ops::DerefMut
438for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
439 fn deref_mut(&mut self) -> &mut Self::Target {
440 &mut self.0
441 }
442}