Blender V5.3
io/usd/hydra/mesh.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 "mesh.hh"
6
7#include <pxr/imaging/hd/materialBindingSchema.h>
8#include <pxr/imaging/hd/materialBindingsSchema.h>
9#include <pxr/imaging/hd/meshSchema.h>
10#include <pxr/imaging/hd/meshTopologySchema.h>
11#include <pxr/imaging/hd/overlayContainerDataSource.h>
12#include <pxr/imaging/hd/primvarSchema.h>
13#include <pxr/imaging/hd/primvarsSchema.h>
14#include <pxr/imaging/hd/retainedDataSource.h>
15#include <pxr/imaging/hd/tokens.h>
16#include <pxr/imaging/hd/visibilitySchema.h>
17#include <pxr/imaging/hd/xformSchema.h>
18#include <pxr/imaging/pxOsd/tokens.h>
19
20#include "BLI_index_mask.hh"
21#include "BLI_task.hh"
22#include "BLI_vector_set.hh"
23
24#include "BKE_attribute.hh"
25#include "BKE_material.hh"
26#include "BKE_mesh.hh"
27#include "BKE_object.hh"
28
29#include "DNA_mesh_types.h"
30#include "DNA_object_types.h"
31
32#include "populate_context.hh"
33#include "util.hh"
34
35namespace blender::io::hydra {
36
37static const pxr::TfToken usd_st_token("st", pxr::TfToken::Immortal);
38
39/* One per-material-slot submesh worth of geometry. */
40struct SubMesh {
41 pxr::VtIntArray face_vertex_counts;
42 pxr::VtIntArray face_vertex_indices;
43 pxr::VtVec3fArray points;
44 pxr::VtVec3fArray normals;
45 pxr::VtVec2fArray uvs;
46 int mat_index = 0;
47};
48
49/* Build a single submesh from the given subset of triangles for a material.
50 * Vertex indices are remapped to a contiguous range covering only the vertices
51 * used by the subset, since Storm warns about indices into unused vertices. */
52static void copy_submesh(const Mesh &mesh,
53 const Span<float3> vert_positions,
54 const Span<int> corner_verts,
55 const Span<int3> corner_tris,
56 const Span<int> tri_faces,
57 const Span<float3> face_normals,
58 const Span<float3> vert_normals,
59 const Span<float3> corner_normals,
60 const bke::MeshNormalDomain normals_domain,
61 const Span<float2> uv_map,
62 const IndexMask &triangles,
63 SubMesh &sm)
64{
66
67 const bool copy_all_verts = triangles.size() == corner_tris.size() &&
68 mesh.verts_no_face().is_empty();
69
70 int dst_verts_num;
71 VectorSet<int> verts;
72 if (copy_all_verts) {
74 corner_verts,
75 corner_tris,
77 dst_verts_num = vert_positions.size();
78 }
79 else {
80 verts.reserve(triangles.size());
81 triangles.foreach_index([&](const int src, const int dst) {
82 const int3 &tri = corner_tris[src];
83 sm.face_vertex_indices[dst * 3 + 0] = verts.index_of_or_add(corner_verts[tri[0]]);
84 sm.face_vertex_indices[dst * 3 + 1] = verts.index_of_or_add(corner_verts[tri[1]]);
85 sm.face_vertex_indices[dst * 3 + 2] = verts.index_of_or_add(corner_verts[tri[2]]);
86 });
87 dst_verts_num = verts.size();
88 }
89
90 resize_uninitialized(sm.points, dst_verts_num);
91 if (copy_all_verts) {
92 for (const int i : vert_positions.index_range()) {
93 const float3 &v = vert_positions[i];
94 sm.points[i] = pxr::GfVec3f(v.x, v.y, v.z);
95 }
96 }
97 else {
98 for (const int i : verts.index_range()) {
99 const float3 &v = vert_positions[verts[i]];
100 sm.points[i] = pxr::GfVec3f(v.x, v.y, v.z);
101 }
102 }
103
105 std::fill(sm.face_vertex_counts.begin(), sm.face_vertex_counts.end(), 3);
106
107 /* Per-corner normals. */
108 resize_uninitialized(sm.normals, triangles.size() * 3);
109 switch (normals_domain) {
111 triangles.foreach_index([&](const int src, const int dst) {
112 const float3 &n = face_normals[tri_faces[src]];
113 for (int c = 0; c < 3; c++) {
114 sm.normals[dst * 3 + c] = pxr::GfVec3f(n.x, n.y, n.z);
115 }
116 });
117 break;
119 triangles.foreach_index([&](const int src, const int dst) {
120 const int3 &tri = corner_tris[src];
121 for (int c = 0; c < 3; c++) {
122 const float3 &n = vert_normals[corner_verts[tri[c]]];
123 sm.normals[dst * 3 + c] = pxr::GfVec3f(n.x, n.y, n.z);
124 }
125 });
126 break;
128 triangles.foreach_index([&](const int src, const int dst) {
129 const int3 &tri = corner_tris[src];
130 for (int c = 0; c < 3; c++) {
131 const float3 &n = corner_normals[tri[c]];
132 sm.normals[dst * 3 + c] = pxr::GfVec3f(n.x, n.y, n.z);
133 }
134 });
135 break;
136 }
137
138 if (!uv_map.is_empty()) {
139 resize_uninitialized(sm.uvs, triangles.size() * 3);
140 triangles.foreach_index([&](const int src, const int dst) {
141 const int3 &tri = corner_tris[src];
142 for (int c = 0; c < 3; c++) {
143 const float2 &uv = uv_map[tri[c]];
144 sm.uvs[dst * 3 + c] = pxr::GfVec2f(uv.x, uv.y);
145 }
146 });
147 }
148}
149
150static Vector<SubMesh> build_submeshes(const Object *object, const Mesh &mesh)
151{
152 const int mat_count = BKE_object_material_count_eval(object);
153 Vector<SubMesh> submeshes(mat_count > 0 ? mat_count : 1);
154 for (const int i : submeshes.index_range()) {
155 submeshes[i].mat_index = i;
156 }
157
158 const Span<float3> vert_positions = mesh.vert_positions();
159 const Span<int> corner_verts = mesh.corner_verts();
160 const Span<int3> corner_tris = mesh.corner_tris();
161 const Span<int> tri_faces = mesh.corner_tri_faces();
162 const bke::AttributeAccessor attributes = mesh.attributes();
163 const StringRef active_uv = mesh.active_uv_map_name();
164 const VArraySpan<float2> uv_map = *attributes.lookup<float2>(active_uv, bke::AttrDomain::Corner);
165 const VArraySpan<int> material_indices = *attributes.lookup<int>("material_index",
167
168 const bke::MeshNormalDomain normals_domain = mesh.normals_domain();
169 const Span<float3> face_normals = (normals_domain == bke::MeshNormalDomain::Face) ?
170 mesh.face_normals() :
171 Span<float3>();
172 const Span<float3> vert_normals = (normals_domain == bke::MeshNormalDomain::Point) ?
173 mesh.vert_normals() :
174 Span<float3>();
175 const Span<float3> corner_normals = (normals_domain == bke::MeshNormalDomain::Corner) ?
176 mesh.corner_normals() :
177 Span<float3>();
178
179 if (material_indices.is_empty()) {
181 vert_positions,
182 corner_verts,
183 corner_tris,
184 tri_faces,
185 face_normals,
186 vert_normals,
187 corner_normals,
188 normals_domain,
189 uv_map,
190 corner_tris.index_range(),
191 submeshes.first());
192 }
193 else {
194 IndexMaskMemory memory;
195 Array<IndexMask> triangles_by_material(submeshes.size());
196 const int max_index = std::max(mat_count - 1, 0);
198 corner_tris.index_range(),
199 memory,
200 [&](const int i) { return std::clamp(material_indices[tri_faces[i]], 0, max_index); },
201 triangles_by_material);
202
203 threading::parallel_for(submeshes.index_range(), 1, [&](const IndexRange range) {
204 for (const int i : range) {
205 copy_submesh(mesh,
206 vert_positions,
207 corner_verts,
208 corner_tris,
209 tri_faces,
210 face_normals,
211 vert_normals,
212 corner_normals,
213 normals_domain,
214 uv_map,
215 triangles_by_material[i],
216 submeshes[i]);
217 }
218 });
219 }
220
221 /* Remove submeshes without faces. */
222 submeshes.remove_if([](const SubMesh &submesh) { return submesh.face_vertex_counts.empty(); });
223
224 return submeshes;
225}
226
227/* Build the geometry-only schema sources for one submesh. */
229 const pxr::SdfPath &material_path,
230 const bool double_sided)
231{
233 out.schema_token = pxr::HdMeshSchema::GetSchemaToken();
234 /* Topology. */
235 pxr::HdContainerDataSourceHandle topology =
236 pxr::HdMeshTopologySchema::Builder()
237 .SetFaceVertexCounts(
238 pxr::HdRetainedTypedSampledDataSource<pxr::VtIntArray>::New(sm.face_vertex_counts))
239 .SetFaceVertexIndices(
240 pxr::HdRetainedTypedSampledDataSource<pxr::VtIntArray>::New(sm.face_vertex_indices))
241 .SetOrientation(pxr::HdMeshTopologySchema::BuildOrientationDataSource(
242 pxr::HdMeshTopologySchemaTokens->rightHanded))
243 .Build();
244
245 out.geometry =
246 pxr::HdMeshSchema::Builder()
247 .SetTopology(topology)
248 .SetSubdivisionScheme(pxr::HdRetainedTypedSampledDataSource<pxr::TfToken>::New(
249 pxr::PxOsdOpenSubdivTokens->none))
250 .SetDoubleSided(pxr::HdRetainedTypedSampledDataSource<bool>::New(double_sided))
251 .Build();
252
253 /* Primvars. */
254 HdContainerBuilder primvars;
255
256 primvars.add(
257 pxr::HdPrimvarsSchemaTokens->points,
258 pxr::HdPrimvarSchema::Builder()
259 .SetPrimvarValue(
260 pxr::HdRetainedTypedSampledDataSource<pxr::VtVec3fArray>::New(sm.points))
261 .SetInterpolation(pxr::HdPrimvarSchema::BuildInterpolationDataSource(
262 pxr::HdPrimvarSchemaTokens->vertex))
263 .SetRole(pxr::HdPrimvarSchema::BuildRoleDataSource(pxr::HdPrimvarSchemaTokens->point))
264 .Build());
265
266 if (!sm.normals.empty()) {
267 primvars.add(
268 pxr::HdPrimvarsSchemaTokens->normals,
269 pxr::HdPrimvarSchema::Builder()
270 .SetPrimvarValue(
271 pxr::HdRetainedTypedSampledDataSource<pxr::VtVec3fArray>::New(sm.normals))
272 .SetInterpolation(pxr::HdPrimvarSchema::BuildInterpolationDataSource(
273 pxr::HdPrimvarSchemaTokens->faceVarying))
274 .SetRole(pxr::HdPrimvarSchema::BuildRoleDataSource(pxr::HdPrimvarSchemaTokens->normal))
275 .Build());
276 }
277
278 if (!sm.uvs.empty()) {
279 primvars.add(
281 pxr::HdPrimvarSchema::Builder()
282 .SetPrimvarValue(pxr::HdRetainedTypedSampledDataSource<pxr::VtVec2fArray>::New(sm.uvs))
283 .SetInterpolation(pxr::HdPrimvarSchema::BuildInterpolationDataSource(
284 pxr::HdPrimvarSchemaTokens->faceVarying))
285 .SetRole(pxr::HdPrimvarSchema::BuildRoleDataSource(
286 pxr::HdPrimvarSchemaTokens->textureCoordinate))
287 .Build());
288 }
289
290 out.primvars = primvars.build();
291
292 /* Material binding. */
293 if (!material_path.IsEmpty()) {
294 pxr::HdContainerDataSourceHandle binding =
295 pxr::HdMaterialBindingSchema::Builder()
296 .SetPath(pxr::HdRetainedTypedSampledDataSource<pxr::SdfPath>::New(material_path))
297 .Build();
298 out.bindings = pxr::HdRetainedContainerDataSource::New(
299 pxr::HdMaterialBindingsSchemaTokens->allPurpose, binding);
300 }
301 return out;
302}
303
305 const BObjectInfo &info,
306 const EmittedGeometryKey &key)
307{
308 ctx.used_emitted_geometry.add(key);
309
310 /* Record geometry set to object mapping to handle updates. */
311 if (!info.is_real_object_data() && info.object_data) {
312 ctx.instance_geometries_by_object.lookup_or_add_default(info.real_object)
313 .append_non_duplicates(info.object_data);
315 }
316
317 /* Already built in this populate? */
318 if (EmittedGeometry *cached = ctx.emitted_geometry.lookup_ptr(key)) {
319 for (const Material *mat : cached->materials) {
320 ctx.get_or_create_material(mat);
321 }
322 return *cached;
323 }
324
325 EmittedGeometry &entry = ctx.emitted_geometry.lookup_or_add_default(key);
326
327 /* Get proper mesh to use. */
328 Mesh *mesh = nullptr;
329 bool needs_clear = false;
330 if (info.is_real_object_data()) {
331 mesh = BKE_object_to_mesh(nullptr, info.real_object, false);
332 needs_clear = (mesh != nullptr);
333 }
334 else if (info.object_data && GS(info.object_data->name) == ID_ME) {
335 mesh = id_cast<Mesh *>(info.object_data);
336 }
337 if (!mesh) {
338 return entry;
339 }
340
341 /* Build and emit submesh per material. */
342 const Vector<SubMesh> submeshes = build_submeshes(info.real_object, *mesh);
343 if (needs_clear) {
345 }
346
347 entry.prims.reserve(submeshes.size());
348 entry.materials.reserve(submeshes.size());
349 for (const SubMesh &sm : submeshes) {
350 const Material *material = BKE_object_material_get_eval(info.real_object, sm.mat_index + 1);
351 const EmittedMaterial *mat_entry = ctx.get_or_create_material(material);
352 const pxr::SdfPath material_path = mat_entry ? mat_entry->path : pxr::SdfPath();
353 const bool double_sided = mat_entry ? mat_entry->double_sided : true;
354
355 entry.prims.append(build_submesh_geometry(sm, material_path, double_sided));
356 entry.materials.append(material);
357 }
358
359 return entry;
360}
361
363{
364 const EmittedGeometryKey key = ctx.emitted_geometry_key(info, pxr::HdPrimTypeTokens->mesh);
365 const EmittedGeometry &cached = get_or_build_emitted_mesh(ctx, info, key);
366 emitted.geometry_keys.append_non_duplicates(key);
367 for (const Material *m : cached.materials) {
368 emitted.materials.append_non_duplicates(m);
369 }
370
371 Object *object = info.iter_object;
372 const pxr::GfMatrix4d transform = gf_matrix_from_transform(object->object_to_world().ptr());
373
374 for (const int sm_index : cached.prims.index_range()) {
375 const pxr::SdfPath path = ctx.submesh_prim_id(object, sm_index);
376 pxr::HdContainerDataSourceHandle prim_ds = compose_gprim_data_source(
377 cached.prims[sm_index], transform, true);
378 ctx.emit_object_prim(emitted, path, pxr::HdPrimTypeTokens->mesh, prim_ds);
379 }
380}
381
383{
384 const EmittedGeometryKey key = ctx.emitted_geometry_key(info, pxr::HdPrimTypeTokens->mesh);
385 const EmittedGeometry &cached = get_or_build_emitted_mesh(ctx, info, key);
386
387 Object *source = info.real_object;
388 const pxr::HdContainerDataSourceHandle instanced_by_ds = ctx.proto_instanced_by(source);
389
390 for (const int sm_index : cached.prims.index_range()) {
391 const pxr::SdfPath proto_path = ctx.instancer_proto_submesh(source, sm_index);
392 pxr::HdContainerDataSourceHandle prim_ds = compose_gprim_data_source(
393 cached.prims[sm_index], pxr::GfMatrix4d(1.0), true, instanced_by_ds);
394
395 ctx.emit_prim(proto_path, pxr::HdPrimTypeTokens->mesh, prim_ds);
396 ctx.all_proto_paths.append(proto_path);
397 ctx.per_proto_indices.append(pxr::VtIntArray());
398 }
399}
400
401} // namespace blender::io::hydra
General operations, lookup, etc. for materials.
General operations, lookup, etc. for blender objects.
Object is a sort of wrapper for general info.
static void from_groups(const IndexMask &universe, LinearAllocator<> &memory, Fn &&get_group_index, MutableSpan< IndexMask > r_masks)
constexpr MutableSpan()=default
Span< NewT > constexpr cast() const
Definition BLI_span.hh:422
constexpr Span()=default
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
int64_t index_of_or_add(const Key &key)
void reserve(const int64_t n)
int64_t size() const
IndexRange index_range() const
int64_t size() const
IndexRange index_range() const
const T & first() const
GAttributeReader lookup(const StringRef name) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
void vert_tris_from_corner_tris(Span< int > corner_verts, Span< int3 > corner_tris, MutableSpan< int3 > vert_tris)
static EmittedGeometryPrim build_submesh_geometry(const SubMesh &sm, const pxr::SdfPath &material_path, const bool double_sided)
void emit_mesh_proto(PopulateContext &ctx, const BObjectInfo &info)
void emit_mesh_object(PopulateContext &ctx, const BObjectInfo &info, EmittedObject &emitted)
static Vector< SubMesh > build_submeshes(const Object *object, const Mesh &mesh)
static void copy_submesh(const Mesh &mesh, const Span< float3 > vert_positions, const Span< int > corner_verts, const Span< int3 > corner_tris, const Span< int > tri_faces, const Span< float3 > face_normals, const Span< float3 > vert_normals, const Span< float3 > corner_normals, const bke::MeshNormalDomain normals_domain, const Span< float2 > uv_map, const IndexMask &triangles, SubMesh &sm)
static const EmittedGeometry & get_or_build_emitted_mesh(PopulateContext &ctx, const BObjectInfo &info, const EmittedGeometryKey &key)
pxr::GfMatrix4d gf_matrix_from_transform(const float m[4][4])
Definition util.hh:20
static const pxr::TfToken usd_st_token("st", pxr::TfToken::Immortal)
pxr::HdContainerDataSourceHandle compose_gprim_data_source(const EmittedGeometryPrim &gprim, const pxr::GfMatrix4d &transform, const bool visible, const pxr::HdContainerDataSourceHandle &instanced_by_overlay)
void resize_uninitialized(pxr::VtArray< T > &array, const int new_size)
Definition util.hh:32
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
int BKE_object_material_count_eval(const Object *ob)
ATTR_WARN_UNUSED_RESULT const BMVert * v
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
Mesh * BKE_object_to_mesh(Depsgraph *depsgraph, Object *object, bool preserve_all_data_layers)
Definition object.cc:5692
Material * BKE_object_material_get_eval(Object *ob, short act)
ID_Type GS(const char *name)
Definition DNA_ID.h:410
VecBase< float, 3 > float3
void BKE_object_to_mesh_clear(Object *object)
Definition object.cc:5701
char name[258]
Definition DNA_ID.h:433
Vector< EmittedGeometryPrim > prims
Vector< const Material * > materials
Vector< const Material * > materials
Vector< EmittedGeometryKey > geometry_keys
void add(const pxr::TfToken &name, const T &value)
Definition util.hh:51
pxr::HdContainerDataSourceHandle build() const
Definition util.hh:63
Map< const Object *, Vector< const ID * > > & instance_geometries_by_object
Set< EmittedGeometryKey > used_emitted_geometry
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))
Set< const Object * > used_instance_sources
pxr::SdfPath submesh_prim_id(const Object *object, int submesh_index) const
Vector< pxr::VtIntArray > per_proto_indices
const EmittedMaterial * get_or_create_material(const Material *material)
Map< EmittedGeometryKey, EmittedGeometry > & emitted_geometry
pxr::HdContainerDataSourceHandle proto_instanced_by(const Object *source) const
pxr::SdfPath instancer_proto_submesh(const Object *source, int submesh_index) const
void emit_prim(const pxr::SdfPath &path, const pxr::TfToken &type, const pxr::HdContainerDataSourceHandle &ds)
EmittedGeometryKey emitted_geometry_key(const BObjectInfo &info, const pxr::TfToken &type) const