Blender V5.3
io/usd/hydra/volume.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "volume.hh"
6
7#include <pxr/imaging/hd/materialBindingSchema.h>
8#include <pxr/imaging/hd/materialBindingsSchema.h>
9#include <pxr/imaging/hd/retainedDataSource.h>
10#include <pxr/imaging/hd/tokens.h>
11#include <pxr/imaging/hd/visibilitySchema.h>
12#include <pxr/imaging/hd/volumeFieldBindingSchema.h>
13#include <pxr/imaging/hd/volumeFieldSchema.h>
14#include <pxr/imaging/hd/xformSchema.h>
15#include <pxr/usd/sdf/assetPath.h>
16#include <pxr/usdImaging/usdVolImaging/tokens.h>
17
18#include "BLI_index_range.hh"
19
20#include "BKE_material.hh"
21#include "BKE_volume.hh"
22
23#include "DNA_object_types.h"
24#include "DNA_scene_types.h"
25#include "DNA_volume_types.h"
26
27#include "populate_context.hh"
28#include "util.hh"
29#include "volume_modifier.hh"
30
31namespace blender::io::hydra {
32
33/* Bprim data source for one VDB field. */
34static pxr::HdContainerDataSourceHandle build_volume_field_data_source(
35 const std::string &filepath, const pxr::TfToken &field_name)
36{
37 return pxr::HdRetainedContainerDataSource::New(
38 pxr::HdVolumeFieldSchema::GetSchemaToken(),
39 pxr::HdVolumeFieldSchema::Builder()
40 .SetFilePath(pxr::HdRetainedTypedSampledDataSource<pxr::SdfAssetPath>::New(
41 pxr::SdfAssetPath(filepath, filepath)))
42 .SetFieldName(pxr::HdRetainedTypedSampledDataSource<pxr::TfToken>::New(field_name))
43 .SetFieldIndex(pxr::HdRetainedTypedSampledDataSource<int>::New(0))
44 .Build());
45}
46
47/* Volume Rprim data source. */
48static pxr::HdContainerDataSourceHandle build_volume_prim_data_source(
49 const Span<VolumeFieldDescriptor> fields,
50 const pxr::GfMatrix4d &transform,
51 const bool visible,
52 const pxr::SdfPath &material_path)
53{
54 HdContainerBuilder field_bindings;
55 field_bindings.reserve(fields.size());
56 for (const VolumeFieldDescriptor &f : fields) {
57 field_bindings.add(f.name, f.field_path);
58 }
59 pxr::HdContainerDataSourceHandle bindings = pxr::HdVolumeFieldBindingSchema::BuildRetained(
60 field_bindings.names.size(), field_bindings.names.data(), field_bindings.values.data());
61
62 pxr::HdContainerDataSourceHandle xform =
63 pxr::HdXformSchema::Builder()
64 .SetMatrix(pxr::HdRetainedTypedSampledDataSource<pxr::GfMatrix4d>::New(transform))
65 .SetResetXformStack(pxr::HdRetainedTypedSampledDataSource<bool>::New(false))
66 .Build();
67 pxr::HdContainerDataSourceHandle visibility =
68 pxr::HdVisibilitySchema::Builder()
69 .SetVisibility(pxr::HdRetainedTypedSampledDataSource<bool>::New(visible))
70 .Build();
71
73 b.add(pxr::HdVolumeFieldBindingSchema::GetSchemaToken(), bindings);
74 b.add(pxr::HdXformSchema::GetSchemaToken(), xform);
75 b.add(pxr::HdVisibilitySchema::GetSchemaToken(), visibility);
76
77 if (!material_path.IsEmpty()) {
78 pxr::HdContainerDataSourceHandle binding =
79 pxr::HdMaterialBindingSchema::Builder()
80 .SetPath(pxr::HdRetainedTypedSampledDataSource<pxr::SdfPath>::New(material_path))
81 .Build();
82 pxr::HdContainerDataSourceHandle bindings_ds = pxr::HdRetainedContainerDataSource::New(
83 pxr::HdMaterialBindingsSchemaTokens->allPurpose, binding);
84 b.add(pxr::HdMaterialBindingsSchema::GetSchemaToken(), bindings_ds);
85 }
86 return b.build();
87}
88
89/* Resolve the VDB file path and per-grid fields for a volume datablock. */
90static std::string build_volume_fields_from_datablock(const Object *object,
91 const pxr::SdfPath &volume_path,
92 Main *bmain,
93 pxr::GfMatrix4d *r_transform,
95{
96 Volume *volume = id_cast<Volume *>(object->data);
97 if (!BKE_volume_load(volume, bmain)) {
98 return {};
99 }
100 std::string filepath = BKE_volume_grids_frame_filepath(volume);
101 if (volume->runtime->grids) {
102 const int num_grids = BKE_volume_num_grids(volume);
103 r_fields->reserve(num_grids);
104 for (const int i : IndexRange(num_grids)) {
105 const bke::VolumeGridData *grid = BKE_volume_grid_get(volume, i);
106 const std::string grid_name = bke::volume_grid::get_name(*grid);
108 f.name = pxr::TfToken(grid_name);
109 f.field_path = volume_path.AppendElementString("VF_" + grid_name);
110 r_fields->append(f);
111 }
112 }
113 *r_transform = gf_matrix_from_transform(object->object_to_world().ptr());
114 BKE_volume_unload(volume);
115 return filepath;
116}
117
118bool emit_volume_object(PopulateContext &ctx, const Object *object, EmittedObject &emitted)
119{
120 const FluidModifierData *fmd = fluid_gas_domain_modifier(object, ctx.depsgraph);
121 const bool is_volume_data = (object->type == OB_VOLUME);
122 if (!is_volume_data && !fmd) {
123 return false;
124 }
125
127 std::string filepath;
128 pxr::GfMatrix4d geometry_xform(1.0);
129 const pxr::SdfPath volume_path = ctx.object_prim_id(object);
130
131 if (is_volume_data) {
132 pxr::GfMatrix4d ignored(1.0);
134 object, volume_path, ctx.bmain, &ignored, &fields);
135 }
136 else {
138 object, fmd, ctx.scene->r.cfra, volume_path, &geometry_xform, &fields);
139 }
140
141 /* Volume datablock with no grids: nothing to publish. */
142 if (fields.is_empty()) {
143 return true;
144 }
145
146 /* TODO: support multi-material volumes. */
147 const Material *material = (BKE_object_material_count_eval(object) > 0) ?
148 BKE_object_material_get_eval(const_cast<Object *>(object), 1) :
149 nullptr;
150 const EmittedMaterial *mat_entry = ctx.get_or_create_material(material);
151 const pxr::SdfPath material_path = mat_entry ? mat_entry->path : pxr::SdfPath();
152 if (material) {
153 emitted.materials.append_non_duplicates(material);
154 }
155
156 const pxr::GfMatrix4d transform = geometry_xform *
157 gf_matrix_from_transform(object->object_to_world().ptr());
158 pxr::HdContainerDataSourceHandle prim_ds = build_volume_prim_data_source(
159 fields.as_span(), transform, true, material_path);
161 emitted, volume_path, pxr::HdPrimTypeTokens->volume, prim_ds, geometry_xform);
162
163 for (const VolumeFieldDescriptor &f : fields) {
164 pxr::HdContainerDataSourceHandle field_ds = build_volume_field_data_source(filepath, f.name);
165 ctx.emit_object_prim(emitted, f.field_path, pxr::UsdVolImagingTokens->openvdbAsset, field_ds);
166 }
167 return true;
168}
169
170void emit_volume_dupli(PopulateContext &ctx, const Object *source, const float dupli_mat[4][4])
171{
172 const int idx = ctx.nonmesh_instance_count.lookup_default(source, 0);
173 ctx.nonmesh_instance_count.add_overwrite(source, idx + 1);
174 const pxr::SdfPath volume_path = ctx.instance_clone_prim_id(source, idx);
176 pxr::GfMatrix4d unused(1.0);
177 const std::string filepath = build_volume_fields_from_datablock(
178 source, volume_path, ctx.bmain, &unused, &fields);
179 if (fields.is_empty()) {
180 return;
181 }
182 const Material *material = (BKE_object_material_count_eval(source) > 0) ?
183 BKE_object_material_get_eval(const_cast<Object *>(source), 1) :
184 nullptr;
185 const EmittedMaterial *mat_entry = ctx.get_or_create_material(material);
186 const pxr::SdfPath material_path = mat_entry ? mat_entry->path : pxr::SdfPath();
187 const pxr::GfMatrix4d transform = gf_matrix_from_transform(dupli_mat);
188 pxr::HdContainerDataSourceHandle prim_ds = build_volume_prim_data_source(
189 fields.as_span(), transform, true, material_path);
190 ctx.emit_prim(volume_path, pxr::HdPrimTypeTokens->volume, prim_ds);
191 for (const VolumeFieldDescriptor &f : fields) {
192 pxr::HdContainerDataSourceHandle field_ds = build_volume_field_data_source(filepath, f.name);
193 ctx.emit_prim(f.field_path, pxr::UsdVolImagingTokens->openvdbAsset, field_ds);
194 }
195}
196
197} // namespace blender::io::hydra
General operations, lookup, etc. for materials.
Volume data-block.
Object is a sort of wrapper for general info.
constexpr IndexRange()=default
constexpr int64_t size() const
Definition BLI_span.hh:256
void append(const T &value)
bool is_empty() const
void reserve(const int64_t min_capacity)
Span< T > as_span() const
std::string get_name(const VolumeGridData &grid)
static std::string build_volume_fields_from_datablock(const Object *object, const pxr::SdfPath &volume_path, Main *bmain, pxr::GfMatrix4d *r_transform, Vector< VolumeFieldDescriptor > *r_fields)
bool emit_volume_object(PopulateContext &ctx, const Object *object, EmittedObject &emitted)
std::string build_volume_fields_from_modifier(const Object *object, const FluidModifierData *fmd, const int frame, const pxr::SdfPath &volume_path, pxr::GfMatrix4d *r_geometry_xform, Vector< VolumeFieldDescriptor > *r_fields)
static pxr::HdContainerDataSourceHandle build_volume_prim_data_source(const Span< VolumeFieldDescriptor > fields, const pxr::GfMatrix4d &transform, const bool visible, const pxr::SdfPath &material_path)
const FluidModifierData * fluid_gas_domain_modifier(const Object *object, const Depsgraph *depsgraph)
pxr::GfMatrix4d gf_matrix_from_transform(const float m[4][4])
Definition util.hh:20
void emit_volume_dupli(PopulateContext &ctx, const Object *source, const float dupli_mat[4][4])
static pxr::HdContainerDataSourceHandle build_volume_field_data_source(const std::string &filepath, const pxr::TfToken &field_name)
int BKE_object_material_count_eval(const Object *ob)
int BKE_volume_num_grids(const Volume *volume)
const bke::VolumeGridData * BKE_volume_grid_get(const Volume *volume, int grid_index)
const char * BKE_volume_grids_frame_filepath(const Volume *volume)
void BKE_volume_unload(Volume *volume)
bool BKE_volume_load(const Volume *volume, const Main *bmain)
Material * BKE_object_material_get_eval(Object *ob, short act)
struct RenderData r
bke::VolumeRuntime * runtime
VolumeGridVector * grids
Vector< const Material * > materials
Vector< pxr::HdDataSourceBaseHandle > values
Definition util.hh:41
void add(const pxr::TfToken &name, const T &value)
Definition util.hh:51
Vector< pxr::TfToken > names
Definition util.hh:40
Map< const Object *, int > nonmesh_instance_count
pxr::SdfPath object_prim_id(const Object *object) const
void emit_object_prim(EmittedObject &emitted, const pxr::SdfPath &path, const pxr::TfToken &type, const pxr::HdContainerDataSourceHandle &ds, const pxr::GfMatrix4d &geometry_xform=pxr::GfMatrix4d(1.0))
pxr::SdfPath instance_clone_prim_id(const Object *source, int instance_index) const
const EmittedMaterial * get_or_create_material(const Material *material)
void emit_prim(const pxr::SdfPath &path, const pxr::TfToken &type, const pxr::HdContainerDataSourceHandle &ds)