Cleanup: Move six mesh-related files to C++
For continued refactoring of the Mesh data structure. See T103343.
This commit is contained in:
parent
3d6fd2906b
commit
f2bb044fdb
|
@ -119,7 +119,7 @@ set(SRC
|
|||
intern/customdata.cc
|
||||
intern/customdata_file.c
|
||||
intern/data_transfer.cc
|
||||
intern/deform.c
|
||||
intern/deform.cc
|
||||
intern/displist.cc
|
||||
intern/dynamicpaint.cc
|
||||
intern/editlattice.c
|
||||
|
|
|
@ -5,11 +5,11 @@
|
|||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
|
@ -46,7 +46,7 @@ bDeformGroup *BKE_object_defgroup_new(Object *ob, const char *name)
|
|||
|
||||
BLI_assert(OB_TYPE_SUPPORT_VGROUP(ob->type));
|
||||
|
||||
defgroup = MEM_callocN(sizeof(bDeformGroup), __func__);
|
||||
defgroup = MEM_cnew<bDeformGroup>(__func__);
|
||||
|
||||
BLI_strncpy(defgroup->name, name, sizeof(defgroup->name));
|
||||
|
||||
|
@ -62,31 +62,26 @@ bDeformGroup *BKE_object_defgroup_new(Object *ob, const char *name)
|
|||
|
||||
void BKE_defgroup_copy_list(ListBase *outbase, const ListBase *inbase)
|
||||
{
|
||||
bDeformGroup *defgroup, *defgroupn;
|
||||
|
||||
BLI_listbase_clear(outbase);
|
||||
|
||||
for (defgroup = inbase->first; defgroup; defgroup = defgroup->next) {
|
||||
defgroupn = BKE_defgroup_duplicate(defgroup);
|
||||
LISTBASE_FOREACH (const bDeformGroup *, defgroup, inbase) {
|
||||
bDeformGroup *defgroupn = BKE_defgroup_duplicate(defgroup);
|
||||
BLI_addtail(outbase, defgroupn);
|
||||
}
|
||||
}
|
||||
|
||||
bDeformGroup *BKE_defgroup_duplicate(const bDeformGroup *ingroup)
|
||||
{
|
||||
bDeformGroup *outgroup;
|
||||
|
||||
if (!ingroup) {
|
||||
BLI_assert(0);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
outgroup = MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
|
||||
bDeformGroup *outgroup = MEM_cnew<bDeformGroup>(__func__);
|
||||
|
||||
/* For now, just copy everything over. */
|
||||
memcpy(outgroup, ingroup, sizeof(bDeformGroup));
|
||||
|
||||
outgroup->next = outgroup->prev = NULL;
|
||||
outgroup->next = outgroup->prev = nullptr;
|
||||
|
||||
return outgroup;
|
||||
}
|
||||
|
@ -132,10 +127,10 @@ void BKE_defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
|
|||
}
|
||||
|
||||
if (dvert_src->totweight) {
|
||||
dvert_dst->dw = MEM_dupallocN(dvert_src->dw);
|
||||
dvert_dst->dw = static_cast<MDeformWeight *>(MEM_dupallocN(dvert_src->dw));
|
||||
}
|
||||
else {
|
||||
dvert_dst->dw = NULL;
|
||||
dvert_dst->dw = nullptr;
|
||||
}
|
||||
|
||||
dvert_dst->totweight = dvert_src->totweight;
|
||||
|
@ -157,7 +152,7 @@ void BKE_defvert_copy_index(MDeformVert *dvert_dst,
|
|||
dw_dst->weight = dw_src->weight;
|
||||
}
|
||||
else {
|
||||
/* Source was NULL, assign zero (could also remove). */
|
||||
/* Source was nullptr, assign zero (could also remove). */
|
||||
dw_dst = BKE_defvert_find_index(dvert_dst, defgroup_dst);
|
||||
|
||||
if (dw_dst) {
|
||||
|
@ -307,7 +302,7 @@ void BKE_defvert_normalize_lock_single(MDeformVert *dvert,
|
|||
}
|
||||
}
|
||||
else {
|
||||
MDeformWeight *dw_lock = NULL;
|
||||
MDeformWeight *dw_lock = nullptr;
|
||||
MDeformWeight *dw;
|
||||
uint i;
|
||||
float tot_weight = 0.0f;
|
||||
|
@ -423,7 +418,7 @@ void BKE_defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int
|
|||
for (dw = dvert->dw, i = 0; i < totweight; dw++, i++) {
|
||||
if (dw->def_nr < flip_map_num) {
|
||||
if (flip_map[dw->def_nr] >= 0) {
|
||||
/* error checkers complain of this but we'll never get NULL return */
|
||||
/* error checkers complain of this but we'll never get nullptr return */
|
||||
dw_cpy = BKE_defvert_ensure_index(dvert, flip_map[dw->def_nr]);
|
||||
dw = &dvert->dw[i]; /* in case array got realloced */
|
||||
|
||||
|
@ -441,7 +436,7 @@ void BKE_defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int
|
|||
bool BKE_object_supports_vertex_groups(const Object *ob)
|
||||
{
|
||||
const ID *id = (const ID *)ob->data;
|
||||
if (id == NULL) {
|
||||
if (id == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -467,7 +462,7 @@ const ListBase *BKE_id_defgroup_list_get(const ID *id)
|
|||
BLI_assert_unreachable();
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static const int *object_defgroup_active_index_get_p(const Object *ob)
|
||||
|
@ -487,7 +482,7 @@ static const int *object_defgroup_active_index_get_p(const Object *ob)
|
|||
return &gpd->vertex_group_active_index;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ListBase *BKE_id_defgroup_list_get_mutable(ID *id)
|
||||
|
@ -498,38 +493,38 @@ ListBase *BKE_id_defgroup_list_get_mutable(ID *id)
|
|||
|
||||
bDeformGroup *BKE_object_defgroup_find_name(const Object *ob, const char *name)
|
||||
{
|
||||
if (name == NULL || name[0] == '\0') {
|
||||
return NULL;
|
||||
if (name == nullptr || name[0] == '\0') {
|
||||
return nullptr;
|
||||
}
|
||||
const ListBase *defbase = BKE_object_defgroup_list(ob);
|
||||
return BLI_findstring(defbase, name, offsetof(bDeformGroup, name));
|
||||
return static_cast<bDeformGroup *>(BLI_findstring(defbase, name, offsetof(bDeformGroup, name)));
|
||||
}
|
||||
|
||||
int BKE_id_defgroup_name_index(const ID *id, const char *name)
|
||||
{
|
||||
int index;
|
||||
if (!BKE_id_defgroup_name_find(id, name, &index, NULL)) {
|
||||
if (!BKE_id_defgroup_name_find(id, name, &index, nullptr)) {
|
||||
return -1;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
bool BKE_id_defgroup_name_find(const struct ID *id,
|
||||
bool BKE_id_defgroup_name_find(const ID *id,
|
||||
const char *name,
|
||||
int *r_index,
|
||||
struct bDeformGroup **r_group)
|
||||
bDeformGroup **r_group)
|
||||
{
|
||||
if (name == NULL || name[0] == '\0') {
|
||||
if (name == nullptr || name[0] == '\0') {
|
||||
return false;
|
||||
}
|
||||
const ListBase *defbase = BKE_id_defgroup_list_get(id);
|
||||
int index;
|
||||
LISTBASE_FOREACH_INDEX (bDeformGroup *, group, defbase, index) {
|
||||
if (STREQ(name, group->name)) {
|
||||
if (r_index != NULL) {
|
||||
if (r_index != nullptr) {
|
||||
*r_index = index;
|
||||
}
|
||||
if (r_group != NULL) {
|
||||
if (r_group != nullptr) {
|
||||
*r_group = group;
|
||||
}
|
||||
return true;
|
||||
|
@ -582,19 +577,19 @@ static int *object_defgroup_unlocked_flip_map_ex(const Object *ob,
|
|||
*r_flip_map_num = defbase_num;
|
||||
|
||||
if (defbase_num == 0) {
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bDeformGroup *dg;
|
||||
char name_flip[sizeof(dg->name)];
|
||||
int i, flip_num;
|
||||
int *map = MEM_mallocN(defbase_num * sizeof(int), __func__);
|
||||
int *map = static_cast<int *>(MEM_mallocN(defbase_num * sizeof(int), __func__));
|
||||
|
||||
for (i = 0; i < defbase_num; i++) {
|
||||
map[i] = -1;
|
||||
}
|
||||
|
||||
for (dg = defbase->first, i = 0; dg; dg = dg->next, i++) {
|
||||
for (dg = static_cast<bDeformGroup *>(defbase->first), i = 0; dg; dg = dg->next, i++) {
|
||||
if (map[i] == -1) { /* may be calculated previously */
|
||||
|
||||
/* in case no valid value is found, use this */
|
||||
|
@ -642,18 +637,17 @@ int *BKE_object_defgroup_flip_map_single(const Object *ob,
|
|||
*r_flip_map_num = defbase_num;
|
||||
|
||||
if (defbase_num == 0) {
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bDeformGroup *dg;
|
||||
char name_flip[sizeof(dg->name)];
|
||||
int i, flip_num, *map = MEM_mallocN(defbase_num * sizeof(int), __func__);
|
||||
char name_flip[sizeof(bDeformGroup::name)];
|
||||
int i, flip_num, *map = static_cast<int *>(MEM_mallocN(defbase_num * sizeof(int), __func__));
|
||||
|
||||
for (i = 0; i < defbase_num; i++) {
|
||||
map[i] = use_default ? i : -1;
|
||||
}
|
||||
|
||||
dg = BLI_findlink(defbase, defgroup);
|
||||
bDeformGroup *dg = static_cast<bDeformGroup *>(BLI_findlink(defbase, defgroup));
|
||||
|
||||
BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
|
||||
if (!STREQ(name_flip, dg->name)) {
|
||||
|
@ -671,7 +665,7 @@ int *BKE_object_defgroup_flip_map_single(const Object *ob,
|
|||
int BKE_object_defgroup_flip_index(const Object *ob, int index, const bool use_default)
|
||||
{
|
||||
const ListBase *defbase = BKE_object_defgroup_list(ob);
|
||||
bDeformGroup *dg = BLI_findlink(defbase, index);
|
||||
bDeformGroup *dg = static_cast<bDeformGroup *>(BLI_findlink(defbase, index));
|
||||
int flip_index = -1;
|
||||
|
||||
if (dg) {
|
||||
|
@ -691,7 +685,7 @@ static bool defgroup_find_name_dupe(const char *name, bDeformGroup *dg, Object *
|
|||
const ListBase *defbase = BKE_object_defgroup_list(ob);
|
||||
bDeformGroup *curdef;
|
||||
|
||||
for (curdef = defbase->first; curdef; curdef = curdef->next) {
|
||||
for (curdef = static_cast<bDeformGroup *>(defbase->first); curdef; curdef = curdef->next) {
|
||||
if (dg != curdef) {
|
||||
if (STREQ(curdef->name, name)) {
|
||||
return true;
|
||||
|
@ -702,46 +696,42 @@ static bool defgroup_find_name_dupe(const char *name, bDeformGroup *dg, Object *
|
|||
return false;
|
||||
}
|
||||
|
||||
struct DeformGroupUniqueNameData {
|
||||
Object *ob;
|
||||
bDeformGroup *dg;
|
||||
};
|
||||
|
||||
static bool defgroup_unique_check(void *arg, const char *name)
|
||||
{
|
||||
struct {
|
||||
Object *ob;
|
||||
void *dg;
|
||||
} *data = arg;
|
||||
DeformGroupUniqueNameData *data = static_cast<DeformGroupUniqueNameData *>(arg);
|
||||
return defgroup_find_name_dupe(name, data->dg, data->ob);
|
||||
}
|
||||
|
||||
void BKE_object_defgroup_unique_name(bDeformGroup *dg, Object *ob)
|
||||
{
|
||||
struct {
|
||||
Object *ob;
|
||||
void *dg;
|
||||
} data;
|
||||
data.ob = ob;
|
||||
data.dg = dg;
|
||||
|
||||
DeformGroupUniqueNameData data{ob, dg};
|
||||
BLI_uniquename_cb(defgroup_unique_check, &data, DATA_("Group"), '.', dg->name, sizeof(dg->name));
|
||||
}
|
||||
|
||||
float BKE_defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
|
||||
float BKE_defvert_find_weight(const MDeformVert *dvert, const int defgroup)
|
||||
{
|
||||
MDeformWeight *dw = BKE_defvert_find_index(dvert, defgroup);
|
||||
return dw ? dw->weight : 0.0f;
|
||||
}
|
||||
|
||||
float BKE_defvert_array_find_weight_safe(const struct MDeformVert *dvert,
|
||||
float BKE_defvert_array_find_weight_safe(const MDeformVert *dvert,
|
||||
const int index,
|
||||
const int defgroup)
|
||||
{
|
||||
/* Invalid defgroup index means the vgroup selected is invalid,
|
||||
* does not exist, in that case it is OK to return 1.0
|
||||
* (i.e. maximum weight, as if no vgroup was selected).
|
||||
* But in case of valid defgroup and NULL dvert data pointer, it means that vgroup **is** valid,
|
||||
* and just totally empty, so we shall return '0.0' value then! */
|
||||
* But in case of valid defgroup and nullptr dvert data pointer, it means that vgroup **is**
|
||||
* valid, and just totally empty, so we shall return '0.0' value then! */
|
||||
if (defgroup == -1) {
|
||||
return 1.0f;
|
||||
}
|
||||
if (dvert == NULL) {
|
||||
if (dvert == nullptr) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
|
@ -764,7 +754,7 @@ MDeformWeight *BKE_defvert_find_index(const MDeformVert *dvert, const int defgro
|
|||
BLI_assert(0);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
MDeformWeight *BKE_defvert_ensure_index(MDeformVert *dvert, const int defgroup)
|
||||
|
@ -774,7 +764,7 @@ MDeformWeight *BKE_defvert_ensure_index(MDeformVert *dvert, const int defgroup)
|
|||
/* do this check always, this function is used to check for it */
|
||||
if (!dvert || defgroup < 0) {
|
||||
BLI_assert(0);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
dw_new = BKE_defvert_find_index(dvert, defgroup);
|
||||
|
@ -782,7 +772,8 @@ MDeformWeight *BKE_defvert_ensure_index(MDeformVert *dvert, const int defgroup)
|
|||
return dw_new;
|
||||
}
|
||||
|
||||
dw_new = MEM_mallocN(sizeof(MDeformWeight) * (dvert->totweight + 1), "deformWeight");
|
||||
dw_new = static_cast<MDeformWeight *>(
|
||||
MEM_mallocN(sizeof(MDeformWeight) * (dvert->totweight + 1), __func__));
|
||||
if (dvert->dw) {
|
||||
memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
|
||||
MEM_freeN(dvert->dw);
|
||||
|
@ -810,8 +801,8 @@ void BKE_defvert_add_index_notest(MDeformVert *dvert, const int defgroup, const
|
|||
return;
|
||||
}
|
||||
|
||||
dw_new = MEM_callocN(sizeof(MDeformWeight) * (dvert->totweight + 1),
|
||||
"defvert_add_to group, new deformWeight");
|
||||
dw_new = static_cast<MDeformWeight *>(
|
||||
MEM_callocN(sizeof(MDeformWeight) * (dvert->totweight + 1), __func__));
|
||||
if (dvert->dw) {
|
||||
memcpy(dw_new, dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
|
||||
MEM_freeN(dvert->dw);
|
||||
|
@ -838,18 +829,19 @@ void BKE_defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
|
|||
* this deform weight, and reshuffle the others.
|
||||
*/
|
||||
if (dvert->totweight) {
|
||||
BLI_assert(dvert->dw != NULL);
|
||||
BLI_assert(dvert->dw != nullptr);
|
||||
|
||||
if (i != dvert->totweight) {
|
||||
dvert->dw[i] = dvert->dw[dvert->totweight];
|
||||
}
|
||||
|
||||
dvert->dw = MEM_reallocN(dvert->dw, sizeof(MDeformWeight) * dvert->totweight);
|
||||
dvert->dw = static_cast<MDeformWeight *>(
|
||||
MEM_reallocN(dvert->dw, sizeof(MDeformWeight) * dvert->totweight));
|
||||
}
|
||||
else {
|
||||
/* If there are no other deform weights left then just remove this one. */
|
||||
MEM_freeN(dvert->dw);
|
||||
dvert->dw = NULL;
|
||||
dvert->dw = nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -877,7 +869,7 @@ int BKE_defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert
|
|||
return -1;
|
||||
}
|
||||
|
||||
bool BKE_defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot)
|
||||
bool BKE_defvert_is_weight_zero(const MDeformVert *dvert, const int defgroup_tot)
|
||||
{
|
||||
MDeformWeight *dw = dvert->dw;
|
||||
for (int i = dvert->totweight; i != 0; i--, dw++) {
|
||||
|
@ -891,14 +883,14 @@ bool BKE_defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgr
|
|||
return true;
|
||||
}
|
||||
|
||||
float BKE_defvert_total_selected_weight(const struct MDeformVert *dv,
|
||||
float BKE_defvert_total_selected_weight(const MDeformVert *dv,
|
||||
int defbase_num,
|
||||
const bool *defbase_sel)
|
||||
{
|
||||
float total = 0.0f;
|
||||
const MDeformWeight *dw = dv->dw;
|
||||
|
||||
if (defbase_sel == NULL) {
|
||||
if (defbase_sel == nullptr) {
|
||||
return total;
|
||||
}
|
||||
|
||||
|
@ -913,7 +905,7 @@ float BKE_defvert_total_selected_weight(const struct MDeformVert *dv,
|
|||
return total;
|
||||
}
|
||||
|
||||
float BKE_defvert_multipaint_collective_weight(const struct MDeformVert *dv,
|
||||
float BKE_defvert_multipaint_collective_weight(const MDeformVert *dv,
|
||||
const int defbase_num,
|
||||
const bool *defbase_sel,
|
||||
const int defbase_sel_num,
|
||||
|
@ -959,7 +951,7 @@ float BKE_defvert_calc_lock_relative_weight(float weight,
|
|||
}
|
||||
|
||||
float BKE_defvert_lock_relative_weight(const float weight,
|
||||
const struct MDeformVert *dv,
|
||||
const MDeformVert *dv,
|
||||
const int defbase_num,
|
||||
const bool *defbase_locked,
|
||||
const bool *defbase_unlocked)
|
||||
|
@ -991,7 +983,8 @@ void BKE_defvert_array_copy(MDeformVert *dst, const MDeformVert *src, int totver
|
|||
|
||||
for (int i = 0; i < totvert; i++) {
|
||||
if (src[i].dw) {
|
||||
dst[i].dw = MEM_mallocN(sizeof(MDeformWeight) * src[i].totweight, "copy_deformWeight");
|
||||
dst[i].dw = static_cast<MDeformWeight *>(
|
||||
MEM_mallocN(sizeof(MDeformWeight) * src[i].totweight, __func__));
|
||||
memcpy(dst[i].dw, src[i].dw, sizeof(MDeformWeight) * src[i].totweight);
|
||||
}
|
||||
}
|
||||
|
@ -1059,7 +1052,8 @@ void BKE_defvert_extract_vgroup_to_edgeweights(const MDeformVert *dvert,
|
|||
{
|
||||
if (dvert && defgroup != -1) {
|
||||
int i = edges_num;
|
||||
float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__);
|
||||
float *tmp_weights = static_cast<float *>(
|
||||
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
|
||||
|
||||
BKE_defvert_extract_vgroup_to_vertweights(
|
||||
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
|
||||
|
@ -1087,7 +1081,8 @@ void BKE_defvert_extract_vgroup_to_loopweights(const MDeformVert *dvert,
|
|||
{
|
||||
if (dvert && defgroup != -1) {
|
||||
int i = loops_num;
|
||||
float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__);
|
||||
float *tmp_weights = static_cast<float *>(
|
||||
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
|
||||
|
||||
BKE_defvert_extract_vgroup_to_vertweights(
|
||||
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
|
||||
|
@ -1109,7 +1104,7 @@ void BKE_defvert_extract_vgroup_to_polyweights(const MDeformVert *dvert,
|
|||
const int defgroup,
|
||||
const int verts_num,
|
||||
const MLoop *loops,
|
||||
const int UNUSED(loops_num),
|
||||
const int /*loops_num*/,
|
||||
const MPoly *polys,
|
||||
const int polys_num,
|
||||
const bool invert_vgroup,
|
||||
|
@ -1117,7 +1112,8 @@ void BKE_defvert_extract_vgroup_to_polyweights(const MDeformVert *dvert,
|
|||
{
|
||||
if (dvert && defgroup != -1) {
|
||||
int i = polys_num;
|
||||
float *tmp_weights = MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__);
|
||||
float *tmp_weights = static_cast<float *>(
|
||||
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
|
||||
|
||||
BKE_defvert_extract_vgroup_to_vertweights(
|
||||
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
|
||||
|
@ -1131,7 +1127,7 @@ void BKE_defvert_extract_vgroup_to_polyweights(const MDeformVert *dvert,
|
|||
for (; j--; ml++) {
|
||||
w += tmp_weights[ml->v];
|
||||
}
|
||||
r_weights[i] = w / (float)mp->totloop;
|
||||
r_weights[i] = w / float(mp->totloop);
|
||||
}
|
||||
|
||||
MEM_freeN(tmp_weights);
|
||||
|
@ -1217,9 +1213,9 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
Object *ob_dst,
|
||||
const MDeformVert *data_src,
|
||||
MDeformVert *data_dst,
|
||||
const CustomData *UNUSED(cd_src),
|
||||
const CustomData * /*cd_src*/,
|
||||
CustomData *cd_dst,
|
||||
const bool UNUSED(use_dupref_dst),
|
||||
const bool /*use_dupref_dst*/,
|
||||
const int tolayers,
|
||||
const bool *use_layers_src,
|
||||
const int num_layers_src)
|
||||
|
@ -1231,7 +1227,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
|
||||
const int tot_dst = BLI_listbase_count(dst_defbase);
|
||||
|
||||
const size_t elem_size = sizeof(*((MDeformVert *)NULL));
|
||||
const size_t elem_size = sizeof(*((MDeformVert *)nullptr));
|
||||
|
||||
switch (tolayers) {
|
||||
case DT_LAYERS_INDEX_DST:
|
||||
|
@ -1258,15 +1254,15 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
}
|
||||
else if (use_delete && idx_dst > idx_src) {
|
||||
while (idx_dst-- > idx_src) {
|
||||
BKE_object_defgroup_remove(ob_dst, dst_defbase->last);
|
||||
BKE_object_defgroup_remove(ob_dst, static_cast<bDeformGroup *>(dst_defbase->last));
|
||||
}
|
||||
}
|
||||
if (r_map) {
|
||||
/* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
|
||||
* Again, use_create is not relevant in this case */
|
||||
if (!data_dst) {
|
||||
data_dst = CustomData_add_layer(
|
||||
cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, NULL, num_elem_dst);
|
||||
data_dst = static_cast<MDeformVert *>(
|
||||
CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, num_elem_dst));
|
||||
}
|
||||
|
||||
while (idx_src--) {
|
||||
|
@ -1287,7 +1283,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
0,
|
||||
0,
|
||||
vgroups_datatransfer_interp,
|
||||
NULL);
|
||||
nullptr);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
@ -1296,7 +1292,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
|
||||
if (use_delete) {
|
||||
/* Remove all unused dst vgroups first, simpler in this case. */
|
||||
for (dg_dst = dst_defbase->first; dg_dst;) {
|
||||
for (dg_dst = static_cast<bDeformGroup *>(dst_defbase->first); dg_dst;) {
|
||||
bDeformGroup *dg_dst_next = dg_dst->next;
|
||||
|
||||
if (BKE_object_defgroup_name_index(ob_src, dg_dst->name) == -1) {
|
||||
|
@ -1306,7 +1302,8 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
}
|
||||
}
|
||||
|
||||
for (idx_src = 0, dg_src = src_list->first; idx_src < num_layers_src;
|
||||
for (idx_src = 0, dg_src = static_cast<bDeformGroup *>(src_list->first);
|
||||
idx_src < num_layers_src;
|
||||
idx_src++, dg_src = dg_src->next) {
|
||||
if (!use_layers_src[idx_src]) {
|
||||
continue;
|
||||
|
@ -1326,8 +1323,8 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
/* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
|
||||
* use_create is not relevant in this case */
|
||||
if (!data_dst) {
|
||||
data_dst = CustomData_add_layer(
|
||||
cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, NULL, num_elem_dst);
|
||||
data_dst = static_cast<MDeformVert *>(CustomData_add_layer(
|
||||
cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, num_elem_dst));
|
||||
}
|
||||
|
||||
data_transfer_layersmapping_add_item(r_map,
|
||||
|
@ -1344,7 +1341,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
|
|||
0,
|
||||
0,
|
||||
vgroups_datatransfer_interp,
|
||||
NULL);
|
||||
nullptr);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
@ -1373,13 +1370,13 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
{
|
||||
int idx_src, idx_dst;
|
||||
|
||||
const size_t elem_size = sizeof(*((MDeformVert *)NULL));
|
||||
const size_t elem_size = sizeof(*((MDeformVert *)nullptr));
|
||||
|
||||
/* NOTE:
|
||||
* VGroups are a bit hairy, since their layout is defined on object level (ob->defbase),
|
||||
* while their actual data is a (mesh) CD layer.
|
||||
* This implies we may have to handle data layout itself while having NULL data itself,
|
||||
* and even have to support NULL data_src in transfer data code
|
||||
* This implies we may have to handle data layout itself while having nullptr data itself,
|
||||
* and even have to support nullptr data_src in transfer data code
|
||||
* (we always create a data_dst, though).
|
||||
*
|
||||
* NOTE: Above comment is outdated, but this function was written when that was true.
|
||||
|
@ -1393,12 +1390,15 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
return true;
|
||||
}
|
||||
|
||||
const MDeformVert *data_src = CustomData_get_layer(cd_src, CD_MDEFORMVERT);
|
||||
const MDeformVert *data_src = static_cast<const MDeformVert *>(
|
||||
CustomData_get_layer(cd_src, CD_MDEFORMVERT));
|
||||
|
||||
MDeformVert *data_dst = CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst);
|
||||
MDeformVert *data_dst = static_cast<MDeformVert *>(
|
||||
CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst));
|
||||
if (data_dst && use_dupref_dst && r_map) {
|
||||
/* If dest is a derivedmesh, we do not want to overwrite cdlayers of org mesh! */
|
||||
data_dst = CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst);
|
||||
data_dst = static_cast<MDeformVert *>(
|
||||
CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst));
|
||||
}
|
||||
|
||||
if (fromlayers == DT_LAYERS_ACTIVE_SRC || fromlayers >= 0) {
|
||||
|
@ -1430,7 +1430,7 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
if (!use_create) {
|
||||
return true;
|
||||
}
|
||||
dg_src = BLI_findlink(src_defbase, idx_src);
|
||||
dg_src = static_cast<bDeformGroup *>(BLI_findlink(src_defbase, idx_src));
|
||||
BKE_object_defgroup_add_name(ob_dst, dg_src->name);
|
||||
idx_dst = BKE_object_defgroup_active_index_get(ob_dst) - 1;
|
||||
}
|
||||
|
@ -1449,7 +1449,7 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
}
|
||||
}
|
||||
else if (tolayers == DT_LAYERS_NAME_DST) {
|
||||
bDeformGroup *dg_src = BLI_findlink(src_defbase, idx_src);
|
||||
bDeformGroup *dg_src = static_cast<bDeformGroup *>(BLI_findlink(src_defbase, idx_src));
|
||||
if ((idx_dst = BKE_object_defgroup_name_index(ob_dst, dg_src->name)) == -1) {
|
||||
if (!use_create) {
|
||||
return true;
|
||||
|
@ -1466,8 +1466,8 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
/* At this stage, we **need** a valid CD_MDEFORMVERT layer on dest!
|
||||
* use_create is not relevant in this case */
|
||||
if (!data_dst) {
|
||||
data_dst = CustomData_add_layer(
|
||||
cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, NULL, num_elem_dst);
|
||||
data_dst = static_cast<MDeformVert *>(
|
||||
CustomData_add_layer(cd_dst, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, num_elem_dst));
|
||||
}
|
||||
|
||||
data_transfer_layersmapping_add_item(r_map,
|
||||
|
@ -1484,12 +1484,12 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
|
|||
0,
|
||||
0,
|
||||
vgroups_datatransfer_interp,
|
||||
NULL);
|
||||
nullptr);
|
||||
}
|
||||
}
|
||||
else {
|
||||
int num_src, num_sel_unused;
|
||||
bool *use_layers_src = NULL;
|
||||
bool *use_layers_src = nullptr;
|
||||
bool ret = false;
|
||||
|
||||
switch (fromlayers) {
|
||||
|
@ -1588,7 +1588,7 @@ void BKE_defbase_blend_write(BlendWriter *writer, const ListBase *defbase)
|
|||
|
||||
void BKE_defvert_blend_write(BlendWriter *writer, int count, const MDeformVert *dvlist)
|
||||
{
|
||||
if (dvlist == NULL) {
|
||||
if (dvlist == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1605,22 +1605,23 @@ void BKE_defvert_blend_write(BlendWriter *writer, int count, const MDeformVert *
|
|||
|
||||
void BKE_defvert_blend_read(BlendDataReader *reader, int count, MDeformVert *mdverts)
|
||||
{
|
||||
if (mdverts == NULL) {
|
||||
if (mdverts == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = count; i > 0; i--, mdverts++) {
|
||||
/* Convert to vertex group allocation system. */
|
||||
MDeformWeight *dw;
|
||||
if (mdverts->dw && (dw = BLO_read_get_new_data_address(reader, mdverts->dw))) {
|
||||
if (mdverts->dw &&
|
||||
(dw = static_cast<MDeformWeight *>(BLO_read_get_new_data_address(reader, mdverts->dw)))) {
|
||||
const size_t dw_len = sizeof(MDeformWeight) * mdverts->totweight;
|
||||
void *dw_tmp = MEM_mallocN(dw_len, __func__);
|
||||
memcpy(dw_tmp, dw, dw_len);
|
||||
mdverts->dw = dw_tmp;
|
||||
mdverts->dw = static_cast<MDeformWeight *>(dw_tmp);
|
||||
MEM_freeN(dw);
|
||||
}
|
||||
else {
|
||||
mdverts->dw = NULL;
|
||||
mdverts->dw = nullptr;
|
||||
mdverts->totweight = 0;
|
||||
}
|
||||
}
|
|
@ -34,8 +34,8 @@ set(INC_SYS
|
|||
|
||||
set(SRC
|
||||
object_add.cc
|
||||
object_bake.c
|
||||
object_bake_api.c
|
||||
object_bake.cc
|
||||
object_bake_api.cc
|
||||
object_collection.c
|
||||
object_constraint.c
|
||||
object_data_transfer.c
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
* \ingroup edobj
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <cstring>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
|
@ -56,14 +56,15 @@
|
|||
|
||||
static Image *bake_object_image_get(Object *ob, int mat_nr)
|
||||
{
|
||||
Image *image = NULL;
|
||||
ED_object_get_active_image(ob, mat_nr + 1, &image, NULL, NULL, NULL);
|
||||
Image *image = nullptr;
|
||||
ED_object_get_active_image(ob, mat_nr + 1, &image, nullptr, nullptr, nullptr);
|
||||
return image;
|
||||
}
|
||||
|
||||
static Image **bake_object_image_get_array(Object *ob)
|
||||
{
|
||||
Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
|
||||
Image **image_array = static_cast<Image **>(
|
||||
MEM_mallocN(sizeof(Material *) * ob->totcol, __func__));
|
||||
for (int i = 0; i < ob->totcol; i++) {
|
||||
image_array[i] = bake_object_image_get(ob, i);
|
||||
}
|
||||
|
@ -74,8 +75,8 @@ static Image **bake_object_image_get_array(Object *ob)
|
|||
|
||||
/* holder of per-object data needed for bake job
|
||||
* needed to make job totally thread-safe */
|
||||
typedef struct MultiresBakerJobData {
|
||||
struct MultiresBakerJobData *next, *prev;
|
||||
struct MultiresBakerJobData {
|
||||
MultiresBakerJobData *next, *prev;
|
||||
/* material aligned image array (for per-face bake image) */
|
||||
struct {
|
||||
Image **array;
|
||||
|
@ -84,10 +85,10 @@ typedef struct MultiresBakerJobData {
|
|||
DerivedMesh *lores_dm, *hires_dm;
|
||||
int lvl, tot_lvl;
|
||||
ListBase images;
|
||||
} MultiresBakerJobData;
|
||||
};
|
||||
|
||||
/* data passing to multires-baker job */
|
||||
typedef struct {
|
||||
struct MultiresBakeJob {
|
||||
Scene *scene;
|
||||
ListBase data;
|
||||
/** Clear the images before baking */
|
||||
|
@ -108,7 +109,7 @@ typedef struct {
|
|||
int threads;
|
||||
/** User scale used to scale displacement when baking derivative map. */
|
||||
float user_scale;
|
||||
} MultiresBakeJob;
|
||||
};
|
||||
|
||||
static bool multiresbake_check(bContext *C, wmOperator *op)
|
||||
{
|
||||
|
@ -178,7 +179,7 @@ static bool multiresbake_check(bContext *C, wmOperator *op)
|
|||
BKE_imageuser_default(&iuser);
|
||||
iuser.tile = tile->tile_number;
|
||||
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, NULL);
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, nullptr);
|
||||
|
||||
if (!ibuf) {
|
||||
BKE_report(
|
||||
|
@ -187,7 +188,7 @@ static bool multiresbake_check(bContext *C, wmOperator *op)
|
|||
ok = false;
|
||||
}
|
||||
else {
|
||||
if (ibuf->rect == NULL && ibuf->rect_float == NULL) {
|
||||
if (ibuf->rect == nullptr && ibuf->rect_float == nullptr) {
|
||||
ok = false;
|
||||
}
|
||||
|
||||
|
@ -200,7 +201,7 @@ static bool multiresbake_check(bContext *C, wmOperator *op)
|
|||
}
|
||||
}
|
||||
|
||||
BKE_image_release_ibuf(ima, ibuf, NULL);
|
||||
BKE_image_release_ibuf(ima, ibuf, nullptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -234,7 +235,7 @@ static DerivedMesh *multiresbake_create_loresdm(Scene *scene, Object *ob, int *l
|
|||
DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
|
||||
tmp_mmd.lvl = mmd->lvl;
|
||||
tmp_mmd.sculptlvl = mmd->lvl;
|
||||
dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
|
||||
dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, MultiresFlags(0));
|
||||
|
||||
cddm->release(cddm);
|
||||
|
||||
|
@ -261,7 +262,7 @@ static DerivedMesh *multiresbake_create_hiresdm(Scene *scene, Object *ob, int *l
|
|||
|
||||
tmp_mmd.lvl = mmd->totlvl;
|
||||
tmp_mmd.sculptlvl = mmd->totlvl;
|
||||
dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
|
||||
dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, MultiresFlags(0));
|
||||
cddm->release(cddm);
|
||||
|
||||
return dm;
|
||||
|
@ -287,7 +288,7 @@ static void clear_single_image(Image *image, ClearFlag flag)
|
|||
BKE_imageuser_default(&iuser);
|
||||
iuser.tile = tile->tile_number;
|
||||
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(image, &iuser, NULL);
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(image, &iuser, nullptr);
|
||||
|
||||
if (flag == CLEAR_TANGENT_NORMAL) {
|
||||
IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? nor_alpha : nor_solid);
|
||||
|
@ -301,7 +302,7 @@ static void clear_single_image(Image *image, ClearFlag flag)
|
|||
|
||||
image->id.tag |= LIB_TAG_DOIT;
|
||||
|
||||
BKE_image_release_ibuf(image, ibuf, NULL);
|
||||
BKE_image_release_ibuf(image, ibuf, nullptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -342,7 +343,7 @@ static int multiresbake_image_exec_locked(bContext *C, wmOperator *op)
|
|||
|
||||
if (scene->r.bake_flag & R_BAKE_CLEAR) { /* clear images */
|
||||
CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
|
||||
ClearFlag clear_flag = 0;
|
||||
ClearFlag clear_flag = ClearFlag(0);
|
||||
|
||||
ob = base->object;
|
||||
// me = (Mesh *)ob->data;
|
||||
|
@ -364,7 +365,7 @@ static int multiresbake_image_exec_locked(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
|
||||
MultiresBakeRender bkr = {NULL};
|
||||
MultiresBakeRender bkr = {nullptr};
|
||||
|
||||
ob = base->object;
|
||||
|
||||
|
@ -439,14 +440,13 @@ static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
|
|||
// bkj->reports = op->reports;
|
||||
|
||||
CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
|
||||
MultiresBakerJobData *data;
|
||||
int lvl;
|
||||
|
||||
ob = base->object;
|
||||
|
||||
multires_flush_sculpt_updates(ob);
|
||||
|
||||
data = MEM_callocN(sizeof(MultiresBakerJobData), "multiresBaker derivedMesh_data");
|
||||
MultiresBakerJobData *data = MEM_cnew<MultiresBakerJobData>(__func__);
|
||||
|
||||
data->ob_image.array = bake_object_image_get_array(ob);
|
||||
data->ob_image.len = ob->totcol;
|
||||
|
@ -464,14 +464,14 @@ static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
|
|||
static void multiresbake_startjob(void *bkv, bool *stop, bool *do_update, float *progress)
|
||||
{
|
||||
MultiresBakerJobData *data;
|
||||
MultiresBakeJob *bkj = bkv;
|
||||
MultiresBakeJob *bkj = static_cast<MultiresBakeJob *>(bkv);
|
||||
int baked_objects = 0, tot_obj;
|
||||
|
||||
tot_obj = BLI_listbase_count(&bkj->data);
|
||||
|
||||
if (bkj->bake_clear) { /* clear images */
|
||||
for (data = bkj->data.first; data; data = data->next) {
|
||||
ClearFlag clear_flag = 0;
|
||||
for (data = static_cast<MultiresBakerJobData *>(bkj->data.first); data; data = data->next) {
|
||||
ClearFlag clear_flag = ClearFlag(0);
|
||||
|
||||
if (bkj->mode == RE_BAKE_NORMALS) {
|
||||
clear_flag = CLEAR_TANGENT_NORMAL;
|
||||
|
@ -484,8 +484,8 @@ static void multiresbake_startjob(void *bkv, bool *stop, bool *do_update, float
|
|||
}
|
||||
}
|
||||
|
||||
for (data = bkj->data.first; data; data = data->next) {
|
||||
MultiresBakeRender bkr = {NULL};
|
||||
for (data = static_cast<MultiresBakerJobData *>(bkj->data.first); data; data = data->next) {
|
||||
MultiresBakeRender bkr = {nullptr};
|
||||
|
||||
/* copy data stored in job descriptor */
|
||||
bkr.scene = bkj->scene;
|
||||
|
@ -526,18 +526,18 @@ static void multiresbake_startjob(void *bkv, bool *stop, bool *do_update, float
|
|||
|
||||
static void multiresbake_freejob(void *bkv)
|
||||
{
|
||||
MultiresBakeJob *bkj = bkv;
|
||||
MultiresBakeJob *bkj = static_cast<MultiresBakeJob *>(bkv);
|
||||
MultiresBakerJobData *data, *next;
|
||||
LinkData *link;
|
||||
|
||||
data = bkj->data.first;
|
||||
data = static_cast<MultiresBakerJobData *>(bkj->data.first);
|
||||
while (data) {
|
||||
next = data->next;
|
||||
data->lores_dm->release(data->lores_dm);
|
||||
data->hires_dm->release(data->hires_dm);
|
||||
|
||||
/* delete here, since this delete will be called from main thread */
|
||||
for (link = data->images.first; link; link = link->next) {
|
||||
for (link = static_cast<LinkData *>(data->images.first); link; link = link->next) {
|
||||
Image *ima = (Image *)link->data;
|
||||
BKE_image_partial_update_mark_full_update(ima);
|
||||
}
|
||||
|
@ -556,14 +556,12 @@ static void multiresbake_freejob(void *bkv)
|
|||
static int multiresbake_image_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
MultiresBakeJob *bkr;
|
||||
wmJob *wm_job;
|
||||
|
||||
if (!multiresbake_check(C, op)) {
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
bkr = MEM_callocN(sizeof(MultiresBakeJob), "MultiresBakeJob data");
|
||||
MultiresBakeJob *bkr = MEM_cnew<MultiresBakeJob>(__func__);
|
||||
init_multiresbake_job(C, bkr);
|
||||
|
||||
if (!bkr->data.first) {
|
||||
|
@ -572,15 +570,15 @@ static int multiresbake_image_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
/* setup job */
|
||||
wm_job = WM_jobs_get(CTX_wm_manager(C),
|
||||
CTX_wm_window(C),
|
||||
scene,
|
||||
"Multires Bake",
|
||||
WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS,
|
||||
WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
|
||||
wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C),
|
||||
CTX_wm_window(C),
|
||||
scene,
|
||||
"Multires Bake",
|
||||
WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS,
|
||||
WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
|
||||
WM_jobs_customdata_set(wm_job, bkr, multiresbake_freejob);
|
||||
WM_jobs_timer(wm_job, 0.5, NC_IMAGE, 0); /* TODO: only draw bake image, can we enforce this. */
|
||||
WM_jobs_callbacks(wm_job, multiresbake_startjob, NULL, NULL, NULL);
|
||||
WM_jobs_callbacks(wm_job, multiresbake_startjob, nullptr, nullptr, nullptr);
|
||||
|
||||
G.is_break = false;
|
||||
|
||||
|
@ -596,7 +594,7 @@ static int multiresbake_image_exec(bContext *C, wmOperator *op)
|
|||
/* ****************** render BAKING ********************** */
|
||||
|
||||
/** Catch escape key to cancel. */
|
||||
static int objects_bake_render_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
|
||||
static int objects_bake_render_modal(bContext *C, wmOperator * /*op*/, const wmEvent *event)
|
||||
{
|
||||
/* no running blender, remove handler and pass through */
|
||||
if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_data_scene(C), WM_JOB_TYPE_OBJECT_BAKE_TEXTURE)) {
|
||||
|
@ -620,7 +618,7 @@ static bool is_multires_bake(Scene *scene)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int objects_bake_render_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(_event))
|
||||
static int objects_bake_render_invoke(bContext *C, wmOperator *op, const wmEvent * /*event*/)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
int result = OPERATOR_CANCELLED;
|
|
@ -65,7 +65,7 @@
|
|||
/* prototypes */
|
||||
static void bake_set_props(wmOperator *op, Scene *scene);
|
||||
|
||||
typedef struct BakeAPIRender {
|
||||
struct BakeAPIRender {
|
||||
/* Data to work on. */
|
||||
Main *main;
|
||||
Scene *scene;
|
||||
|
@ -113,13 +113,13 @@ typedef struct BakeAPIRender {
|
|||
ReportList *reports;
|
||||
int result;
|
||||
ScrArea *area;
|
||||
} BakeAPIRender;
|
||||
};
|
||||
|
||||
/* callbacks */
|
||||
|
||||
static void bake_progress_update(void *bjv, float progress)
|
||||
{
|
||||
BakeAPIRender *bj = bjv;
|
||||
BakeAPIRender *bj = static_cast<BakeAPIRender *>(bjv);
|
||||
|
||||
if (bj->progress && *bj->progress != progress) {
|
||||
*bj->progress = progress;
|
||||
|
@ -130,7 +130,7 @@ static void bake_progress_update(void *bjv, float progress)
|
|||
}
|
||||
|
||||
/** Catch escape key to cancel. */
|
||||
static int bake_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
|
||||
static int bake_modal(bContext *C, wmOperator * /*op*/, const wmEvent *event)
|
||||
{
|
||||
/* no running blender, remove handler and pass through */
|
||||
if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_data_scene(C), WM_JOB_TYPE_OBJECT_BAKE)) {
|
||||
|
@ -151,7 +151,7 @@ static int bake_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
|
|||
* for exec() when there is no render job
|
||||
* NOTE: this won't check for the escape key being pressed, but doing so isn't thread-safe.
|
||||
*/
|
||||
static bool bake_break(void *UNUSED(rjv))
|
||||
static bool bake_break(void * /*rjv*/)
|
||||
{
|
||||
if (G.is_break) {
|
||||
return true;
|
||||
|
@ -162,7 +162,7 @@ static bool bake_break(void *UNUSED(rjv))
|
|||
static void bake_update_image(ScrArea *area, Image *image)
|
||||
{
|
||||
if (area && area->spacetype == SPACE_IMAGE) { /* in case the user changed while baking */
|
||||
SpaceImage *sima = area->spacedata.first;
|
||||
SpaceImage *sima = static_cast<SpaceImage *>(area->spacedata.first);
|
||||
if (sima) {
|
||||
sima->image = image;
|
||||
}
|
||||
|
@ -186,7 +186,7 @@ static bool write_internal_bake_pixels(Image *image,
|
|||
ImBuf *ibuf;
|
||||
void *lock;
|
||||
bool is_float;
|
||||
char *mask_buffer = NULL;
|
||||
char *mask_buffer = nullptr;
|
||||
const size_t pixels_num = (size_t)width * (size_t)height;
|
||||
|
||||
ImageUser iuser;
|
||||
|
@ -199,11 +199,11 @@ static bool write_internal_bake_pixels(Image *image,
|
|||
}
|
||||
|
||||
if (margin > 0 || !is_clear) {
|
||||
mask_buffer = MEM_callocN(sizeof(char) * pixels_num, "Bake Mask");
|
||||
mask_buffer = static_cast<char *>(MEM_callocN(sizeof(char) * pixels_num, "Bake Mask"));
|
||||
RE_bake_mask_fill(pixel_array, pixels_num, mask_buffer);
|
||||
}
|
||||
|
||||
is_float = (ibuf->rect_float != NULL);
|
||||
is_float = (ibuf->rect_float != nullptr);
|
||||
|
||||
/* colormanagement conversions */
|
||||
if (!is_noncolor) {
|
||||
|
@ -296,7 +296,7 @@ static bool write_internal_bake_pixels(Image *image,
|
|||
imb_freemipmapImBuf(ibuf);
|
||||
}
|
||||
|
||||
BKE_image_release_ibuf(image, ibuf, NULL);
|
||||
BKE_image_release_ibuf(image, ibuf, nullptr);
|
||||
|
||||
if (mask_buffer) {
|
||||
MEM_freeN(mask_buffer);
|
||||
|
@ -332,7 +332,7 @@ static bool write_external_bake_pixels(const char *filepath,
|
|||
char const *uv_layer,
|
||||
const float uv_offset[2])
|
||||
{
|
||||
ImBuf *ibuf = NULL;
|
||||
ImBuf *ibuf = nullptr;
|
||||
bool ok = false;
|
||||
bool is_float;
|
||||
|
||||
|
@ -382,10 +382,10 @@ static bool write_external_bake_pixels(const char *filepath,
|
|||
|
||||
/* margins */
|
||||
if (margin > 0) {
|
||||
char *mask_buffer = NULL;
|
||||
char *mask_buffer = nullptr;
|
||||
const size_t pixels_num = (size_t)width * (size_t)height;
|
||||
|
||||
mask_buffer = MEM_callocN(sizeof(char) * pixels_num, "Bake Mask");
|
||||
mask_buffer = static_cast<char *>(MEM_callocN(sizeof(char) * pixels_num, "Bake Mask"));
|
||||
RE_bake_mask_fill(pixel_array, pixels_num, mask_buffer);
|
||||
RE_bake_margin(ibuf, mask_buffer, margin, margin_type, mesh_eval, uv_layer, uv_offset);
|
||||
|
||||
|
@ -429,7 +429,7 @@ static bool bake_object_check(const Scene *scene,
|
|||
BKE_view_layer_synced_ensure(scene, view_layer);
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base == NULL) {
|
||||
if (base == nullptr) {
|
||||
BKE_reportf(reports, RPT_ERROR, "Object \"%s\" is not in view layer", ob->id.name + 2);
|
||||
return false;
|
||||
}
|
||||
|
@ -468,11 +468,11 @@ static bool bake_object_check(const Scene *scene,
|
|||
}
|
||||
|
||||
for (int i = 0; i < ob->totcol; i++) {
|
||||
const bNodeTree *ntree = NULL;
|
||||
const bNode *node = NULL;
|
||||
const bNodeTree *ntree = nullptr;
|
||||
const bNode *node = nullptr;
|
||||
const int mat_nr = i + 1;
|
||||
Image *image;
|
||||
ED_object_get_active_image(ob, mat_nr, &image, NULL, &node, &ntree);
|
||||
ED_object_get_active_image(ob, mat_nr, &image, nullptr, &node, &ntree);
|
||||
|
||||
if (image) {
|
||||
|
||||
|
@ -514,7 +514,7 @@ static bool bake_object_check(const Scene *scene,
|
|||
}
|
||||
else {
|
||||
Material *mat = BKE_object_material_get(ob, mat_nr);
|
||||
if (mat != NULL) {
|
||||
if (mat != nullptr) {
|
||||
BKE_reportf(reports,
|
||||
RPT_INFO,
|
||||
"No active image found in material \"%s\" (%d) for object \"%s\"",
|
||||
|
@ -614,7 +614,8 @@ static bool bake_objects_check(Main *bmain,
|
|||
return false;
|
||||
}
|
||||
|
||||
for (link = selected_objects->first; link; link = link->next) {
|
||||
for (link = static_cast<CollectionPointerLink *>(selected_objects->first); link;
|
||||
link = link->next) {
|
||||
Object *ob_iter = (Object *)link->ptr.data;
|
||||
|
||||
if (ob_iter == ob) {
|
||||
|
@ -643,8 +644,10 @@ static bool bake_objects_check(Main *bmain,
|
|||
return false;
|
||||
}
|
||||
|
||||
for (link = selected_objects->first; link; link = link->next) {
|
||||
if (!bake_object_check(scene, view_layer, link->ptr.data, target, reports)) {
|
||||
for (link = static_cast<CollectionPointerLink *>(selected_objects->first); link;
|
||||
link = link->next) {
|
||||
if (!bake_object_check(
|
||||
scene, view_layer, static_cast<Object *>(link->ptr.data), target, reports)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -655,8 +658,7 @@ static bool bake_objects_check(Main *bmain,
|
|||
/* it needs to be called after bake_objects_check since the image tagging happens there */
|
||||
static void bake_targets_clear(Main *bmain, const bool is_tangent)
|
||||
{
|
||||
Image *image;
|
||||
for (image = bmain->images.first; image; image = image->id.next) {
|
||||
LISTBASE_FOREACH (Image *, image, &bmain->images) {
|
||||
if ((image->id.tag & LIB_TAG_DOIT) != 0) {
|
||||
RE_bake_ibuf_clear(image, is_tangent);
|
||||
}
|
||||
|
@ -704,17 +706,17 @@ static bool bake_targets_init_image_textures(const BakeAPIRender *bkr,
|
|||
|
||||
/* Allocate material mapping. */
|
||||
targets->materials_num = materials_num;
|
||||
targets->material_to_image = MEM_callocN(sizeof(Image *) * targets->materials_num,
|
||||
"BakeTargets.material_to_image");
|
||||
targets->material_to_image = static_cast<Image **>(
|
||||
MEM_callocN(sizeof(Image *) * targets->materials_num, __func__));
|
||||
|
||||
/* Error handling and tag (in case multiple materials share the same image). */
|
||||
BKE_main_id_tag_idcode(bkr->main, ID_IM, LIB_TAG_DOIT, false);
|
||||
|
||||
targets->images = NULL;
|
||||
targets->images = nullptr;
|
||||
|
||||
for (int i = 0; i < materials_num; i++) {
|
||||
Image *image;
|
||||
ED_object_get_active_image(ob, i + 1, &image, NULL, NULL, NULL);
|
||||
ED_object_get_active_image(ob, i + 1, &image, nullptr, nullptr, nullptr);
|
||||
|
||||
targets->material_to_image[i] = image;
|
||||
|
||||
|
@ -723,8 +725,8 @@ static bool bake_targets_init_image_textures(const BakeAPIRender *bkr,
|
|||
if (image && !(image->id.tag & LIB_TAG_DOIT)) {
|
||||
LISTBASE_FOREACH (ImageTile *, tile, &image->tiles) {
|
||||
/* Add bake image. */
|
||||
targets->images = MEM_recallocN(targets->images,
|
||||
sizeof(BakeImage) * (targets->images_num + 1));
|
||||
targets->images = static_cast<BakeImage *>(
|
||||
MEM_recallocN(targets->images, sizeof(BakeImage) * (targets->images_num + 1)));
|
||||
targets->images[targets->images_num].image = image;
|
||||
targets->images[targets->images_num].tile_number = tile->tile_number;
|
||||
targets->images_num++;
|
||||
|
@ -878,7 +880,7 @@ static bool bake_targets_output_external(const BakeAPIRender *bkr,
|
|||
bake->im_format.imtype,
|
||||
true,
|
||||
false,
|
||||
NULL);
|
||||
nullptr);
|
||||
|
||||
if (bkr->is_automatic_name) {
|
||||
BLI_path_suffix(name, FILE_MAX, ob->id.name + 2, "_");
|
||||
|
@ -949,7 +951,7 @@ static bool bake_targets_init_vertex_colors(Main *bmain,
|
|||
return false;
|
||||
}
|
||||
|
||||
Mesh *me = ob->data;
|
||||
Mesh *me = static_cast<Mesh *>(ob->data);
|
||||
if (!BKE_id_attributes_color_find(&me->id, me->active_color_attribute)) {
|
||||
BKE_report(reports, RPT_ERROR, "No active color attribute to bake to");
|
||||
return false;
|
||||
|
@ -958,18 +960,18 @@ static bool bake_targets_init_vertex_colors(Main *bmain,
|
|||
/* Ensure mesh and editmesh topology are in sync. */
|
||||
ED_object_editmode_load(bmain, ob);
|
||||
|
||||
targets->images = MEM_callocN(sizeof(BakeImage), "BakeTargets.images");
|
||||
targets->images = MEM_cnew<BakeImage>(__func__);
|
||||
targets->images_num = 1;
|
||||
|
||||
targets->material_to_image = MEM_callocN(sizeof(int) * ob->totcol,
|
||||
"BakeTargets.material_to_image");
|
||||
targets->material_to_image = static_cast<Image **>(
|
||||
MEM_callocN(sizeof(Image *) * ob->totcol, __func__));
|
||||
targets->materials_num = ob->totcol;
|
||||
|
||||
BakeImage *bk_image = &targets->images[0];
|
||||
bk_image->width = me->totloop;
|
||||
bk_image->height = 1;
|
||||
bk_image->offset = 0;
|
||||
bk_image->image = NULL;
|
||||
bk_image->image = nullptr;
|
||||
|
||||
targets->pixels_num = bk_image->width * bk_image->height;
|
||||
|
||||
|
@ -1009,7 +1011,7 @@ static void bake_targets_populate_pixels_color_attributes(BakeTargets *targets,
|
|||
Mesh *me_eval,
|
||||
BakePixel *pixel_array)
|
||||
{
|
||||
Mesh *me = ob->data;
|
||||
Mesh *me = static_cast<Mesh *>(ob->data);
|
||||
const int pixels_num = targets->pixels_num;
|
||||
|
||||
/* Initialize blank pixels. */
|
||||
|
@ -1029,7 +1031,7 @@ static void bake_targets_populate_pixels_color_attributes(BakeTargets *targets,
|
|||
|
||||
/* Populate through adjacent triangles, first triangle wins. */
|
||||
const int tottri = poly_to_tri_count(me_eval->totpoly, me_eval->totloop);
|
||||
MLoopTri *looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
|
||||
MLoopTri *looptri = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__));
|
||||
|
||||
const MLoop *loops = BKE_mesh_loops(me_eval);
|
||||
BKE_mesh_recalc_looptri(loops,
|
||||
|
@ -1040,8 +1042,10 @@ static void bake_targets_populate_pixels_color_attributes(BakeTargets *targets,
|
|||
looptri);
|
||||
|
||||
/* For mapping back to original mesh in case there are modifiers. */
|
||||
const int *vert_origindex = CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX);
|
||||
const int *poly_origindex = CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX);
|
||||
const int *vert_origindex = static_cast<const int *>(
|
||||
CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX));
|
||||
const int *poly_origindex = static_cast<const int *>(
|
||||
CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX));
|
||||
const MPoly *orig_polys = BKE_mesh_polys(me);
|
||||
const MLoop *orig_loops = BKE_mesh_loops(me);
|
||||
|
||||
|
@ -1053,7 +1057,7 @@ static void bake_targets_populate_pixels_color_attributes(BakeTargets *targets,
|
|||
uint v = loops[l].v;
|
||||
|
||||
/* Map back to original loop if there are modifiers. */
|
||||
if (vert_origindex != NULL && poly_origindex != NULL) {
|
||||
if (vert_origindex != nullptr && poly_origindex != nullptr) {
|
||||
l = find_original_loop(
|
||||
orig_polys, orig_loops, vert_origindex, poly_origindex, lt->poly, v);
|
||||
if (l == ORIGINDEX_NONE || l >= me->totloop) {
|
||||
|
@ -1129,11 +1133,11 @@ static void convert_float_color_to_byte_color(const MPropCol *float_colors,
|
|||
|
||||
static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
||||
{
|
||||
Mesh *me = ob->data;
|
||||
Mesh *me = static_cast<Mesh *>(ob->data);
|
||||
BMEditMesh *em = me->edit_mesh;
|
||||
CustomDataLayer *active_color_layer = BKE_id_attributes_color_find(&me->id,
|
||||
me->active_color_attribute);
|
||||
BLI_assert(active_color_layer != NULL);
|
||||
BLI_assert(active_color_layer != nullptr);
|
||||
const eAttrDomain domain = BKE_id_attribute_domain(&me->id, active_color_layer);
|
||||
|
||||
const int channels_num = targets->channels_num;
|
||||
|
@ -1144,10 +1148,12 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
|||
const int totvert = me->totvert;
|
||||
const int totloop = me->totloop;
|
||||
|
||||
MPropCol *mcol = MEM_malloc_arrayN(totvert, sizeof(MPropCol), __func__);
|
||||
MPropCol *mcol = static_cast<MPropCol *>(
|
||||
MEM_malloc_arrayN(totvert, sizeof(MPropCol), __func__));
|
||||
|
||||
/* Accumulate float vertex colors in scene linear color space. */
|
||||
int *num_loops_for_vertex = MEM_callocN(sizeof(int) * me->totvert, "num_loops_for_vertex");
|
||||
int *num_loops_for_vertex = static_cast<int *>(
|
||||
MEM_callocN(sizeof(int) * me->totvert, "num_loops_for_vertex"));
|
||||
memset(mcol, 0, sizeof(MPropCol) * me->totvert);
|
||||
|
||||
const MLoop *mloop = BKE_mesh_loops(me);
|
||||
|
@ -1177,7 +1183,8 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
|||
memcpy(data, &mcol[i], sizeof(MPropCol));
|
||||
}
|
||||
else {
|
||||
convert_float_color_to_byte_color(&mcol[i], 1, is_noncolor, data);
|
||||
convert_float_color_to_byte_color(
|
||||
&mcol[i], 1, is_noncolor, static_cast<MLoopCol *>(data));
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
@ -1188,7 +1195,8 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
|||
memcpy(active_color_layer->data, mcol, sizeof(MPropCol) * me->totvert);
|
||||
}
|
||||
else {
|
||||
convert_float_color_to_byte_color(mcol, totvert, is_noncolor, active_color_layer->data);
|
||||
convert_float_color_to_byte_color(
|
||||
mcol, totvert, is_noncolor, static_cast<MLoopCol *>(active_color_layer->data));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1218,7 +1226,8 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
|||
memcpy(data, &color, sizeof(MPropCol));
|
||||
}
|
||||
else {
|
||||
convert_float_color_to_byte_color(&color, 1, is_noncolor, data);
|
||||
convert_float_color_to_byte_color(
|
||||
&color, 1, is_noncolor, static_cast<MLoopCol *>(data));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1226,14 +1235,14 @@ static bool bake_targets_output_vertex_colors(BakeTargets *targets, Object *ob)
|
|||
else {
|
||||
/* Copy to mesh. */
|
||||
if (active_color_layer->type == CD_PROP_COLOR) {
|
||||
MPropCol *colors = active_color_layer->data;
|
||||
MPropCol *colors = static_cast<MPropCol *>(active_color_layer->data);
|
||||
for (int i = 0; i < me->totloop; i++) {
|
||||
zero_v4(colors[i].color);
|
||||
bake_result_add_to_rgba(colors[i].color, &result[i * channels_num], channels_num);
|
||||
}
|
||||
}
|
||||
else {
|
||||
MLoopCol *colors = active_color_layer->data;
|
||||
MLoopCol *colors = static_cast<MLoopCol *>(active_color_layer->data);
|
||||
for (int i = 0; i < me->totloop; i++) {
|
||||
MPropCol color;
|
||||
zero_v4(color.color);
|
||||
|
@ -1281,8 +1290,8 @@ static bool bake_targets_init(const BakeAPIRender *bkr,
|
|||
|
||||
targets->is_noncolor = is_noncolor_pass(bkr->pass_type);
|
||||
targets->channels_num = RE_pass_depth(bkr->pass_type);
|
||||
targets->result = MEM_callocN(sizeof(float) * targets->channels_num * targets->pixels_num,
|
||||
"bake return pixels");
|
||||
targets->result = static_cast<float *>(MEM_callocN(
|
||||
sizeof(float) * targets->channels_num * targets->pixels_num, "bake return pixels"));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
@ -1352,23 +1361,23 @@ static int bake(const BakeAPIRender *bkr,
|
|||
int op_result = OPERATOR_CANCELLED;
|
||||
bool ok = false;
|
||||
|
||||
Object *ob_cage = NULL;
|
||||
Object *ob_cage_eval = NULL;
|
||||
Object *ob_low_eval = NULL;
|
||||
Object *ob_cage = nullptr;
|
||||
Object *ob_cage_eval = nullptr;
|
||||
Object *ob_low_eval = nullptr;
|
||||
|
||||
BakeHighPolyData *highpoly = NULL;
|
||||
BakeHighPolyData *highpoly = nullptr;
|
||||
int tot_highpoly = 0;
|
||||
|
||||
Mesh *me_low_eval = NULL;
|
||||
Mesh *me_cage_eval = NULL;
|
||||
Mesh *me_low_eval = nullptr;
|
||||
Mesh *me_cage_eval = nullptr;
|
||||
|
||||
MultiresModifierData *mmd_low = NULL;
|
||||
MultiresModifierData *mmd_low = nullptr;
|
||||
int mmd_flags_low = 0;
|
||||
|
||||
BakePixel *pixel_array_low = NULL;
|
||||
BakePixel *pixel_array_high = NULL;
|
||||
BakePixel *pixel_array_low = nullptr;
|
||||
BakePixel *pixel_array_high = nullptr;
|
||||
|
||||
BakeTargets targets = {NULL};
|
||||
BakeTargets targets = {nullptr};
|
||||
|
||||
const bool preserve_origindex = (bkr->target == R_BAKE_TARGET_VERTEX_COLORS);
|
||||
|
||||
|
@ -1395,8 +1404,9 @@ static int bake(const BakeAPIRender *bkr,
|
|||
CollectionPointerLink *link;
|
||||
tot_highpoly = 0;
|
||||
|
||||
for (link = selected_objects->first; link; link = link->next) {
|
||||
Object *ob_iter = link->ptr.data;
|
||||
for (link = static_cast<CollectionPointerLink *>(selected_objects->first); link;
|
||||
link = link->next) {
|
||||
Object *ob_iter = static_cast<Object *>(link->ptr.data);
|
||||
|
||||
if (ob_iter == ob_low) {
|
||||
continue;
|
||||
|
@ -1406,9 +1416,10 @@ static int bake(const BakeAPIRender *bkr,
|
|||
}
|
||||
|
||||
if (bkr->is_cage && bkr->custom_cage[0] != '\0') {
|
||||
ob_cage = BLI_findstring(&bmain->objects, bkr->custom_cage, offsetof(ID, name) + 2);
|
||||
ob_cage = static_cast<Object *>(
|
||||
BLI_findstring(&bmain->objects, bkr->custom_cage, offsetof(ID, name) + 2));
|
||||
|
||||
if (ob_cage == NULL || ob_cage->type != OB_MESH) {
|
||||
if (ob_cage == nullptr || ob_cage->type != OB_MESH) {
|
||||
BKE_report(reports, RPT_ERROR, "No valid cage object");
|
||||
goto cleanup;
|
||||
}
|
||||
|
@ -1445,8 +1456,9 @@ static int bake(const BakeAPIRender *bkr,
|
|||
|
||||
/* Populate the pixel array with the face data. Except if we use a cage, then
|
||||
* it is populated later with the cage mesh (smoothed version of the mesh). */
|
||||
pixel_array_low = MEM_mallocN(sizeof(BakePixel) * targets.pixels_num, "bake pixels low poly");
|
||||
if ((bkr->is_selected_to_active && (ob_cage == NULL) && bkr->is_cage) == false) {
|
||||
pixel_array_low = static_cast<BakePixel *>(
|
||||
MEM_mallocN(sizeof(BakePixel) * targets.pixels_num, "bake pixels low poly"));
|
||||
if ((bkr->is_selected_to_active && (ob_cage == nullptr) && bkr->is_cage) == false) {
|
||||
bake_targets_populate_pixels(bkr, &targets, ob_low, me_low_eval, pixel_array_low);
|
||||
}
|
||||
|
||||
|
@ -1469,7 +1481,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
else if (bkr->is_cage) {
|
||||
bool is_changed = false;
|
||||
|
||||
ModifierData *md = ob_low_eval->modifiers.first;
|
||||
ModifierData *md = static_cast<ModifierData *>(ob_low_eval->modifiers.first);
|
||||
while (md) {
|
||||
ModifierData *md_next = md->next;
|
||||
|
||||
|
@ -1498,15 +1510,17 @@ static int bake(const BakeAPIRender *bkr,
|
|||
BKE_object_handle_data_update(depsgraph, scene, ob_low_eval);
|
||||
}
|
||||
|
||||
me_cage_eval = BKE_mesh_new_from_object(NULL, ob_low_eval, false, preserve_origindex);
|
||||
me_cage_eval = BKE_mesh_new_from_object(nullptr, ob_low_eval, false, preserve_origindex);
|
||||
bake_targets_populate_pixels(bkr, &targets, ob_low, me_cage_eval, pixel_array_low);
|
||||
}
|
||||
|
||||
highpoly = MEM_callocN(sizeof(BakeHighPolyData) * tot_highpoly, "bake high poly objects");
|
||||
highpoly = static_cast<BakeHighPolyData *>(
|
||||
MEM_callocN(sizeof(BakeHighPolyData) * tot_highpoly, "bake high poly objects"));
|
||||
|
||||
/* populate highpoly array */
|
||||
for (link = selected_objects->first; link; link = link->next) {
|
||||
Object *ob_iter = link->ptr.data;
|
||||
for (link = static_cast<CollectionPointerLink *>(selected_objects->first); link;
|
||||
link = link->next) {
|
||||
Object *ob_iter = static_cast<Object *>(link->ptr.data);
|
||||
|
||||
if (ob_iter == ob_low) {
|
||||
continue;
|
||||
|
@ -1518,7 +1532,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
highpoly[i].ob_eval->visibility_flag &= ~OB_HIDE_RENDER;
|
||||
highpoly[i].ob_eval->base_flag |= (BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT |
|
||||
BASE_ENABLED_RENDER);
|
||||
highpoly[i].me = BKE_mesh_new_from_object(NULL, highpoly[i].ob_eval, false, false);
|
||||
highpoly[i].me = BKE_mesh_new_from_object(nullptr, highpoly[i].ob_eval, false, false);
|
||||
|
||||
/* Low-poly to high-poly transformation matrix. */
|
||||
copy_m4_m4(highpoly[i].obmat, highpoly[i].ob->object_to_world);
|
||||
|
@ -1531,7 +1545,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
|
||||
BLI_assert(i == tot_highpoly);
|
||||
|
||||
if (ob_cage != NULL) {
|
||||
if (ob_cage != nullptr) {
|
||||
ob_cage_eval->visibility_flag |= OB_HIDE_RENDER;
|
||||
ob_cage_eval->base_flag &= ~(BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT |
|
||||
BASE_ENABLED_RENDER);
|
||||
|
@ -1540,8 +1554,8 @@ static int bake(const BakeAPIRender *bkr,
|
|||
ob_low_eval->base_flag &= ~(BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT | BASE_ENABLED_RENDER);
|
||||
|
||||
/* populate the pixel arrays with the corresponding face data for each high poly object */
|
||||
pixel_array_high = MEM_mallocN(sizeof(BakePixel) * targets.pixels_num,
|
||||
"bake pixels high poly");
|
||||
pixel_array_high = static_cast<BakePixel *>(
|
||||
MEM_mallocN(sizeof(BakePixel) * targets.pixels_num, "bake pixels high poly"));
|
||||
|
||||
if (!RE_bake_pixels_populate_from_objects(
|
||||
me_low_eval,
|
||||
|
@ -1550,7 +1564,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
highpoly,
|
||||
tot_highpoly,
|
||||
targets.pixels_num,
|
||||
ob_cage != NULL,
|
||||
ob_cage != nullptr,
|
||||
bkr->cage_extrusion,
|
||||
bkr->max_ray_distance,
|
||||
ob_low_eval->object_to_world,
|
||||
|
@ -1637,8 +1651,8 @@ static int bake(const BakeAPIRender *bkr,
|
|||
}
|
||||
else {
|
||||
/* From multi-resolution. */
|
||||
Mesh *me_nores = NULL;
|
||||
ModifierData *md = NULL;
|
||||
Mesh *me_nores = nullptr;
|
||||
ModifierData *md = nullptr;
|
||||
int mode;
|
||||
|
||||
BKE_object_eval_reset(ob_low_eval);
|
||||
|
@ -1649,7 +1663,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
md->mode &= ~eModifierMode_Render;
|
||||
|
||||
/* Evaluate modifiers again. */
|
||||
me_nores = BKE_mesh_new_from_object(NULL, ob_low_eval, false, false);
|
||||
me_nores = BKE_mesh_new_from_object(nullptr, ob_low_eval, false, false);
|
||||
bake_targets_populate_pixels(bkr, &targets, ob_low, me_nores, pixel_array_low);
|
||||
}
|
||||
|
||||
|
@ -1662,7 +1676,7 @@ static int bake(const BakeAPIRender *bkr,
|
|||
ob_low_eval->object_to_world);
|
||||
|
||||
if (md) {
|
||||
BKE_id_free(NULL, &me_nores->id);
|
||||
BKE_id_free(nullptr, &me_nores->id);
|
||||
md->mode = mode;
|
||||
}
|
||||
}
|
||||
|
@ -1694,8 +1708,8 @@ cleanup:
|
|||
|
||||
if (highpoly) {
|
||||
for (int i = 0; i < tot_highpoly; i++) {
|
||||
if (highpoly[i].me != NULL) {
|
||||
BKE_id_free(NULL, &highpoly[i].me->id);
|
||||
if (highpoly[i].me != nullptr) {
|
||||
BKE_id_free(nullptr, &highpoly[i].me->id);
|
||||
}
|
||||
}
|
||||
MEM_freeN(highpoly);
|
||||
|
@ -1715,12 +1729,12 @@ cleanup:
|
|||
|
||||
bake_targets_free(&targets);
|
||||
|
||||
if (me_low_eval != NULL) {
|
||||
BKE_id_free(NULL, &me_low_eval->id);
|
||||
if (me_low_eval != nullptr) {
|
||||
BKE_id_free(nullptr, &me_low_eval->id);
|
||||
}
|
||||
|
||||
if (me_cage_eval != NULL) {
|
||||
BKE_id_free(NULL, &me_cage_eval->id);
|
||||
if (me_cage_eval != nullptr) {
|
||||
BKE_id_free(nullptr, &me_cage_eval->id);
|
||||
}
|
||||
|
||||
DEG_graph_free(depsgraph);
|
||||
|
@ -1738,12 +1752,12 @@ static void bake_init_api_data(wmOperator *op, bContext *C, BakeAPIRender *bkr)
|
|||
bkr->main = CTX_data_main(C);
|
||||
bkr->view_layer = CTX_data_view_layer(C);
|
||||
bkr->scene = CTX_data_scene(C);
|
||||
bkr->area = screen ? BKE_screen_find_big_area(screen, SPACE_IMAGE, 10) : NULL;
|
||||
bkr->area = screen ? BKE_screen_find_big_area(screen, SPACE_IMAGE, 10) : nullptr;
|
||||
|
||||
bkr->pass_type = RNA_enum_get(op->ptr, "type");
|
||||
bkr->pass_type = eScenePassType(RNA_enum_get(op->ptr, "type"));
|
||||
bkr->pass_filter = RNA_enum_get(op->ptr, "pass_filter");
|
||||
bkr->margin = RNA_int_get(op->ptr, "margin");
|
||||
bkr->margin_type = RNA_enum_get(op->ptr, "margin_type");
|
||||
bkr->margin_type = eBakeMarginType(RNA_enum_get(op->ptr, "margin_type"));
|
||||
|
||||
bkr->save_mode = (eBakeSaveMode)RNA_enum_get(op->ptr, "save_mode");
|
||||
bkr->target = (eBakeTarget)RNA_enum_get(op->ptr, "target");
|
||||
|
@ -1759,9 +1773,9 @@ static void bake_init_api_data(wmOperator *op, bContext *C, BakeAPIRender *bkr)
|
|||
bkr->max_ray_distance = RNA_float_get(op->ptr, "max_ray_distance");
|
||||
|
||||
bkr->normal_space = RNA_enum_get(op->ptr, "normal_space");
|
||||
bkr->normal_swizzle[0] = RNA_enum_get(op->ptr, "normal_r");
|
||||
bkr->normal_swizzle[1] = RNA_enum_get(op->ptr, "normal_g");
|
||||
bkr->normal_swizzle[2] = RNA_enum_get(op->ptr, "normal_b");
|
||||
bkr->normal_swizzle[0] = eBakeNormalSwizzle(RNA_enum_get(op->ptr, "normal_r"));
|
||||
bkr->normal_swizzle[1] = eBakeNormalSwizzle(RNA_enum_get(op->ptr, "normal_g"));
|
||||
bkr->normal_swizzle[2] = eBakeNormalSwizzle(RNA_enum_get(op->ptr, "normal_b"));
|
||||
|
||||
bkr->width = RNA_int_get(op->ptr, "width");
|
||||
bkr->height = RNA_int_get(op->ptr, "height");
|
||||
|
@ -1800,7 +1814,7 @@ static int bake_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Render *re;
|
||||
int result = OPERATOR_CANCELLED;
|
||||
BakeAPIRender bkr = {NULL};
|
||||
BakeAPIRender bkr = {nullptr};
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
|
||||
G.is_break = false;
|
||||
|
@ -1812,7 +1826,7 @@ static int bake_exec(bContext *C, wmOperator *op)
|
|||
re = bkr.render;
|
||||
|
||||
/* setup new render */
|
||||
RE_test_break_cb(re, NULL, bake_break);
|
||||
RE_test_break_cb(re, nullptr, bake_break);
|
||||
|
||||
if (!bake_pass_filter_check(bkr.pass_type, bkr.pass_filter, bkr.reports)) {
|
||||
goto finally;
|
||||
|
@ -1843,13 +1857,14 @@ static int bake_exec(bContext *C, wmOperator *op)
|
|||
else {
|
||||
CollectionPointerLink *link;
|
||||
bkr.is_clear = bkr.is_clear && BLI_listbase_is_single(&bkr.selected_objects);
|
||||
for (link = bkr.selected_objects.first; link; link = link->next) {
|
||||
Object *ob_iter = link->ptr.data;
|
||||
result = bake(&bkr, ob_iter, NULL, bkr.reports);
|
||||
for (link = static_cast<CollectionPointerLink *>(bkr.selected_objects.first); link;
|
||||
link = link->next) {
|
||||
Object *ob_iter = static_cast<Object *>(link->ptr.data);
|
||||
result = bake(&bkr, ob_iter, nullptr, bkr.reports);
|
||||
}
|
||||
}
|
||||
|
||||
RE_SetReports(re, NULL);
|
||||
RE_SetReports(re, nullptr);
|
||||
|
||||
finally:
|
||||
G.is_rendering = false;
|
||||
|
@ -1857,7 +1872,7 @@ finally:
|
|||
return result;
|
||||
}
|
||||
|
||||
static void bake_startjob(void *bkv, bool *UNUSED(stop), bool *do_update, float *progress)
|
||||
static void bake_startjob(void *bkv, bool * /*stop*/, bool *do_update, float *progress)
|
||||
{
|
||||
BakeAPIRender *bkr = (BakeAPIRender *)bkv;
|
||||
|
||||
|
@ -1896,9 +1911,10 @@ static void bake_startjob(void *bkv, bool *UNUSED(stop), bool *do_update, float
|
|||
else {
|
||||
CollectionPointerLink *link;
|
||||
bkr->is_clear = bkr->is_clear && BLI_listbase_is_single(&bkr->selected_objects);
|
||||
for (link = bkr->selected_objects.first; link; link = link->next) {
|
||||
Object *ob_iter = link->ptr.data;
|
||||
bkr->result = bake(bkr, ob_iter, NULL, bkr->reports);
|
||||
for (link = static_cast<CollectionPointerLink *>(bkr->selected_objects.first); link;
|
||||
link = link->next) {
|
||||
Object *ob_iter = static_cast<Object *>(link->ptr.data);
|
||||
bkr->result = bake(bkr, ob_iter, nullptr, bkr->reports);
|
||||
|
||||
if (bkr->result == OPERATOR_CANCELLED) {
|
||||
return;
|
||||
|
@ -1906,7 +1922,7 @@ static void bake_startjob(void *bkv, bool *UNUSED(stop), bool *do_update, float
|
|||
}
|
||||
}
|
||||
|
||||
RE_SetReports(bkr->render, NULL);
|
||||
RE_SetReports(bkr->render, nullptr);
|
||||
}
|
||||
|
||||
static void bake_job_complete(void *bkv)
|
||||
|
@ -2037,10 +2053,9 @@ static void bake_set_props(wmOperator *op, Scene *scene)
|
|||
}
|
||||
}
|
||||
|
||||
static int bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
|
||||
static int bake_invoke(bContext *C, wmOperator *op, const wmEvent * /*event*/)
|
||||
{
|
||||
wmJob *wm_job;
|
||||
BakeAPIRender *bkr;
|
||||
Render *re;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
|
||||
|
@ -2051,7 +2066,7 @@ static int bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)
|
|||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
bkr = MEM_mallocN(sizeof(BakeAPIRender), "render bake");
|
||||
BakeAPIRender *bkr = static_cast<BakeAPIRender *>(MEM_mallocN(sizeof(BakeAPIRender), __func__));
|
||||
|
||||
/* init bake render */
|
||||
bake_init_api_data(op, C, bkr);
|
||||
|
@ -2059,7 +2074,7 @@ static int bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)
|
|||
re = bkr->render;
|
||||
|
||||
/* setup new render */
|
||||
RE_test_break_cb(re, NULL, bake_break);
|
||||
RE_test_break_cb(re, nullptr, bake_break);
|
||||
RE_progress_cb(re, bkr, bake_progress_update);
|
||||
|
||||
/* setup job */
|
||||
|
@ -2074,7 +2089,7 @@ static int bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)
|
|||
WM_jobs_timer(
|
||||
wm_job, 0.5, (bkr->target == R_BAKE_TARGET_VERTEX_COLORS) ? NC_GEOM | ND_DATA : NC_IMAGE, 0);
|
||||
WM_jobs_callbacks_ex(
|
||||
wm_job, bake_startjob, NULL, NULL, NULL, bake_job_complete, bake_job_canceled);
|
||||
wm_job, bake_startjob, nullptr, nullptr, nullptr, bake_job_complete, bake_job_canceled);
|
||||
|
||||
G.is_break = false;
|
||||
G.is_rendering = true;
|
||||
|
@ -2121,7 +2136,7 @@ void OBJECT_OT_bake(wmOperatorType *ot)
|
|||
RNA_def_property_flag(prop, PROP_ENUM_FLAG);
|
||||
RNA_def_string_file_path(ot->srna,
|
||||
"filepath",
|
||||
NULL,
|
||||
nullptr,
|
||||
FILE_MAX,
|
||||
"File Path",
|
||||
"Image filepath to use when saving externally");
|
||||
|
@ -2185,7 +2200,7 @@ void OBJECT_OT_bake(wmOperatorType *ot)
|
|||
1.0f);
|
||||
RNA_def_string(ot->srna,
|
||||
"cage_object",
|
||||
NULL,
|
||||
nullptr,
|
||||
MAX_NAME,
|
||||
"Cage Object",
|
||||
"Object to use as cage, instead of calculating the cage from the active object "
|
||||
|
@ -2245,7 +2260,7 @@ void OBJECT_OT_bake(wmOperatorType *ot)
|
|||
"Automatically name the output file with the pass type");
|
||||
RNA_def_string(ot->srna,
|
||||
"uv_layer",
|
||||
NULL,
|
||||
nullptr,
|
||||
MAX_CUSTOMDATA_LAYER_NAME_NO_PREFIX,
|
||||
"UV Layer",
|
||||
"UV layer to override active");
|
|
@ -29,7 +29,7 @@ set(INC_SYS
|
|||
)
|
||||
|
||||
set(SRC
|
||||
drawobject.c
|
||||
drawobject.cc
|
||||
space_view3d.cc
|
||||
view3d_buttons.c
|
||||
view3d_camera_control.c
|
||||
|
|
|
@ -53,11 +53,11 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
return;
|
||||
}
|
||||
|
||||
const Mesh *me = ob->data;
|
||||
const Mesh *me = static_cast<const Mesh *>(ob->data);
|
||||
{
|
||||
Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
|
||||
const Mesh *me_eval = BKE_object_get_evaluated_mesh(ob_eval);
|
||||
if (me_eval != NULL) {
|
||||
if (me_eval != nullptr) {
|
||||
me = me_eval;
|
||||
}
|
||||
}
|
||||
|
@ -65,7 +65,7 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
GPU_front_facing(ob->transflag & OB_NEG_SCALE);
|
||||
|
||||
/* Just to create the data to pass to immediate mode! (sigh) */
|
||||
const int *facemap_data = CustomData_get_layer(&me->pdata, CD_FACEMAP);
|
||||
const int *facemap_data = static_cast<const int *>(CustomData_get_layer(&me->pdata, CD_FACEMAP));
|
||||
if (facemap_data) {
|
||||
GPU_blend(GPU_BLEND_ALPHA);
|
||||
|
||||
|
@ -76,7 +76,7 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
int mpoly_len = me->totpoly;
|
||||
int mloop_len = me->totloop;
|
||||
|
||||
facemap_data = CustomData_get_layer(&me->pdata, CD_FACEMAP);
|
||||
facemap_data = static_cast<const int *>(CustomData_get_layer(&me->pdata, CD_FACEMAP));
|
||||
|
||||
/* Make a batch and free it each time for now. */
|
||||
const int looptris_len = poly_to_tri_count(mpoly_len, mloop_len);
|
||||
|
@ -100,9 +100,12 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
for (mp = polys, i = 0; i < mpoly_len; i++, mp++) {
|
||||
if (facemap_data[i] == facemap) {
|
||||
for (int j = 2; j < mp->totloop; j++) {
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[loops[mlt->tri[0]].v]);
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[loops[mlt->tri[1]].v]);
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[loops[mlt->tri[2]].v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)),
|
||||
positions[loops[mlt->tri[0]].v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)),
|
||||
positions[loops[mlt->tri[1]].v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)),
|
||||
positions[loops[mlt->tri[2]].v]);
|
||||
vbo_len_used += 3;
|
||||
mlt++;
|
||||
}
|
||||
|
@ -120,9 +123,10 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
const MLoop *ml_a = ml_start + 1;
|
||||
const MLoop *ml_b = ml_start + 2;
|
||||
for (int j = 2; j < mp->totloop; j++) {
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[ml_start->v]);
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[ml_a->v]);
|
||||
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), positions[ml_b->v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)),
|
||||
positions[ml_start->v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)), positions[ml_a->v]);
|
||||
copy_v3_v3(static_cast<float *>(GPU_vertbuf_raw_step(&pos_step)), positions[ml_b->v]);
|
||||
vbo_len_used += 3;
|
||||
|
||||
ml_a++;
|
||||
|
@ -136,7 +140,7 @@ void ED_draw_object_facemap(Depsgraph *depsgraph,
|
|||
GPU_vertbuf_data_resize(vbo_pos, vbo_len_used);
|
||||
}
|
||||
|
||||
GPUBatch *draw_batch = GPU_batch_create(GPU_PRIM_TRIS, vbo_pos, NULL);
|
||||
GPUBatch *draw_batch = GPU_batch_create(GPU_PRIM_TRIS, vbo_pos, nullptr);
|
||||
GPU_batch_program_set_builtin(draw_batch, GPU_SHADER_3D_UNIFORM_COLOR);
|
||||
GPU_batch_uniform_4fv(draw_batch, "color", col);
|
||||
GPU_batch_draw(draw_batch);
|
|
@ -32,7 +32,7 @@ set(SRC
|
|||
uvedit_rip.c
|
||||
uvedit_select.c
|
||||
uvedit_smart_stitch.c
|
||||
uvedit_unwrap_ops.c
|
||||
uvedit_unwrap_ops.cc
|
||||
|
||||
uvedit_clipboard_graph_iso.hh
|
||||
uvedit_intern.h
|
||||
|
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue