pub fn builder<'a, H: Hash + Eq + Copy>(
input_map: InputMap<H>,
) -> ThinBuilder<'a, H>Examples found in repository?
More examples
examples/simple-fxaa.rs (line 58)
13fn main() {
14 use Action::*;
15 let event_loop = EventLoop::new().unwrap();
16 event_loop.set_control_flow(ControlFlow::Poll);
17
18 let mut colour = ResizableTexture2d::default();
19 let mut depth = ResizableDepthTexture2d::default();
20
21 let input = { use base_input_codes::*; input_map!(
22 (Left, ArrowLeft, KeyA, LeftStickLeft ),
23 (Right, ArrowRight, KeyD, LeftStickRight),
24 (Forward, ArrowUp, KeyW, LeftStickUp ),
25 (Back, ArrowDown, KeyS, LeftStickDown ),
26 (LookRight, MouseMoveRight, RightStickRight),
27 (LookLeft, MouseMoveLeft, RightStickLeft ),
28 (LookUp, MouseMoveUp, RightStickUp ),
29 (LookDown, MouseMoveDown, RightStickDown ),
30 (FXAA, KeyF, GamepadInput::North)
31 ) };
32 struct Graphics {
33 screen_indices: IndexBuffer<u32>,
34 screen_vertices: VertexBuffer<Vertex>,
35 screen_uvs: VertexBuffer<TextureCoords>,
36
37 teapot_indices: IndexBuffer<u16>,
38 teapot_vertices: VertexBuffer<Vertex>,
39 teapot_uvs: VertexBuffer<TextureCoords>,
40 teapot_normals: VertexBuffer<Normal>,
41
42 fxaa: Program, normal: Program, program: Program
43 }
44 let graphics: Rc<RefCell<Option<Graphics>>> = Rc::default();
45 let graphics_setup = graphics.clone();
46
47 let draw_parameters = DrawParameters {
48 backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
49 ..params::alias_3d()
50 };
51 let mut fxaa_on = true;
52
53 let mut pos = vec3(0.0, 0.0, -30.0);
54 let mut rot = vec2(0.0, 0.0);
55
56 let mut frame_start = Instant::now();
57
58 thin_engine::builder(input).with_setup(|display, window, _| {
59 window.set_title("FXAA Test");
60 let _ = window.set_cursor_grab(CursorGrabMode::Confined);
61 let _ = window.set_cursor_grab(CursorGrabMode::Locked);
62 window.set_cursor_visible(false);
63
64 let (screen_indices, screen_vertices, screen_uvs) = mesh!(
65 display, &screen::INDICES, &screen::VERTICES, &screen::UVS
66 ).unwrap();
67 let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
68 display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
69 ).unwrap();
70
71 let program = Program::from_source(
72 display,
73 "#version 140
74 in vec3 position;
75 in vec3 normal;
76
77 out vec3 v_normal;
78
79 uniform mat4 model;
80 uniform mat4 perspective;
81 uniform mat4 camera;
82
83 void main() {
84 mat3 norm_mat = transpose(inverse(mat3(camera * model)));
85 v_normal = normalize(norm_mat * normal);
86 gl_Position = perspective * camera * model * vec4(position, 1);
87 }",
88 "#version 140
89 out vec4 colour;
90 in vec3 v_normal;
91 uniform vec3 light;
92 uniform mat4 camera;
93 uniform vec3 ambient;
94 uniform vec3 albedo;
95 uniform float shine;
96 void main() {
97 vec3 camera_dir = inverse(mat3(camera)) * vec3(0, 0, -1);
98 vec3 half_dir = normalize(camera_dir + light);
99 float specular = pow(max(dot(half_dir, v_normal), 0.0), shine);
100 float light_level = max(dot(light, v_normal), 0.0);
101 colour = vec4(albedo * light_level + ambient + vec3(specular), 1.0);
102 }", None
103 ).unwrap();
104 let fxaa = shaders::fxaa_shader(display).unwrap();
105 let normal = Program::from_source(
106 display,
107 "#version 140
108 in vec2 texture_coords;
109 out vec2 uv;
110 in vec3 position;
111 void main() {
112 uv = texture_coords;
113 gl_Position = vec4(position, 1);
114 }",
115 "#version 140
116 in vec2 uv;
117 uniform sampler2D tex;
118 out vec4 colour;
119 void main() {
120 colour = texture(tex, uv);
121 }", None
122 ).unwrap();
123 graphics_setup.replace(Some(Graphics {
124 screen_indices, screen_vertices, screen_uvs,
125 teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
126 program, normal, fxaa
127 }));
128 }).with_update(|input, display, _, _, _| {
129 let graphics = graphics.borrow();
130 let Graphics {
131 screen_indices, screen_vertices, screen_uvs,
132 teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
133 program, normal, fxaa
134 } = graphics.as_ref().unwrap();
135 let teapot_mesh = (teapot_vertices, teapot_normals, teapot_uvs);
136 let screen_mesh = (screen_vertices, screen_uvs);
137
138 let delta_time = frame_start.elapsed().as_secs_f32();
139 frame_start = Instant::now();
140
141 // using a small resolution to better show the effect of fxaa.
142 let size = (380, 216);
143 display.resize(size);
144 depth.resize_to_display(&display);
145 colour.resize_to_display(&display);
146
147 // press f or gamepad north to toggle FXAA
148 if input.pressed(FXAA) { fxaa_on = !fxaa_on }
149
150 let colour = colour.texture();
151 let depth = depth.texture();
152 let mut frame = SimpleFrameBuffer::with_depth_buffer(
153 display, colour, depth
154 ).unwrap();
155
156 let perspective = Mat4::perspective_3d(size, 1.0, 1024.0, 0.1);
157
158 // set camera rotation
159 let look_move = input.dir(LookRight, LookLeft, LookUp, LookDown);
160 rot += look_move.scale(delta_time * 15.0);
161 rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
162 let rx = Quat::from_y_rot(rot.x);
163 let ry = Quat::from_x_rot(-rot.y);
164 let rot = rx * ry;
165
166 // move player based on camera
167 let dir = input.dir_max_len_1(Right, Left, Forward, Back);
168 let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
169 pos += Mat3::from_rot(rx) * move_dir;
170
171 frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
172 // draw teapot
173 frame.draw(
174 teapot_mesh, teapot_indices,
175 program, &uniform! {
176 perspective: perspective,
177 model: Mat4::from_scale(Vec3::splat(0.1)),
178 camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
179 light: vec3(0.1, 0.25, -1.0).normalise(),
180 albedo: vec3(0.5, 0.1, 0.4),
181 ambient: vec3(0.0, 0.05, 0.1),
182 shine: 50.0f32,
183 },
184 &draw_parameters,
185 ).unwrap();
186
187 let mut frame = display.draw();
188 frame.draw(
189 screen_mesh, screen_indices, if fxaa_on { fxaa } else { normal },
190 &shaders::fxaa_uniforms(colour), &DrawParameters::default()
191 ).unwrap();
192 frame.finish().unwrap();
193 }).build(event_loop).unwrap();
194}