575da1f9683ffb7a4235ff1232c4ea07c1b31728
[blender.git] / source / blender / draw / engines / workbench / workbench_volume.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 2018, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw_engine
21  */
22
23 #include "workbench_private.h"
24
25 #include "BKE_object.h"
26 #include "BKE_smoke.h"
27
28 #include "BLI_rand.h"
29 #include "BLI_dynstr.h"
30
31 #include "DNA_modifier_types.h"
32 #include "DNA_object_force_types.h"
33 #include "DNA_smoke_types.h"
34
35 #include "GPU_draw.h"
36
37 enum {
38   VOLUME_SH_SLICE = 0,
39   VOLUME_SH_COBA,
40   VOLUME_SH_CUBIC,
41 };
42
43 #define VOLUME_SH_MAX (1 << (VOLUME_SH_CUBIC + 1))
44
45 static struct {
46   struct GPUShader *volume_sh[VOLUME_SH_MAX];
47   struct GPUShader *volume_coba_sh;
48   struct GPUShader *volume_slice_sh;
49   struct GPUShader *volume_slice_coba_sh;
50   struct GPUTexture *dummy_tex;
51   struct GPUTexture *dummy_coba_tex;
52 } e_data = {{NULL}};
53
54 extern char datatoc_workbench_volume_vert_glsl[];
55 extern char datatoc_workbench_volume_frag_glsl[];
56 extern char datatoc_common_view_lib_glsl[];
57
58 static GPUShader *volume_shader_get(bool slice, bool coba, bool cubic)
59 {
60   int id = 0;
61   id += (slice) ? (1 << VOLUME_SH_SLICE) : 0;
62   id += (coba) ? (1 << VOLUME_SH_COBA) : 0;
63   id += (cubic) ? (1 << VOLUME_SH_CUBIC) : 0;
64
65   if (!e_data.volume_sh[id]) {
66     DynStr *ds = BLI_dynstr_new();
67
68     if (slice) {
69       BLI_dynstr_append(ds, "#define VOLUME_SLICE\n");
70     }
71     if (coba) {
72       BLI_dynstr_append(ds, "#define USE_COBA\n");
73     }
74     if (cubic) {
75       BLI_dynstr_append(ds, "#define USE_TRICUBIC\n");
76     }
77
78     char *defines = BLI_dynstr_get_cstring(ds);
79     BLI_dynstr_free(ds);
80
81     e_data.volume_sh[id] = DRW_shader_create_with_lib(datatoc_workbench_volume_vert_glsl,
82                                                       NULL,
83                                                       datatoc_workbench_volume_frag_glsl,
84                                                       datatoc_common_view_lib_glsl,
85                                                       defines);
86
87     MEM_freeN(defines);
88   }
89
90   return e_data.volume_sh[id];
91 }
92
93 void workbench_volume_engine_init(void)
94 {
95   if (!e_data.dummy_tex) {
96     float pixel[4] = {0.0f, 0.0f, 0.0f, 0.0f};
97     e_data.dummy_tex = GPU_texture_create_3d(1, 1, 1, GPU_RGBA8, pixel, NULL);
98     e_data.dummy_coba_tex = GPU_texture_create_1d(1, GPU_RGBA8, pixel, NULL);
99   }
100 }
101
102 void workbench_volume_engine_free(void)
103 {
104   for (int i = 0; i < VOLUME_SH_MAX; ++i) {
105     DRW_SHADER_FREE_SAFE(e_data.volume_sh[i]);
106   }
107   DRW_TEXTURE_FREE_SAFE(e_data.dummy_tex);
108   DRW_TEXTURE_FREE_SAFE(e_data.dummy_coba_tex);
109 }
110
111 void workbench_volume_cache_init(WORKBENCH_Data *vedata)
112 {
113   vedata->psl->volume_pass = DRW_pass_create(
114       "Volumes", DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ALPHA_PREMUL | DRW_STATE_CULL_FRONT);
115 }
116
117 void workbench_volume_cache_populate(WORKBENCH_Data *vedata,
118                                      Scene *scene,
119                                      Object *ob,
120                                      ModifierData *md)
121 {
122   SmokeModifierData *smd = (SmokeModifierData *)md;
123   SmokeDomainSettings *sds = smd->domain;
124   WORKBENCH_PrivateData *wpd = vedata->stl->g_data;
125   WORKBENCH_EffectInfo *effect_info = vedata->stl->effects;
126   DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
127   DRWShadingGroup *grp = NULL;
128
129   /* Don't show smoke before simulation starts, this could be made an option in the future. */
130   if (!sds->fluid || CFRA < sds->point_cache[0]->startframe) {
131     return;
132   }
133
134   wpd->volumes_do = true;
135   const bool show_highres = BKE_smoke_show_highres(scene, sds);
136   if (sds->use_coba) {
137     GPU_create_smoke_coba_field(smd);
138   }
139   else if (!sds->wt || !show_highres) {
140     GPU_create_smoke(smd, 0);
141   }
142   else if (sds->wt && show_highres) {
143     GPU_create_smoke(smd, 1);
144   }
145
146   if ((!sds->use_coba && sds->tex == NULL) || (sds->use_coba && sds->tex_field == NULL)) {
147     return;
148   }
149
150   const bool use_slice = (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
151                           sds->axis_slice_method == AXIS_SLICE_SINGLE);
152   const bool cubic_interp = (sds->interp_method == VOLUME_INTERP_CUBIC);
153   GPUShader *sh = volume_shader_get(use_slice, sds->use_coba, cubic_interp);
154
155   if (use_slice) {
156     float invviewmat[4][4];
157     DRW_view_viewmat_get(NULL, invviewmat, true);
158
159     const int axis = (sds->slice_axis == SLICE_AXIS_AUTO) ?
160                          axis_dominant_v3_single(invviewmat[2]) :
161                          sds->slice_axis - 1;
162     float dim[3];
163     BKE_object_dimensions_get(ob, dim);
164     /* 0.05f to acheive somewhat the same opacity as the full view.  */
165     float step_length = max_ff(1e-16f, dim[axis] * 0.05f);
166
167     grp = DRW_shgroup_create(sh, vedata->psl->volume_pass);
168     DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
169     DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
170     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
171     DRW_shgroup_state_disable(grp, DRW_STATE_CULL_FRONT);
172   }
173   else {
174     double noise_ofs;
175     BLI_halton_1d(3, 0.0, effect_info->jitter_index, &noise_ofs);
176     float dim[3], step_length, max_slice;
177     float slice_ct[3] = {sds->res[0], sds->res[1], sds->res[2]};
178     mul_v3_fl(slice_ct, max_ff(0.001f, sds->slice_per_voxel));
179     max_slice = max_fff(slice_ct[0], slice_ct[1], slice_ct[2]);
180     BKE_object_dimensions_get(ob, dim);
181     invert_v3(slice_ct);
182     mul_v3_v3(dim, slice_ct);
183     step_length = len_v3(dim);
184
185     grp = DRW_shgroup_create(sh, vedata->psl->volume_pass);
186     DRW_shgroup_uniform_vec4(grp, "viewvecs[0]", (float *)wpd->viewvecs, 3);
187     DRW_shgroup_uniform_int_copy(grp, "samplesLen", max_slice);
188     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
189     DRW_shgroup_uniform_float_copy(grp, "noiseOfs", noise_ofs);
190     DRW_shgroup_state_enable(grp, DRW_STATE_CULL_FRONT);
191   }
192
193   if (sds->use_coba) {
194     DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex_field);
195     DRW_shgroup_uniform_texture(grp, "transferTexture", sds->tex_coba);
196   }
197   else {
198     static float white[3] = {1.0f, 1.0f, 1.0f};
199     bool use_constant_color = ((sds->active_fields & SM_ACTIVE_COLORS) == 0 &&
200                                (sds->active_fields & SM_ACTIVE_COLOR_SET) != 0);
201     DRW_shgroup_uniform_texture(grp, "densityTexture", sds->tex);
202     DRW_shgroup_uniform_texture(grp, "shadowTexture", sds->tex_shadow);
203     DRW_shgroup_uniform_texture(
204         grp, "flameTexture", (sds->tex_flame) ? sds->tex_flame : e_data.dummy_tex);
205     DRW_shgroup_uniform_texture(
206         grp, "flameColorTexture", (sds->tex_flame) ? sds->tex_flame_coba : e_data.dummy_coba_tex);
207     DRW_shgroup_uniform_vec3(
208         grp, "activeColor", (use_constant_color) ? sds->active_color : white, 1);
209   }
210   DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
211   DRW_shgroup_uniform_float_copy(grp, "densityScale", 10.0f * sds->display_thickness);
212
213   if (use_slice) {
214     DRW_shgroup_call(grp, DRW_cache_quad_get(), ob);
215   }
216   else {
217     DRW_shgroup_call(grp, DRW_cache_cube_get(), ob);
218   }
219
220   BLI_addtail(&wpd->smoke_domains, BLI_genericNodeN(smd));
221 }
222
223 void workbench_volume_smoke_textures_free(WORKBENCH_PrivateData *wpd)
224 {
225   /* Free Smoke Textures after rendering */
226   /* XXX This is a waste of processing and GPU bandwidth if nothing
227    * is updated. But the problem is since Textures are stored in the
228    * modifier we don't want them to take precious VRAM if the
229    * modifier is not used for display. We should share them for
230    * all viewport in a redraw at least. */
231   for (LinkData *link = wpd->smoke_domains.first; link; link = link->next) {
232     SmokeModifierData *smd = (SmokeModifierData *)link->data;
233     GPU_free_smoke(smd);
234   }
235   BLI_freelistN(&wpd->smoke_domains);
236 }