Blender V5.3
topology_refiner_factory.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2015 Blender Foundation
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 *
5 * Author: Sergey Sharybin. */
6
7#ifdef _MSC_VER
8# include <iso646.h>
9#endif
10
11#include <algorithm>
12#include <cassert>
13#include <cstdio>
14#include <memory>
15
16#include <opensubdiv/far/topologyRefinerFactory.h>
17
19
22
26
27// See #OffsetIndices::size().
28static int faces_num_from_offsets(const std::span<const int> face_offsets)
29{
30 return face_offsets.empty() ? 0 : int(face_offsets.size()) - 1;
31}
32
33// See #OffsetIndices::total_size().
34[[maybe_unused]] static int total_size_from_offsets(const std::span<const int> face_offsets)
35{
36 return face_offsets.empty() ? 0 : face_offsets.back() - face_offsets.front();
37}
38
39using TopologyRefinerFactoryType = OpenSubdiv::Far::TopologyRefinerFactory<TopologyRefinerData>;
40
42
43template<>
44inline bool TopologyRefinerFactory<TopologyRefinerData>::resizeComponentTopology(
45 TopologyRefiner &refiner, const TopologyRefinerData &cb_data)
46{
47 const OpenSubdiv_Converter *converter = cb_data.converter;
48
49 // Vertices.
50 setNumBaseVertices(refiner, converter->verts_num);
51
52 // Faces and face-vertices.
53 const std::span<const int> face_offsets = converter->face_offsets;
54 const int num_faces = faces_num_from_offsets(face_offsets);
55 setNumBaseFaces(refiner, num_faces);
56 for (int face_index = 0; face_index < num_faces; ++face_index) {
57 setNumBaseFaceVertices(
58 refiner, face_index, face_offsets[face_index + 1] - face_offsets[face_index]);
59 }
60
61 // If converter does not provide full topology, we are done.
62 //
63 // The rest is needed to define relations between faces-of-edge and
64 // edges-of-vertex, which is not available for partially specified mesh.
65 if (!converter->specifiesFullTopology(converter)) {
66 return true;
67 }
68
69 // Edges and edge-faces.
70 const int num_edges = converter->edges.size();
71 setNumBaseEdges(refiner, num_edges);
72 for (int edge_index = 0; edge_index < num_edges; ++edge_index) {
73 const int num_edge_faces = converter->getNumEdgeFaces(converter, edge_index);
74 setNumBaseEdgeFaces(refiner, edge_index, num_edge_faces);
75 }
76
77 // Vertex-faces and vertex-edges.
78 for (int vertex_index = 0; vertex_index < converter->verts_num; ++vertex_index) {
79 const int num_vert_edges = converter->getNumVertexEdges(converter, vertex_index);
80 const int num_vert_faces = converter->getNumVertexFaces(converter, vertex_index);
81 setNumBaseVertexEdges(refiner, vertex_index, num_vert_edges);
82 setNumBaseVertexFaces(refiner, vertex_index, num_vert_faces);
83 }
84
85 return true;
86}
87
88template<>
89inline bool TopologyRefinerFactory<TopologyRefinerData>::assignComponentTopology(
90 TopologyRefiner &refiner, const TopologyRefinerData &cb_data)
91{
92 using Far::IndexArray;
93
94 const OpenSubdiv_Converter *converter = cb_data.converter;
95
96 const bool full_topology_specified = converter->specifiesFullTopology(converter);
97
98 const std::span<const int> face_offsets = converter->face_offsets;
99 const std::span<const int> src_corner_verts = converter->corner_verts;
100 const int num_faces = faces_num_from_offsets(face_offsets);
101
102 // Vertices of face.
103 for (int face_index = 0; face_index < num_faces; ++face_index) {
104 const int start = face_offsets[face_index];
105 const std::span<const int> face_verts = src_corner_verts.subspan(
106 start, face_offsets[face_index + 1] - start);
107 IndexArray dst_face_verts = getBaseFaceVertices(refiner, face_index);
108 std::copy_n(face_verts.data(), face_verts.size(), dst_face_verts.begin());
109 }
110
111 // If converter does not provide full topology, we are done.
112 //
113 // The rest is needed to define relations between faces-of-edge and
114 // edges-of-vertex, which is not available for partially specified mesh.
115 if (!full_topology_specified) {
116 return true;
117 }
118
119 // Vertex relations.
120 std::vector<int> vertex_faces, vertex_edges;
121 for (int vertex_index = 0; vertex_index < converter->verts_num; ++vertex_index) {
122 // Vertex-faces.
123 IndexArray dst_vertex_faces = getBaseVertexFaces(refiner, vertex_index);
124 const int num_vertex_faces = converter->getNumVertexFaces(converter, vertex_index);
125 vertex_faces.resize(num_vertex_faces);
126 converter->getVertexFaces(converter, vertex_index, vertex_faces.data());
127
128 // Vertex-edges.
129 IndexArray dst_vertex_edges = getBaseVertexEdges(refiner, vertex_index);
130 const int num_vertex_edges = converter->getNumVertexEdges(converter, vertex_index);
131 vertex_edges.resize(num_vertex_edges);
132 converter->getVertexEdges(converter, vertex_index, vertex_edges.data());
133 memcpy(&dst_vertex_edges[0], vertex_edges.data(), sizeof(int) * num_vertex_edges);
134 memcpy(&dst_vertex_faces[0], vertex_faces.data(), sizeof(int) * num_vertex_faces);
135 }
136
137 // Edge relations.
138 const std::span<const std::pair<int, int>> edges = converter->edges;
139 for (int edge_index = 0; edge_index < int(edges.size()); ++edge_index) {
140 // Vertices this edge connects.
141 IndexArray dst_edge_vertices = getBaseEdgeVertices(refiner, edge_index);
142 dst_edge_vertices[0] = edges[edge_index].first;
143 dst_edge_vertices[1] = edges[edge_index].second;
144
145 // Faces adjacent to this edge.
146 IndexArray dst_edge_faces = getBaseEdgeFaces(refiner, edge_index);
147 converter->getEdgeFaces(converter, edge_index, &dst_edge_faces[0]);
148 }
149
150 // Face relations.
151 for (int face_index = 0; face_index < num_faces; ++face_index) {
152 IndexArray dst_face_edges = getBaseFaceEdges(refiner, face_index);
153 converter->getFaceEdges(converter, face_index, &dst_face_edges[0]);
154 }
155
156 populateBaseLocalIndices(refiner);
157
158 return true;
159}
160
161template<>
162inline bool TopologyRefinerFactory<TopologyRefinerData>::assignComponentTags(
163 TopologyRefiner &refiner, const TopologyRefinerData &cb_data)
164{
165 using OpenSubdiv::Sdc::Crease;
166
167 /* Not static assert because Crease::SHARPNESS_INFINITE is not constexpr. */
168 assert(OPENSUBDIV_SHARPNESS_INFINITE == Crease::SHARPNESS_INFINITE);
169
170 const OpenSubdiv_Converter *converter = cb_data.converter;
171
172 const bool full_topology_specified = converter->specifiesFullTopology(converter);
173 const std::span<const float> edge_sharpness = converter->edge_sharpness;
174 for (int edge_index = 0; edge_index < int(edge_sharpness.size()); ++edge_index) {
175 const float sharpness = edge_sharpness[edge_index];
176 if (sharpness < 1e-6f) {
177 continue;
178 }
179
180 if (full_topology_specified) {
181 setBaseEdgeSharpness(refiner, edge_index, sharpness);
182 }
183 else {
184 // TODO(sergey): Should be a faster way to find reconstructed edge to
185 // specify sharpness for (assuming, findBaseEdge has linear complexity).
186 const std::pair<int, int> edge_vertices = converter->edges[edge_index];
187 const int base_edge_index = findBaseEdge(refiner, edge_vertices.first, edge_vertices.second);
188 if (base_edge_index == OpenSubdiv::Far::INDEX_INVALID) {
189 printf("OpenSubdiv Error: failed to find reconstructed edge\n");
190 return false;
191 }
192 setBaseEdgeSharpness(refiner, base_edge_index, sharpness);
193 }
194 }
195
196 // OpenSubdiv expects non-manifold vertices to be sharp but at the time it
197 // handles correct cases when vertex is a corner of plane. Currently mark
198 // vertices which are adjacent to a loose edge as sharp, but this decision
199 // needs some more investigation.
200 const std::span<const float> vert_sharpness = converter->vert_sharpness;
201 for (int vertex_index = 0; vertex_index < converter->verts_num; ++vertex_index) {
202 float sharpness = vert_sharpness.empty() ? 0.0f : vert_sharpness[vertex_index];
203
204 // If its vertex where 2 non-manifold edges meet adjust vertex sharpness to
205 // the edges.
206 // This way having a plane with all 4 edges set to be sharp produces sharp
207 // corners in the subdivided result.
208 const ConstIndexArray vertex_edges = getBaseVertexEdges(refiner, vertex_index);
209 if (!Crease::IsInfinite(sharpness) && vertex_edges.size() == 2) {
210 const int edge0 = vertex_edges[0], edge1 = vertex_edges[1];
211 const float sharpness0 = refiner._levels[0]->getEdgeSharpness(edge0);
212 const float sharpness1 = refiner._levels[0]->getEdgeSharpness(edge1);
213 // TODO(sergey): Find a better mixing between edge and vertex sharpness.
214 sharpness += std::min(sharpness0, sharpness1);
215 sharpness = std::min(sharpness, Crease::SHARPNESS_INFINITE);
216 }
217
218 setBaseVertexSharpness(refiner, vertex_index, sharpness);
219 }
220 return true;
221}
222
223template<>
224inline bool TopologyRefinerFactory<TopologyRefinerData>::assignFaceVaryingTopology(
225 TopologyRefiner &refiner, const TopologyRefinerData &cb_data)
226{
227 const OpenSubdiv_Converter *converter = cb_data.converter;
228 if (converter->getNumUVLayers == nullptr) {
229 assert(converter->precalcUVLayer == nullptr);
230 assert(converter->getNumUVCoordinates == nullptr);
231 assert(converter->getFaceCornerUVIndex == nullptr);
232 assert(converter->finishUVLayer == nullptr);
233 return true;
234 }
235 const int num_layers = converter->getNumUVLayers(converter);
236 if (num_layers <= 0) {
237 // No UV maps, we can skip any face-varying data.
238 return true;
239 }
240 const int num_faces = getNumBaseFaces(refiner);
241 for (int layer_index = 0; layer_index < num_layers; ++layer_index) {
242 converter->precalcUVLayer(converter, layer_index);
243 const int num_uvs = converter->getNumUVCoordinates(converter);
244 // Fill in per-corner index of the UV.
245 const int channel = createBaseFVarChannel(refiner, num_uvs);
246 // TODO(sergey): Need to check whether converter changed the winding of
247 // face to match OpenSubdiv's expectations.
248 for (int face_index = 0; face_index < num_faces; ++face_index) {
249 Far::IndexArray dst_face_uvs = getBaseFaceFVarValues(refiner, face_index, channel);
250 for (int corner = 0; corner < dst_face_uvs.size(); ++corner) {
251 const int uv_index = converter->getFaceCornerUVIndex(converter, face_index, corner);
252 dst_face_uvs[corner] = uv_index;
253 }
254 }
255 converter->finishUVLayer(converter);
256 }
257 return true;
258}
259
260template<>
261inline void TopologyRefinerFactory<TopologyRefinerData>::reportInvalidTopology(
262 TopologyError /*errCode*/, const char *msg, const TopologyRefinerData & /*mesh*/)
263{
264 printf("OpenSubdiv Error: %s\n", msg);
265}
266
267} // namespace OpenSubdiv::OPENSUBDIV_VERSION::Far
268
269namespace blender::opensubdiv {
270
271static OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
272{
273 using OpenSubdiv::Sdc::Options;
274
275 const Options::FVarLinearInterpolation linear_interpolation = getFVarLinearInterpolationFromCAPI(
276 converter->fvar_linear_interpolation);
277
279 options.SetVtxBoundaryInterpolation(
281 options.SetCreasingMethod(Options::CREASE_UNIFORM);
282 options.SetFVarLinearInterpolation(linear_interpolation);
283
284 return options;
285}
286
287static TopologyRefinerFactoryType::Options getTopologyRefinerOptions(
288 OpenSubdiv_Converter *converter)
289{
290 using OpenSubdiv::Sdc::SchemeType;
291
292 OpenSubdiv::Sdc::Options sdc_options = getSDCOptions(converter);
293
294 const SchemeType scheme_type = getSchemeTypeFromCAPI(converter->scheme_type);
295 TopologyRefinerFactoryType::Options topology_options(scheme_type, sdc_options);
296
297 // NOTE: When debugging topology conversion related functionality it is helpful to set this
298 // to truth. In all other cases leave it at false. so debugging of other areas is not affected
299 // by performance penalty happening in this module.
300 topology_options.validateFullTopology = false;
301
302 return topology_options;
303}
304
305// Copy the topology of the base mesh out of the converter, so that a later converter can be
306// compared against it.
307static void storeBaseMeshTopology(const OpenSubdiv_Converter *converter,
308 TopologyRefinerImpl &refiner_impl)
309{
310 refiner_impl.base_verts_num = converter->verts_num;
311 refiner_impl.base_face_offsets.assign(converter->face_offsets.begin(),
312 converter->face_offsets.end());
313 assert(converter->corner_verts.size() == total_size_from_offsets(converter->face_offsets));
314 refiner_impl.base_corner_verts.assign(converter->corner_verts.begin(),
315 converter->corner_verts.end());
316 assert(converter->edge_sharpness.empty() ||
317 converter->edge_sharpness.size() == converter->edges.size());
318 refiner_impl.base_edge_sharpness.assign(converter->edge_sharpness.begin(),
319 converter->edge_sharpness.end());
320 assert(converter->vert_sharpness.empty() ||
321 int(converter->vert_sharpness.size()) == refiner_impl.base_verts_num);
322 refiner_impl.base_vert_sharpness.assign(converter->vert_sharpness.begin(),
323 converter->vert_sharpness.end());
324
325 // Only up to the last sharp one is stored, see #TopologyRefinerImpl::base_edges_sparse.
326 const std::span<const float> sharpness = converter->edge_sharpness;
327 int stored_edges_num = 0;
328 for (int edge_index = int(sharpness.size()) - 1; edge_index >= 0; edge_index--) {
329 if (sharpness[edge_index] >= 1e-6f) {
330 stored_edges_num = edge_index + 1;
331 break;
332 }
333 }
334 const std::span<const std::pair<int, int>> edges = converter->edges.first(stored_edges_num);
335 refiner_impl.base_edges_sparse.assign(edges.begin(), edges.end());
336}
337
340{
341 using OpenSubdiv::Far::TopologyRefiner;
342
343 auto topology_refiner_impl = std::make_unique<TopologyRefinerImpl>();
344 topology_refiner_impl->settings = settings;
345 storeBaseMeshTopology(converter, *topology_refiner_impl);
346
347 TopologyRefinerData cb_data;
348 cb_data.converter = converter;
349
350 // Create OpenSubdiv descriptor for the topology refiner.
351 TopologyRefinerFactoryType::Options topology_refiner_options = getTopologyRefinerOptions(
352 converter);
353 TopologyRefiner *topology_refiner = TopologyRefinerFactoryType::Create(cb_data,
354 topology_refiner_options);
355 if (topology_refiner == nullptr) {
356 return nullptr;
357 }
358 topology_refiner_impl->topology_refiner = topology_refiner;
359
360 return topology_refiner_impl.release();
361}
362
363} // namespace blender::opensubdiv
OpenSubdiv::Far::TopologyRefiner * topology_refiner
static TopologyRefinerImpl * createFromConverter(OpenSubdiv_Converter *converter, const OpenSubdiv_TopologyRefinerSettings &settings)
std::vector< std::pair< int, int > > base_edges_sparse
#define printf
CCL_NAMESPACE_BEGIN struct Options options
#define assert(assertion)
OpenSubdiv::Sdc::Options::VtxBoundaryInterpolation getVtxBoundaryInterpolationFromCAPI(OpenSubdiv_VtxBoundaryInterpolation boundary_interpolation)
OpenSubdiv::Sdc::SchemeType getSchemeTypeFromCAPI(OpenSubdiv_SchemeType type)
static OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
static void storeBaseMeshTopology(const OpenSubdiv_Converter *converter, TopologyRefinerImpl &refiner_impl)
static TopologyRefinerFactoryType::Options getTopologyRefinerOptions(OpenSubdiv_Converter *converter)
OpenSubdiv::Sdc::Options::FVarLinearInterpolation getFVarLinearInterpolationFromCAPI(OpenSubdiv_FVarLinearInterpolation linear_interpolation)
constexpr float OPENSUBDIV_SHARPNESS_INFINITE
void(*) getFaceEdges(const OpenSubdiv_Converter *converter, const int face_index, int *face_edges)
OpenSubdiv_VtxBoundaryInterpolation vtx_boundary_interpolation
std::span< const float > edge_sharpness
OpenSubdiv_FVarLinearInterpolation fvar_linear_interpolation
std::span< const float > vert_sharpness
void(*) getVertexEdges(const OpenSubdiv_Converter *converter, const int vertex_index, int *vertex_edges)
int(*) getNumUVCoordinates(const OpenSubdiv_Converter *converter)
OpenSubdiv_SchemeType scheme_type
void(*) getVertexFaces(const OpenSubdiv_Converter *converter, const int vertex_index, int *vertex_faces)
int(*) getNumVertexFaces(const OpenSubdiv_Converter *converter, const int vertex_index)
std::span< const int > face_offsets
std::span< const std::pair< int, int > > edges
void(*) precalcUVLayer(const OpenSubdiv_Converter *converter, const int layer_index)
void(*) getEdgeFaces(const OpenSubdiv_Converter *converter, const int edge, int *edge_faces)
int(*) getNumVertexEdges(const OpenSubdiv_Converter *converter, const int vertex_index)
int(*) getNumUVLayers(const OpenSubdiv_Converter *converter)
std::span< const int > corner_verts
int(*) getFaceCornerUVIndex(const OpenSubdiv_Converter *converter, const int face_index, const int corner_index)
int(*) getNumEdgeFaces(const OpenSubdiv_Converter *converter, const int edge_index)
bool(*) specifiesFullTopology(const OpenSubdiv_Converter *converter)
void(*) finishUVLayer(const OpenSubdiv_Converter *converter)
const OpenSubdiv_Converter * converter
static int faces_num_from_offsets(const std::span< const int > face_offsets)
OpenSubdiv::Far::TopologyRefinerFactory< TopologyRefinerData > TopologyRefinerFactoryType
static int total_size_from_offsets(const std::span< const int > face_offsets)