abd5bb828154890deb56a26aba6a4e7af1577afc
[blender.git] / source / blender / draw / engines / eevee / eevee_motion_blur.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * Copyright 2016, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw_engine
21  *
22  * Gather all screen space effects technique such as Bloom, Motion Blur, DoF, SSAO, SSR, ...
23  */
24
25 #include "DRW_render.h"
26
27 #include "BKE_camera.h"
28 #include "BKE_object.h"
29 #include "BKE_animsys.h"
30
31 #include "DNA_anim_types.h"
32 #include "DNA_camera_types.h"
33 #include "DNA_screen_types.h"
34
35 #include "ED_screen.h"
36
37 #include "DEG_depsgraph.h"
38 #include "DEG_depsgraph_query.h"
39
40 #include "eevee_private.h"
41 #include "GPU_texture.h"
42
43 static struct {
44   /* Motion Blur */
45   struct GPUShader *motion_blur_sh;
46 } e_data = {NULL}; /* Engine data */
47
48 extern char datatoc_effect_motion_blur_frag_glsl[];
49
50 static void eevee_motion_blur_camera_get_matrix_at_time(Scene *scene,
51                                                         ARegion *ar,
52                                                         RegionView3D *rv3d,
53                                                         View3D *v3d,
54                                                         Object *camera,
55                                                         float time,
56                                                         float r_mat[4][4])
57 {
58   float obmat[4][4];
59
60   /* HACK */
61   Object cam_cpy = *camera;
62   Camera camdata_cpy = *(Camera *)(camera->data);
63   cam_cpy.data = &camdata_cpy;
64
65   /* Reset original pointers, so direct evaluation does not attempt to flush
66    * animation back to the original object: otherwise viewport with motion
67    * blur enabled will always loose non-keyed changes. */
68   cam_cpy.id.orig_id = NULL;
69   camdata_cpy.id.orig_id = NULL;
70
71   const DRWContextState *draw_ctx = DRW_context_state_get();
72
73   /* Past matrix */
74   /* FIXME : This is a temporal solution that does not take care of parent animations */
75   /* Recalc Anim manually */
76   BKE_animsys_evaluate_animdata(
77       draw_ctx->depsgraph, scene, &camdata_cpy.id, camdata_cpy.adt, time, ADT_RECALC_ALL);
78   BKE_object_where_is_calc_time(draw_ctx->depsgraph, scene, &cam_cpy, time);
79
80   /* Compute winmat */
81   CameraParams params;
82   BKE_camera_params_init(&params);
83
84   if (v3d != NULL) {
85     BKE_camera_params_from_view3d(&params, draw_ctx->depsgraph, v3d, rv3d);
86     BKE_camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
87   }
88   else {
89     BKE_camera_params_from_object(&params, &cam_cpy);
90     BKE_camera_params_compute_viewplane(
91         &params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
92   }
93
94   BKE_camera_params_compute_matrix(&params);
95
96   /* FIXME Should be done per view (MULTIVIEW) */
97   normalize_m4_m4(obmat, cam_cpy.obmat);
98   invert_m4(obmat);
99   mul_m4_m4m4(r_mat, params.winmat, obmat);
100 }
101
102 static void eevee_create_shader_motion_blur(void)
103 {
104   e_data.motion_blur_sh = DRW_shader_create_fullscreen(datatoc_effect_motion_blur_frag_glsl, NULL);
105 }
106
107 int EEVEE_motion_blur_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *vedata, Object *camera)
108 {
109   EEVEE_StorageList *stl = vedata->stl;
110   EEVEE_EffectsInfo *effects = stl->effects;
111
112   const DRWContextState *draw_ctx = DRW_context_state_get();
113   const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
114   Scene *scene = draw_ctx->scene;
115
116   View3D *v3d = draw_ctx->v3d;
117   RegionView3D *rv3d = draw_ctx->rv3d;
118   ARegion *ar = draw_ctx->ar;
119
120   if (scene_eval->eevee.flag & SCE_EEVEE_MOTION_BLUR_ENABLED) {
121     /* Update Motion Blur Matrices */
122     if (camera) {
123       float persmat[4][4];
124       float ctime = DEG_get_ctime(draw_ctx->depsgraph);
125       float delta = scene_eval->eevee.motion_blur_shutter;
126       Object *ob_camera_eval = DEG_get_evaluated_object(draw_ctx->depsgraph, camera);
127
128       /* Viewport Matrix */
129       /* Note: This does not have TAA jitter applied. */
130       DRW_view_persmat_get(NULL, persmat, false);
131
132       bool view_is_valid = (stl->g_data->view_updated == false);
133
134       if (draw_ctx->evil_C != NULL) {
135         struct wmWindowManager *wm = CTX_wm_manager(draw_ctx->evil_C);
136         view_is_valid = view_is_valid && (ED_screen_animation_no_scrub(wm) == NULL);
137       }
138
139       /* The view is jittered by the oglrenderer. So avoid testing in this case. */
140       if (!DRW_state_is_image_render()) {
141         view_is_valid = view_is_valid && compare_m4m4(persmat, effects->prev_drw_persmat, FLT_MIN);
142         /* WATCH: assume TAA init code runs last. */
143         if (scene_eval->eevee.taa_samples == 1) {
144           /* Only if TAA is disabled. If not, TAA will update prev_drw_persmat itself. */
145           copy_m4_m4(effects->prev_drw_persmat, persmat);
146         }
147       }
148
149       effects->motion_blur_mat_cached = view_is_valid && !DRW_state_is_image_render();
150
151       /* Current matrix */
152       if (effects->motion_blur_mat_cached == false) {
153         eevee_motion_blur_camera_get_matrix_at_time(
154             scene, ar, rv3d, v3d, ob_camera_eval, ctime, effects->current_world_to_ndc);
155       }
156
157       /* Only continue if camera is not being keyed */
158       if (DRW_state_is_image_render() ||
159           compare_m4m4(persmat, effects->current_world_to_ndc, 0.0001f)) {
160         /* Past matrix */
161         if (effects->motion_blur_mat_cached == false) {
162           eevee_motion_blur_camera_get_matrix_at_time(
163               scene, ar, rv3d, v3d, ob_camera_eval, ctime - delta, effects->past_world_to_ndc);
164
165 #if 0 /* for future high quality blur */
166           /* Future matrix */
167           eevee_motion_blur_camera_get_matrix_at_time(
168               scene, ar, rv3d, v3d, ob_camera_eval, ctime + delta, effects->future_world_to_ndc);
169 #endif
170           invert_m4_m4(effects->current_ndc_to_world, effects->current_world_to_ndc);
171         }
172
173         effects->motion_blur_mat_cached = true;
174         effects->motion_blur_samples = scene_eval->eevee.motion_blur_samples;
175
176         if (!e_data.motion_blur_sh) {
177           eevee_create_shader_motion_blur();
178         }
179
180         return EFFECT_MOTION_BLUR | EFFECT_POST_BUFFER;
181       }
182     }
183   }
184
185   return 0;
186 }
187
188 void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *vedata)
189 {
190   EEVEE_PassList *psl = vedata->psl;
191   EEVEE_StorageList *stl = vedata->stl;
192   EEVEE_EffectsInfo *effects = stl->effects;
193   DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
194
195   struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
196
197   if ((effects->enabled_effects & EFFECT_MOTION_BLUR) != 0) {
198     DRW_PASS_CREATE(psl->motion_blur, DRW_STATE_WRITE_COLOR);
199
200     DRWShadingGroup *grp = DRW_shgroup_create(e_data.motion_blur_sh, psl->motion_blur);
201     DRW_shgroup_uniform_int(grp, "samples", &effects->motion_blur_samples, 1);
202     DRW_shgroup_uniform_mat4(grp, "currInvViewProjMatrix", effects->current_ndc_to_world);
203     DRW_shgroup_uniform_mat4(grp, "pastViewProjMatrix", effects->past_world_to_ndc);
204     DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &effects->source_buffer);
205     DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
206     DRW_shgroup_call(grp, quad, NULL);
207   }
208 }
209
210 void EEVEE_motion_blur_draw(EEVEE_Data *vedata)
211 {
212   EEVEE_PassList *psl = vedata->psl;
213   EEVEE_TextureList *txl = vedata->txl;
214   EEVEE_FramebufferList *fbl = vedata->fbl;
215   EEVEE_StorageList *stl = vedata->stl;
216   EEVEE_EffectsInfo *effects = stl->effects;
217
218   /* Motion Blur */
219   if ((effects->enabled_effects & EFFECT_MOTION_BLUR) != 0) {
220     GPU_framebuffer_bind(effects->target_buffer);
221     DRW_draw_pass(psl->motion_blur);
222     SWAP_BUFFERS();
223   }
224 }
225
226 void EEVEE_motion_blur_free(void)
227 {
228   DRW_SHADER_FREE_SAFE(e_data.motion_blur_sh);
229 }