Blender V5.3
draw_volume.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include "DRW_gpu_wrapper.hh"
12#include "DRW_render.hh"
13
14#include "DNA_fluid_types.h"
15#include "DNA_volume_types.h"
16
17#include "BLI_string.hh"
18
19#include "BKE_global.hh"
20#include "BKE_mesh.hh"
21#include "BKE_modifier.hh"
22#include "BKE_volume.hh"
23#include "BKE_volume_render.hh"
24
25#include "GPU_material.hh"
26
27#include "draw_cache.hh"
28#include "draw_common_c.hh"
30
31#include "draw_common.hh"
32
33namespace blender::draw {
34
36
40
42 {
43 for (VolumeInfosBuf *ubo : ubos) {
44 delete ubo;
45 }
46 }
47
48 void reset()
49 {
50 used = 0;
51 }
52
54 {
55 if (used >= ubos.size()) {
56 VolumeInfosBuf *buf = new VolumeInfosBuf();
57 ubos.append(buf);
58 }
59 return ubos[used++];
60 }
61};
62
65
68
70 {
71 const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
72 const float one[4] = {1.0f, 1.0f, 1.0f, 1.0f};
74 dummy_zero.ensure_3d(gpu::TextureFormat::SFLOAT_32_32_32_32, int3(1), usage, zero);
75 dummy_one.ensure_3d(gpu::TextureFormat::SFLOAT_32_32_32_32, int3(1), usage, one);
78 }
79
81 {
82 switch (default_value) {
83 case GPU_DEFAULT_0:
84 return dummy_zero;
85 case GPU_DEFAULT_1:
86 return dummy_one;
87 }
88 return dummy_zero;
89 }
90};
91
92void DRW_volume_init(DRWData *drw_data)
93{
94 if (drw_data == nullptr) {
95 drw_data = drw_get().data;
96 }
97 if (drw_data->volume_module == nullptr) {
98 drw_data->volume_module = MEM_new<VolumeModule>("VolumeModule");
99 }
100 drw_data->volume_module->ubo_pool.reset();
101}
102
104{
105 MEM_delete(module);
106}
107
108/* -------------------------------------------------------------------- */
111
112template<typename PassType>
114{
116 VolumeInfosBuf &volume_infos = *module.ubo_pool.alloc();
117 volume_infos.density_scale = 1.0f;
118 volume_infos.color_mul = float4(1.0f);
119 volume_infos.temperature_mul = 1.0f;
120 volume_infos.temperature_bias = 0.0f;
121 for (int i : IndexRange(DRW_GRID_PER_VOLUME_MAX)) {
122 volume_infos.grids_xform[i] = float4x4::identity();
123 }
124 volume_infos.push_update();
125
126 PassType *sub = &ps.sub("World Volume");
127 for (const GPUMaterialAttribute *attr : attrs) {
128 sub->bind_texture(attr->input_name, module.grid_default_texture(attr->default_value));
129 }
130 sub->bind_ubo("drw_volume", volume_infos);
131
132 return sub;
133}
134
135template<typename PassType>
137 Object *ob,
139{
141 BKE_volume_load(&volume, G.main);
142
143 /* Render nothing if there is no attribute. */
144 if (BKE_volume_num_grids(&volume) == 0) {
145 return nullptr;
146 }
147
149 VolumeInfosBuf &volume_infos = *module.ubo_pool.alloc();
150
151 volume_infos.density_scale = BKE_volume_density_scale(&volume, ob->object_to_world().ptr());
152 volume_infos.color_mul = float4(1.0f);
153 volume_infos.temperature_mul = 1.0f;
154 volume_infos.temperature_bias = 0.0f;
155
156 PassType *sub = &ps.sub("Volume Object SubPass");
157
158 /* Bind volume grid textures. */
159 int grid_id = 0;
160 for (const GPUMaterialAttribute *attr : attrs) {
161 const bke::VolumeGridData *volume_grid = BKE_volume_grid_find(&volume, attr->name);
162 const DRWVolumeGrid *drw_grid = (volume_grid) ?
164 nullptr;
165 /* Handle 3 cases here:
166 * - Grid exists and texture was loaded -> use texture.
167 * - Grid exists but has zero size or failed to load -> use zero.
168 * - Grid does not exist -> use default value. */
169 const gpu::Texture *grid_tex = (drw_grid) ? drw_grid->texture :
170 (volume_grid) ?
171 module.dummy_zero :
172 module.grid_default_texture(attr->default_value);
173 /* TODO(@pragma37): bind_texture const support ? */
174 sub->bind_texture(attr->input_name, const_cast<gpu::Texture *>(grid_tex));
175
176 volume_infos.grids_xform[grid_id++] = drw_grid ? float4x4(drw_grid->object_to_texture) :
178 }
179
180 volume_infos.push_update();
181
182 sub->bind_ubo("drw_volume", volume_infos);
183
184 return sub;
185}
186
187template<typename PassType>
189 Scene *scene,
190 Object *ob,
192{
194 VolumeInfosBuf &volume_infos = *module.ubo_pool.alloc();
195
196 ModifierData *md = nullptr;
197
198 volume_infos.density_scale = 1.0f;
199 volume_infos.color_mul = float4(1.0f);
200 volume_infos.temperature_mul = 1.0f;
201 volume_infos.temperature_bias = 0.0f;
202
203 bool has_fluid_modifier = (md = BKE_modifiers_findby_type(ob, eModifierType_Fluid)) &&
205 (reinterpret_cast<FluidModifierData *>(md))->domain != nullptr;
206 FluidModifierData *fmd = has_fluid_modifier ? reinterpret_cast<FluidModifierData *>(md) :
207 nullptr;
208 FluidDomainSettings *fds = has_fluid_modifier ? fmd->domain : nullptr;
209
210 PassType *sub = nullptr;
211
212 if (!has_fluid_modifier || (fds->type != FLUID_DOMAIN_TYPE_GAS)) {
213 /* No volume attributes or fluid domain. */
214 sub = &ps.sub("Volume Mesh SubPass");
215 int grid_id = 0;
216 for (const GPUMaterialAttribute *attr : attrs) {
217 sub->bind_texture(attr->input_name, module.grid_default_texture(attr->default_value));
218 volume_infos.grids_xform[grid_id++] = float4x4::identity();
219 }
220 }
221 else if (fds->fluid) {
222 /* Smoke Simulation. */
224
225 sub = &ps.sub("Volume Modifier SubPass");
226
227 float3 location, scale;
229 float3 orco_mul = math::safe_rcp(scale * 2.0);
230 float3 orco_add = (location - scale) * -orco_mul;
231 /* Replace OrcoTexCoFactors with a matrix multiplication. */
232 float4x4 orco_mat = math::from_scale<float4x4>(orco_mul);
233 orco_mat.location() = orco_add;
234
235 int grid_id = 0;
236 for (const GPUMaterialAttribute *attr : attrs) {
237 if (STREQ(attr->name, "density")) {
238 sub->bind_texture(attr->input_name,
239 fds->tex_density ? &fds->tex_density : &module.dummy_one);
240 }
241 else if (STREQ(attr->name, "color")) {
242 sub->bind_texture(attr->input_name, fds->tex_color ? &fds->tex_color : &module.dummy_one);
243 }
244 else if (STR_ELEM(attr->name, "flame", "temperature")) {
245 sub->bind_texture(attr->input_name, fds->tex_flame ? &fds->tex_flame : &module.dummy_zero);
246 }
247 else {
248 sub->bind_texture(attr->input_name, module.grid_default_texture(attr->default_value));
249 }
250 volume_infos.grids_xform[grid_id++] = orco_mat;
251 }
252
253 bool use_constant_color = ((fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) == 0 &&
255 if (use_constant_color) {
256 volume_infos.color_mul = float4(UNPACK3(fds->active_color), 1.0f);
257 }
258
259 /* Output is such that 0..1 maps to 0..1000K. */
260 volume_infos.temperature_mul = fds->flame_max_temp - fds->flame_ignition;
261 volume_infos.temperature_bias = fds->flame_ignition;
262 }
263
264 if (sub) {
265 volume_infos.push_update();
266 sub->bind_ubo("drw_volume", volume_infos);
267 }
268
269 return sub;
270}
271
272template<typename PassType>
274 Scene *scene,
275 Object *ob,
276 GPUMaterial *gpu_material)
277{
278 ListBaseT<GPUMaterialAttribute> attr_list = GPU_material_attributes(gpu_material);
280 if (ob == nullptr) {
281 return volume_world_grids_init(ps, attrs);
282 }
283 if (ob->type == OB_VOLUME) {
284 return volume_object_grids_init(ps, ob, attrs);
285 }
286 return drw_volume_object_mesh_init(ps, scene, ob, attrs);
287}
288
290 Scene *scene,
291 Object *ob,
292 GPUMaterial *gpu_material)
293{
294 return volume_sub_pass_implementation(ps, scene, ob, gpu_material);
295}
296
298 Scene *scene,
299 Object *ob,
300 GPUMaterial *gpu_material)
301{
302 return volume_sub_pass_implementation(ps, scene, ob, gpu_material);
303}
304
306
307} // namespace blender::draw
Volume data-block.
Volume data-block rendering and viewport drawing utilities.
#define STR_ELEM(...)
#define UNPACK3(a)
#define STREQ(a, b)
constexpr IndexRange()=default
int64_t size() const
void append(const T &value)
bool ensure_3d(gpu::TextureFormat format, int3 extent, eGPUTextureUsage usage=GPU_TEXTURE_USAGE_GENERAL, const float *data=nullptr, int mip_len=1)
detail::PassBase< command::DrawMultiBuf > Sub
Definition draw_pass.hh:509
float3x3 scale(float3x3 mat, float2 scale)
PassType
draw::UniformBuffer< VolumeInfos > VolumeInfosBuf
PassMain::Sub * volume_sub_pass(PassMain::Sub &ps, Scene *scene, Object *ob, GPUMaterial *gpu_material)
PassType * volume_object_grids_init(PassType &ps, Object *ob, ListBaseWrapper< GPUMaterialAttribute > &attrs)
PassType * volume_world_grids_init(PassType &ps, ListBaseWrapper< GPUMaterialAttribute > &attrs)
PassType * volume_sub_pass_implementation(PassType &ps, Scene *scene, Object *ob, GPUMaterial *gpu_material)
void DRW_volume_init(DRWData *drw_data=nullptr)
PassType * drw_volume_object_mesh_init(PassType &ps, Scene *scene, Object *ob, ListBaseWrapper< GPUMaterialAttribute > &attrs)
DRWVolumeGrid * DRW_volume_batch_cache_get_grid(Volume *volume, const bke::VolumeGridData *volume_grid)
void DRW_volume_module_free(draw::VolumeModule *module)
T safe_rcp(const T &a)
MatT from_scale(const VecBase< typename MatT::base_type, ScaleDim > &scale)
int BKE_volume_num_grids(const Volume *volume)
unsigned int uint
Definition BKE_text.h:55
const bke::VolumeGridData * BKE_volume_grid_find(const Volume *volume, StringRef name)
@ GPU_SAMPLER_EXTEND_MODE_REPEAT
DRWContext & drw_get()
MatBase< float, 4, 4 > float4x4
@ FLUID_DOMAIN_USE_NOISE
@ FLUID_DOMAIN_ACTIVE_COLORS
@ FLUID_DOMAIN_ACTIVE_COLOR_SET
Global G
Definition blender.cc:57
VecBase< float, 4 > float4
VecBase< int32_t, 3 > int3
@ GPU_TEXTURE_USAGE_SHADER_READ
T & DRW_object_get_data_for_drawing(const Object &object)
ListBaseWrapperTemplate< ListBase, T > ListBaseWrapper
void BKE_mesh_texspace_get(Mesh *mesh, float r_texspace_location[3], float r_texspace_size[3])
ListBaseT< GPUMaterialAttribute > GPU_material_attributes(const GPUMaterial *material)
bool BKE_volume_load(const Volume *volume, const Main *bmain)
void DRW_smoke_ensure(FluidModifierData *fmd, int highres)
void GPU_texture_extend_mode(gpu::Texture *texture, GPUSamplerExtendMode extend_mode)
float BKE_volume_density_scale(const Volume *volume, const float matrix[4][4])
ModifierData * BKE_modifiers_findby_type(const Object *ob, ModifierType type)
VecBase< float, 3 > float3
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
@ FLUID_DOMAIN_TYPE_GAS
float4x4 grids_xform[16]
draw::VolumeModule * volume_module
eFluidDomain_ActiveFields active_fields
struct FluidDomainSettings * domain
gpu::Texture * grid_default_texture(GPUDefaultValue default_value)
VolumeUniformBufPool ubo_pool
Vector< VolumeInfosBuf * > ubos