blender
/
blender
130
398
Fork 572
Code Issues 6.2k Pull Requests 747 Projects 19 Wiki Activity

Cleanup: Remove remaining subdiv/subsurf files to C++ 

For continued refactoring of the Mesh data structure. See T103343.
This commit is contained in:
Hans Goudey 2023-01-19 21:40:50 -06:00
parent 1e8cc72f85
commit bbc35fef25
16 changed files with 406 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_multires.h
View File

@ -41,7 +41,7 @@ void multires_flush_sculpt_updates(struct Object *object);
void multires_force_sculpt_rebuild(struct Object *object);
void multires_force_external_reload(struct Object *object);
/* internal, only called in subsurf_ccg.c */
/* internal, only called in subsurf_ccg.cc */
void multires_modifier_update_mdisps(struct DerivedMesh *dm, struct Scene *scene);
void multires_modifier_update_hidden(struct DerivedMesh *dm);

28
source/blender/blenkernel/CMakeLists.txt
View File

@ -268,22 +268,22 @@ set(SRC
intern/sound.c
intern/speaker.c
intern/studiolight.c
intern/subdiv.c
intern/subdiv.cc
intern/subdiv_ccg.cc
intern/subdiv_ccg_mask.c
intern/subdiv_ccg_material.c
intern/subdiv_converter.c
intern/subdiv_converter_mesh.c
intern/subdiv_deform.c
intern/subdiv_displacement.c
intern/subdiv_displacement_multires.c
intern/subdiv_eval.c
intern/subdiv_foreach.c
intern/subdiv_ccg_mask.cc
intern/subdiv_ccg_material.cc
intern/subdiv_converter.cc
intern/subdiv_converter_mesh.cc
intern/subdiv_deform.cc
intern/subdiv_displacement.cc
intern/subdiv_displacement_multires.cc
intern/subdiv_eval.cc
intern/subdiv_foreach.cc
intern/subdiv_mesh.cc
intern/subdiv_modifier.cc
intern/subdiv_stats.c
intern/subdiv_topology.c
intern/subsurf_ccg.c
intern/subdiv_stats.cc
intern/subdiv_topology.cc
intern/subsurf_ccg.cc
intern/text.c
intern/text_suggestions.c
intern/texture.cc
@ -848,4 +848,4 @@ if(WITH_GTESTS)
# RNA_prototypes.h
add_dependencies(bf_blenkernel_tests bf_rna)
endif()
endif()

32
source/blender/blenkernel/intern/subdiv.c → source/blender/blenkernel/intern/subdiv.cc
View File

@ -96,7 +96,7 @@ bool BKE_subdiv_settings_equal(const SubdivSettings *settings_a, const SubdivSet
/* Creation from scratch. */
Subdiv *BKE_subdiv_new_from_converter(const SubdivSettings *settings,
struct OpenSubdiv_Converter *converter)
OpenSubdiv_Converter *converter)
{
SubdivStats stats;
BKE_subdiv_stats_init(&stats);
@ -104,7 +104,7 @@ Subdiv *BKE_subdiv_new_from_converter(const SubdivSettings *settings,
OpenSubdiv_TopologyRefinerSettings topology_refiner_settings;
topology_refiner_settings.level = settings->level;
topology_refiner_settings.is_adaptive = settings->is_adaptive;
struct OpenSubdiv_TopologyRefiner *osd_topology_refiner = NULL;
OpenSubdiv_TopologyRefiner *osd_topology_refiner = nullptr;
if (converter->getNumVertices(converter) != 0) {
osd_topology_refiner = openSubdiv_createTopologyRefinerFromConverter(
converter, &topology_refiner_settings);
@ -114,11 +114,11 @@ Subdiv *BKE_subdiv_new_from_converter(const SubdivSettings *settings,
* The thing here is: OpenSubdiv can only deal with faces, but our
* side of subdiv also deals with loose vertices and edges. */
}
Subdiv *subdiv = MEM_callocN(sizeof(Subdiv), "subdiv from converter");
Subdiv *subdiv = MEM_cnew<Subdiv>(__func__);
subdiv->settings = *settings;
subdiv->topology_refiner = osd_topology_refiner;
subdiv->evaluator = NULL;
subdiv->displacement_evaluator = NULL;
subdiv->evaluator = nullptr;
subdiv->displacement_evaluator = nullptr;
BKE_subdiv_stats_end(&stats, SUBDIV_STATS_TOPOLOGY_REFINER_CREATION_TIME);
subdiv->stats = stats;
return subdiv;
@ -127,7 +127,7 @@ Subdiv *BKE_subdiv_new_from_converter(const SubdivSettings *settings,
Subdiv *BKE_subdiv_new_from_mesh(const SubdivSettings *settings, const Mesh *mesh)
{
if (mesh->totvert == 0) {
return NULL;
return nullptr;
}
OpenSubdiv_Converter converter;
BKE_subdiv_converter_init_for_mesh(&converter, settings, mesh);
@ -144,7 +144,7 @@ Subdiv *BKE_subdiv_update_from_converter(Subdiv *subdiv,
{
/* Check if the existing descriptor can be re-used. */
bool can_reuse_subdiv = true;
if (subdiv != NULL && subdiv->topology_refiner != NULL) {
if (subdiv != nullptr && subdiv->topology_refiner != nullptr) {
if (!BKE_subdiv_settings_equal(&subdiv->settings, settings)) {
can_reuse_subdiv = false;
}
@ -162,7 +162,7 @@ Subdiv *BKE_subdiv_update_from_converter(Subdiv *subdiv,
return subdiv;
}
/* Create new subdiv. */
if (subdiv != NULL) {
if (subdiv != nullptr) {
BKE_subdiv_free(subdiv);
}
return BKE_subdiv_new_from_converter(settings, converter);
@ -183,7 +183,7 @@ Subdiv *BKE_subdiv_update_from_mesh(Subdiv *subdiv,
void BKE_subdiv_free(Subdiv *subdiv)
{
if (subdiv->evaluator != NULL) {
if (subdiv->evaluator != nullptr) {
const eOpenSubdivEvaluator evaluator_type = subdiv->evaluator->type;
if (evaluator_type != OPENSUBDIV_EVALUATOR_CPU) {
/* Let the draw code do the freeing, to ensure that the OpenGL context is valid. */
@ -192,11 +192,11 @@ void BKE_subdiv_free(Subdiv *subdiv)
}
openSubdiv_deleteEvaluator(subdiv->evaluator);
}
if (subdiv->topology_refiner != NULL) {
if (subdiv->topology_refiner != nullptr) {
openSubdiv_deleteTopologyRefiner(subdiv->topology_refiner);
}
BKE_subdiv_displacement_detach(subdiv);
if (subdiv->cache_.face_ptex_offset != NULL) {
if (subdiv->cache_.face_ptex_offset != nullptr) {
MEM_freeN(subdiv->cache_.face_ptex_offset);
}
MEM_freeN(subdiv);
@ -208,16 +208,16 @@ void BKE_subdiv_free(Subdiv *subdiv)
int *BKE_subdiv_face_ptex_offset_get(Subdiv *subdiv)
{
if (subdiv->cache_.face_ptex_offset != NULL) {
if (subdiv->cache_.face_ptex_offset != nullptr) {
return subdiv->cache_.face_ptex_offset;
}
OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
if (topology_refiner == NULL) {
return NULL;
if (topology_refiner == nullptr) {
return nullptr;
}
const int num_coarse_faces = topology_refiner->getNumFaces(topology_refiner);
subdiv->cache_.face_ptex_offset = MEM_malloc_arrayN(
num_coarse_faces + 1, sizeof(int), "subdiv face_ptex_offset");
subdiv->cache_.face_ptex_offset = static_cast<int *>(
MEM_malloc_arrayN(num_coarse_faces + 1, sizeof(int), __func__));
int ptex_offset = 0;
for (int face_index = 0; face_index < num_coarse_faces; face_index++) {
const int num_ptex_faces = topology_refiner->getNumFacePtexFaces(topology_refiner, face_index);

30
source/blender/blenkernel/intern/subdiv_ccg_mask.c → source/blender/blenkernel/intern/subdiv_ccg_mask.cc
View File

@ -5,7 +5,7 @@
* \ingroup bke
*/
#include <math.h>
#include <cmath>
#include "BKE_subdiv_ccg.h"
@ -22,12 +22,12 @@
#include "MEM_guardedalloc.h"
typedef struct PolyCornerIndex {
struct PolyCornerIndex {
int poly_index;
int corner;
} PolyCornerIndex;
};
typedef struct GridPaintMaskData {
struct GridPaintMaskData {
// int grid_size;
const MPoly *mpoly;
const GridPaintMask *grid_paint_mask;
@ -38,7 +38,7 @@ typedef struct GridPaintMaskData {
* there we only have one ptex.
*/
PolyCornerIndex *ptex_poly_corner;
} GridPaintMaskData;
};
static int mask_get_grid_and_coord(SubdivCCGMaskEvaluator *mask_evaluator,
const int ptex_face_index,
@ -48,7 +48,7 @@ static int mask_get_grid_and_coord(SubdivCCGMaskEvaluator *mask_evaluator,
float *grid_u,
float *grid_v)
{
GridPaintMaskData *data = mask_evaluator->user_data;
GridPaintMaskData *data = static_cast<GridPaintMaskData *>(mask_evaluator->user_data);
const PolyCornerIndex *poly_corner = &data->ptex_poly_corner[ptex_face_index];
const MPoly *poly = &data->mpoly[poly_corner->poly_index];
const int start_grid_index = poly->loopstart + poly_corner->corner;
@ -70,7 +70,7 @@ BLI_INLINE float read_mask_grid(const GridPaintMask *mask_grid,
const float grid_u,
const float grid_v)
{
if (mask_grid->data == NULL) {
if (mask_grid->data == nullptr) {
return 0;
}
const int grid_size = BKE_subdiv_grid_size_from_level(mask_grid->level);
@ -92,7 +92,7 @@ static float eval_mask(SubdivCCGMaskEvaluator *mask_evaluator,
static void free_mask_data(SubdivCCGMaskEvaluator *mask_evaluator)
{
GridPaintMaskData *data = mask_evaluator->user_data;
GridPaintMaskData *data = static_cast<GridPaintMaskData *>(mask_evaluator->user_data);
MEM_freeN(data->ptex_poly_corner);
MEM_freeN(data);
}
@ -113,12 +113,12 @@ static int count_num_ptex_faces(const Mesh *mesh)
static void mask_data_init_mapping(SubdivCCGMaskEvaluator *mask_evaluator, const Mesh *mesh)
{
GridPaintMaskData *data = mask_evaluator->user_data;
GridPaintMaskData *data = static_cast<GridPaintMaskData *>(mask_evaluator->user_data);
const MPoly *mpoly = BKE_mesh_polys(mesh);
const int num_ptex_faces = count_num_ptex_faces(mesh);
/* Allocate memory. */
data->ptex_poly_corner = MEM_malloc_arrayN(
num_ptex_faces, sizeof(*data->ptex_poly_corner), "ptex poly corner");
data->ptex_poly_corner = static_cast<PolyCornerIndex *>(
MEM_malloc_arrayN(num_ptex_faces, sizeof(*data->ptex_poly_corner), __func__));
/* Fill in offsets. */
int ptex_face_index = 0;
PolyCornerIndex *ptex_poly_corner = data->ptex_poly_corner;
@ -141,9 +141,10 @@ static void mask_data_init_mapping(SubdivCCGMaskEvaluator *mask_evaluator, const
static void mask_init_data(SubdivCCGMaskEvaluator *mask_evaluator, const Mesh *mesh)
{
GridPaintMaskData *data = mask_evaluator->user_data;
GridPaintMaskData *data = static_cast<GridPaintMaskData *>(mask_evaluator->user_data);
data->mpoly = BKE_mesh_polys(mesh);
data->grid_paint_mask = CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
data->grid_paint_mask = static_cast<const GridPaintMask *>(
CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK));
mask_data_init_mapping(mask_evaluator, mesh);
}
@ -153,8 +154,7 @@ static void mask_init_functions(SubdivCCGMaskEvaluator *mask_evaluator)
mask_evaluator->free = free_mask_data;
}
bool BKE_subdiv_ccg_mask_init_from_paint(SubdivCCGMaskEvaluator *mask_evaluator,
const struct Mesh *mesh)
bool BKE_subdiv_ccg_mask_init_from_paint(SubdivCCGMaskEvaluator *mask_evaluator, const Mesh *mesh)
{
if (!CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK)) {
return false;

8
source/blender/blenkernel/intern/subdiv_ccg_material.c → source/blender/blenkernel/intern/subdiv_ccg_material.cc
View File

@ -13,11 +13,11 @@
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
typedef struct CCGMaterialFromMeshData {
struct CCGMaterialFromMeshData {
const Mesh *mesh;
const MPoly *polys;
const int *material_indices;
} CCGMaterialFromMeshData;
};
static DMFlagMat subdiv_ccg_material_flags_eval(
SubdivCCGMaterialFlagsEvaluator *material_flags_evaluator, const int coarse_face_index)
@ -40,8 +40,8 @@ static void subdiv_ccg_material_flags_free(
void BKE_subdiv_ccg_material_flags_init_from_mesh(
SubdivCCGMaterialFlagsEvaluator *material_flags_evaluator, const Mesh *mesh)
{
CCGMaterialFromMeshData *data = MEM_mallocN(sizeof(CCGMaterialFromMeshData),
"ccg material eval");
CCGMaterialFromMeshData *data = static_cast<CCGMaterialFromMeshData *>(
MEM_mallocN(sizeof(CCGMaterialFromMeshData), __func__));
data->mesh = mesh;
data->material_indices = (const int *)CustomData_get_layer_named(
&mesh->pdata, CD_PROP_INT32, "material_index");

2
source/blender/blenkernel/intern/subdiv_converter.c → source/blender/blenkernel/intern/subdiv_converter.cc
View File

@ -11,7 +11,7 @@
#include "opensubdiv_converter_capi.h"
void BKE_subdiv_converter_free(struct OpenSubdiv_Converter *converter)
void BKE_subdiv_converter_free(OpenSubdiv_Converter *converter)
{
if (converter->freeUserData) {
converter->freeUserData(converter);

8
source/blender/blenkernel/intern/subdiv_converter.h
View File

@ -9,6 +9,10 @@
#include "BKE_subdiv.h"
#ifdef __cplusplus
extern "C" {
#endif
/* NOTE: Was initially used to get proper enumerator types, but this makes
* it tricky to compile without OpenSubdiv. */
/* #include "opensubdiv_converter_capi.h" */
@ -34,3 +38,7 @@ int BKE_subdiv_converter_vtx_boundary_interpolation_from_settings(const SubdivSe
/* TODO(sergey): Find a way to make it OpenSubdiv_FVarLinearInterpolation,
* without breaking compilation without OpenSubdiv. */
int BKE_subdiv_converter_fvar_linear_from_settings(const SubdivSettings *settings);
#ifdef __cplusplus
}
#endif

75
source/blender/blenkernel/intern/subdiv_converter_mesh.c → source/blender/blenkernel/intern/subdiv_converter_mesh.cc
View File

@ -7,7 +7,7 @@
#include "subdiv_converter.h"
#include <string.h>
#include <cstring>
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
@ -31,7 +31,7 @@
* This forces Catmark scheme with all edges marked as infinitely sharp. */
#define BUGGY_SIMPLE_SCHEME_WORKAROUND 1
typedef struct ConverterStorage {
struct ConverterStorage {
SubdivSettings settings;
const Mesh *mesh;
const float (*vert_positions)[3];
@ -66,7 +66,7 @@ typedef struct ConverterStorage {
/* Number of non-loose elements. */
int num_manifold_vertices;
int num_manifold_edges;
} ConverterStorage;
};
static OpenSubdiv_SchemeType get_scheme_type(const OpenSubdiv_Converter *converter)
{
@ -74,7 +74,7 @@ static OpenSubdiv_SchemeType get_scheme_type(const OpenSubdiv_Converter *convert
(void)converter;
return OSD_SCHEME_CATMARK;
#else
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
if (storage->settings.is_simple) {
return OSD_SCHEME_BILINEAR;
}
@ -85,45 +85,47 @@ static OpenSubdiv_SchemeType get_scheme_type(const OpenSubdiv_Converter *convert
}
static OpenSubdiv_VtxBoundaryInterpolation get_vtx_boundary_interpolation(
const struct OpenSubdiv_Converter *converter)
const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
return BKE_subdiv_converter_vtx_boundary_interpolation_from_settings(&storage->settings);
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return OpenSubdiv_VtxBoundaryInterpolation(
BKE_subdiv_converter_vtx_boundary_interpolation_from_settings(&storage->settings));
}
static OpenSubdiv_FVarLinearInterpolation get_fvar_linear_interpolation(
const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
return BKE_subdiv_converter_fvar_linear_from_settings(&storage->settings);
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return OpenSubdiv_FVarLinearInterpolation(
BKE_subdiv_converter_fvar_linear_from_settings(&storage->settings));
}
static bool specifies_full_topology(const OpenSubdiv_Converter *UNUSED(converter))
static bool specifies_full_topology(const OpenSubdiv_Converter * /*converter*/)
{
return false;
}
static int get_num_faces(const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return storage->mesh->totpoly;
}
static int get_num_edges(const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return storage->num_manifold_edges;
}
static int get_num_vertices(const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return storage->num_manifold_vertices;
}
static int get_num_face_vertices(const OpenSubdiv_Converter *converter, int manifold_face_index)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return storage->polys[manifold_face_index].totloop;
}
@ -131,7 +133,7 @@ static void get_face_vertices(const OpenSubdiv_Converter *converter,
int manifold_face_index,
int *manifold_face_vertices)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
const MPoly *poly = &storage->polys[manifold_face_index];
const MLoop *mloop = storage->loops;
for (int corner = 0; corner < poly->totloop; corner++) {
@ -144,7 +146,7 @@ static void get_edge_vertices(const OpenSubdiv_Converter *converter,
int manifold_edge_index,
int *manifold_edge_vertices)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
const int edge_index = storage->manifold_edge_index_reverse[manifold_edge_index];
const MEdge *edge = &storage->edges[edge_index];
manifold_edge_vertices[0] = storage->manifold_vertex_index[edge->v1];
@ -153,7 +155,7 @@ static void get_edge_vertices(const OpenSubdiv_Converter *converter,
static float get_edge_sharpness(const OpenSubdiv_Converter *converter, int manifold_edge_index)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
#if BUGGY_SIMPLE_SCHEME_WORKAROUND
if (storage->settings.is_simple) {
return 10.0f;
@ -169,7 +171,7 @@ static float get_edge_sharpness(const OpenSubdiv_Converter *converter, int manif
static bool is_infinite_sharp_vertex(const OpenSubdiv_Converter *converter,
int manifold_vertex_index)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
#if BUGGY_SIMPLE_SCHEME_WORKAROUND
if (storage->settings.is_simple) {
return true;
@ -181,7 +183,7 @@ static bool is_infinite_sharp_vertex(const OpenSubdiv_Converter *converter,
static float get_vertex_sharpness(const OpenSubdiv_Converter *converter, int manifold_vertex_index)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
if (!storage->settings.use_creases || storage->cd_vertex_crease == NULL) {
return 0.0f;
}
@ -191,23 +193,24 @@ static float get_vertex_sharpness(const OpenSubdiv_Converter *converter, int man
static int get_num_uv_layers(const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
const Mesh *mesh = storage->mesh;
return CustomData_number_of_layers(&mesh->ldata, CD_PROP_FLOAT2);
}
static void precalc_uv_layer(const OpenSubdiv_Converter *converter, const int layer_index)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
const Mesh *mesh = storage->mesh;
const float(*mloopuv)[2] = CustomData_get_layer_n(&mesh->ldata, CD_PROP_FLOAT2, layer_index);
const float(*mloopuv)[2] = static_cast<const float(*)[2]>(
CustomData_get_layer_n(&mesh->ldata, CD_PROP_FLOAT2, layer_index));
const int num_poly = mesh->totpoly;
const int num_vert = mesh->totvert;
const float limit[2] = {STD_UV_CONNECT_LIMIT, STD_UV_CONNECT_LIMIT};
/* Initialize memory required for the operations. */
if (storage->loop_uv_indices == NULL) {
storage->loop_uv_indices = MEM_malloc_arrayN(
mesh->totloop, sizeof(int), "loop uv vertex index");
storage->loop_uv_indices = static_cast<int *>(
MEM_malloc_arrayN(mesh->totloop, sizeof(int), "loop uv vertex index"));
}
UvVertMap *uv_vert_map = BKE_mesh_uv_vert_map_create(
storage->polys,
@ -241,13 +244,13 @@ static void precalc_uv_layer(const OpenSubdiv_Converter *converter, const int la
BKE_mesh_uv_vert_map_free(uv_vert_map);
}
static void finish_uv_layer(const OpenSubdiv_Converter *UNUSED(converter))
static void finish_uv_layer(const OpenSubdiv_Converter * /*converter*/)
{
}
static int get_num_uvs(const OpenSubdiv_Converter *converter)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
return storage->num_uv_coordinates;
}
@ -255,14 +258,14 @@ static int get_face_corner_uv_index(const OpenSubdiv_Converter *converter,
const int face_index,
const int corner)
{
ConverterStorage *storage = converter->user_data;
ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
const MPoly *mp = &storage->polys[face_index];
return storage->loop_uv_indices[mp->loopstart + corner];
}
static void free_user_data(const OpenSubdiv_Converter *converter)
{
ConverterStorage *user_data = converter->user_data;
ConverterStorage *user_data = static_cast<ConverterStorage *>(converter->user_data);
MEM_SAFE_FREE(user_data->loop_uv_indices);
MEM_freeN(user_data->manifold_vertex_index);
MEM_freeN(user_data->infinite_sharp_vertices_map);
@ -315,11 +318,12 @@ static void initialize_manifold_index_array(const BLI_bitmap *used_map,
{
int *indices = NULL;
if (r_indices != NULL) {
indices = MEM_malloc_arrayN(num_elements, sizeof(int), "manifold indices");
indices = static_cast<int *>(MEM_malloc_arrayN(num_elements, sizeof(int), "manifold indices"));
}
int *indices_reverse = NULL;
if (r_indices_reverse != NULL) {
indices_reverse = MEM_malloc_arrayN(num_elements, sizeof(int), "manifold indices reverse");
indices_reverse = static_cast<int *>(
MEM_malloc_arrayN(num_elements, sizeof(int), "manifold indices reverse"));
}
int offset = 0;
for (int i = 0; i < num_elements; i++) {
@ -392,21 +396,24 @@ static void init_user_data(OpenSubdiv_Converter *converter,
const SubdivSettings *settings,
const Mesh *mesh)
{
ConverterStorage *user_data = MEM_mallocN(sizeof(ConverterStorage), __func__);
ConverterStorage *user_data = static_cast<ConverterStorage *>(
MEM_mallocN(sizeof(ConverterStorage), __func__));
user_data->settings = *settings;
user_data->mesh = mesh;
user_data->vert_positions = BKE_mesh_vert_positions(mesh);
user_data->edges = BKE_mesh_edges(mesh);
user_data->polys = BKE_mesh_polys(mesh);
user_data->loops = BKE_mesh_loops(mesh);
user_data->cd_vertex_crease = CustomData_get_layer(&mesh->vdata, CD_CREASE);
user_data->cd_edge_crease = CustomData_get_layer(&mesh->edata, CD_CREASE);
user_data->cd_vertex_crease = static_cast<const float *>(
CustomData_get_layer(&mesh->vdata, CD_CREASE));
user_data->cd_edge_crease = static_cast<const float *>(
CustomData_get_layer(&mesh->edata, CD_CREASE));
user_data->loop_uv_indices = NULL;
initialize_manifold_indices(user_data);
converter->user_data = user_data;
}
void BKE_subdiv_converter_init_for_mesh(struct OpenSubdiv_Converter *converter,
void BKE_subdiv_converter_init_for_mesh(OpenSubdiv_Converter *converter,
const SubdivSettings *settings,
const Mesh *mesh)
{

51
source/blender/blenkernel/intern/subdiv_deform.c → source/blender/blenkernel/intern/subdiv_deform.cc
View File

@ -27,7 +27,7 @@
/** \name Subdivision context
* \{ */
typedef struct SubdivDeformContext {
struct SubdivDeformContext {
const Mesh *coarse_mesh;
Subdiv *subdiv;
@ -45,15 +45,15 @@ typedef struct SubdivDeformContext {
int *accumulated_counters;
bool have_displacement;
} SubdivDeformContext;
};
static void subdiv_mesh_prepare_accumulator(SubdivDeformContext *ctx, int num_vertices)
{
if (!ctx->have_displacement) {
return;
}
ctx->accumulated_counters = MEM_calloc_arrayN(
num_vertices, sizeof(*ctx->accumulated_counters), "subdiv accumulated counters");
ctx->accumulated_counters = static_cast<int *>(
MEM_calloc_arrayN(num_vertices, sizeof(*ctx->accumulated_counters), __func__));
}
static void subdiv_mesh_context_free(SubdivDeformContext *ctx)
@ -98,46 +98,47 @@ static void subdiv_accumulate_vertex_displacement(SubdivDeformContext *ctx,
* \{ */
static bool subdiv_mesh_topology_info(const SubdivForeachContext *foreach_context,
const int UNUSED(num_vertices),
const int UNUSED(num_edges),
const int UNUSED(num_loops),
const int UNUSED(num_polygons),
const int *UNUSED(subdiv_polygon_offset))
const int /*num_vertices*/,
const int /*num_edges*/,
const int /*num_loops*/,
const int /*num_polygons*/,
const int * /*subdiv_polygon_offset*/)
{
SubdivDeformContext *subdiv_context = foreach_context->user_data;
SubdivDeformContext *subdiv_context = static_cast<SubdivDeformContext *>(
foreach_context->user_data);
subdiv_mesh_prepare_accumulator(subdiv_context, subdiv_context->coarse_mesh->totvert);
return true;
}
static void subdiv_mesh_vertex_every_corner(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int ptex_face_index,
const float u,
const float v,
const int coarse_vertex_index,
const int UNUSED(coarse_poly_index),
const int UNUSED(coarse_corner),
const int UNUSED(subdiv_vertex_index))
const int /*coarse_poly_index*/,
const int /*coarse_corner*/,
const int /*subdiv_vertex_index*/)
{
SubdivDeformContext *ctx = foreach_context->user_data;
SubdivDeformContext *ctx = static_cast<SubdivDeformContext *>(foreach_context->user_data);
subdiv_accumulate_vertex_displacement(ctx, ptex_face_index, u, v, coarse_vertex_index);
}
static void subdiv_mesh_vertex_corner(const SubdivForeachContext *foreach_context,
void *UNUSED(tls),
void * /*tls*/,
const int ptex_face_index,
const float u,
const float v,
const int coarse_vertex_index,
const int UNUSED(coarse_poly_index),
const int UNUSED(coarse_corner),
const int UNUSED(subdiv_vertex_index))
const int /*coarse_poly_index*/,
const int /*coarse_corner*/,
const int /*subdiv_vertex_index*/)
{
SubdivDeformContext *ctx = foreach_context->user_data;
SubdivDeformContext *ctx = static_cast<SubdivDeformContext *>(foreach_context->user_data);
BLI_assert(coarse_vertex_index != ORIGINDEX_NONE);
BLI_assert(coarse_vertex_index < ctx->num_verts);
float inv_num_accumulated = 1.0f;
if (ctx->accumulated_counters != NULL) {
if (ctx->accumulated_counters != nullptr) {
inv_num_accumulated = 1.0f / ctx->accumulated_counters[coarse_vertex_index];
}
/* Displacement is accumulated in subdiv vertex position.
@ -179,8 +180,8 @@ static void setup_foreach_callbacks(const SubdivDeformContext *subdiv_context,
/** \name Public entry point
* \{ */
void BKE_subdiv_deform_coarse_vertices(struct Subdiv *subdiv,
const struct Mesh *coarse_mesh,
void BKE_subdiv_deform_coarse_vertices(Subdiv *subdiv,
const Mesh *coarse_mesh,
float (*vertex_cos)[3],
int num_verts)
{
@ -188,7 +189,7 @@ void BKE_subdiv_deform_coarse_vertices(struct Subdiv *subdiv,
/* Make sure evaluator is up to date with possible new topology, and that
* is refined for the new positions of coarse vertices. */
if (!BKE_subdiv_eval_begin_from_mesh(
subdiv, coarse_mesh, vertex_cos, SUBDIV_EVALUATOR_TYPE_CPU, NULL)) {
subdiv, coarse_mesh, vertex_cos, SUBDIV_EVALUATOR_TYPE_CPU, nullptr)) {
/* This could happen in two situations:
* - OpenSubdiv is disabled.
* - Something totally bad happened, and OpenSubdiv rejected our
@ -206,7 +207,7 @@ void BKE_subdiv_deform_coarse_vertices(struct Subdiv *subdiv,
subdiv_context.subdiv = subdiv;
subdiv_context.vertex_cos = vertex_cos;
subdiv_context.num_verts = num_verts;
subdiv_context.have_displacement = (subdiv->displacement_evaluator != NULL);
subdiv_context.have_displacement = (subdiv->displacement_evaluator != nullptr);
SubdivForeachContext foreach_context;
setup_foreach_callbacks(&subdiv_context, &foreach_context);

6
source/blender/blenkernel/intern/subdiv_displacement.c → source/blender/blenkernel/intern/subdiv_displacement.cc
View File

@ -13,12 +13,12 @@
void BKE_subdiv_displacement_detach(Subdiv *subdiv)
{
if (subdiv->displacement_evaluator == NULL) {
if (subdiv->displacement_evaluator == nullptr) {
return;
}
if (subdiv->displacement_evaluator->free != NULL) {
if (subdiv->displacement_evaluator->free != nullptr) {
subdiv->displacement_evaluator->free(subdiv->displacement_evaluator);
}
MEM_freeN(subdiv->displacement_evaluator);
subdiv->displacement_evaluator = NULL;
subdiv->displacement_evaluator = nullptr;
}

56
source/blender/blenkernel/intern/subdiv_displacement_multires.c → source/blender/blenkernel/intern/subdiv_displacement_multires.cc
View File

@ -5,7 +5,7 @@
* \ingroup bke
*/
#include <math.h>
#include <cmath>
#include "BKE_subdiv.h"
@ -24,12 +24,12 @@
#include "MEM_guardedalloc.h"
typedef struct PolyCornerIndex {
struct PolyCornerIndex {
int poly_index;
int corner;
} PolyCornerIndex;
};
typedef struct MultiresDisplacementData {
struct MultiresDisplacementData {
Subdiv *subdiv;
int grid_size;
/* Mesh is used to read external displacement. */
@ -49,7 +49,7 @@ typedef struct MultiresDisplacementData {
/* Sanity check, is used in debug builds.
* Controls that initialize() was called prior to eval_displacement(). */
bool is_initialized;
} MultiresDisplacementData;
};
/* Denotes which grid to use to average value of the displacement read from the
* grid which corresponds to the ptex face. */
@ -68,7 +68,8 @@ static int displacement_get_grid_and_coord(SubdivDisplacement *displacement,
float *grid_u,
float *grid_v)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
const PolyCornerIndex *poly_corner = &data->ptex_poly_corner[ptex_face_index];
const MPoly *poly = &data->mpoly[poly_corner->poly_index];
const int start_grid_index = poly->loopstart + poly_corner->corner;
@ -91,7 +92,8 @@ static const MDisps *displacement_get_other_grid(SubdivDisplacement *displacemen
const int corner,
const int corner_delta)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
const PolyCornerIndex *poly_corner = &data->ptex_poly_corner[ptex_face_index];
const MPoly *poly = &data->mpoly[poly_corner->poly_index];
const int effective_corner = (poly->totloop == 4) ? corner : poly_corner->corner;
@ -105,7 +107,7 @@ BLI_INLINE eAverageWith read_displacement_grid(const MDisps *displacement_grid,
const float grid_v,
float r_tangent_D[3])
{
if (displacement_grid->disps == NULL) {
if (displacement_grid->disps == nullptr) {
zero_v3(r_tangent_D);
return AVERAGE_WITH_NONE;
}
@ -216,7 +218,8 @@ static void average_with_other(SubdivDisplacement *displacement,
const int corner_delta,
float r_D[3])
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
const MDisps *other_displacement_grid = displacement_get_other_grid(
displacement, ptex_face_index, corner, corner_delta);
int other_ptex_face_index, other_corner_index;
@ -239,11 +242,12 @@ static void average_with_other(SubdivDisplacement *displacement,
static void average_with_all(SubdivDisplacement *displacement,
const int ptex_face_index,
const int corner,
const float UNUSED(grid_u),
const float UNUSED(grid_v),
const float /*grid_u*/,
const float /*grid_v*/,
float r_D[3])
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
const PolyCornerIndex *poly_corner = &data->ptex_poly_corner[ptex_face_index];
const MPoly *poly = &data->mpoly[poly_corner->poly_index];
const int num_corners = poly->totloop;
@ -256,7 +260,7 @@ static void average_with_next(SubdivDisplacement *displacement,
const int ptex_face_index,
const int corner,
const float grid_u,
const float UNUSED(grid_v),
const float /*grid_v*/,
float r_D[3])
{
average_with_other(displacement, ptex_face_index, corner, 0.0f, grid_u, 1, r_D);
@ -265,7 +269,7 @@ static void average_with_next(SubdivDisplacement *displacement,
static void average_with_prev(SubdivDisplacement *displacement,
const int ptex_face_index,
const int corner,
const float UNUSED(grid_u),
const float /*grid_u*/,
const float grid_v,
float r_D[3])
{
@ -314,7 +318,8 @@ static int displacement_get_face_corner(MultiresDisplacementData *data,
static void initialize(SubdivDisplacement *displacement)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
multiresModifier_ensure_external_read(data->mesh, data->mmd);
data->is_initialized = true;
}
@ -327,7 +332,8 @@ static void eval_displacement(SubdivDisplacement *displacement,
const float dPdv[3],
float r_D[3])
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
BLI_assert(data->is_initialized);
const int grid_size = data->grid_size;
/* Get displacement in tangent space. */
@ -351,7 +357,8 @@ static void eval_displacement(SubdivDisplacement *displacement,
static void free_displacement(SubdivDisplacement *displacement)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
MEM_freeN(data->ptex_poly_corner);
MEM_freeN(data);
}
@ -371,12 +378,13 @@ static int count_num_ptex_faces(const Mesh *mesh)
static void displacement_data_init_mapping(SubdivDisplacement *displacement, const Mesh *mesh)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
const MPoly *mpoly = BKE_mesh_polys(mesh);
const int num_ptex_faces = count_num_ptex_faces(mesh);
/* Allocate memory. */
data->ptex_poly_corner = MEM_malloc_arrayN(
num_ptex_faces, sizeof(*data->ptex_poly_corner), "ptex poly corner");
data->ptex_poly_corner = static_cast<PolyCornerIndex *>(
MEM_malloc_arrayN(num_ptex_faces, sizeof(*data->ptex_poly_corner), "ptex poly corner"));
/* Fill in offsets. */
int ptex_face_index = 0;
PolyCornerIndex *ptex_poly_corner = data->ptex_poly_corner;
@ -402,13 +410,14 @@ static void displacement_init_data(SubdivDisplacement *displacement,
Mesh *mesh,
const MultiresModifierData *mmd)
{
MultiresDisplacementData *data = displacement->user_data;
MultiresDisplacementData *data = static_cast<MultiresDisplacementData *>(
displacement->user_data);
data->subdiv = subdiv;
data->grid_size = BKE_subdiv_grid_size_from_level(mmd->totlvl);
data->mesh = mesh;
data->mmd = mmd;
data->mpoly = BKE_mesh_polys(mesh);
data->mdisps = CustomData_get_layer(&mesh->ldata, CD_MDISPS);
data->mdisps = static_cast<const MDisps *>(CustomData_get_layer(&mesh->ldata, CD_MDISPS));
data->face_ptex_offset = BKE_subdiv_face_ptex_offset_get(subdiv);
data->is_initialized = false;
displacement_data_init_mapping(displacement, mesh);
@ -433,8 +442,7 @@ void BKE_subdiv_displacement_attach_from_multires(Subdiv *subdiv,
return;
}
/* Allocate all required memory. */
SubdivDisplacement *displacement = MEM_callocN(sizeof(SubdivDisplacement),
"multires displacement");
SubdivDisplacement *displacement = MEM_cnew<SubdivDisplacement>("multires displacement");
displacement->user_data = MEM_callocN(sizeof(MultiresDisplacementData),
"multires displacement data");
displacement_init_data(displacement, subdiv, mesh, mmd);

44
source/blender/blenkernel/intern/subdiv_eval.c → source/blender/blenkernel/intern/subdiv_eval.cc
View File

@ -53,19 +53,19 @@ bool BKE_subdiv_eval_begin(Subdiv *subdiv,
const OpenSubdiv_EvaluatorSettings *settings)
{
BKE_subdiv_stats_reset(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
if (subdiv->topology_refiner == NULL) {
if (subdiv->topology_refiner == nullptr) {
/* Happens on input mesh with just loose geometry,
* or when OpenSubdiv is disabled */
return false;
}
if (subdiv->evaluator == NULL) {
if (subdiv->evaluator == nullptr) {
eOpenSubdivEvaluator opensubdiv_evaluator_type =
opensubdiv_evalutor_from_subdiv_evaluator_type(evaluator_type);
BKE_subdiv_stats_begin(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
subdiv->evaluator = openSubdiv_createEvaluatorFromTopologyRefiner(
subdiv->topology_refiner, opensubdiv_evaluator_type, evaluator_cache);
BKE_subdiv_stats_end(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
if (subdiv->evaluator == NULL) {
if (subdiv->evaluator == nullptr) {
return false;
}
}
@ -97,7 +97,8 @@ static void set_coarse_positions(Subdiv *subdiv,
}
}
/* Use a temporary buffer so we do not upload vertices one at a time to the GPU. */
float(*buffer)[3] = MEM_mallocN(sizeof(float[3]) * mesh->totvert, "subdiv tmp coarse positions");
float(*buffer)[3] = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(float[3]) * mesh->totvert, __func__));
int manifold_vertex_count = 0;
for (int vertex_index = 0, manifold_vertex_index = 0; vertex_index < mesh->totvert;
vertex_index++) {
@ -105,7 +106,7 @@ static void set_coarse_positions(Subdiv *subdiv,
continue;
}
const float *vertex_co;
if (coarse_vertex_cos != NULL) {
if (coarse_vertex_cos != nullptr) {
vertex_co = coarse_vertex_cos[vertex_index];
}
else {
@ -122,20 +123,20 @@ static void set_coarse_positions(Subdiv *subdiv,
}
/* Context which is used to fill face varying data in parallel. */
typedef struct FaceVaryingDataFromUVContext {
struct FaceVaryingDataFromUVContext {
OpenSubdiv_TopologyRefiner *topology_refiner;
const Mesh *mesh;
const MPoly *polys;
const float (*mloopuv)[2];
float (*buffer)[2];
int layer_index;
} FaceVaryingDataFromUVContext;
};
static void set_face_varying_data_from_uv_task(void *__restrict userdata,
const int face_index,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
FaceVaryingDataFromUVContext *ctx = userdata;
FaceVaryingDataFromUVContext *ctx = static_cast<FaceVaryingDataFromUVContext *>(userdata);
OpenSubdiv_TopologyRefiner *topology_refiner = ctx->topology_refiner;
const int layer_index = ctx->layer_index;
const MPoly *mpoly = &ctx->polys[face_index];
@ -164,7 +165,8 @@ static void set_face_varying_data_from_uv(Subdiv *subdiv,
const int num_fvar_values = topology_refiner->getNumFVarValues(topology_refiner, layer_index);
/* Use a temporary buffer so we do not upload UVs one at a time to the GPU. */
float(*buffer)[2] = MEM_mallocN(sizeof(float[2]) * num_fvar_values, "temp UV storage");
float(*buffer)[2] = static_cast<float(*)[2]>(
MEM_mallocN(sizeof(float[2]) * num_fvar_values, __func__));
FaceVaryingDataFromUVContext ctx;
ctx.topology_refiner = topology_refiner;
@ -188,8 +190,10 @@ static void set_face_varying_data_from_uv(Subdiv *subdiv,
static void set_vertex_data_from_orco(Subdiv *subdiv, const Mesh *mesh)
{
const float(*orco)[3] = CustomData_get_layer(&mesh->vdata, CD_ORCO);
const float(*cloth_orco)[3] = CustomData_get_layer(&mesh->vdata, CD_CLOTH_ORCO);
const float(*orco)[3] = static_cast<const float(*)[3]>(
CustomData_get_layer(&mesh->vdata, CD_ORCO));
const float(*cloth_orco)[3] = static_cast<const float(*)[3]>(
CustomData_get_layer(&mesh->vdata, CD_CLOTH_ORCO));
if (orco || cloth_orco) {
OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
@ -241,7 +245,7 @@ bool BKE_subdiv_eval_refine_from_mesh(Subdiv *subdiv,
const Mesh *mesh,
const float (*coarse_vertex_cos)[3])
{
if (subdiv->evaluator == NULL) {
if (subdiv->evaluator == nullptr) {
/* NOTE: This situation is supposed to be handled by begin(). */
BLI_assert_msg(0, "Is not supposed to happen");
return false;
@ -251,7 +255,8 @@ bool BKE_subdiv_eval_refine_from_mesh(Subdiv *subdiv,
/* Set face-varying data to UV maps. */
const int num_uv_layers = CustomData_number_of_layers(&mesh->ldata, CD_PROP_FLOAT2);
for (int layer_index = 0; layer_index < num_uv_layers; layer_index++) {
const float(*mloopuv)[2] = CustomData_get_layer_n(&mesh->ldata, CD_PROP_FLOAT2, layer_index);
const float(*mloopuv)[2] = static_cast<const float(*)[2]>(
CustomData_get_layer_n(&mesh->ldata, CD_PROP_FLOAT2, layer_index));
set_face_varying_data_from_uv(subdiv, mesh, mloopuv, layer_index);
}
/* Set vertex data to orco. */
@ -265,10 +270,10 @@ bool BKE_subdiv_eval_refine_from_mesh(Subdiv *subdiv,
void BKE_subdiv_eval_init_displacement(Subdiv *subdiv)
{
if (subdiv->displacement_evaluator == NULL) {
if (subdiv->displacement_evaluator == nullptr) {
return;
}
if (subdiv->displacement_evaluator->initialize == NULL) {
if (subdiv->displacement_evaluator->initialize == nullptr) {
return;
}
subdiv->displacement_evaluator->initialize(subdiv->displacement_evaluator);
@ -281,7 +286,8 @@ void BKE_subdiv_eval_init_displacement(Subdiv *subdiv)
void BKE_subdiv_eval_limit_point(
Subdiv *subdiv, const int ptex_face_index, const float u, const float v, float r_P[3])
{
BKE_subdiv_eval_limit_point_and_derivatives(subdiv, ptex_face_index, u, v, r_P, NULL, NULL);
BKE_subdiv_eval_limit_point_and_derivatives(
subdiv, ptex_face_index, u, v, r_P, nullptr, nullptr);
}
void BKE_subdiv_eval_limit_point_and_derivatives(Subdiv *subdiv,
@ -305,7 +311,7 @@ void BKE_subdiv_eval_limit_point_and_derivatives(Subdiv *subdiv,
* which there must be proper derivatives. This might break continuity of normals, but is better
* that giving totally unusable derivatives. */
if (r_dPdu != NULL && r_dPdv != NULL) {
if (r_dPdu != nullptr && r_dPdv != nullptr) {
if ((is_zero_v3(r_dPdu) || is_zero_v3(r_dPdv)) || equals_v3v3(r_dPdu, r_dPdv)) {
subdiv->evaluator->evaluateLimit(subdiv->evaluator,
ptex_face_index,
@ -356,7 +362,7 @@ void BKE_subdiv_eval_displacement(Subdiv *subdiv,
const float dPdv[3],
float r_D[3])
{
if (subdiv->displacement_evaluator == NULL) {
if (subdiv->displacement_evaluator == nullptr) {
zero_v3(r_D);
return;
}

64
source/blender/blenkernel/intern/subdiv_foreach.c → source/blender/blenkernel/intern/subdiv_foreach.cc
View File

@ -65,7 +65,7 @@ BLI_INLINE int ptex_face_resolution_get(const MPoly *poly, int resolution)
/** \name Context which is passed to all threaded tasks
* \{ */
typedef struct SubdivForeachTaskContext {
struct SubdivForeachTaskContext {
const Mesh *coarse_mesh;
const MEdge *coarse_edges;
const MPoly *coarse_polys;
@ -109,7 +109,7 @@ typedef struct SubdivForeachTaskContext {
* were already evaluated.
*/
BLI_bitmap *coarse_edges_used_map;
} SubdivForeachTaskContext;
};
/** \} */
@ -120,7 +120,7 @@ typedef struct SubdivForeachTaskContext {
static void *subdiv_foreach_tls_alloc(SubdivForeachTaskContext *ctx)
{
const SubdivForeachContext *foreach_context = ctx->foreach_context;
void *tls = NULL;
void *tls = nullptr;
if (foreach_context->user_data_tls_size != 0) {
tls = MEM_mallocN(foreach_context->user_data_tls_size, "tls");
memcpy(tls, foreach_context->user_data_tls, foreach_context->user_data_tls_size);
@ -130,10 +130,10 @@ static void *subdiv_foreach_tls_alloc(SubdivForeachTaskContext *ctx)
static void subdiv_foreach_tls_free(SubdivForeachTaskContext *ctx, void *tls)
{
if (tls == NULL) {
if (tls == nullptr) {
return;
}
if (ctx->foreach_context != NULL) {
if (ctx->foreach_context != nullptr) {
ctx->foreach_context->user_data_tls_free(tls);
}
MEM_freeN(tls);
@ -260,12 +260,12 @@ static void subdiv_foreach_ctx_init(Subdiv *subdiv, SubdivForeachTaskContext *ct
/* Allocate maps and offsets. */
ctx->coarse_vertices_used_map = BLI_BITMAP_NEW(coarse_mesh->totvert, "vertices used map");
ctx->coarse_edges_used_map = BLI_BITMAP_NEW(coarse_mesh->totedge, "edges used map");
ctx->subdiv_vertex_offset = MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_vertex_offset), "vertex_offset");
ctx->subdiv_edge_offset = MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_edge_offset), "subdiv_edge_offset");
ctx->subdiv_polygon_offset = MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_polygon_offset), "subdiv_edge_offset");
ctx->subdiv_vertex_offset = static_cast<int *>(MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_vertex_offset), "vertex_offset"));
ctx->subdiv_edge_offset = static_cast<int *>(MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_edge_offset), "subdiv_edge_offset"));
ctx->subdiv_polygon_offset = static_cast<int *>(MEM_malloc_arrayN(
coarse_mesh->totpoly, sizeof(*ctx->subdiv_polygon_offset), "subdiv_edge_offset"));
/* Initialize all offsets. */
subdiv_foreach_ctx_init_offsets(ctx);
/* Calculate number of geometry in the result subdivision mesh. */
@ -399,7 +399,7 @@ static void subdiv_foreach_every_corner_vertices_special(SubdivForeachTaskContex
static void subdiv_foreach_every_corner_vertices(SubdivForeachTaskContext *ctx, void *tls)
{
if (ctx->foreach_context->vertex_every_corner == NULL) {
if (ctx->foreach_context->vertex_every_corner == nullptr) {
return;
}
const Mesh *coarse_mesh = ctx->coarse_mesh;
@ -576,7 +576,7 @@ static void subdiv_foreach_every_edge_vertices_special(SubdivForeachTaskContext
static void subdiv_foreach_every_edge_vertices(SubdivForeachTaskContext *ctx, void *tls)
{
if (ctx->foreach_context->vertex_every_edge == NULL) {
if (ctx->foreach_context->vertex_every_edge == nullptr) {
return;
}
const Mesh *coarse_mesh = ctx->coarse_mesh;
@ -672,7 +672,7 @@ static void subdiv_foreach_inner_vertices(SubdivForeachTaskContext *ctx,
/* Traverse all vertices which are emitted from given coarse polygon. */
static void subdiv_foreach_vertices(SubdivForeachTaskContext *ctx, void *tls, const int poly_index)
{
if (ctx->foreach_context->vertex_inner != NULL) {
if (ctx->foreach_context->vertex_inner != nullptr) {
subdiv_foreach_inner_vertices(ctx, tls, &ctx->coarse_polys[poly_index]);
}
}
@ -1664,7 +1664,7 @@ static void subdiv_foreach_loose_vertices_task(void *__restrict userdata,
const int coarse_vertex_index,
const TaskParallelTLS *__restrict tls)
{
SubdivForeachTaskContext *ctx = userdata;
SubdivForeachTaskContext *ctx = static_cast<SubdivForeachTaskContext *>(userdata);
if (BLI_BITMAP_TEST_BOOL(ctx->coarse_vertices_used_map, coarse_vertex_index)) {
/* Vertex is not loose, was handled when handling polygons. */
return;
@ -1678,7 +1678,7 @@ static void subdiv_foreach_vertices_of_loose_edges_task(void *__restrict userdat
const int coarse_edge_index,
const TaskParallelTLS *__restrict tls)
{
SubdivForeachTaskContext *ctx = userdata;
SubdivForeachTaskContext *ctx = static_cast<SubdivForeachTaskContext *>(userdata);
if (BLI_BITMAP_TEST_BOOL(ctx->coarse_edges_used_map, coarse_edge_index)) {
/* Vertex is not loose, was handled when handling polygons. */
return;
@ -1720,7 +1720,7 @@ static void subdiv_foreach_vertices_of_loose_edges_task(void *__restrict userdat
static void subdiv_foreach_single_geometry_vertices(SubdivForeachTaskContext *ctx, void *tls)
{
if (ctx->foreach_context->vertex_corner == NULL) {
if (ctx->foreach_context->vertex_corner == nullptr) {
return;
}
const Mesh *coarse_mesh = ctx->coarse_mesh;
@ -1759,10 +1759,10 @@ static void subdiv_foreach_single_thread_tasks(SubdivForeachTaskContext *ctx)
subdiv_foreach_tls_free(ctx, tls);
const SubdivForeachContext *foreach_context = ctx->foreach_context;
const bool is_loose_geometry_tagged = (foreach_context->vertex_every_edge != NULL &&
foreach_context->vertex_every_corner != NULL);
const bool is_loose_geometry_tags_needed = (foreach_context->vertex_loose != NULL ||
foreach_context->vertex_of_loose_edge != NULL);
const bool is_loose_geometry_tagged = (foreach_context->vertex_every_edge != nullptr &&
foreach_context->vertex_every_corner != nullptr);
const bool is_loose_geometry_tags_needed = (foreach_context->vertex_loose != nullptr ||
foreach_context->vertex_of_loose_edge != nullptr);
if (is_loose_geometry_tagged && is_loose_geometry_tags_needed) {
subdiv_foreach_mark_non_loose_geometry(ctx);
}
@ -1772,17 +1772,17 @@ static void subdiv_foreach_task(void *__restrict userdata,
const int poly_index,
const TaskParallelTLS *__restrict tls)
{
SubdivForeachTaskContext *ctx = userdata;
SubdivForeachTaskContext *ctx = static_cast<SubdivForeachTaskContext *>(userdata);
/* Traverse hi-poly vertex coordinates and normals. */
subdiv_foreach_vertices(ctx, tls->userdata_chunk, poly_index);
/* Traverse mesh geometry for the given base poly index. */
if (ctx->foreach_context->edge != NULL) {
if (ctx->foreach_context->edge != nullptr) {
subdiv_foreach_edges(ctx, tls->userdata_chunk, poly_index);
}
if (ctx->foreach_context->loop != NULL) {
if (ctx->foreach_context->loop != nullptr) {
subdiv_foreach_loops(ctx, tls->userdata_chunk, poly_index);
}
if (ctx->foreach_context->poly != NULL) {
if (ctx->foreach_context->poly != nullptr) {
subdiv_foreach_polys(ctx, tls->userdata_chunk, poly_index);
}
}
@ -1791,13 +1791,13 @@ static void subdiv_foreach_boundary_edges_task(void *__restrict userdata,
const int edge_index,
const TaskParallelTLS *__restrict tls)
{
SubdivForeachTaskContext *ctx = userdata;
SubdivForeachTaskContext *ctx = static_cast<SubdivForeachTaskContext *>(userdata);
subdiv_foreach_boundary_edges(ctx, tls->userdata_chunk, edge_index);
}
static void subdiv_foreach_free(const void *__restrict userdata, void *__restrict userdata_chunk)
{
const SubdivForeachTaskContext *ctx = userdata;
const SubdivForeachTaskContext *ctx = static_cast<const SubdivForeachTaskContext *>(userdata);
ctx->foreach_context->user_data_tls_free(userdata_chunk);
}
@ -1814,7 +1814,7 @@ bool BKE_subdiv_foreach_subdiv_geometry(Subdiv *subdiv,
ctx.settings = mesh_settings;
ctx.foreach_context = context;
subdiv_foreach_ctx_init(subdiv, &ctx);
if (context->topology_info != NULL) {
if (context->topology_info != nullptr) {
if (!context->topology_info(context,
ctx.num_subdiv_vertices,
ctx.num_subdiv_edges,
@ -1833,7 +1833,7 @@ bool BKE_subdiv_foreach_subdiv_geometry(Subdiv *subdiv,
parallel_range_settings.userdata_chunk = context->user_data_tls;
parallel_range_settings.userdata_chunk_size = context->user_data_tls_size;
parallel_range_settings.min_iter_per_thread = 1;
if (context->user_data_tls_free != NULL) {
if (context->user_data_tls_free != nullptr) {
parallel_range_settings.func_free = subdiv_foreach_free;
}
@ -1845,21 +1845,21 @@ bool BKE_subdiv_foreach_subdiv_geometry(Subdiv *subdiv,
BLI_task_parallel_range(
0, coarse_mesh->totpoly, &ctx, subdiv_foreach_task, &parallel_range_settings);
if (context->vertex_loose != NULL) {
if (context->vertex_loose != nullptr) {
BLI_task_parallel_range(0,
coarse_mesh->totvert,
&ctx,
subdiv_foreach_loose_vertices_task,
&parallel_range_settings);
}
if (context->vertex_of_loose_edge != NULL) {
if (context->vertex_of_loose_edge != nullptr) {
BLI_task_parallel_range(0,
coarse_mesh->totedge,
&ctx,
subdiv_foreach_vertices_of_loose_edges_task,
&parallel_range_settings);
}
if (context->edge != NULL) {
if (context->edge != nullptr) {
BLI_task_parallel_range(0,
coarse_mesh->totedge,
&ctx,

0
source/blender/blenkernel/intern/subdiv_stats.c → source/blender/blenkernel/intern/subdiv_stats.cc
View File

2
source/blender/blenkernel/intern/subdiv_topology.c → source/blender/blenkernel/intern/subdiv_topology.cc
View File

@ -11,7 +11,7 @@
#include "opensubdiv_topology_refiner_capi.h"
int BKE_subdiv_topology_num_fvar_layers_get(const struct Subdiv *subdiv)
int BKE_subdiv_topology_num_fvar_layers_get(const Subdiv *subdiv)
{
OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
return topology_refiner->getNumFVarChannels(topology_refiner);

386
source/blender/blenkernel/intern/subsurf_ccg.c → source/blender/blenkernel/intern/subsurf_ccg.cc
View File

@ -5,18 +5,11 @@
* \ingroup bke
*/
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
# ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wvla"
# endif
# define USE_DYNSIZE
#endif
#include <float.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include "atomic_ops.h"
@ -36,6 +29,7 @@
#include "BLI_task.h"
#include "BLI_threads.h"
#include "BLI_utildefines.h"
#include "BLI_vector.hh"
#include "BKE_ccg.h"
#include "BKE_cdderivedmesh.h"
@ -49,10 +43,6 @@
#include "BKE_scene.h"
#include "BKE_subsurf.h"
#ifndef USE_DYNSIZE
# include "BLI_array.h"
#endif
#include "CCGSubSurf.h"
/* assumes MLoop's are laid out 4 for each poly, in order */
@ -66,26 +56,26 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
static void *arena_alloc(CCGAllocatorHDL a, int numBytes)
{
return BLI_memarena_alloc(a, numBytes);
return BLI_memarena_alloc(reinterpret_cast<MemArena *>(a), numBytes);
}
static void *arena_realloc(CCGAllocatorHDL a, void *ptr, int newSize, int oldSize)
{
void *p2 = BLI_memarena_alloc(a, newSize);
void *p2 = BLI_memarena_alloc(reinterpret_cast<MemArena *>(a), newSize);
if (ptr) {
memcpy(p2, ptr, oldSize);
}
return p2;
}
static void arena_free(CCGAllocatorHDL UNUSED(a), void *UNUSED(ptr))
static void arena_free(CCGAllocatorHDL /*a*/, void * /*ptr*/)
{
/* do nothing */
}
static void arena_release(CCGAllocatorHDL a)
{
BLI_memarena_free(a);
BLI_memarena_free(reinterpret_cast<MemArena *>(a));
}
typedef enum {
@ -96,6 +86,7 @@ typedef enum {
CCG_ALLOC_MASK = 8,
CCG_SIMPLE_SUBDIV = 16,
} CCGFlags;
ENUM_OPERATORS(CCGFlags, CCG_SIMPLE_SUBDIV);
static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels, int numLayers, CCGFlags flags)
{
@ -111,7 +102,7 @@ static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels, int numLaye
if (prevSS) {
int oldUseAging;
ccgSubSurf_getUseAgeCounts(prevSS, &oldUseAging, NULL, NULL, NULL);
ccgSubSurf_getUseAgeCounts(prevSS, &oldUseAging, nullptr, nullptr, nullptr);
if ((oldUseAging != useAging) ||
(ccgSubSurf_getSimpleSubdiv(prevSS) != !!(flags & CCG_SIMPLE_SUBDIV))) {
@ -153,7 +144,7 @@ static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels, int numLaye
ccgSS = ccgSubSurf_new(&ifc, subdivLevels, &allocatorIFC, allocator);
}
else {
ccgSS = ccgSubSurf_new(&ifc, subdivLevels, NULL, NULL);
ccgSS = ccgSubSurf_new(&ifc, subdivLevels, nullptr, nullptr);
}
if (useAging) {
@ -240,7 +231,7 @@ static int getFaceIndex(
}
static void get_face_uv_map_vert(
UvVertMap *vmap, struct MPoly *mpoly, struct MLoop *ml, int fi, CCGVertHDL *fverts)
UvVertMap *vmap, MPoly *mpoly, MLoop *ml, int fi, CCGVertHDL *fverts)
{
UvMapVert *v, *nv;
int j, nverts = mpoly[fi].totloop;
@ -271,11 +262,8 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
int i, seam;
UvMapVert *v;
UvVertMap *vmap;
blender::Vector<CCGVertHDL, 16> fverts;
float limit[2];
#ifndef USE_DYNSIZE
CCGVertHDL *fverts = NULL;
BLI_array_declare(fverts);
#endif
EdgeSet *eset;
float uv[3] = {0.0f, 0.0f, 0.0f}; /* only first 2 values are written into */
@ -285,7 +273,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
* Also, initially intention is to treat merged vertices from mirror modifier as seams.
* This fixes a very old regression (2.49 was correct here) */
vmap = BKE_mesh_uv_vert_map_create(
mpoly, NULL, NULL, mloop, mloopuv, totface, totvert, limit, false, true);
mpoly, nullptr, nullptr, mloop, mloopuv, totface, totvert, limit, false, true);
if (!vmap) {
return 0;
}
@ -304,7 +292,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
}
}
seam = (v != NULL);
seam = (v != nullptr);
for (v = BKE_mesh_uv_vert_map_get_vert(vmap, i); v; v = v->next) {
if (v->separate) {
@ -330,14 +318,9 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
/* uint *fv = &mp->v1; */
MLoop *ml = mloop + mp->loopstart;
#ifdef USE_DYNSIZE
CCGVertHDL fverts[nverts];
#else
BLI_array_clear(fverts);
BLI_array_grow_items(fverts, nverts);
#endif
fverts.reinitialize(nverts);
get_face_uv_map_vert(vmap, mpoly, ml, i, fverts);
get_face_uv_map_vert(vmap, mpoly, ml, i, fverts.data());
for (j = 0, j_next = nverts - 1; j < nverts; j_next = j++) {
uint v0 = POINTER_AS_UINT(fverts[j_next]);
@ -362,21 +345,12 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
int nverts = mp->totloop;
CCGFace *f;
#ifdef USE_DYNSIZE
CCGVertHDL fverts[nverts];
#else
BLI_array_clear(fverts);
BLI_array_grow_items(fverts, nverts);
#endif
fverts.reinitialize(nverts);
get_face_uv_map_vert(vmap, mpoly, ml, i, fverts);
ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), nverts, fverts, &f);
get_face_uv_map_vert(vmap, mpoly, ml, i, fverts.data());
ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), nverts, fverts.data(), &f);
}
#ifndef USE_DYNSIZE
BLI_array_free(fverts);
#endif
BKE_mesh_uv_vert_map_free(vmap);
ccgSubSurf_processSync(ss);
@ -387,20 +361,21 @@ static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *
{
CCGFaceIterator fi;
int index, gridSize, gridFaces, /*edgeSize,*/ totface, x, y, S;
const float(*dmloopuv)[2] = CustomData_get_layer_n(&dm->loopData, CD_PROP_FLOAT2, n);
const float(*dmloopuv)[2] = static_cast<const float(*)[2]>(
CustomData_get_layer_n(&dm->loopData, CD_PROP_FLOAT2, n));
/* need to update both CD_MTFACE & CD_PROP_FLOAT2, hrmf, we could get away with
* just tface except applying the modifier then looses subsurf UV */
MTFace *tface = CustomData_get_layer_n_for_write(
&result->faceData, CD_MTFACE, n, result->numTessFaceData);
float(*mloopuv)[2] = CustomData_get_layer_n_for_write(
&result->loopData, CD_PROP_FLOAT2, n, result->getNumLoops(dm));
MTFace *tface = static_cast<MTFace *>(
CustomData_get_layer_n_for_write(&result->faceData, CD_MTFACE, n, result->numTessFaceData));
float(*mloopuv)[2] = static_cast<float(*)[2]>(CustomData_get_layer_n_for_write(
&result->loopData, CD_PROP_FLOAT2, n, result->getNumLoops(dm)));
if (!dmloopuv || (!tface && !mloopuv)) {
return;
}
/* create a CCGSubSurf from uv's */
CCGSubSurf *uvss = _getSubSurf(NULL, ccgSubSurf_getSubdivisionLevels(ss), 2, CCG_USE_ARENA);
CCGSubSurf *uvss = _getSubSurf(nullptr, ccgSubSurf_getSubdivisionLevels(ss), 2, CCG_USE_ARENA);
if (!ss_sync_from_uv(uvss, ss, dm, dmloopuv)) {
ccgSubSurf_free(uvss);
@ -414,7 +389,8 @@ static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *
gridFaces = gridSize - 1;
/* make a map from original faces to CCGFaces */
CCGFace **faceMap = MEM_mallocN(totface * sizeof(*faceMap), "facemapuv");
CCGFace **faceMap = static_cast<CCGFace **>(
MEM_mallocN(totface * sizeof(*faceMap), "facemapuv"));
for (ccgSubSurf_initFaceIterator(uvss, &fi); !ccgFaceIterator_isStopped(&fi);
ccgFaceIterator_next(&fi)) {
CCGFace *f = ccgFaceIterator_getCurrent(&fi);
@ -430,7 +406,8 @@ static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *
int numVerts = ccgSubSurf_getFaceNumVerts(f);
for (S = 0; S < numVerts; S++) {
float(*faceGridData)[2] = ccgSubSurf_getFaceGridDataArray(uvss, f, S);
float(*faceGridData)[2] = static_cast<float(*)[2]>(
ccgSubSurf_getFaceGridDataArray(uvss, f, S));
for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {
@ -472,16 +449,16 @@ static void set_subsurf_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *result,
#define SUB_ELEMS_FACE 50
typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
typedef struct FaceVertWeightEntry {
struct FaceVertWeightEntry {
FaceVertWeight *weight;
float *w;
int valid;
} FaceVertWeightEntry;
};
typedef struct WeightTable {
struct WeightTable {
FaceVertWeightEntry *weight_table;
int len;
} WeightTable;
};
static float *get_ss_weights(WeightTable *wtable, int gridCuts, int faceLen)
{
@ -496,14 +473,15 @@ static float *get_ss_weights(WeightTable *wtable, int gridCuts, int faceLen)
MEM_freeN(wtable->weight_table);
}
wtable->weight_table = tmp;
wtable->weight_table = static_cast<FaceVertWeightEntry *>(tmp);
wtable->len = faceLen + 1;
}
if (!wtable->weight_table[faceLen].valid) {
wtable->weight_table[faceLen].valid = 1;
wtable->weight_table[faceLen].w = w = MEM_callocN(
sizeof(float) * faceLen * faceLen * (gridCuts + 2) * (gridCuts + 2), "weight table alloc");
wtable->weight_table[faceLen].w = w = static_cast<float *>(
MEM_callocN(sizeof(float) * faceLen * faceLen * (gridCuts + 2) * (gridCuts + 2),
"weight table alloc"));
fac = 1.0f / (float)faceLen;
for (i = 0; i < faceLen; i++) {
@ -560,10 +538,7 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
int useFlatSubdiv)
{
float creaseFactor = (float)ccgSubSurf_getSubdivisionLevels(ss);
#ifndef USE_DYNSIZE
CCGVertHDL *fVerts = NULL;
BLI_array_declare(fVerts);
#endif
blender::Vector<CCGVertHDL, 16> fverts;
float(*positions)[3] = (float(*)[3])dm->getVertArray(dm);
MEdge *medge = dm->getEdgeArray(dm);
MEdge *me;
@ -610,23 +585,18 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
for (i = 0; i < dm->numPolyData; i++, mp++) {
CCGFace *f;
#ifdef USE_DYNSIZE
CCGVertHDL fVerts[mp->totloop];
#else
BLI_array_clear(fVerts);
BLI_array_grow_items(fVerts, mp->totloop);
#endif
fverts.reinitialize(mp->totloop);
ml = mloop + mp->loopstart;
for (j = 0; j < mp->totloop; j++, ml++) {
fVerts[j] = POINTER_FROM_UINT(ml->v);
fverts[j] = POINTER_FROM_UINT(ml->v);
}
/* This is very bad, means mesh is internally inconsistent.
* it is not really possible to continue without modifying
* other parts of code significantly to handle missing faces.
* since this really shouldn't even be possible we just bail. */
if (ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), mp->totloop, fVerts, &f) ==
if (ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), mp->totloop, fverts.data(), &f) ==
eCCGError_InvalidValue) {
static int hasGivenError = 0;
@ -644,17 +614,13 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
}
ccgSubSurf_processSync(ss);
#ifndef USE_DYNSIZE
BLI_array_free(fVerts);
#endif
}
static void ss_sync_from_derivedmesh(CCGSubSurf *ss,
DerivedMesh *dm,
float (*vertexCos)[3],
int use_flat_subdiv,
bool UNUSED(use_subdiv_uvs))
bool /*use_subdiv_uvs*/)
{
ss_sync_ccg_from_derivedmesh(ss, dm, vertexCos, use_flat_subdiv);
}
@ -718,7 +684,7 @@ static void UNUSED_FUNCTION(ccgDM_getMinMax)(DerivedMesh *dm, float r_min[3], fl
for (ccgSubSurf_initVertIterator(ss, &vi); !ccgVertIterator_isStopped(&vi);
ccgVertIterator_next(&vi)) {
CCGVert *v = ccgVertIterator_getCurrent(&vi);
float *co = ccgSubSurf_getVertData(ss, v);
float *co = static_cast<float *>(ccgSubSurf_getVertData(ss, v));
minmax_v3_v3v3(co, r_min, r_max);
}
@ -726,7 +692,7 @@ static void UNUSED_FUNCTION(ccgDM_getMinMax)(DerivedMesh *dm, float r_min[3], fl
for (ccgSubSurf_initEdgeIterator(ss, &ei); !ccgEdgeIterator_isStopped(&ei);
ccgEdgeIterator_next(&ei)) {
CCGEdge *e = ccgEdgeIterator_getCurrent(&ei);
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
CCGElem *edgeData = static_cast<CCGElem *>(ccgSubSurf_getEdgeDataArray(ss, e));
for (i = 0; i < edgeSize; i++) {
minmax_v3_v3v3(CCG_elem_offset_co(&key, edgeData, i), r_min, r_max);
@ -739,7 +705,7 @@ static void UNUSED_FUNCTION(ccgDM_getMinMax)(DerivedMesh *dm, float r_min[3], fl
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
for (S = 0; S < numVerts; S++) {
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
CCGElem *faceGridData = static_cast<CCGElem *>(ccgSubSurf_getFaceGridDataArray(ss, f, S));
for (y = 0; y < gridSize; y++) {
for (x = 0; x < gridSize; x++) {
@ -812,13 +778,13 @@ static CCGElem *get_vertex_elem(CCGDerivedMesh *ccgdm, int vertNum)
offset = vertNum - ccgdm->faceMap[i].startVert;
if (offset < 1) {
return ccgSubSurf_getFaceCenterData(f);
return static_cast<CCGElem *>(ccgSubSurf_getFaceCenterData(f));
}
if (offset < gridSideEnd) {
offset -= 1;
grid = offset / gridSideVerts;
x = offset % gridSideVerts + 1;
return ccgSubSurf_getFaceGridEdgeData(ss, f, grid, x);
return static_cast<CCGElem *>(ccgSubSurf_getFaceGridEdgeData(ss, f, grid, x));
}
if (offset < gridInternalEnd) {
offset -= gridSideEnd;
@ -826,7 +792,7 @@ static CCGElem *get_vertex_elem(CCGDerivedMesh *ccgdm, int vertNum)
offset %= gridInternalVerts;
y = offset / gridSideVerts + 1;
x = offset % gridSideVerts + 1;
return ccgSubSurf_getFaceGridData(ss, f, grid, x, y);
return static_cast<CCGElem *>(ccgSubSurf_getFaceGridData(ss, f, grid, x, y));
}
}
if ((vertNum < ccgdm->vertMap[0].startVert) && (ccgSubSurf_getNumEdges(ss) > 0)) {
@ -843,7 +809,7 @@ static CCGElem *get_vertex_elem(CCGDerivedMesh *ccgdm, int vertNum)
e = ccgdm->edgeMap[i].edge;
x = vertNum - ccgdm->edgeMap[i].startVert + 1;
return ccgSubSurf_getEdgeData(ss, e, x);
return static_cast<CCGElem *>(ccgSubSurf_getEdgeData(ss, e, x));
}
/* this vert comes from vert data */
@ -851,7 +817,7 @@ static CCGElem *get_vertex_elem(CCGDerivedMesh *ccgdm, int vertNum)
i = vertNum - ccgdm->vertMap[0].startVert;
v = ccgdm->vertMap[i].vert;
return ccgSubSurf_getVertData(ss, v);
return static_cast<CCGElem *>(ccgSubSurf_getVertData(ss, v));
}
static void ccgDM_getFinalVertCo(DerivedMesh *dm, int vertNum, float r_co[3])
@ -901,12 +867,12 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
CCGFace *f = ccgdm->faceMap[index].face;
int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
vd = ccgSubSurf_getFaceCenterData(f);
vd = static_cast<CCGElem *>(ccgSubSurf_getFaceCenterData(f));
ccgDM_to_MVert(r_positions[i++], &key, vd);
for (S = 0; S < numVerts; S++) {
for (x = 1; x < gridSize - 1; x++) {
vd = ccgSubSurf_getFaceGridEdgeData(ss, f, S, x);
vd = static_cast<CCGElem *>(ccgSubSurf_getFaceGridEdgeData(ss, f, S, x));
ccgDM_to_MVert(r_positions[i++], &key, vd);
}
}
@ -914,7 +880,7 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
for (S = 0; S < numVerts; S++) {
for (y = 1; y < gridSize - 1; y++) {
for (x = 1; x < gridSize - 1; x++) {
vd = ccgSubSurf_getFaceGridData(ss, f, S, x, y);
vd = static_cast<CCGElem *>(ccgSubSurf_getFaceGridData(ss, f, S, x, y));
ccgDM_to_MVert(r_positions[i++], &key, vd);
}
}
@ -930,7 +896,7 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
/* NOTE(@campbellbarton): This gives errors with `--debug-fpe` the normals don't seem to be
* unit length. This is most likely caused by edges with no faces which are now zeroed out,
* see comment in: `ccgSubSurf__calcVertNormals()`. */
vd = ccgSubSurf_getEdgeData(ss, e, x);
vd = static_cast<CCGElem *>(ccgSubSurf_getEdgeData(ss, e, x));
ccgDM_to_MVert(r_positions[i++], &key, vd);
}
}
@ -939,7 +905,7 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
for (index = 0; index < totvert; index++) {
CCGVert *v = ccgdm->vertMap[index].vert;
vd = ccgSubSurf_getVertData(ss, v);
vd = static_cast<CCGElem *>(ccgSubSurf_getVertData(ss, v));
ccgDM_to_MVert(r_positions[i++], &key, vd);
}
}
@ -1017,20 +983,20 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
}
}
typedef struct CopyFinalLoopArrayData {
struct CopyFinalLoopArrayData {
CCGDerivedMesh *ccgdm;
MLoop *mloop;
int grid_size;
int *grid_offset;
int edge_size;
size_t mloop_index;
} CopyFinalLoopArrayData;
};
static void copyFinalLoopArray_task_cb(void *__restrict userdata,
const int iter,
const TaskParallelTLS *__restrict UNUSED(tls))
const TaskParallelTLS *__restrict /*tls*/)
{
CopyFinalLoopArrayData *data = userdata;
CopyFinalLoopArrayData *data = static_cast<CopyFinalLoopArrayData *>(userdata);
CCGDerivedMesh *ccgdm = data->ccgdm;
CCGSubSurf *ss = ccgdm->ss;
const int grid_size = data->grid_size;
@ -1157,12 +1123,12 @@ static void ccgDM_release(DerivedMesh *dm)
/* Check that mmd still exists */
if (!ccgdm->multires.local_mmd &&
BLI_findindex(&ccgdm->multires.ob->modifiers, ccgdm->multires.mmd) < 0) {
ccgdm->multires.mmd = NULL;
ccgdm->multires.mmd = nullptr;
}
if (ccgdm->multires.mmd) {
if (ccgdm->multires.modified_flags & MULTIRES_COORDS_MODIFIED) {
multires_modifier_update_mdisps(dm, NULL);
multires_modifier_update_mdisps(dm, nullptr);
}
if (ccgdm->multires.modified_flags & MULTIRES_HIDDEN_MODIFIED) {
multires_modifier_update_hidden(dm);
@ -1171,7 +1137,7 @@ static void ccgDM_release(DerivedMesh *dm)
}
if (ccgdm->ehash) {
BLI_edgehash_free(ccgdm->ehash, NULL);
BLI_edgehash_free(ccgdm->ehash, nullptr);
}
if (ccgdm->reverseFaceMap) {
@ -1232,7 +1198,7 @@ static void *ccgDM_get_vert_data_layer(DerivedMesh *dm, int type)
/* Avoid re-creation if the layer exists already */
BLI_rw_mutex_lock(&ccgdm->origindex_cache_rwlock, THREAD_LOCK_READ);
origindex = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
origindex = static_cast<int *>(DM_get_vert_data_layer(dm, CD_ORIGINDEX));
BLI_rw_mutex_unlock(&ccgdm->origindex_cache_rwlock);
if (origindex) {
return origindex;
@ -1240,8 +1206,8 @@ static void *ccgDM_get_vert_data_layer(DerivedMesh *dm, int type)
BLI_rw_mutex_lock(&ccgdm->origindex_cache_rwlock, THREAD_LOCK_WRITE);
origindex = CustomData_add_layer(
&dm->vertData, CD_ORIGINDEX, CD_SET_DEFAULT, NULL, dm->numVertData);
origindex = static_cast<int *>(CustomData_add_layer(
&dm->vertData, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, dm->numVertData));
totorig = ccgSubSurf_getNumVerts(ss);
totnone = dm->numVertData - totorig;
@ -1274,13 +1240,13 @@ static void *ccgDM_get_edge_data_layer(DerivedMesh *dm, int type)
int edgeSize = ccgSubSurf_getEdgeSize(ss);
/* Avoid re-creation if the layer exists already */
origindex = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
origindex = static_cast<int *>(DM_get_edge_data_layer(dm, CD_ORIGINDEX));
if (origindex) {
return origindex;
}
origindex = CustomData_add_layer(
&dm->edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, NULL, dm->numEdgeData);
origindex = static_cast<int *>(CustomData_add_layer(
&dm->edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, dm->numEdgeData));
totedge = ccgSubSurf_getNumEdges(ss);
totorig = totedge * (edgeSize - 1);
@ -1317,13 +1283,13 @@ static void *ccgDM_get_poly_data_layer(DerivedMesh *dm, int type)
int gridFaces = ccgSubSurf_getGridSize(ss) - 1;
/* Avoid re-creation if the layer exists already */
origindex = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
origindex = static_cast<int *>(DM_get_poly_data_layer(dm, CD_ORIGINDEX));
if (origindex) {
return origindex;
}
origindex = CustomData_add_layer(
&dm->polyData, CD_ORIGINDEX, CD_SET_DEFAULT, NULL, dm->numPolyData);
origindex = static_cast<int *>(CustomData_add_layer(
&dm->polyData, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, dm->numPolyData));
totface = ccgSubSurf_getNumFaces(ss);
@ -1384,7 +1350,7 @@ static void ccgdm_create_grids(DerivedMesh *dm)
// gridSize = ccgDM_getGridSize(dm); /* UNUSED */
/* compute offset into grid array for each face */
gridOffset = MEM_mallocN(sizeof(int) * numFaces, "ccgdm.gridOffset");
gridOffset = static_cast<int *>(MEM_mallocN(sizeof(int) * numFaces, "ccgdm.gridOffset"));
for (gIndex = 0, index = 0; index < numFaces; index++) {
CCGFace *f = ccgdm->faceMap[index].face;
@ -1395,18 +1361,21 @@ static void ccgdm_create_grids(DerivedMesh *dm)
}
/* compute grid data */
gridData = MEM_mallocN(sizeof(CCGElem *) * numGrids, "ccgdm.gridData");
gridFaces = MEM_mallocN(sizeof(CCGFace *) * numGrids, "ccgdm.gridFaces");
gridFlagMats = MEM_mallocN(sizeof(DMFlagMat) * numGrids, "ccgdm.gridFlagMats");
gridData = static_cast<CCGElem **>(MEM_mallocN(sizeof(CCGElem *) * numGrids, "ccgdm.gridData"));
gridFaces = static_cast<CCGFace **>(
MEM_mallocN(sizeof(CCGFace *) * numGrids, "ccgdm.gridFaces"));
gridFlagMats = static_cast<DMFlagMat *>(
MEM_mallocN(sizeof(DMFlagMat) * numGrids, "ccgdm.gridFlagMats"));
ccgdm->gridHidden = MEM_callocN(sizeof(*ccgdm->gridHidden) * numGrids, "ccgdm.gridHidden");
ccgdm->gridHidden = static_cast<unsigned int **>(
MEM_callocN(sizeof(*ccgdm->gridHidden) * numGrids, "ccgdm.gridHidden"));
for (gIndex = 0, index = 0; index < numFaces; index++) {
CCGFace *f = ccgdm->faceMap[index].face;
int numVerts = ccgSubSurf_getFaceNumVerts(f);
for (S = 0; S < numVerts; S++, gIndex++) {
gridData[gIndex] = ccgSubSurf_getFaceGridDataArray(ss, f, S);
gridData[gIndex] = static_cast<CCGElem *>(ccgSubSurf_getFaceGridDataArray(ss, f, S));
gridFaces[gIndex] = f;
gridFlagMats[gIndex] = ccgdm->faceFlags[index];
}
@ -1466,7 +1435,7 @@ static void ccgDM_recalcLoopTri(DerivedMesh *dm)
DM_ensure_looptri_data(dm);
MLoopTri *mlooptri = dm->looptris.array_wip;
BLI_assert(tottri == 0 || mlooptri != NULL);
BLI_assert(tottri == 0 || mlooptri != nullptr);
BLI_assert(poly_to_tri_count(dm->numPolyData, dm->numLoopData) == dm->looptris.num);
BLI_assert(tottri == dm->looptris.num);
@ -1486,9 +1455,9 @@ static void ccgDM_recalcLoopTri(DerivedMesh *dm)
lt->poly = poly_index;
}
BLI_assert(dm->looptris.array == NULL);
BLI_assert(dm->looptris.array == nullptr);
atomic_cas_ptr((void **)&dm->looptris.array, dm->looptris.array, dm->looptris.array_wip);
dm->looptris.array_wip = NULL;
dm->looptris.array_wip = nullptr;
}
static void set_default_ccgdm_callbacks(CCGDerivedMesh *ccgdm)
@ -1530,7 +1499,8 @@ static void create_ccgdm_maps(CCGDerivedMesh *ccgdm, CCGSubSurf *ss)
int totvert, totedge, totface;
totvert = ccgSubSurf_getNumVerts(ss);
ccgdm->vertMap = MEM_mallocN(totvert * sizeof(*ccgdm->vertMap), "vertMap");
ccgdm->vertMap = static_cast<decltype(CCGDerivedMesh::vertMap)>(
MEM_mallocN(totvert * sizeof(*ccgdm->vertMap), "vertMap"));
for (ccgSubSurf_initVertIterator(ss, &vi); !ccgVertIterator_isStopped(&vi);
ccgVertIterator_next(&vi)) {
CCGVert *v = ccgVertIterator_getCurrent(&vi);
@ -1539,7 +1509,8 @@ static void create_ccgdm_maps(CCGDerivedMesh *ccgdm, CCGSubSurf *ss)
}
totedge = ccgSubSurf_getNumEdges(ss);
ccgdm->edgeMap = MEM_mallocN(totedge * sizeof(*ccgdm->edgeMap), "edgeMap");
ccgdm->edgeMap = static_cast<decltype(CCGDerivedMesh::edgeMap)>(
MEM_mallocN(totedge * sizeof(*ccgdm->edgeMap), "edgeMap"));
for (ccgSubSurf_initEdgeIterator(ss, &ei); !ccgEdgeIterator_isStopped(&ei);
ccgEdgeIterator_next(&ei)) {
CCGEdge *e = ccgEdgeIterator_getCurrent(&ei);
@ -1548,7 +1519,8 @@ static void create_ccgdm_maps(CCGDerivedMesh *ccgdm, CCGSubSurf *ss)
}
totface = ccgSubSurf_getNumFaces(ss);
ccgdm->faceMap = MEM_mallocN(totface * sizeof(*ccgdm->faceMap), "faceMap");
ccgdm->faceMap = static_cast<decltype(CCGDerivedMesh::faceMap)>(
MEM_mallocN(totface * sizeof(*ccgdm->faceMap), "faceMap"));
for (ccgSubSurf_initFaceIterator(ss, &fi); !ccgFaceIterator_isStopped(&fi);
ccgFaceIterator_next(&fi)) {
CCGFace *f = ccgFaceIterator_getCurrent(&fi);
@ -1573,20 +1545,17 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
int vertNum = 0, edgeNum = 0, faceNum = 0;
short *edgeFlags = ccgdm->edgeFlags;
DMFlagMat *faceFlags = ccgdm->faceFlags;
int *polyidx = NULL;
#ifndef USE_DYNSIZE
int *loopidx = NULL, *vertidx = NULL;
BLI_array_declare(loopidx);
BLI_array_declare(vertidx);
#endif
int *polyidx = nullptr;
blender::Vector<int, 16> loopidx;
blender::Vector<int, 16> vertidx;
int loopindex, loopindex2;
int edgeSize;
int gridSize;
int gridFaces, gridCuts;
int gridSideEdges;
int gridInternalEdges;
WeightTable wtable = {NULL};
MEdge *medge = NULL;
WeightTable wtable = {nullptr};
MEdge *medge = nullptr;
bool has_edge_cd;
edgeSize = ccgSubSurf_getEdgeSize(ss);
@ -1599,15 +1568,15 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
medge = dm->getEdgeArray(dm);
const MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
const int *material_indices = CustomData_get_layer_named(
&dm->polyData, CD_MPOLY, "material_index");
const int *base_polyOrigIndex = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
const MPoly *mpoly = static_cast<const MPoly *>(CustomData_get_layer(&dm->polyData, CD_MPOLY));
const int *material_indices = static_cast<const int *>(
CustomData_get_layer_named(&dm->polyData, CD_MPOLY, "material_index"));
const int *base_polyOrigIndex = static_cast<const int *>(
CustomData_get_layer(&dm->polyData, CD_ORIGINDEX));
int *vertOrigIndex = DM_get_vert_data_layer(&ccgdm->dm, CD_ORIGINDEX);
int *edgeOrigIndex = DM_get_edge_data_layer(&ccgdm->dm, CD_ORIGINDEX);
int *polyOrigIndex = DM_get_poly_data_layer(&ccgdm->dm, CD_ORIGINDEX);
int *vertOrigIndex = static_cast<int *>(DM_get_vert_data_layer(&ccgdm->dm, CD_ORIGINDEX));
int *edgeOrigIndex = static_cast<int *>(DM_get_edge_data_layer(&ccgdm->dm, CD_ORIGINDEX));
int *polyOrigIndex = static_cast<int *>(DM_get_poly_data_layer(&ccgdm->dm, CD_ORIGINDEX));
has_edge_cd = ((ccgdm->dm.edgeData.totlayer - (edgeOrigIndex ? 1 : 0)) != 0);
@ -1620,9 +1589,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
int g2_wid = gridCuts + 2;
float *w, *w2;
int s, x, y;
#ifdef USE_DYNSIZE
int loopidx[numVerts], vertidx[numVerts];
#endif
w = get_ss_weights(&wtable, gridCuts, numVerts);
ccgdm->faceMap[index].startVert = vertNum;
@ -1636,18 +1603,12 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
/* set the face base vert */
*((int *)ccgSubSurf_getFaceUserData(ss, f)) = vertNum;
#ifndef USE_DYNSIZE
BLI_array_clear(loopidx);
BLI_array_grow_items(loopidx, numVerts);
#endif
loopidx.reinitialize(numVerts);
for (s = 0; s < numVerts; s++) {
loopidx[s] = loopindex++;
}
#ifndef USE_DYNSIZE
BLI_array_clear(vertidx);
BLI_array_grow_items(vertidx, numVerts);
#endif
vertidx.reinitialize(numVerts);
for (s = 0; s < numVerts; s++) {
CCGVert *v = ccgSubSurf_getFaceVert(f, s);
vertidx[s] = POINTER_AS_INT(ccgSubSurf_getVertVertHandle(v));
@ -1655,7 +1616,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
/* I think this is for interpolating the center vert? */
w2 = w; // + numVerts*(g2_wid-1) * (g2_wid-1); //numVerts*((g2_wid-1) * g2_wid+g2_wid-1);
DM_interp_vert_data(dm, &ccgdm->dm, vertidx, w2, numVerts, vertNum);
DM_interp_vert_data(dm, &ccgdm->dm, vertidx.data(), w2, numVerts, vertNum);
if (vertOrigIndex) {
*vertOrigIndex = ORIGINDEX_NONE;
vertOrigIndex++;
@ -1667,7 +1628,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
for (s = 0; s < numVerts; s++) {
for (x = 1; x < gridFaces; x++) {
w2 = w + s * numVerts * g2_wid * g2_wid + x * numVerts;
DM_interp_vert_data(dm, &ccgdm->dm, vertidx, w2, numVerts, vertNum);
DM_interp_vert_data(dm, &ccgdm->dm, vertidx.data(), w2, numVerts, vertNum);
if (vertOrigIndex) {
*vertOrigIndex = ORIGINDEX_NONE;
@ -1683,7 +1644,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
for (y = 1; y < gridFaces; y++) {
for (x = 1; x < gridFaces; x++) {
w2 = w + s * numVerts * g2_wid * g2_wid + (y * g2_wid + x) * numVerts;
DM_interp_vert_data(dm, &ccgdm->dm, vertidx, w2, numVerts, vertNum);
DM_interp_vert_data(dm, &ccgdm->dm, vertidx.data(), w2, numVerts, vertNum);
if (vertOrigIndex) {
*vertOrigIndex = ORIGINDEX_NONE;
@ -1706,23 +1667,43 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {
w2 = w + s * numVerts * g2_wid * g2_wid + (y * g2_wid + x) * numVerts;
CustomData_interp(
&dm->loopData, &ccgdm->dm.loopData, loopidx, w2, NULL, numVerts, loopindex2);
CustomData_interp(&dm->loopData,
&ccgdm->dm.loopData,
loopidx.data(),
w2,
nullptr,
numVerts,
loopindex2);
loopindex2++;
w2 = w + s * numVerts * g2_wid * g2_wid + ((y + 1) * g2_wid + (x)) * numVerts;
CustomData_interp(
&dm->loopData, &ccgdm->dm.loopData, loopidx, w2, NULL, numVerts, loopindex2);
CustomData_interp(&dm->loopData,
&ccgdm->dm.loopData,
loopidx.data(),
w2,
nullptr,
numVerts,
loopindex2);
loopindex2++;
w2 = w + s * numVerts * g2_wid * g2_wid + ((y + 1) * g2_wid + (x + 1)) * numVerts;
CustomData_interp(
&dm->loopData, &ccgdm->dm.loopData, loopidx, w2, NULL, numVerts, loopindex2);
CustomData_interp(&dm->loopData,
&ccgdm->dm.loopData,
loopidx.data(),
w2,
nullptr,
numVerts,
loopindex2);
loopindex2++;
w2 = w + s * numVerts * g2_wid * g2_wid + ((y)*g2_wid + (x + 1)) * numVerts;
CustomData_interp(
&dm->loopData, &ccgdm->dm.loopData, loopidx, w2, NULL, numVerts, loopindex2);
CustomData_interp(&dm->loopData,
&ccgdm->dm.loopData,
loopidx.data(),
w2,
nullptr,
numVerts,
loopindex2);
loopindex2++;
/* Copy over poly data, e.g. #CD_FACEMAP. */
@ -1832,10 +1813,6 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
vertNum++;
}
#ifndef USE_DYNSIZE
BLI_array_free(vertidx);
BLI_array_free(loopidx);
#endif
free_ss_weights(&wtable);
BLI_assert(vertNum == ccgSubSurf_getNumFinalVerts(ss));
@ -1851,7 +1828,7 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
{
const int totedge = ccgSubSurf_getNumEdges(ss);
const int totface = ccgSubSurf_getNumFaces(ss);
CCGDerivedMesh *ccgdm = MEM_callocN(sizeof(*ccgdm), "ccgdm");
CCGDerivedMesh *ccgdm = MEM_cnew<CCGDerivedMesh>(__func__);
BLI_assert(totedge == ccgSubSurf_getNumEdges(ss));
BLI_assert(totface == ccgSubSurf_getNumFaces(ss));
@ -1864,8 +1841,8 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
ccgSubSurf_getNumFinalFaces(ss) * 4,
ccgSubSurf_getNumFinalFaces(ss));
ccgdm->reverseFaceMap = MEM_callocN(sizeof(int) * ccgSubSurf_getNumFinalFaces(ss),
"reverseFaceMap");
ccgdm->reverseFaceMap = static_cast<int *>(
MEM_callocN(sizeof(int) * ccgSubSurf_getNumFinalFaces(ss), "reverseFaceMap"));
create_ccgdm_maps(ccgdm, ss);
@ -1876,8 +1853,9 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
ccgdm->useSubsurfUv = useSubsurfUv;
/* CDDM hack. */
ccgdm->edgeFlags = MEM_callocN(sizeof(short) * totedge, "edgeFlags");
ccgdm->faceFlags = MEM_callocN(sizeof(DMFlagMat) * totface, "faceFlags");
ccgdm->edgeFlags = static_cast<short *>(MEM_callocN(sizeof(short) * totedge, "edgeFlags"));
ccgdm->faceFlags = static_cast<DMFlagMat *>(
MEM_callocN(sizeof(DMFlagMat) * totface, "faceFlags"));
set_ccgdm_all_geometry(ccgdm, ss, dm, useSubsurfUv != 0);
@ -1895,14 +1873,16 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
/***/
struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
struct SubsurfModifierData *smd,
const struct Scene *scene,
float (*vertCos)[3],
SubsurfFlags flags)
DerivedMesh *subsurf_make_derived_from_derived(DerivedMesh *dm,
SubsurfModifierData *smd,
const Scene *scene,
float (*vertCos)[3],
SubsurfFlags flags)
{
const int useSimple = (smd->subdivType == ME_SIMPLE_SUBSURF) ? CCG_SIMPLE_SUBDIV : 0;
const CCGFlags useAging = (smd->flags & eSubsurfModifierFlag_DebugIncr) ? CCG_USE_AGING : 0;
const CCGFlags useSimple = (smd->subdivType == ME_SIMPLE_SUBSURF) ? CCG_SIMPLE_SUBDIV :
CCGFlags(0);
const CCGFlags useAging = (smd->flags & eSubsurfModifierFlag_DebugIncr) ? CCG_USE_AGING :
CCGFlags(0);
const int useSubsurfUv = (smd->uv_smooth != SUBSURF_UV_SMOOTH_NONE);
const int drawInteriorEdges = !(smd->flags & eSubsurfModifierFlag_ControlEdges);
const bool ignore_simplify = (flags & SUBSURF_IGNORE_SIMPLIFY);
@ -1911,25 +1891,30 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
/* NOTE: editmode calculation can only run once per
* modifier stack evaluation (uses freed cache) T36299. */
if (flags & SUBSURF_FOR_EDIT_MODE) {
int levels = (scene != NULL && !ignore_simplify) ?
int levels = (scene != nullptr && !ignore_simplify) ?
get_render_subsurf_level(&scene->r, smd->levels, false) :
smd->levels;
/* TODO(sergey): Same as emCache below. */
if ((flags & SUBSURF_IN_EDIT_MODE) && smd->mCache) {
ccgSubSurf_free(smd->mCache);
smd->mCache = NULL;
ccgSubSurf_free(static_cast<CCGSubSurf *>(smd->mCache));
smd->mCache = nullptr;
}
smd->emCache = _getSubSurf(smd->emCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
smd->emCache = _getSubSurf(static_cast<CCGSubSurf *>(smd->emCache),
levels,
3,
useSimple | useAging | CCG_CALC_NORMALS);
ss_sync_from_derivedmesh(smd->emCache, dm, vertCos, useSimple, useSubsurfUv);
result = getCCGDerivedMesh(smd->emCache, drawInteriorEdges, useSubsurfUv, dm);
ss_sync_from_derivedmesh(
static_cast<CCGSubSurf *>(smd->emCache), dm, vertCos, useSimple, useSubsurfUv);
result = getCCGDerivedMesh(
static_cast<CCGSubSurf *>(smd->emCache), drawInteriorEdges, useSubsurfUv, dm);
}
else if (flags & SUBSURF_USE_RENDER_PARAMS) {
/* Do not use cache in render mode. */
CCGSubSurf *ss;
int levels = (scene != NULL && !ignore_simplify) ?
int levels = (scene != nullptr && !ignore_simplify) ?
get_render_subsurf_level(&scene->r, smd->renderLevels, true) :
smd->renderLevels;
@ -1937,7 +1922,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
return dm;
}
ss = _getSubSurf(NULL, levels, 3, useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS);
ss = _getSubSurf(nullptr, levels, 3, useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS);
ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple, useSubsurfUv);
@ -1947,7 +1932,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
}
else {
int useIncremental = (smd->flags & eSubsurfModifierFlag_Incremental);
int levels = (scene != NULL && !ignore_simplify) ?
int levels = (scene != nullptr && !ignore_simplify) ?
get_render_subsurf_level(&scene->r, smd->levels, false) :
smd->levels;
CCGSubSurf *ss;
@ -1964,25 +1949,28 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
* mode, so now we have a parameter to verify it. - brecht
*/
if (!(flags & SUBSURF_IN_EDIT_MODE) && smd->emCache) {
ccgSubSurf_free(smd->emCache);
smd->emCache = NULL;
ccgSubSurf_free(static_cast<CCGSubSurf *>(smd->emCache));
smd->emCache = nullptr;
}
if (useIncremental && (flags & SUBSURF_IS_FINAL_CALC)) {
smd->mCache = ss = _getSubSurf(
smd->mCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
smd->mCache = ss = _getSubSurf(static_cast<CCGSubSurf *>(smd->mCache),
levels,
3,
useSimple | useAging | CCG_CALC_NORMALS);
ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple, useSubsurfUv);
result = getCCGDerivedMesh(smd->mCache, drawInteriorEdges, useSubsurfUv, dm);
result = getCCGDerivedMesh(
static_cast<CCGSubSurf *>(smd->mCache), drawInteriorEdges, useSubsurfUv, dm);
}
else {
CCGFlags ccg_flags = useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS;
CCGSubSurf *prevSS = NULL;
CCGSubSurf *prevSS = nullptr;
if (smd->mCache && (flags & SUBSURF_IS_FINAL_CALC)) {
ccgSubSurf_free(smd->mCache);
smd->mCache = NULL;
if ((smd->mCache) && (flags & SUBSURF_IS_FINAL_CALC)) {
ccgSubSurf_free(static_cast<CCGSubSurf *>(smd->mCache));
smd->mCache = nullptr;
}
if (flags & SUBSURF_ALLOC_PAINT_MASK) {
@ -2017,12 +2005,12 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
* calculated vert positions is incorrect for the verts
* on the boundary of the mesh.
*/
CCGSubSurf *ss = _getSubSurf(NULL, 1, 3, CCG_USE_ARENA);
CCGSubSurf *ss = _getSubSurf(nullptr, 1, 3, CCG_USE_ARENA);
float edge_sum[3], face_sum[3];
CCGVertIterator vi;
DerivedMesh *dm = CDDM_from_mesh(me);
ss_sync_from_derivedmesh(ss, dm, NULL, 0, 0);
ss_sync_from_derivedmesh(ss, dm, nullptr, 0, 0);
for (ccgSubSurf_initVertIterator(ss, &vi); !ccgVertIterator_isStopped(&vi);
ccgVertIterator_next(&vi)) {
@ -2030,7 +2018,6 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
int idx = POINTER_AS_INT(ccgSubSurf_getVertVertHandle(v));
int N = ccgSubSurf_getVertNumEdges(v);
int numFaces = ccgSubSurf_getVertNumFaces(v);
float *co;
int i;
zero_v3(edge_sum);
@ -2038,11 +2025,12 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
for (i = 0; i < N; i++) {
CCGEdge *e = ccgSubSurf_getVertEdge(v, i);
add_v3_v3v3(edge_sum, edge_sum, ccgSubSurf_getEdgeData(ss, e, 1));
add_v3_v3v3(
edge_sum, edge_sum, static_cast<const float *>(ccgSubSurf_getEdgeData(ss, e, 1)));
}
for (i = 0; i < numFaces; i++) {
CCGFace *f = ccgSubSurf_getVertFace(v, i);
add_v3_v3(face_sum, ccgSubSurf_getFaceCenterData(f));
add_v3_v3(face_sum, static_cast<const float *>(ccgSubSurf_getFaceCenterData(f)));
}
/* ad-hoc correction for boundary vertices, to at least avoid them
@ -2051,7 +2039,7 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
mul_v3_fl(face_sum, (float)N / (float)numFaces);
}
co = ccgSubSurf_getVertData(ss, v);
const float *co = static_cast<const float *>(ccgSubSurf_getVertData(ss, v));
r_positions[idx][0] = (co[0] * N * N + edge_sum[0] * 4 + face_sum[0]) / (N * (N + 5));
r_positions[idx][1] = (co[1] * N * N + edge_sum[1] * 4 + face_sum[1]) / (N * (N + 5));
r_positions[idx][2] = (co[2] * N * N + edge_sum[2] * 4 + face_sum[2]) / (N * (N + 5));