131 for (
const StringRef name : coarse_mesh.uv_map_names()) {
138 ctx->
uv_maps.append(std::move(uv_map));
155 if (
const auto *src =
static_cast<const float3 *
>(
164 if (
const auto *src =
static_cast<const float2 *
>(
175 if (
const auto *src =
static_cast<const int *
>(
184 if (
const auto *src =
static_cast<const int *
>(
193 if (
const auto *src =
static_cast<const int *
>(
249 const int ptex_of_face_index)
251 const int first_ptex_loop_index = coarse_face.
start() + ptex_of_face_index;
256 const int last_ptex_loop_index = coarse_face.
start() +
257 (ptex_of_face_index + coarse_face.
size() - 1) %
259 loops_of_ptex->
first_loop = first_ptex_loop_index;
260 loops_of_ptex->
last_loop = last_ptex_loop_index;
261 if (coarse_face.
size() == 4) {
283 result += src[src_indices[i]] * weights[i];
289 const std::array<int, 4> &src_indices,
293 for (
const int i :
IndexRange(src_indices.size())) {
294 result += src[src_indices[i]] * weights[i];
300 const std::array<int, 2> &src_indices,
307 const std::array<int, 2> &src_indices,
314 if constexpr (!std::is_same_v<T, std::string>) {
315 const Span<T> src_attr = src[attr].typed<
T>();
317 if constexpr (std::is_same_v<T, bool>) {
319 src_attr, src_indices, {1.0f - factor, factor});
323 factor, src_attr[src_indices[0]], src_attr[src_indices[1]]);
331 const std::array<int, 4> &src_indices,
338 if constexpr (!std::is_same_v<T, std::string>) {
339 const Span<T> src_attr = src[attr].typed<
T>();
341 if constexpr (std::is_same_v<T, bool>) {
343 src_attr, src_indices,
Span(&weights.x, 4));
347 src_attr[src_indices[0]],
348 src_attr[src_indices[1]],
349 src_attr[src_indices[2]],
350 src_attr[src_indices[3]]);
365 if constexpr (!std::is_same_v<T, std::string>) {
366 const Span<T> src_attr = src[attr].typed<
T>();
380 const CPPType &type = src[attr].type();
417 const CPPType &type = ctx.coarse_vert_attr_spans[i].type();
418 void *data = this->allocator.allocate_array(type, 4);
419 this->storage_spans[i] = {type, data, 4};
432 if (coarse_face.
size() == 4) {
449 const float weight = 1.0f /
float(coarse_face.
size());
452 for (
int i = 0; i < coarse_face.
size(); i++) {
473 if (coarse_face.
size() == 4) {
495 const int first_loop_index = loops_of_ptex.
first_loop;
496 const int last_loop_index = loops_of_ptex.
last_loop;
497 const std::array<int, 2> first_indices{
500 (first_loop_index - coarse_face.
start() + 1) %
501 coarse_face.
size()]};
563 const CPPType &type = ctx.coarse_corner_attr_spans[i].type();
564 void *data = this->allocator.allocate_array(type, 4);
565 this->storage_spans[i] = {type, data, 4};
574 if (coarse_face.
size() == 4) {
593 const float weight = 1.0f /
float(coarse_face.
size());
596 for (
int i = 0; i < coarse_face.
size(); i++) {
598 indices[i] = coarse_face.
start() + i;
621 if (coarse_face.
size() == 4) {
629 coarse_face.
start() + corner,
645 const int base_loop_index = coarse_face.
start();
646 const int first_loop_index = loops_of_ptex.
first_loop;
647 const int second_loop_index = base_loop_index +
648 (first_loop_index - base_loop_index + 1) % coarse_face.
size();
649 const std::array<int, 2> first_indices{first_loop_index, second_loop_index};
716 const int ptex_face_index,
719 const int subdiv_vert_index)
744 const int ptex_face_index,
747 const int subdiv_vert_index)
782 if (iter.
domain != domain) {
807 coarse_varray_spans.
append(std::move(src));
808 coarse_spans.
append(coarse_varray_spans.
last());
809 dst_writers.
append(std::move(dst));
815 const int num_vertices,
833 if (num_faces != 0) {
843 vert_skip_names.
add(group.
name);
875 Set<StringRef> corner_skip_names{
".corner_vert",
".corner_edge",
"custom_normal"};
877 for (
const StringRef name : coarse_mesh.uv_map_names()) {
878 corner_skip_names.add_new(name);
905 const int coarse_vert_index,
906 const int subdiv_vert_index)
922 const int subdiv_vert_index,
945 const int ptex_face_index,
948 const int coarse_vert_index,
949 const int subdiv_vert_index)
954 float D[3] = {0.0f, 0.0f, 0.0f};
964 subdiv_position +=
D;
971 const int ptex_face_index,
975 const int subdiv_vert_index)
980 float D[3] = {0.0f, 0.0f, 0.0f};
998 const int ptex_face_index,
1001 const int subdiv_vert_index)
1009 const int ptex_face_index,
1015 const int subdiv_vert_index)
1018 foreach_context, tls, ptex_face_index, u,
v, subdiv_vert_index);
1023 const int ptex_face_index,
1029 const int subdiv_vert_index)
1032 foreach_context, tls, ptex_face_index, u,
v, subdiv_vert_index);
1037 const int ptex_face_index,
1040 const int coarse_vert_index,
1043 const int subdiv_vert_index)
1048 ctx, ptex_face_index, u,
v, coarse_vert_index, subdiv_vert_index);
1053 const int coarse_face_index,
1054 const int coarse_corner)
1073 const int ptex_face_index,
1077 const int coarse_face_index,
1078 const int coarse_corner,
1079 const int subdiv_vert_index)
1090 if (coarse_face.
size() == 4) {
1091 if (u == 0.5f &&
v == 0.5f) {
1096 if (u == 1.0f &&
v == 1.0f) {
1104 const int subdiv_vert_index,
1116 const int ptex_face_index,
1119 const int coarse_face_index,
1120 const int coarse_corner,
1121 const int subdiv_vert_index)
1141 const int subdiv_edge_index,
1142 const int coarse_edge_index)
1169 const int coarse_edge_index,
1170 const int subdiv_edge_index,
1172 const int subdiv_v1,
1173 const int subdiv_v2)
1188 const int subdiv_loop_index,
1214 const int corner_index,
1215 const int ptex_face_index,
1220 for (
const int i : ctx->
uv_maps.index_range()) {
1227 const int coarse_face_index,
1228 const int coarse_corner)
1247 const int ptex_face_index,
1251 const int coarse_face_index,
1252 const int coarse_corner,
1253 const int subdiv_loop_index,
1254 const int subdiv_vert_index,
1255 const int subdiv_edge_index)
1277 for (const int i : ctx->coarse_face_attrs.index_range()) {
1278 bke::attribute_math::gather_to_groups(subdiv_faces_by_base_face,
1279 ctx->coarse_faces.index_range(),
1280 ctx->coarse_face_attr_spans[i],
1281 ctx->subdiv_face_attr_spans[i]);
1284 array_utils::gather_to_groups(subdiv_faces_by_base_face,
1285 ctx->coarse_faces.index_range(),
1286 ctx->coarse_face_origindex,
1287 ctx->subdiv_face_origindex);
1300 const int coarse_vert_index,
1301 const int subdiv_vert_index)
1317 const auto neighbor_edge_if_single = [&](
const int vert) -> std::optional<int2> {
1318 const Span<int> neighbors = vert_to_edge_map[vert];
1319 if (neighbors.
size() != 2) {
1320 return std::nullopt;
1322 return neighbors[0] == edge_index ? coarse_edges[neighbors[1]] : coarse_edges[neighbors[0]];
1324 const int2 edge = coarse_edges[edge_index];
1325 return {neighbor_edge_if_single(edge[0]), neighbor_edge_if_single(edge[1])};
1330 const int2 &coarse_edge,
1331 const std::array<std::optional<int2>, 2> &neighbors)
1333 std::array<float3, 4>
result;
1335 result[1] = coarse_positions[coarse_edge[0]];
1336 result[2] = coarse_positions[coarse_edge[1]];
1338 if (
const std::optional<int2> &other = neighbors[0]) {
1345 if (
const std::optional<int2> &other = neighbors[1]) {
1357 const int coarse_edge_index,
1358 const bool is_simple,
1361 const int2 edge = coarse_edges[coarse_edge_index];
1363 return math::interpolate(coarse_positions[edge[0]], coarse_positions[edge[1]], u);
1367 coarse_edges, vert_to_edge_map, coarse_edge_index);
1369 coarse_positions, edge, neighbors);
1376 const int2 &coarse_edge,
1378 const int subdiv_vert_index)
1383 const std::array<int, 2> coarse_vert_indices{coarse_edge[0], coarse_edge[1]};
1385 coarse_vert_indices,
1395 ctx->
coarse_dverts, coarse_vert_indices, {1.0f - u, u}, dvert_mix_buffer);
1401 const int coarse_edge_index,
1403 const int subdiv_vert_index)
1411 if (!
ELEM(u, 0.0, 1.0)) {
1433 *foreach_context = {};
1476 subdiv_context.
settings = settings;
1483 if (!coarse_mesh->loose_edges().is_empty()) {
1498 foreach_context.
user_data = &subdiv_context;
1518 if (coarse_mesh->verts_no_face().is_empty()) {
1519 result->tag_loose_verts_none();
1521 if (coarse_mesh->loose_edges().is_empty()) {
1522 result->tag_loose_edges_none();
1524 result->tag_overlapping_none();
1526 if (
subdiv->settings.is_simple) {
1548 for (
const StringRef name : {
"skin_modifier_root",
"skin_modifier_loose"}) {
CustomData interface, see also DNA_customdata_types.h.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define CD_MASK_MULTIRES_GRIDS
Span< T > as_span() const
void copy_construct(const void *src, void *dst) const
const void * default_value() const
CommonVArrayInfo common_info() const
const CPPType & type() const
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
void provide_buffer(void *buffer, const int64_t size)
constexpr int64_t size() const
constexpr void copy_from(Span< T > values) const
bool contains(const Key &key) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
void append(const T &value)
const T & last(const int64_t n=0) const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
GAttributeReader get() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
GSpanAttributeWriter lookup_for_write_span(StringRef name)
T mix_indices(const Span< T > src, const Span< int > indices)
T mix4(const float4 &weights, const T &v0, const T &v1, const T &v2, const T &v3)
void to_static_type(const CPPType &cpp_type, Fn &&fn)
T mix2(float factor, const T &a, const T &b)
int edge_other_vert(const int2 edge, const int vert)
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
static bool subdiv_mesh_topology_info(const ForeachContext *foreach_context, const int, const int, const int, const int, const Span< int >)
static void subdiv_mesh_vert_displacement_every_edge(const ForeachContext *foreach_context, void *tls, const int ptex_face_index, const float u, const float v, const int, const int, const int, const int subdiv_vert_index)
void free(Subdiv *subdiv)
static void subdiv_mesh_ensure_loop_interpolation(SubdivMeshContext *ctx, SubdivMeshTLS *tls, const int coarse_face_index, const int coarse_corner)
static void subdiv_mesh_vert_of_loose_edge_interpolate(SubdivMeshContext *ctx, const int2 &coarse_edge, const float u, const int subdiv_vert_index)
float3 eval_final_point(Subdiv *subdiv, int ptex_face_index, float u, float v)
BLI_INLINE float4 quad_weights_from_uv(float u, float v)
static void subdiv_vert_data_copy(const SubdivMeshContext *ctx, const int coarse_vert_index, const int subdiv_vert_index)
static void evaluate_vert_and_apply_displacement_interpolate(const SubdivMeshContext *ctx, const int ptex_face_index, const float u, const float v, VerticesForInterpolation *vert_interpolation, const int subdiv_vert_index)
static void subdiv_mesh_ctx_cache_uv_layers(SubdivMeshContext *ctx)
@ SUBDIV_VTX_BOUNDARY_EDGE_ONLY
static void subdiv_mesh_vert_displacement_every_corner_or_edge(const ForeachContext *foreach_context, void *, const int ptex_face_index, const float u, const float v, const int subdiv_vert_index)
static void loop_interpolation_from_corner(const SubdivMeshContext *ctx, LoopsForInterpolation *loop_interpolation, const IndexRange coarse_face, const int corner)
bool eval_begin_from_mesh(Subdiv *subdiv, const Mesh *mesh, eSubdivEvaluatorType evaluator_type, Span< float3 > coarse_vert_positions={}, OpenSubdiv_EvaluatorCache *evaluator_cache=nullptr)
static void subdiv_mesh_vert_corner(const ForeachContext *foreach_context, void *, const int ptex_face_index, const float u, const float v, const int coarse_vert_index, const int, const int, const int)
static void create_attrs_and_retrieve_interp_spans(const AttributeAccessor src_attrs, const bke::AttrDomain domain, const Set< StringRef > &skip_names, MutableAttributeAccessor dst_attrs, Vector< GVArraySpan > &coarse_varray_spans, Vector< GSpan > &coarse_spans, Vector< GSpanAttributeWriter > &dst_writers, Vector< GMutableSpan > &dst_spans)
float3 mesh_interpolate_position_on_edge(Span< float3 > coarse_positions, Span< int2 > coarse_edges, GroupedSpan< int > vert_to_edge_map, int coarse_edge_index, bool is_simple, float u)
float3 eval_limit_point(Subdiv *subdiv, int ptex_face_index, float u, float v)
static void evaluate_vert_and_apply_displacement_copy(const SubdivMeshContext *ctx, const int ptex_face_index, const float u, const float v, const int coarse_vert_index, const int subdiv_vert_index)
static void subdiv_vert_orco_evaluate(const SubdivMeshContext *ctx, const int ptex_face_index, const float u, const float v, const int subdiv_vert_index)
bool foreach_subdiv_geometry(Subdiv *subdiv, const ForeachContext *context, const ToMeshSettings *mesh_settings, const Mesh *coarse_mesh)
static void subdiv_mesh_vert_inner(const ForeachContext *foreach_context, void *tls_v, const int ptex_face_index, const float u, const float v, const int coarse_face_index, const int coarse_corner, const int subdiv_vert_index)
void calculate_limit_positions(Mesh *mesh, MutableSpan< float3 > limit_positions)
static bool subdiv_mesh_is_center_vert(const IndexRange coarse_face, const float u, const float v)
static void loop_interpolation_from_face(const SubdivMeshContext *ctx, LoopsForInterpolation *loop_interpolation, const IndexRange coarse_face)
@ SUBDIV_FVAR_LINEAR_INTERPOLATION_CORNERS_AND_JUNCTIONS
static void subdiv_mesh_vert_displacement_every_corner(const ForeachContext *foreach_context, void *tls, const int ptex_face_index, const float u, const float v, const int, const int, const int, const int subdiv_vert_index)
static void subdiv_mesh_face(const ForeachContext *foreach_context, OffsetIndices< int > subdiv_faces_by_base_face)
static float3 mix_normals(const Span< float3 > src, const Span< int > src_indices, const Span< float > weights)
static void subdiv_mesh_edge(const ForeachContext *foreach_context, void *, const int coarse_edge_index, const int subdiv_edge_index, const bool, const int subdiv_v1, const int subdiv_v2)
static void subdiv_mesh_vert_loose(const ForeachContext *foreach_context, void *, const int coarse_vert_index, const int subdiv_vert_index)
static void vert_interpolation_from_corner(const SubdivMeshContext *ctx, VerticesForInterpolation *vert_interpolation, const IndexRange coarse_face, const int corner)
static void subdiv_mesh_vert_of_loose_edge(const ForeachContext *foreach_context, void *, const int coarse_edge_index, const float u, const int subdiv_vert_index)
void deform_coarse_vertices(Subdiv *subdiv, const Mesh *coarse_mesh, MutableSpan< float3 > vert_positions)
static void loops_of_ptex_get(LoopsOfPtex *loops_of_ptex, const IndexRange coarse_face, const int ptex_of_face_index)
static void mix_attrs(const Span< GSpan > src, const std::array< int, 2 > &src_indices, const float factor, const int dst_index, const Span< GMutableSpan > dst)
static void subdiv_eval_uv_layer(SubdivMeshContext *ctx, const int corner_index, const int ptex_face_index, const float u, const float v)
void eval_limit_point_and_derivatives(Subdiv *subdiv, int ptex_face_index, float u, float v, float3 &r_P, float3 &r_dPdu, float3 &r_dPdv)
static void subdiv_mesh_ensure_vert_interpolation(SubdivMeshContext *ctx, SubdivMeshTLS *tls, const int coarse_face_index, const int coarse_corner)
static void setup_foreach_callbacks(const SubdivDeformContext *subdiv_context, ForeachContext *foreach_context)
static void subdiv_mesh_prepare_accumulator(SubdivDeformContext *ctx, int num_vertices)
void eval_displacement(Subdiv *subdiv, int ptex_face_index, float u, float v, const float3 &dPdu, const float3 &dPdv, float3 &r_D)
@ SUBDIV_EVALUATOR_TYPE_CPU
static std::array< std::optional< int2 >, 2 > find_edge_neighbors(const Span< int2 > coarse_edges, const GroupedSpan< int > vert_to_edge_map, const int edge_index)
static void subdiv_mesh_tls_free(void *tls_v)
static void subdiv_vert_data_interpolate(const SubdivMeshContext *ctx, const int subdiv_vert_index, VerticesForInterpolation *vert_interpolation, const float u, const float v)
static void copy_attrs(const Span< GSpan > src, const int src_index, const int dst_index, const Span< GMutableSpan > dst)
void stats_begin(SubdivStats *stats, StatsValue value)
void stats_end(SubdivStats *stats, StatsValue value)
void eval_vert_data(Subdiv *subdiv, int ptex_face_index, float u, float v, float r_vert_data[])
void eval_face_varying(Subdiv *subdiv, int face_varying_channel, int ptex_face_index, float u, float v, float2 &r_face_varying)
Mesh * subdiv_to_mesh(Subdiv *subdiv, const ToMeshSettings *settings, const Mesh *coarse_mesh)
static void subdiv_accumulate_vert_displacement(SubdivDeformContext *ctx, const int ptex_face_index, const float u, const float v, int vert_index)
static std::array< float3, 4 > find_loose_edge_interpolation_positions(const Span< float3 > coarse_positions, const int2 &coarse_edge, const std::array< std::optional< int2 >, 2 > &neighbors)
static void subdiv_mesh_tag_center_vert(const IndexRange coarse_face, const int subdiv_vert_index, const float u, const float v, SubdivMeshContext *ctx)
@ SUBDIV_STATS_SUBDIV_TO_MESH_GEOMETRY
@ SUBDIV_STATS_SUBDIV_TO_MESH
Subdiv * update_from_mesh(Subdiv *subdiv, const Settings *settings, const Mesh *mesh)
static void subdiv_mesh_ctx_cache_custom_data_layers(SubdivMeshContext *ctx)
static void subdiv_interpolate_corner_data(const SubdivMeshContext *ctx, const int subdiv_loop_index, const LoopsForInterpolation *loop_interpolation, const float u, const float v)
static void subdiv_mesh_context_free(SubdivDeformContext *ctx)
static void subdiv_mesh_loop(const ForeachContext *foreach_context, void *tls_v, const int ptex_face_index, const float u, const float v, const int, const int coarse_face_index, const int coarse_corner, const int subdiv_loop_index, const int subdiv_vert_index, const int subdiv_edge_index)
static void subdiv_mesh_vert_edge(const ForeachContext *foreach_context, void *tls_v, const int ptex_face_index, const float u, const float v, const int, const int coarse_face_index, const int coarse_corner, const int subdiv_vert_index)
static void vert_interpolation_from_face(const SubdivMeshContext *ctx, VerticesForInterpolation *vert_interpolation, const IndexRange coarse_face)
static void subdiv_copy_edge_data(SubdivMeshContext *ctx, const int subdiv_edge_index, const int coarse_edge_index)
MDeformVert mix_deform_verts(const Span< MDeformVert > src, const Span< int > indices, const Span< float > weights, MDeformWeightSet &dw_buffer)
CustomIDVectorSet< MDeformWeight, WeightIndexGetter, 64 > MDeformWeightSet
T interpolate(const T &a, const T &b, const FactorT &t)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
void fill_constant_group_size(int size, int start_offset, MutableSpan< int > offsets)
void memory_bandwidth_bound_task(const int64_t approximate_bytes_touched, const Function &function)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BLI_INLINE float D(const float *data, const int res[3], int x, int y, int z)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BKE_defvert_array_copy(MDeformVert *dst, const MDeformVert *src, int totvert)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
void BKE_defvert_array_free_elems(MDeformVert *dvert, int totvert)
ATTR_WARN_UNUSED_RESULT const BMVert * v
MINLINE void mul_v3_fl(float r[3], float f)
VecBase< float, 4 > float4
void BKE_mesh_copy_parameters_for_eval(Mesh *me_dst, const Mesh *me_src)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
MINLINE void add_v3_v3(float r[3], const float a[3])
void key_curve_position_weights(float t, float data[4], KeyInterpolationType type)
VecBase< float, 3 > float3
const CustomData_MeshMasks CD_MASK_EVERYTHING
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< bDeformGroup > vertex_group_names
bke::MeshRuntime * runtime
SharedCache< Bounds< float3 > > bounds_cache
MutableVArraySpan< T > span
ForeachVertFromEdgeCb vert_every_edge
ForeachVertFromCornerCb vert_corner
void(*) user_data_tls_free(void *tls)
ForeachVertFromCornerCb vert_every_corner
ForeachVertInnerCb vert_inner
ForeachTopologyInformationCb topology_info
ForeachLooseCb vert_loose
ForeachVertOfLooseEdgeCb vert_of_loose_edge
ForeachVertFromEdgeCb vert_edge
size_t user_data_tls_size
Span< float3 > CD_NORMAL_data
AlignedBuffer< 1024, 64 > buffer
LinearAllocator allocator
Array< GSpan > storage_spans
LoopsForInterpolation(const SubdivMeshContext &ctx)
std::array< int, 4 > loop_indices
std::array< float3, 4 > CD_NORMAL_storage
std::array< float2, 4 > CD_ORIGSPACE_MLOOP_storage
Span< GSpan > corner_data
Span< float2 > CD_ORIGSPACE_MLOOP_data
VtxBoundaryInterpolation vtx_boundary_interpolation
FVarLinearInterpolation fvar_linear_interpolation
MutableSpan< int > subdiv_corner_edges
Vector< GVArraySpan > coarse_edge_attrs
Vector< GSpanAttributeWriter > subdiv_vert_attrs
Vector< GMutableSpan > subdiv_edge_attr_spans
int * accumulated_counters
Span< MDeformVert > coarse_dverts
Vector< GSpan > coarse_vert_attr_spans
Array< int > vert_to_edge_indices
Array< int > vert_to_edge_offsets
GroupedSpan< int > vert_to_edge_map
MutableSpan< int > subdiv_vert_origindex
MutableSpan< float2 > subdiv_CD_ORIGSPACE_MLOOP
MutableSpan< float3 > subdiv_CD_NORMAL
Vector< GSpan > coarse_corner_attr_spans
MutableSpan< int > subdiv_corner_verts
Span< int > coarse_face_origindex
Span< int2 > coarse_edges
MutableSpan< int > subdiv_face_origindex
Span< int > coarse_vert_origindex
Span< float3 > coarse_positions
Vector< GSpanAttributeWriter > subdiv_edge_attrs
const ToMeshSettings * settings
Vector< GSpanAttributeWriter > subdiv_face_attrs
Span< float2 > coarse_CD_ORIGSPACE_MLOOP
Vector< GMutableSpan > subdiv_corner_attr_spans
Vector< GMutableSpan > subdiv_face_attr_spans
Vector< GVArraySpan > coarse_face_attrs
Span< float3 > coarse_CD_NORMAL
Vector< GVArraySpan > coarse_corner_attrs
Vector< GVArraySpan > coarse_vert_attrs
MutableSpan< int2 > subdiv_edges
Vector< GSpanAttributeWriter > subdiv_corner_attrs
MutableSpan< MDeformVert > subdiv_dverts
Vector< GSpan > coarse_face_attr_spans
OffsetIndices< int > coarse_faces
Vector< GMutableSpan > subdiv_vert_attr_spans
Array< bool > subdiv_face_dot_tags
Array< bool > subdiv_display_edges
MutableSpan< float3 > subdiv_positions
Vector< bke::SpanAttributeWriter< float2 > > uv_maps
Span< int > coarse_corner_verts
Span< int > coarse_edge_origindex
MutableSpan< int > subdiv_edge_origindex
Vector< GSpan > coarse_edge_attr_spans
int loop_interpolation_coarse_corner
LoopsForInterpolation * loop_interpolation
int vert_interpolation_coarse_corner
VerticesForInterpolation * vert_interpolation
int vert_interpolation_coarse_face_index
int loop_interpolation_coarse_face_index
AlignedBuffer< 1024, 64 > buffer
~VerticesForInterpolation()
Array< GSpan > storage_spans
MDeformWeightSet dvert_mix_buffer
std::array< MDeformVert, 4 > dverts_storage
VerticesForInterpolation(const SubdivMeshContext &ctx)
Span< MDeformVert > dverts_data
std::array< int, 4 > vert_indices
LinearAllocator allocator