      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147

    // Copyright (c) 2016 The vulkano developers
    // Licensed under the Apache License, Version 2.0
    // <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT
    // license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
    // at your option. All files in the project carrying such
    // notice may not be copied, modified, or distributed except
    // according to those terms.

    //! Stage when triangles are turned into pixels.
    //!
    //! The rasterization is the stage when collections of triangles are turned into collections
    //! of pixels or samples.
    //!

    use vk;

    /// State of the rasterizer.
    #[derive(Clone, Debug)]
    pub struct Rasterization {
        /// If true, then the depth value of the vertices will be clamped to [0.0 ; 1.0]. If false,
        /// fragments whose depth is outside of this range will be discarded.
        pub depth_clamp: bool,

        /// If true, all the fragments will be discarded. This is usually used when your vertex shader
        /// has some side effects and you don't need to run the fragment shader.
        pub rasterizer_discard: bool,

        /// This setting can ask the rasterizer to downgrade triangles into lines or points, or lines
        /// into points.
        pub polygon_mode: PolygonMode,

        /// Specifies whether front faces or back faces should be discarded, or none, or both.
        pub cull_mode: CullMode,

        /// Specifies which triangle orientation corresponds to the front or the triangle.
        pub front_face: FrontFace,

        /// Width, in pixels, of lines when drawing lines.
        ///
        /// If you pass `None`, then this state will be considered as dynamic and the line width will
        /// need to be set when you build the command buffer.
        pub line_width: Option<f32>,

        pub depth_bias: DepthBiasControl,
    }

    impl Default for Rasterization {
        #[inline]
        fn default() -> Rasterization {
            Rasterization {
                depth_clamp: false,
                rasterizer_discard: false,
                polygon_mode: Default::default(),
                cull_mode: Default::default(),
                front_face: Default::default(),
                line_width: Some(1.0),
                depth_bias: DepthBiasControl::Disabled,
            }
        }
    }

    #[derive(Copy, Clone, Debug)]
    pub enum DepthBiasControl {
        Disabled,
        Dynamic,
        Static(DepthBias),
    }

    impl DepthBiasControl {
        #[inline]
        pub fn is_dynamic(&self) -> bool {
            match *self {
                DepthBiasControl::Dynamic => true,
                _ => false,
            }
        }
    }

    #[derive(Copy, Clone, Debug)]
    pub struct DepthBias {
        pub constant_factor: f32,
        /// Requires the `depth_bias_clamp` feature to be enabled.
        pub clamp: f32,
        pub slope_factor: f32,
    }

    /// Specifies the culling mode.
    ///
    /// This setting works in pair with `front_face`. The `front_face` setting tells the GPU whether
    /// clockwise or counter-clockwise correspond to the front and the back of each triangle. Then
    /// `cull_mode` lets you specify whether front faces should be discarded, back faces should be
    /// discarded, or none, or both.
    #[derive(Copy, Clone, Debug)]
    #[repr(u32)]
    pub enum CullMode {
        /// No culling.
        None = vk::CULL_MODE_NONE,
        /// The faces facing the front of the screen (ie. facing the user) will be removed.
        Front = vk::CULL_MODE_FRONT_BIT,
        /// The faces facing the back of the screen will be removed.
        Back = vk::CULL_MODE_BACK_BIT,
        /// All faces will be removed.
        FrontAndBack = vk::CULL_MODE_FRONT_AND_BACK,
    }

    impl Default for CullMode {
        #[inline]
        fn default() -> CullMode {
            CullMode::None
        }
    }

    /// Specifies which triangle orientation corresponds to the front or the triangle.
    #[derive(Copy, Clone, Debug)]
    #[repr(u32)]
    pub enum FrontFace {
        /// Triangles whose vertices are oriented counter-clockwise on the screen will be considered
        /// as facing their front. Otherwise they will be considered as facing their back.
        CounterClockwise = vk::FRONT_FACE_COUNTER_CLOCKWISE,

        /// Triangles whose vertices are oriented clockwise on the screen will be considered
        /// as facing their front. Otherwise they will be considered as facing their back.
        Clockwise = vk::FRONT_FACE_CLOCKWISE,
    }

    impl Default for FrontFace {
        #[inline]
        fn default() -> FrontFace {
            FrontFace::CounterClockwise
        }
    }

    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum PolygonMode {
        Fill = vk::POLYGON_MODE_FILL,
        Line = vk::POLYGON_MODE_LINE,
        Point = vk::POLYGON_MODE_POINT,
    }

    impl Default for PolygonMode {
        #[inline]
        fn default() -> PolygonMode {
            PolygonMode::Fill
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)