50 if (
const CustomRequest *request_type = std::get_if<CustomRequest>(&value)) {
53 const GenericRequest &attr = std::get<GenericRequest>(value);
97 struct AttributeData {
112 void tag_dirty(
const IndexMask &node_mask);
167 const IndexMask &nodes_to_update)
override;
171 const IndexMask &nodes_to_update)
override;
200void DrawCacheImpl::AttributeData::tag_dirty(
const IndexMask &node_mask)
203 node_mask.
set_bits(this->dirty_nodes);
209 data->tag_dirty(node_mask);
212 data->tag_dirty(node_mask);
218 dirty_topology_.resize(std::max(dirty_topology_.size(), node_mask.
min_array_size()),
false);
219 node_mask.
set_bits(dirty_topology_);
232 data->tag_dirty(node_mask);
239 data->tag_dirty(node_mask);
245 for (
const auto &[data_request,
data] : attribute_vbos_.items()) {
246 if (
const GenericRequest *request = std::get_if<GenericRequest>(&data_request)) {
247 if (*request == attribute_name) {
248 data.tag_dirty(node_mask);
257 ptr = std::make_unique<DrawCacheImpl>();
267 mask.foreach_index([&](
const int i) { ibos[i].reset(); });
275 mask.foreach_index([&](
const int i) { vbos[i].reset(); });
289 "pos", gpu::VertAttrType::SFLOAT_32_32_32);
296 "nor", gpu::VertAttrType::SNORM_16_16_16_16);
303 gpu::VertAttrType::SFLOAT_32);
310 "fset", gpu::VertAttrType::UNORM_8_8_8_8);
320 bool is_render, is_active;
321 const char *prefix =
"a";
354 using VBOType =
typename Converter::VBOType;
356 for (
const int face : face_indices) {
357 for (
const int vert : corner_verts.
slice(faces[face])) {
372 using VBOType =
typename Converter::VBOType;
375 for (
const int face : face_indices) {
376 const int face_size = faces[face].
size();
377 std::fill_n(
data, face_size, Converter::convert(
attribute[face]));
390 using VBOType =
typename Converter::VBOType;
393 for (
const int face : face_indices) {
394 for (
const int corner : faces[face]) {
403 return *
static_cast<const T *
>(
POINTER_OFFSET(vert.head.data, offset));
421 using VBOType =
typename Converter::VBOType;
424 for (
const BMFace *face : faces) {
428 const BMLoop *
l = face->l_first;
443 using VBOType =
typename Converter::VBOType;
446 for (
const BMFace *face : faces) {
462 using VBOType =
typename Converter::VBOType;
465 for (
const BMFace *face : faces) {
469 const BMLoop *
l = face->l_first;
481 return std::count_if(faces.
begin(), faces.
end(), [&](
const BMFace *face) {
482 return !BM_elem_flag_test_bool(face, BM_ELEM_HIDDEN);
488 free_batches(lines_batches_, lines_batches_.index_range());
489 free_batches(lines_batches_coarse_, lines_batches_coarse_.index_range());
510 free_ibos(lines_ibos_coarse_, nodes_to_free);
512 free_ibos(tris_ibos_coarse_, nodes_to_free);
518 for (AttributeData &
data : attribute_vbos_.
values()) {
525 for (MutableSpan<gpu::Batch *> batches : tris_batches_.values()) {
557 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
563 const int verts_per_grid = use_flat_layout[i] ?
square_i(subdiv_ccg.grid_size - 1) * 4 :
565 const int verts_num =
nodes[i].grids().size() * verts_per_grid;
607 faces, corner_verts, vert_positions,
nodes[i].faces(), *vbos[i]);
631 for (
const int face :
nodes[i].faces()) {
632 if (!sharp_faces.
is_empty() && sharp_faces[face]) {
633 const int face_size = faces[face].
size();
638 for (
const int vert : corner_verts.
slice(faces[face])) {
662 if (!
mask.is_empty()) {
666 for (
const int face :
nodes[i].faces()) {
667 for (
const int vert : corner_verts.
slice(faces[face])) {
700 for (
const int face :
nodes[i].faces()) {
701 const int id = face_sets[face];
703 uchar4 fset_color(UCHAR_MAX);
704 if (
id != color_default) {
709 fset_color[0] = fset_color[1] = fset_color[2] = UCHAR_MAX;
712 const int face_size = faces[face].
size();
713 std::fill_n(
data, face_size, fset_color);
744 object,
attribute_format(orig_mesh_data, name, data_type), node_mask, vbos);
748 if constexpr (!std::is_void_v<typename AttributeConverter<T>::VBOType>) {
749 const VArraySpan<T> src = attr.varray.typed<T>();
750 switch (attr.domain) {
751 case bke::AttrDomain::Point:
752 extract_data_vert_mesh<T>(faces, corner_verts, src, nodes[i].faces(), *vbos[i]);
754 case bke::AttrDomain::Face:
755 extract_data_face_mesh<T>(faces, src, nodes[i].faces(), *vbos[i]);
757 case bke::AttrDomain::Corner:
758 extract_data_corner_mesh<T>(faces, src, nodes[i].faces(), *vbos[i]);
761 BLI_assert_unreachable();
777 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
784 if (use_flat_layout[i]) {
785 const int grid_size_1 = key.
grid_size - 1;
786 for (
const int grid :
nodes[i].grids()) {
788 for (
int y = 0;
y < grid_size_1;
y++) {
789 for (
int x = 0;
x < grid_size_1;
x++) {
803 for (
const int grid :
nodes[i].grids()) {
805 std::copy_n(grid_positions.
data(), grid_positions.
size(),
data);
822 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
826 const Span<int> grid_to_face_map = subdiv_ccg.grid_to_face_map;
834 if (use_flat_layout[i]) {
835 const int grid_size_1 = key.
grid_size - 1;
836 for (
const int grid :
nodes[i].grids()) {
839 if (!sharp_faces.
is_empty() && sharp_faces[grid_to_face_map[grid]]) {
840 for (
int y = 0;
y < grid_size_1;
y++) {
841 for (
int x = 0;
x < grid_size_1;
x++) {
854 for (
int y = 0;
y < grid_size_1;
y++) {
855 for (
int x = 0;
x < grid_size_1;
x++) {
868 for (
const int grid :
nodes[i].grids()) {
887 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
895 if (use_flat_layout[i]) {
896 const int grid_size_1 = key.
grid_size - 1;
897 for (
const int grid :
nodes[i].grids()) {
899 for (
int y = 0;
y < grid_size_1;
y++) {
900 for (
int x = 0;
x < grid_size_1;
x++) {
914 for (
const int grid :
nodes[i].grids()) {
916 std::copy_n(grid_masks.
data(), grid_masks.
size(),
data);
938 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
942 const Span<int> grid_to_face_map = subdiv_ccg.grid_to_face_map;
952 const int verts_per_grid = use_flat_layout[i] ?
square_i(key.
grid_size - 1) * 4 :
957 const int fset = face_sets[grid_to_face_map[grids[i]]];
958 if (fset != color_default) {
962 std::fill_n(
data, verts_per_grid,
color);
963 data += verts_per_grid;
975 const int uv_map_index,
976 const float grid_size_1_inv,
977 const int ptex_face_index,
978 const int grid_start,
985 const float grid_u =
x * grid_size_1_inv;
986 const float grid_v =
y * grid_size_1_inv;
991 subdiv_ccg.
subdiv, uv_map_index, ptex_face_index, u,
v,
result[grid_start + offset]);
995 const int uv_map_index,
996 const float grid_size_1_inv,
997 const int ptex_face_index,
998 const int grid_start,
1004 const float u = 1.0f - (
y * grid_size_1_inv);
1005 const float v = 1.0f - (
x * grid_size_1_inv);
1007 subdiv_ccg.
subdiv, uv_map_index, ptex_face_index, u,
v,
result[grid_start + offset]);
1011 const int uv_map_index,
1016 const int grid_size_1 = key.
grid_size - 1;
1017 const int grid_area_1 = grid_size_1 * grid_size_1;
1018 const int verts_per_grid = grid_area_1 * 4;
1021 const float grid_size_1_inv = 1.0f / (key.
grid_size - 1);
1024 for (const int i : range) {
1025 const int grid = grids[i];
1026 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1027 const IndexRange face = subdiv_ccg.faces[face_index];
1028 const int corner = grid - face.start();
1029 if (face.size() == 4) {
1030 const int ptex_face_index = face_ptex_offset[face_index];
1031 for (int y = 0; y < grid_size_1; y++) {
1032 for (int x = 0; x < grid_size_1; x++) {
1033 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1034 calc_quad_uv(subdiv_ccg,
1044 calc_quad_uv(subdiv_ccg,
1054 calc_quad_uv(subdiv_ccg,
1064 calc_quad_uv(subdiv_ccg,
1078 const int ptex_face_index = face_ptex_offset[face_index] + corner;
1079 for (int y = 0; y < grid_size_1; y++) {
1080 for (int x = 0; x < grid_size_1; x++) {
1081 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1082 calc_non_quad_uv(subdiv_ccg,
1091 calc_non_quad_uv(subdiv_ccg,
1100 calc_non_quad_uv(subdiv_ccg,
1109 calc_non_quad_uv(subdiv_ccg,
1126 const int uv_map_index,
1135 const float grid_size_1_inv = 1.0f / (grid_size - 1);
1137 for (const int i : range) {
1138 const int grid = grids[i];
1139 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1140 const IndexRange face = subdiv_ccg.faces[face_index];
1141 const int corner = grid - face.start();
1142 if (face.size() == 4) {
1143 const int ptex_face_index = face_ptex_offset[face_index];
1144 for (int y = 0; y < grid_size; y++) {
1145 const float grid_v = y * grid_size_1_inv;
1146 for (int x = 0; x < grid_size; x++) {
1147 const float grid_u = x * grid_size_1_inv;
1150 bke::subdiv::rotate_grid_to_quad(corner, grid_u, grid_v, &u, &v);
1151 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1152 bke::subdiv::eval_face_varying(
1153 subdiv_ccg.subdiv, uv_map_index, ptex_face_index, u, v, result[element]);
1158 const int ptex_face_index = face_ptex_offset[face_index] + corner;
1159 for (int y = 0; y < grid_size; y++) {
1160 const float u = 1.0f - (y * grid_size_1_inv);
1161 for (int x = 0; x < grid_size; x++) {
1162 const float v = 1.0f - (x * grid_size_1_inv);
1163 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1164 bke::subdiv::eval_face_varying(
1165 subdiv_ccg.subdiv, uv_map_index, ptex_face_index, u, v, result[element]);
1174 const int uv_map_index,
1176 const bool use_flat_layout,
1180 if (use_flat_layout) {
1183 if (!use_flat_layout) {
1190 const BitSpan use_flat_layout,
1198 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
1208 const int uv_channel = orig_mesh_data.
uv_map_names.index_of_try(name);
1209 if (uv_channel == -1) [[unlikely]] {
1211 "Unable to find appropriate FVar channel for given UV map");
1228 const float grid_size_1_inv)
1230 const float grid_u =
x * grid_size_1_inv;
1231 const float grid_v =
y * grid_size_1_inv;
1240 const float grid_size_1_inv)
1242 const float u = 1.0f - (
y * grid_size_1_inv);
1243 const float v = 1.0f - (
x * grid_size_1_inv);
1256 using VBOType =
typename Converter::VBOType;
1259 const int grid_size_1 = key.
grid_size - 1;
1260 const int grid_area_1 = grid_size_1 * grid_size_1;
1261 const int verts_per_grid = grid_area_1 * 4;
1262 const float grid_size_1_inv = 1.0f / (key.
grid_size - 1);
1266 for (const int i : range) {
1267 const int grid = grids[i];
1268 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1269 const IndexRange face = subdiv_ccg.faces[face_index];
1270 const int corner = grid - face.start();
1271 if (face.size() == 4) {
1272 Span<int> face_verts = corner_verts.slice(face);
1273 for (int y = 0; y < grid_size_1; y++) {
1274 for (int x = 0; x < grid_size_1; x++) {
1275 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1276 dst[start] = Converter::convert(
1277 bke::attribute_math::mix4(quad_weights_from_grid(corner, x, y, grid_size_1_inv),
1281 src[face_verts[3]]));
1282 dst[start + 1] = Converter::convert(bke::attribute_math::mix4(
1283 quad_weights_from_grid(corner, x + 1, y, grid_size_1_inv),
1287 src[face_verts[3]]));
1288 dst[start + 2] = Converter::convert(bke::attribute_math::mix4(
1289 quad_weights_from_grid(corner, x + 1, y + 1, grid_size_1_inv),
1293 src[face_verts[3]]));
1294 dst[start + 3] = Converter::convert(bke::attribute_math::mix4(
1295 quad_weights_from_grid(corner, x, y + 1, grid_size_1_inv),
1299 src[face_verts[3]]));
1304 const std::array<T, 4> values =
1305 bke::subdiv::interpolate_vert_data_for_subdivided_irregular_face<T>(
1306 corner_verts, face, grid, src);
1307 for (int y = 0; y < grid_size_1; y++) {
1308 for (int x = 0; x < grid_size_1; x++) {
1309 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1310 dst[start] = Converter::convert(bke::attribute_math::mix4(
1311 quad_weights_from_irregular_corner(x, y, grid_size_1_inv),
1316 dst[start + 1] = Converter::convert(bke::attribute_math::mix4(
1317 quad_weights_from_irregular_corner(x + 1, y, grid_size_1_inv),
1322 dst[start + 2] = Converter::convert(bke::attribute_math::mix4(
1323 quad_weights_from_irregular_corner(x + 1, y + 1, grid_size_1_inv),
1328 dst[start + 3] = Converter::convert(bke::attribute_math::mix4(
1329 quad_weights_from_irregular_corner(x, y + 1, grid_size_1_inv),
1349 using VBOType =
typename Converter::VBOType;
1355 const float grid_size_1_inv = 1.0f / (grid_size - 1);
1358 for (const int i : range) {
1359 const int grid = grids[i];
1360 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1361 const IndexRange face = subdiv_ccg.faces[face_index];
1362 const int corner = grid - face.start();
1363 if (face.size() == 4) {
1364 const Span<int> face_verts = corner_verts.slice(face);
1365 for (int y = 0; y < grid_size; y++) {
1366 for (int x = 0; x < grid_size; x++) {
1367 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1368 dst[element] = Converter::convert(
1369 bke::attribute_math::mix4(quad_weights_from_grid(corner, x, y, grid_size_1_inv),
1373 src[face_verts[3]]));
1378 const std::array<T, 4> values =
1379 bke::subdiv::interpolate_vert_data_for_subdivided_irregular_face<T>(
1380 corner_verts, face, grid, src);
1381 for (int y = 0; y < grid_size; y++) {
1382 for (int x = 0; x < grid_size; x++) {
1383 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1384 dst[element] = Converter::convert(bke::attribute_math::mix4(
1385 quad_weights_from_irregular_corner(x, y, grid_size_1_inv),
1399 const BitSpan &use_flat_layout,
1407 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
1417 if constexpr (!std::is_void_v<typename AttributeConverter<T>::VBOType>) {
1418 if (use_flat_layout[i]) {
1419 interpolate_vert_data_for_flat_layout<T>(
1420 subdiv_ccg, corner_verts, nodes[i].grids(), attr.typed<T>(), *vbos[i]);
1423 interpolate_vert_data_for_standard_layout<T>(
1424 subdiv_ccg, corner_verts, nodes[i].grids(), attr.typed<T>(), *vbos[i]);
1439 using VBOType =
typename Converter::VBOType;
1442 const int grid_size_1 = key.
grid_size - 1;
1443 const int grid_area_1 = grid_size_1 * grid_size_1;
1444 const int verts_per_grid = grid_area_1 * 4;
1445 const float grid_size_1_inv = 1.0f / (key.
grid_size - 1);
1449 for (const int i : range) {
1450 const int grid = grids[i];
1451 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1452 const IndexRange face = subdiv_ccg.faces[face_index];
1453 const int corner = grid - face.start();
1454 if (face.size() == 4) {
1455 for (int y = 0; y < grid_size_1; y++) {
1456 for (int x = 0; x < grid_size_1; x++) {
1457 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1458 dst[start] = Converter::convert(
1459 bke::attribute_math::mix4(quad_weights_from_grid(corner, x, y, grid_size_1_inv),
1464 dst[start + 1] = Converter::convert(bke::attribute_math::mix4(
1465 quad_weights_from_grid(corner, x + 1, y, grid_size_1_inv),
1470 dst[start + 2] = Converter::convert(bke::attribute_math::mix4(
1471 quad_weights_from_grid(corner, x + 1, y + 1, grid_size_1_inv),
1476 dst[start + 3] = Converter::convert(bke::attribute_math::mix4(
1477 quad_weights_from_grid(corner, x, y + 1, grid_size_1_inv),
1486 const std::array<T, 4> values =
1487 bke::subdiv::interpolate_corner_data_for_subdivided_irregular_face<T>(face, grid, src);
1488 for (int y = 0; y < grid_size_1; y++) {
1489 for (int x = 0; x < grid_size_1; x++) {
1490 const int start = verts_per_grid * i + CCG_grid_xy_to_index(grid_size_1, x, y) * 4;
1491 dst[start] = Converter::convert(bke::attribute_math::mix4(
1492 quad_weights_from_irregular_corner(x, y, grid_size_1_inv),
1497 dst[start + 1] = Converter::convert(bke::attribute_math::mix4(
1498 quad_weights_from_irregular_corner(x + 1, y, grid_size_1_inv),
1503 dst[start + 2] = Converter::convert(bke::attribute_math::mix4(
1504 quad_weights_from_irregular_corner(x + 1, y + 1, grid_size_1_inv),
1509 dst[start + 3] = Converter::convert(bke::attribute_math::mix4(
1510 quad_weights_from_irregular_corner(x, y + 1, grid_size_1_inv),
1529 using VBOType =
typename Converter::VBOType;
1535 const float grid_size_1_inv = 1.0f / (grid_size - 1);
1538 for (const int i : range) {
1539 const int grid = grids[i];
1540 const int face_index = subdiv_ccg.grid_to_face_map[grid];
1541 const IndexRange face = subdiv_ccg.faces[face_index];
1542 const int corner = grid - face.start();
1543 if (face.size() == 4) {
1544 for (int y = 0; y < grid_size; y++) {
1545 for (int x = 0; x < grid_size; x++) {
1546 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1547 dst[element] = Converter::convert(
1548 bke::attribute_math::mix4(quad_weights_from_grid(corner, x, y, grid_size_1_inv),
1557 const std::array<T, 4> values =
1558 bke::subdiv::interpolate_corner_data_for_subdivided_irregular_face<T>(face, grid, src);
1559 for (int y = 0; y < grid_size; y++) {
1560 for (int x = 0; x < grid_size; x++) {
1561 const int element = i * grid_area + CCG_grid_xy_to_index(grid_size, x, y);
1562 dst[element] = Converter::convert(bke::attribute_math::mix4(
1563 quad_weights_from_irregular_corner(x, y, grid_size_1_inv),
1578 const BitSpan &use_flat_layout,
1586 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
1593 if constexpr (!std::is_void_v<typename AttributeConverter<T>::VBOType>) {
1594 if (use_flat_layout[i]) {
1595 interpolate_corner_data_for_flat_layout<T>(
1596 subdiv_ccg, nodes[i].grids(), attr.typed<T>(), *vbos[i]);
1599 interpolate_corner_data_for_standard_layout<T>(
1600 subdiv_ccg, nodes[i].grids(), attr.typed<T>(), *vbos[i]);
1610 const bool use_flat_layout,
1616 using VBOType =
typename Converter::VBOType;
1619 const int verts_per_grid = use_flat_layout ? (key.
grid_size - 1) * (key.
grid_size - 1) * 4 :
1624 std::fill_n(dst, verts_per_grid, Converter::convert(src[face_index]));
1625 dst += verts_per_grid;
1631 const BitSpan &use_flat_layout,
1639 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
1646 if constexpr (!std::is_void_v<typename AttributeConverter<T>::VBOType>) {
1647 fill_face_data_grids<T>(
1648 subdiv_ccg, use_flat_layout[i], nodes[i].grids(), attr.typed<T>(), *vbos[i]);
1657 const BitSpan use_flat_layout,
1683 fill_uvs_grids(
object, orig_mesh_data, use_flat_layout, node_mask, name, vbos);
1695 object, orig_mesh_data, use_flat_layout, node_mask, name, vbos);
1704 object, orig_mesh_data, use_flat_layout, node_mask, name, vbos);
1713 object, orig_mesh_data, use_flat_layout, node_mask, name, vbos);
1731 for (
const BMFace *face :
1737 const BMLoop *
l = face->l_first;
1760 for (
const BMFace *face :
1767 const BMLoop *
l = face->l_first;
1791 const BMesh &
bm = *
object.runtime->sculpt_session->bm;
1794 if (cd_offset != -1) {
1798 for (
const BMFace *face :
1804 const BMLoop *
l = face->l_first;
1816 node_mask.
foreach_index([&](
const int i) { vbos[i]->
data<
float>().fill(0.0f); },
1829 const BMesh &
bm = *
object.runtime->sculpt_session->bm;
1838 for (
const BMFace *face :
1846 if (fset != color_default) {
1870 const BMesh &
bm = *
object.runtime->sculpt_session->bm;
1889 const auto &faces = BKE_pbvh_bmesh_node_faces(
1890 &const_cast<bke::pbvh::BMeshNode &>(nodes[i]));
1891 if constexpr (!std::is_void_v<typename AttributeConverter<T>::VBOType>) {
1892 switch (attr.domain) {
1893 case bke::AttrDomain::Point:
1894 extract_data_vert_bmesh<T>(faces, attr.offset, *vbos[i]);
1896 case bke::AttrDomain::Face:
1897 extract_data_face_bmesh<T>(faces, attr.offset, *vbos[i]);
1899 case bke::AttrDomain::Corner:
1900 extract_data_corner_bmesh<T>(faces, attr.offset, *vbos[i]);
1903 BLI_assert_unreachable();
1915 int corners_count = 0;
1916 for (
const int face : face_indices) {
1917 if (!hide_poly.
is_empty() && hide_poly[face]) {
1920 corners_count += faces[face].
size();
1927 int node_corner_offset = 0;
1929 for (
const int face_index : face_indices) {
1930 const int face_size = faces[face_index].
size();
1931 if (!hide_poly.
is_empty() && hide_poly[face_index]) {
1932 node_corner_offset += face_size;
1936 const int next = (i == face_size - 1) ? 0 : i + 1;
1937 data[line_index] =
uint2(i, next) + node_corner_offset;
1941 node_corner_offset += face_size;
1948 const int visible_faces_num)
1958 for (
const BMFace *face : faces) {
1963 data[line_index] =
uint2(vert_index, vert_index + 1);
1965 data[line_index] =
uint2(vert_index + 1, vert_index + 2);
1967 data[line_index] =
uint2(vert_index + 2, vert_index);
1985 const int grid_vert_len = gridsize * gridsize;
1986 for (
int i = 0; i < totgrid; i++, offset += grid_vert_len) {
1990 grid_hidden[grid_indices[i]];
1992 for (
int y = 0;
y < gridsize - skip;
y += skip) {
1993 for (
int x = 0;
x < gridsize - skip;
x += skip) {
2024 const int grid_vert_len =
square_uint(gridsize - 1) * 4;
2025 for (
int i = 0; i < totgrid; i++, offset += grid_vert_len) {
2027 grid_hidden[grid_indices[i]];
2030 for (
int y = 0;
y < gridsize - skip;
y += skip) {
2031 for (
int x = 0;
x < gridsize - skip;
x += skip) {
2037 v0 = (
y * (gridsize - 1) +
x) * 4;
2040 v1 = (
y * (gridsize - 1) +
x + skip - 1) * 4;
2041 v2 = ((
y + skip - 1) * (gridsize - 1) +
x + skip - 1) * 4;
2042 v3 = ((
y + skip - 1) * (gridsize - 1) +
x) * 4;
2068 int display_gridsize,
2077 const int grid_vert_len = gridsize * gridsize;
2078 for (
int i = 0; i < totgrid; i++, offset += grid_vert_len) {
2080 bool grid_visible =
false;
2083 grid_hidden[grid_indices[i]];
2085 for (
int y = 0;
y < gridsize - skip;
y += skip) {
2086 for (
int x = 0;
x < gridsize - skip;
x += skip) {
2102 if (
y / skip + 2 == display_gridsize) {
2106 grid_visible =
true;
2118 int display_gridsize,
2127 const int grid_vert_len =
square_uint(gridsize - 1) * 4;
2128 for (
int i = 0; i < totgrid; i++, offset += grid_vert_len) {
2129 bool grid_visible =
false;
2131 grid_hidden[grid_indices[i]];
2134 for (
int y = 0;
y < gridsize - skip;
y += skip) {
2135 for (
int x = 0;
x < gridsize - skip;
x += skip) {
2141 v0 = (
y * (gridsize - 1) +
x) * 4;
2144 v1 = (
y * (gridsize - 1) +
x + skip - 1) * 4;
2145 v2 = ((
y + skip - 1) * (gridsize - 1) +
x + skip - 1) * 4;
2146 v3 = ((
y + skip - 1) * (gridsize - 1) +
x) * 4;
2166 if (
y / skip + 2 == display_gridsize) {
2170 grid_visible =
true;
2185 switch (
pbvh.type()) {
2190 const VArray material_indices = *attributes.
lookup<
int>(
"material_index",
2192 if (!material_indices) {
2197 for (const int i : range) {
2198 const Span<int> face_indices = nodes[i].faces();
2199 if (face_indices.is_empty()) {
2202 node_materials[i] = material_indices[face_indices.first()];
2205 return node_materials;
2211 const VArray material_indices = *attributes.lookup<
int>(
"material_index",
2213 if (!material_indices) {
2220 for (const int i : range) {
2221 const Span<int> grids = nodes[i].grids();
2222 if (grids.is_empty()) {
2225 node_materials[i] = material_indices[grid_faces[grids.first()]];
2228 return node_materials;
2241 switch (
pbvh.type()) {
2254 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
2260 for (const int i : range) {
2261 const Span<int> grids = nodes[i].grids();
2262 if (grids.is_empty()) {
2265 use_flat_layout[i] = std::any_of(grids.begin(), grids.end(), [&](const int grid) {
2266 return sharp_faces[grid_to_face_map[grid]];
2290 for (
const int face : face_indices) {
2291 if (hide_poly[face]) {
2303 int node_corner_offset = 0;
2304 for (
const int face_index : face_indices) {
2306 if (!hide_poly.
is_empty() && hide_poly[face_index]) {
2307 node_corner_offset += face.
size();
2312 const int corner = tri[i];
2313 const int index_in_face = corner - face.
first();
2314 data[tri_index][i] = node_corner_offset + index_in_face;
2318 node_corner_offset += face.
size();
2326 const bool do_coarse,
2328 const bool use_flat_layout)
2331 int display_gridsize = gridsize;
2332 int totgrid = grid_indices.
size();
2335 const int display_level = do_coarse ? 0 : key.
level;
2337 if (display_level < key.
level) {
2338 display_gridsize = (1 << display_level) + 1;
2339 skip = 1 << (key.
level - display_level - 1);
2343 grid_hidden, grid_indices, key.
grid_size, display_gridsize);
2351 if (use_flat_layout) {
2353 grid_indices, grid_hidden, gridsize, skip, totgrid,
data);
2361 builder.
index_max = 6 * visible_quad_len;
2370 const bool do_coarse,
2372 const bool use_flat_layout)
2375 int display_gridsize = gridsize;
2376 int totgrid = grid_indices.
size();
2379 const int display_level = do_coarse ? 0 : key.
level;
2381 if (display_level < key.
level) {
2382 display_gridsize = (1 << display_level) + 1;
2383 skip = 1 << (key.
level - display_level - 1);
2396 if (use_flat_layout) {
2398 grid_indices, display_gridsize, grid_hidden, gridsize, skip, totgrid,
data);
2402 grid_indices, display_gridsize, grid_hidden, gridsize, skip, totgrid,
data);
2406 &builder, 0, 2 * totgrid * display_gridsize * (display_gridsize - 1),
false));
2410 const OrigMeshData &orig_mesh_data,
2420 node_mask, memory, [&](
const int i) {
return !ibos[i]; });
2422 switch (
pbvh.type()) {
2431 ibos[i] = create_lines_index_faces(faces, hide_poly,
nodes[i].faces());
2437 const Span<bke::pbvh::GridsNode> nodes =
pbvh.nodes<bke::pbvh::GridsNode>();
2440 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
2443 key, subdiv_ccg.grid_hidden, coarse, nodes[i].grids(), use_flat_layout_[i]);
2449 const Span<bke::pbvh::BMeshNode> nodes =
pbvh.nodes<bke::pbvh::BMeshNode>();
2453 &
const_cast<bke::pbvh::BMeshNode &
>(nodes[i]));
2465BitSpan DrawCacheImpl::ensure_use_flat_layout(
const Object &
object,
2466 const OrigMeshData &orig_mesh_data)
2470 if (use_flat_layout_.size() !=
pbvh.nodes_num()) {
2473 return use_flat_layout_;
2484 const OrigMeshData &orig_mesh_data,
2490 AttributeData &
data = attribute_vbos_.lookup_or_add_default(attr);
2502 node_mask, memory, [&](
const int i) {
return !vbos[i]; });
2507 switch (
pbvh.type()) {
2509 if (
const CustomRequest *request_type = std::get_if<CustomRequest>(&attr)) {
2510 switch (*request_type) {
2511 case CustomRequest::Position:
2512 update_positions_mesh(
object,
mask, vbos);
2514 case CustomRequest::Normal:
2515 update_normals_mesh(
object,
mask, vbos);
2517 case CustomRequest::Mask:
2518 update_masks_mesh(
object, orig_mesh_data,
mask, vbos);
2520 case CustomRequest::FaceSet:
2521 update_face_sets_mesh(
object, orig_mesh_data,
mask, vbos);
2527 object, orig_mesh_data, mask, std::get<GenericRequest>(attr), vbos);
2532 if (
const CustomRequest *request_type = std::get_if<CustomRequest>(&attr)) {
2533 switch (*request_type) {
2534 case CustomRequest::Position:
2537 case CustomRequest::Normal:
2540 case CustomRequest::Mask:
2543 case CustomRequest::FaceSet:
2550 object, orig_mesh_data, use_flat_layout_, mask, std::get<GenericRequest>(attr), vbos);
2555 if (
const CustomRequest *request_type = std::get_if<CustomRequest>(&attr)) {
2556 switch (*request_type) {
2557 case CustomRequest::Position:
2560 case CustomRequest::Normal:
2563 case CustomRequest::Mask:
2566 case CustomRequest::FaceSet:
2573 object, orig_mesh_data, mask, std::get<GenericRequest>(attr), vbos);
2581 dirty_mask.foreach_index_optimized<
int>([&](
const int i) {
data.dirty_nodes[i].reset(); });
2588Span<gpu::IndexBufPtr> DrawCacheImpl::ensure_tri_indices(
const Object &
object,
2589 const OrigMeshData &orig_mesh_data,
2590 const IndexMask &node_mask,
2595 switch (
pbvh.type()) {
2597 const Span<bke::pbvh::MeshNode> nodes =
pbvh.nodes<bke::pbvh::MeshNode>();
2599 Vector<gpu::IndexBufPtr> &ibos = tris_ibos_;
2605 IndexMaskMemory memory;
2607 node_mask, memory, [&](
const int i) {
return !ibos[i]; });
2610 const OffsetIndices<int> faces = mesh.faces();
2611 const Span<int3> corner_tris = mesh.corner_tris();
2612 const bke::AttributeAccessor attributes = orig_mesh_data.attributes;
2614 nodes_to_calculate.foreach_index(
2629 const Span<bke::pbvh::GridsNode> nodes =
pbvh.nodes<bke::pbvh::GridsNode>();
2631 Vector<gpu::IndexBufPtr> &ibos = coarse ? tris_ibos_coarse_ : tris_ibos_;
2632 ibos.resize(nodes.
size());
2637 IndexMaskMemory memory;
2639 node_mask, memory, [&](
const int i) {
return !ibos[i]; });
2641 const SubdivCCG &subdiv_ccg = *
object.runtime->sculpt_session->subdiv_ccg;
2644 nodes_to_calculate.foreach_index(
2647 key, subdiv_ccg.grid_hidden, coarse, nodes[i].grids(), use_flat_layout_[i]);
2665 const OrigMeshData orig_mesh_data{*id_cast<const Mesh *>(object_orig.
data)};
2668 this->ensure_use_flat_layout(
object, orig_mesh_data);
2669 this->free_nodes_with_changed_topology(
pbvh);
2675 this->ensure_attribute_data(
object, orig_mesh_data, attr, nodes_to_update);
2682 if (
const AttributeData *attr_data = attribute_vbos_.lookup_ptr(attr)) {
2683 attr_vbos.
append(attr_data->vbos);
2712 const OrigMeshData orig_mesh_data(*id_cast<const Mesh *>(object_orig.
data));
2715 this->ensure_use_flat_layout(
object, orig_mesh_data);
2716 this->free_nodes_with_changed_topology(
pbvh);
2744 const OrigMeshData orig_mesh_data(*id_cast<const Mesh *>(object_orig.
data));
2746 material_indices_.size() !=
pbvh.nodes_num())
2750 return material_indices_;
CustomData interface, see also DNA_customdata_types.h.
A BVH for high poly meshes.
Object is a sort of wrapper for general info.
#define GPU_batch_create(primitive_type, vertex_buf, index_buf)
#define GPU_BATCH_DISCARD_SAFE(batch)
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define POINTER_OFFSET(v, ofs)
#define BLI_assert_msg(a, msg)
#define BM_elem_flag_test(ele, hflag)
constexpr int64_t size() const
BitVector(Allocator allocator={}) noexcept
const CPPType & type() const
const CPPType & type() const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_union(const IndexMask &mask_a, const IndexMask &mask_b, LinearAllocator<> &memory)
static IndexMask from_bits(BitSpan bits, LinearAllocator<> &memory)
static IndexMask from_intersection(const IndexMask &mask_a, const IndexMask &mask_b, LinearAllocator<> &memory)
constexpr int64_t first() const
constexpr int64_t size() const
constexpr IndexRange()=default
ValueIterator values() const &
constexpr T * data() const
constexpr IndexRange index_range() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T * data() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
void add_multiple(Span< Key > keys)
void append(const T &value)
void resize(const int64_t new_size)
void resize(const int64_t new_size_in_bits, const bool value=false)
bool contains(StringRef name) const
GAttributeReader lookup(const StringRef name) const
constexpr bool is_empty() const
void tag_visibility_changed(const IndexMask &node_mask) override
void tag_positions_changed(const IndexMask &node_mask) override
~DrawCacheImpl() override
Span< int > ensure_material_indices(const Object &object) override
void tag_attribute_changed(const IndexMask &node_mask, StringRef attribute_name) override
Span< gpu::Batch * > ensure_tris_batches(const Object &object, const ViewportRequest &request, const IndexMask &nodes_to_update) override
void tag_masks_changed(const IndexMask &node_mask) override
void tag_topology_changed(const IndexMask &node_mask) override
void tag_face_sets_changed(const IndexMask &node_mask) override
Span< gpu::Batch * > ensure_lines_batches(const Object &object, const ViewportRequest &request, const IndexMask &nodes_to_update) override
IndexMask slice_content(IndexRange range) const
int64_t min_array_size() const
void set_bits(MutableBitSpan r_bits, int64_t offset=0) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
void to_static_type(const CPPType &cpp_type, Fn &&fn)
IndexRange grid_range(const int grid_area, const int grid)
int face_triangles_num(const int face_size)
IndexRange face_triangles_range(OffsetIndices< int > faces, int face_i)
pbvh::Tree * pbvh_get(Object &object)
Span< float3 > vert_normals_eval_from_eval(const Object &object_eval)
int count_grid_quads(const BitGroupVector<> &grid_hidden, Span< int > grid_indices, int gridsize, int display_gridsize)
Span< float3 > vert_positions_eval_from_eval(const Object &object_eval)
Span< float3 > face_normals_eval_from_eval(const Object &object_eval)
BLI_INLINE float4 quad_weights_from_uv(float u, float v)
BLI_INLINE void rotate_grid_to_quad(int corner, float grid_u, float grid_v, float *r_quad_u, float *r_quad_v)
void eval_face_varying(Subdiv *subdiv, int face_varying_channel, int ptex_face_index, float u, float v, float2 &r_face_varying)
Span< int > face_ptex_offset_get(Subdiv *subdiv)
std::optional< eCustomDataType > attr_type_to_custom_data_type(AttrType attr_type)
AttrType cpp_type_to_attribute_type(const CPPType &type)
void extract_data_vert_mesh(const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< T > attribute, const Span< int > face_indices, gpu::VertBuf &vbo)
static BLI_NOINLINE void flush_vbo_data(const Span< gpu::VertBufPtr > vbos, const IndexMask &node_mask)
static BLI_NOINLINE void update_face_sets_bmesh(const Object &object, const OrigMeshData &orig_mesh_data, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void fill_masks_grids(const Object &object, const BitSpan use_flat_layout, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void ensure_vbos_allocated_bmesh(const Object &object, const GPUVertFormat &format, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void fill_uvs_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan use_flat_layout, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void update_positions_bmesh(const Object &object, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
void extract_data_corner_mesh(const OffsetIndices< int > faces, const Span< T > attribute, const Span< int > face_indices, gpu::VertBuf &vbo)
static void interpolate_corner_data_for_flat_layout(const SubdivCCG &subdiv_ccg, const Span< int > grids, const Span< T > src, gpu::VertBuf &vbo)
static void update_normals_mesh(const Object &object, const IndexMask &node_mask, MutableSpan< gpu::VertBufPtr > vbos)
static void calc_node_uvs_for_standard_layout(const SubdivCCG &subdiv_ccg, const int uv_map_index, Span< int > grids, MutableSpan< float2 > result)
static int count_visible_tris_bmesh(const Set< BMFace *, 0 > &faces)
const T & bmesh_cd_loop_get(const BMLoop &loop, const int offset)
static gpu::IndexBufPtr create_lines_index_faces(const OffsetIndices< int > faces, const Span< bool > hide_poly, const Span< int > face_indices)
static BitVector calc_use_flat_layout(const Object &object, const OrigMeshData &orig_mesh_data)
static BLI_NOINLINE void update_generic_attribute_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan use_flat_layout, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static const GPUVertFormat & normal_format()
static const GPUVertFormat & face_set_format()
DrawCache & ensure_draw_data(std::unique_ptr< bke::pbvh::DrawCache > &ptr)
static const GPUVertFormat & position_format()
static BLI_NOINLINE void update_generic_attribute_mesh(const Object &object, const OrigMeshData &orig_mesh_data, const IndexMask &node_mask, const StringRef name, MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void update_masks_bmesh(const Object &object, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void calc_generic_vert_attribute_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan &use_flat_layout, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void fill_generic_face_attribute_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan &use_flat_layout, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static float4 quad_weights_from_grid(const int corner, const int x, const int y, const float grid_size_1_inv)
static void create_lines_index_grids_flat_layout(const Span< int > grid_indices, int display_gridsize, const BitGroupVector<> &grid_hidden, const int gridsize, const int skip, const int totgrid, MutableSpan< uint2 > data)
const T & bmesh_cd_face_get(const BMFace &face, const int offset)
static void calc_node_uvs(const SubdivCCG &subdiv_ccg, const int uv_map_index, const bke::pbvh::GridsNode &node, const bool use_flat_layout, MutableSpan< float2 > result)
static void create_lines_index_grids(const Span< int > grid_indices, int display_gridsize, const BitGroupVector<> &grid_hidden, const int gridsize, const int skip, const int totgrid, MutableSpan< uint2 > data)
static BLI_NOINLINE void update_generic_attribute_bmesh(const Object &object, const OrigMeshData &orig_mesh_data, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static void calc_quad_uv(const SubdivCCG &subdiv_ccg, const int uv_map_index, const float grid_size_1_inv, const int ptex_face_index, const int grid_start, const int corner, const int x, const int y, const int offset, MutableSpan< float2 > result)
static void interpolate_vert_data_for_standard_layout(const SubdivCCG &subdiv_ccg, const Span< int > corner_verts, const Span< int > grids, const Span< T > src, gpu::VertBuf &vbo)
static int create_tri_index_grids_flat_layout(const Span< int > grid_indices, const BitGroupVector<> &grid_hidden, const int gridsize, const int skip, const int totgrid, MutableSpan< uint3 > data)
void extract_data_face_bmesh(const Set< BMFace *, 0 > &faces, const int cd_offset, gpu::VertBuf &vbo)
static Array< int > calc_material_indices(const Object &object, const OrigMeshData &orig_mesh_data)
short4 normal_float_to_short(const float3 &value)
static BLI_NOINLINE void free_vbos(const MutableSpan< gpu::VertBufPtr > vbos, const IndexMask &node_mask)
static BLI_NOINLINE void fill_face_sets_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan use_flat_layout, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static gpu::IndexBufPtr create_tri_index_mesh(const OffsetIndices< int > faces, const Span< int3 > corner_tris, const Span< bool > hide_poly, const bke::pbvh::MeshNode &node)
static BLI_NOINLINE void free_batches(const MutableSpan< gpu::Batch * > batches, const IndexMask &node_mask)
void extract_data_vert_bmesh(const Set< BMFace *, 0 > &faces, const int cd_offset, gpu::VertBuf &vbo)
void extract_data_face_mesh(const OffsetIndices< int > faces, const Span< T > attribute, const Span< int > face_indices, gpu::VertBuf &vbo)
static BLI_NOINLINE void update_masks_mesh(const Object &object, const OrigMeshData &orig_mesh_data, const IndexMask &node_mask, MutableSpan< gpu::VertBufPtr > vbos)
static void calc_non_quad_uv(const SubdivCCG &subdiv_ccg, const int uv_map_index, const float grid_size_1_inv, const int ptex_face_index, const int grid_start, const int x, const int y, const int offset, MutableSpan< float2 > result)
static BLI_NOINLINE void calc_generic_corner_attribute_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan &use_flat_layout, const IndexMask &node_mask, const StringRef name, const MutableSpan< gpu::VertBufPtr > vbos)
static GPUVertFormat attribute_format(const OrigMeshData &orig_mesh_data, const StringRef name, const bke::AttrType data_type)
static void update_positions_mesh(const Object &object, const IndexMask &node_mask, MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void update_normals_bmesh(const Object &object, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static void fill_face_data_grids(const SubdivCCG &subdiv_ccg, const bool use_flat_layout, const Span< int > grids, const Span< T > src, gpu::VertBuf &vbo)
static void interpolate_vert_data_for_flat_layout(const SubdivCCG &subdiv_ccg, const Span< int > corner_verts, const Span< int > grids, const Span< T > src, gpu::VertBuf &vbo)
void extract_data_corner_bmesh(const Set< BMFace *, 0 > &faces, const int cd_offset, gpu::VertBuf &vbo)
static void interpolate_corner_data_for_standard_layout(const SubdivCCG &subdiv_ccg, const Span< int > grids, const Span< T > src, gpu::VertBuf &vbo)
static BLI_NOINLINE void ensure_vbos_allocated_mesh(const Object &object, const GPUVertFormat &format, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void fill_normals_grids(const Object &object, const OrigMeshData &orig_mesh_data, const BitSpan use_flat_layout, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void ensure_vbos_allocated_grids(const Object &object, const GPUVertFormat &format, const BitSpan use_flat_layout, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static BLI_NOINLINE void fill_positions_grids(const Object &object, const BitSpan use_flat_layout, const IndexMask &node_mask, const MutableSpan< gpu::VertBufPtr > vbos)
static gpu::IndexBufPtr create_lines_index_bmesh(const Set< BMFace *, 0 > &faces, const int visible_faces_num)
static BLI_NOINLINE void free_ibos(const MutableSpan< gpu::IndexBufPtr > ibos, const IndexMask &node_mask)
static int create_tri_index_grids(const Span< int > grid_indices, const BitGroupVector<> &grid_hidden, const int gridsize, const int skip, const int totgrid, MutableSpan< uint3 > data)
const T & bmesh_cd_vert_get(const BMVert &vert, const int offset)
static float4 quad_weights_from_irregular_corner(const int x, const int y, const float grid_size_1_inv)
static const GPUVertFormat & mask_format()
std::string GenericRequest
static void calc_node_uvs_for_flat_layout(const SubdivCCG &subdiv_ccg, const int uv_map_index, Span< int > grids, MutableSpan< float2 > result)
static BLI_NOINLINE void update_face_sets_mesh(const Object &object, const OrigMeshData &orig_mesh_data, const IndexMask &node_mask, MutableSpan< gpu::VertBufPtr > vbos)
std::variant< CustomRequest, GenericRequest > AttributeRequest
GPUVertFormat init_format_for_attribute(const bke::AttrType data_type, const StringRef vbo_name)
void DRW_cdlayer_attr_aliases_add(GPUVertFormat *format, const char *base_name, bke::AttrType data_type, StringRef layer_name, bool is_active_render, bool is_active_layer)
constexpr ParallelGrainSize grain_size(int grain_size)
std::unique_ptr< IndexBuf, IndexBufDeleter > IndexBufPtr
std::unique_ptr< gpu::VertBuf, gpu::VertBufDeleter > VertBufPtr
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
VecBase< uint32_t, 2 > uint2
VecBase< int16_t, 3 > short3
VecBase< uint8_t, 4 > uchar4
unsigned __int64 uint64_t
void GPU_indexbuf_init(GPUIndexBufBuilder *, GPUPrimType, uint prim_len, uint vertex_len)
const Set< BMFace *, 0 > & BKE_pbvh_bmesh_node_faces(bke::pbvh::BMeshNode *node)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
MINLINE int square_i(int a)
GPUVertFormat GPU_vertformat_from_attribute(StringRef name, gpu::VertAttrType type)
void GPU_vertbuf_use(gpu::VertBuf *)
VecBase< uint32_t, 3 > uint3
ATTR_WARN_UNUSED_RESULT const BMVert * v
bool BKE_paint_is_grid_face_hidden(BoundedBitSpan grid_hidden, int gridsize, int x, int y)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
MINLINE void normal_float_to_short_v3(short out[3], const float in[3])
VecBase< float, 4 > float4
VecBase< int16_t, 4 > short4
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
T & DRW_object_get_data_for_drawing(const Object &object)
BMesh const char void * data
float normal_quad_v3(float n[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
MutableSpan< uint32_t > GPU_indexbuf_get_data(GPUIndexBufBuilder *)
gpu::IndexBuf * GPU_indexbuf_calloc()
BMDataLayerLookup BM_data_layer_lookup(const BMesh &bm, const StringRef name)
eCustomDataMask CD_TYPE_AS_MASK(eCustomDataType type)
MINLINE int poly_to_tri_count(int poly_count, int corner_count)
int CCG_grid_xy_to_index(const int grid_size, const int x, const int y)
void GPU_indexbuf_build_in_place(GPUIndexBufBuilder *, gpu::IndexBuf *)
T * DEG_get_original(T *id)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
void BKE_paint_face_set_overlay_color_get(int face_set, int seed, uchar r_color[4])
void GPU_vertbuf_data_alloc(gpu::VertBuf &verts, uint v_len)
gpu::IndexBuf * GPU_indexbuf_build_ex(GPUIndexBufBuilder *builder, uint index_min, uint index_max, bool uses_restart_indices)
VecBase< float, 3 > float3
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
int GPU_batch_vertbuf_add(gpu::Batch *batch, gpu::VertBuf *vertex_buf, bool own_vbo)
MINLINE unsigned int square_uint(unsigned int a)
uint64_t operator()(const draw::pbvh::AttributeRequest &value) const
bool uses_restart_indices
bke::subdiv::Subdiv * subdiv
Span< int > grid_to_face_map
OrigMeshData(const Mesh &mesh)
VectorSet< StringRef > uv_map_names
bke::AttributeAccessor attributes
Vector< AttributeRequest > attributes