caper 0.13.0

Minimalist game framework
Documentation 
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
148
149
150
151
152
153
154
155
156
157
158
159
160

use glium::backend::Facade;
use glium::framebuffer::SimpleFrameBuffer;
use glium::index::{IndexBuffer, PrimitiveType};
use glium::texture::{DepthFormat, DepthTexture2d, MipmapsOption, Texture2d};
use glium::vertex::VertexBuffer;
use glium::Surface;

use types::Vertex;

use time;

/// struct representing a post effect
pub struct PostEffect {
    /// The vertex buffer to render
    pub vertex_buffer: VertexBuffer<Vertex>,
    /// The index buffer to render
    pub index_buffer: IndexBuffer<u16>,
    /// The current shader being used for post processing
    pub current_shader: &'static str,
    /// The time the post effect was initialised
    pub start_time: f32,
    /// The scale factor that the scene will be rendered
    /// in relation to to the full window resolution
    pub downscale_factor: f32,
    /// Options for the default post shader
    pub post_shader_options: PostShaderOptions,
}

impl PostEffect {
    /// creates a new instance of a post effect
    pub fn new<F>(facade: &F) -> PostEffect
    where
        F: Facade + Clone,
    {
        let vert_arr = [
            Vertex {
                position: [-1.0, -1.0, 0.0],
                normal: [0.0, 0.0, 0.0],
                texture: [0.0, 0.0],
            },
            Vertex {
                position: [-1.0, 1.0, 0.0],
                normal: [0.0, 0.0, 0.0],
                texture: [0.0, 1.0],
            },
            Vertex {
                position: [1.0, 1.0, 0.0],
                normal: [0.0, 0.0, 0.0],
                texture: [1.0, 1.0],
            },
            Vertex {
                position: [1.0, -1.0, 0.0],
                normal: [0.0, 0.0, 0.0],
                texture: [1.0, 0.0],
            },
        ];

        let ind_arr = [1 as u16, 2, 0, 3];

        PostEffect {
            vertex_buffer: VertexBuffer::new(facade, &vert_arr).unwrap(),
            index_buffer: IndexBuffer::new(facade, PrimitiveType::TriangleStrip, &ind_arr).unwrap(),
            current_shader: "default",
            start_time: time::precise_time_s() as f32,
            downscale_factor: 1.0f32,
            post_shader_options: PostShaderOptions::default(),
        }
    }
}

/// Contains all the options for the default post shader
#[derive(Builder, Clone, PartialEq)]
#[builder(default)]
pub struct PostShaderOptions {
    /// The offset for the chromatic aberration
    pub chrom_offset: f32,
    /// The mix amount for the chromatic aberration, if this is at 0.0 chromatic aberration is off
    pub chrom_amt: f32,
    /// Whether blur is on
    pub blur: bool,
    /// The amount of blur
    pub blur_amt: f32,
    /// The radius of the blur
    pub blur_radius: f32,
    /// The weight of the blur
    pub blur_weight: f32,
    /// Whether bokeh is on
    pub bokeh: bool,
    /// Bokeh focal depth
    pub bokeh_focal_depth: f32,
    /// Bokeh focal width
    pub bokeh_focal_width: f32,
    /// Colour grading
    pub color_offset: (f32, f32, f32, f32),
    /// Greyscale
    pub greyscale: bool,
    /// Noise
    pub noise: f32,
    /// Scanline
    pub scanline: f32,
    /// Scanline count
    pub scanline_count: i32,
}

impl Default for PostShaderOptions {
    fn default() -> Self {
        PostShaderOptions {
            chrom_offset: 0.003f32,
            chrom_amt: 0.0f32,
            blur: false,
            blur_amt: 1.0f32,
            blur_radius: 1.0f32,
            blur_weight: 1.0f32,
            bokeh: false,
            bokeh_focal_depth: 0.2f32,
            bokeh_focal_width: 0.2f32,
            color_offset: (1f32, 1f32, 1f32, 1f32),
            greyscale: false,
            noise: 0f32,
            scanline: 0f32,
            scanline_count: 0i32,
        }
    }
}

/// Renders the post effect on to the scene rendered in the draw FnMut
pub fn render_to_texture<T, F, C>(
    system: &PostEffect,
    context: &C,
    target: &mut T,
    mut draw: F,
) -> (Texture2d, DepthTexture2d)
where
    T: Surface,
    F: FnMut(&mut SimpleFrameBuffer),
    C: Facade + Clone,
{
    let target_dimensions = target.get_dimensions();

    let target_color = Texture2d::empty(
        context,
        (target_dimensions.0 as f32 * system.downscale_factor) as u32,
        (target_dimensions.1 as f32 * system.downscale_factor) as u32,
    )
    .unwrap();

    let target_depth = DepthTexture2d::empty_with_format(
        context,
        DepthFormat::F32,
        MipmapsOption::NoMipmap,
        (target_dimensions.0 as f32 * system.downscale_factor) as u32,
        (target_dimensions.1 as f32 * system.downscale_factor) as u32,
    )
    .unwrap();

    // first pass draw the scene into a buffer
    draw(&mut SimpleFrameBuffer::with_depth_buffer(context, &target_color, &target_depth).unwrap());

    (target_color, target_depth)
}