/**
* Currently this is only used for Python scripts
* which may fail to keep matching UV/TexFace layers.
*
* \note This should only perform any changes in exceptional cases,
* if we need this to be faster we could inline #BM_data_layer_add and only
* call #update_data_blocks once at the end.
*/
void BM_mesh_cd_validate(BMesh *bm)
{
int totlayer_mtex = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
int totlayer_uv = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
if (LIKELY(totlayer_mtex == totlayer_uv)) {
/* pass */
}
else if (totlayer_mtex < totlayer_uv) {
const int uv_index_first = CustomData_get_layer_index(&bm->ldata, CD_MLOOPUV);
do {
const char *from_name = bm->ldata.layers[uv_index_first + totlayer_mtex].name;
BM_data_layer_add_named(bm, &bm->pdata, CD_MTEXPOLY, from_name);
CustomData_set_layer_unique_name(&bm->pdata, totlayer_mtex);
} while (totlayer_uv != ++totlayer_mtex);
}
else if (totlayer_uv < totlayer_mtex) {
const int mtex_index_first = CustomData_get_layer_index(&bm->pdata, CD_MTEXPOLY);
do {
const char *from_name = bm->pdata.layers[mtex_index_first + totlayer_uv].name;
BM_data_layer_add_named(bm, &bm->ldata, CD_MLOOPUV, from_name);
CustomData_set_layer_unique_name(&bm->ldata, totlayer_uv);
} while (totlayer_mtex != ++totlayer_uv);
}
BLI_assert(totlayer_mtex == totlayer_uv);
}
/**
* Duplicate of BM_mesh_cd_validate() for Mesh data.
*/
void BKE_mesh_cd_validate(Mesh *me)
{
int totlayer_mtex = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
int totlayer_uv = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
int totlayer_mcol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
int mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
int uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
int i;
/* XXX For now, do not delete those, just warn they are not really usable. */
if (UNLIKELY(totlayer_mtex > MAX_MTFACE)) {
printf("WARNING! More UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
MAX_MTFACE, totlayer_mtex - MAX_MTFACE);
}
if (UNLIKELY(totlayer_uv > MAX_MTFACE)) {
printf("WARNING! More UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
MAX_MTFACE, totlayer_uv - MAX_MTFACE);
}
if (UNLIKELY(totlayer_mcol > MAX_MCOL)) {
printf("WARNING! More VCol layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
MAX_MCOL, totlayer_mcol - MAX_MCOL);
}
if (LIKELY(totlayer_mtex == totlayer_uv)) {
/* pass */
}
else if (totlayer_mtex < totlayer_uv) {
do {
const char *from_name = me->ldata.layers[uv_index + totlayer_mtex].name;
CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, from_name);
CustomData_set_layer_unique_name(&me->pdata, totlayer_mtex);
} while (totlayer_uv != ++totlayer_mtex);
mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
}
else if (totlayer_uv < totlayer_mtex) {
do {
const char *from_name = me->pdata.layers[mtex_index + totlayer_uv].name;
CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, from_name);
CustomData_set_layer_unique_name(&me->ldata, totlayer_uv);
} while (totlayer_mtex != ++totlayer_uv);
uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
}
BLI_assert(totlayer_mtex == totlayer_uv);
/* Check uv/tex names match as well!!! */
for (i = 0; i < totlayer_mtex; i++, mtex_index++, uv_index++) {
const char *name_src = me->pdata.layers[mtex_index].name;
const char *name_dst = me->ldata.layers[uv_index].name;
if (!STREQ(name_src, name_dst)) {
BKE_mesh_uv_cdlayer_rename_index(me, mtex_index, uv_index, -1, name_src, false);
}
}
}
static PyObject *bpy_bmlayercollection_items(BPy_BMLayerCollection *self)
{
PyObject *ret;
PyObject *item;
int index;
CustomData *data;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type);
ret = PyList_New(0);
if (index != -1) {
int tot = CustomData_number_of_layers(data, self->type);
for ( ; tot-- > 0; index++) {
item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
PyList_Append(ret, item);
Py_DECREF(item);
}
}
return ret;
}
static PyObject *bpy_bmlayercollection_values(BPy_BMLayerCollection *self)
{
PyObject *ret;
PyObject *item;
int index;
CustomData *data;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type);
ret = PyList_New(0);
if (index != -1) {
int tot = CustomData_number_of_layers(data, self->type);
for ( ; tot-- > 0; index++) {
item = PyTuple_New(2);
PyTuple_SET_ITEM(item, 0, PyUnicode_FromString(data->layers[index].name));
PyTuple_SET_ITEM(item, 1, BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index));
PyList_Append(ret, item);
Py_DECREF(item);
}
}
return ret;
}
static PyObject *bpy_bmlayercollection_keys(BPy_BMLayerCollection *self)
{
PyObject *ret;
PyObject *item;
int index;
CustomData *data;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type); /* absolute, but no need to make relative */
ret = PyList_New(0);
if (index != -1) {
int tot = CustomData_number_of_layers(data, self->type);
for ( ; tot-- > 0; index++) {
item = PyUnicode_FromString(data->layers[index].name);
PyList_Append(ret, item);
Py_DECREF(item);
}
}
return ret;
}
char *bc_CustomData_get_layer_name(const struct CustomData *data, int type, int n)
{
int layer_index = CustomData_get_layer_index(data, type);
if (layer_index < 0) return NULL;
return data->layers[layer_index + n].name;
}
static PyObject *bpy_bmlayercollection_items(BPy_BMLayerCollection *self)
{
PyObject *ret;
PyObject *item;
int index;
CustomData *data;
int tot, i;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type);
tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0;
ret = PyList_New(tot);
for (i = 0; tot-- > 0; index++) {
item = PyTuple_New(2);
PyTuple_SET_ITEMS(item,
PyUnicode_FromString(data->layers[index].name),
BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i));
PyList_SET_ITEM(ret, i++, item);
}
return ret;
}
static PyObject *bpy_bmlayercollection_get(BPy_BMLayerCollection *self, PyObject *args)
{
const char *key;
PyObject *def = Py_None;
BPY_BM_CHECK_OBJ(self);
if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) {
return NULL;
}
else {
CustomData *data;
int index;
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_named_layer_index(data, self->type, key); /* absolute index */
if (index != -1) {
index -= CustomData_get_layer_index(data, self->type); /* make relative */
return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
}
return Py_INCREF(def), def;
}
/**
* Duplicate of BM_mesh_cd_validate() for Mesh data.
*/
void BKE_mesh_cd_validate(Mesh *me)
{
int totlayer_mtex = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
int totlayer_uv = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
int mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
int uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
int i;
if (LIKELY(totlayer_mtex == totlayer_uv)) {
/* pass */
}
else if (totlayer_mtex < totlayer_uv) {
do {
const char *from_name = me->ldata.layers[uv_index + totlayer_mtex].name;
CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, from_name);
CustomData_set_layer_unique_name(&me->pdata, totlayer_mtex);
} while (totlayer_uv != ++totlayer_mtex);
mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
}
else if (totlayer_uv < totlayer_mtex) {
do {
const char *from_name = me->pdata.layers[mtex_index + totlayer_uv].name;
CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, from_name);
CustomData_set_layer_unique_name(&me->ldata, totlayer_uv);
} while (totlayer_mtex != ++totlayer_uv);
uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
}
BLI_assert(totlayer_mtex == totlayer_uv);
/* Check uv/tex names match as well!!! */
for (i = 0; i < totlayer_mtex; i++, mtex_index++, uv_index++) {
const char *name_src = me->pdata.layers[mtex_index].name;
const char *name_dst = me->ldata.layers[uv_index].name;
if (!STREQ(name_src, name_dst)) {
BKE_mesh_uv_cdlayer_rename_index(me, mtex_index, uv_index, -1, name_src, false);
}
}
}
static PyObject *bpy_bmlayercollection_active_get(BPy_BMLayerItem *self, void *UNUSED(flag))
{
CustomData *data;
int index;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_active_layer_index(data, self->type); /* absolute */
if (index != -1) {
index -= CustomData_get_layer_index(data, self->type); /* make relative */
return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
else {
Py_RETURN_NONE;
}
}
static PyObject *bpy_bmlayercollection_subscript_str(BPy_BMLayerCollection *self, const char *keyname)
{
CustomData *data;
int index;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_named_layer_index(data, self->type, keyname); /* absolute */
if (index != -1) {
index -= CustomData_get_layer_index(data, self->type); /* make relative */
return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
else {
PyErr_Format(PyExc_KeyError,
"BMLayerCollection[key]: key \"%.200s\" not found", keyname);
return NULL;
}
}
MTex *MeshImporter::assign_textures_to_uvlayer(COLLADAFW::TextureCoordinateBinding &ctexture,
Mesh *me, TexIndexTextureArrayMap& texindex_texarray_map,
MTex *color_texture)
{
const COLLADAFW::TextureMapId texture_index = ctexture.getTextureMapId();
size_t setindex = ctexture.getSetIndex();
std::string uvname = ctexture.getSemantic();
if (setindex == -1) return NULL;
const CustomData *data = &me->fdata;
int layer_index = CustomData_get_layer_index(data, CD_MTFACE);
if (layer_index == -1) return NULL;
CustomDataLayer *cdl = &data->layers[layer_index + setindex];
/* set uvname to bind_vertex_input semantic */
BLI_strncpy(cdl->name, uvname.c_str(), sizeof(cdl->name));
if (texindex_texarray_map.find(texture_index) == texindex_texarray_map.end()) {
fprintf(stderr, "Cannot find texture array by texture index.\n");
return color_texture;
}
std::vector<MTex *> textures = texindex_texarray_map[texture_index];
std::vector<MTex *>::iterator it;
for (it = textures.begin(); it != textures.end(); it++) {
MTex *texture = *it;
if (texture) {
BLI_strncpy(texture->uvname, uvname.c_str(), sizeof(texture->uvname));
if (texture->mapto == MAP_COL) color_texture = texture;
}
}
return color_texture;
}
static PyObject *bpy_bmlayercollection_verify(BPy_BMLayerCollection *self)
{
int index;
CustomData *data;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type);
if (index == -1) {
BM_data_layer_add(self->bm, data, self->type);
index = 0;
}
else {
index = CustomData_get_active_layer_index(data, self->type) - index; /* make relative */
}
BLI_assert(index >= 0);
return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
static PyObject *bpy_bmlayercollection_values(BPy_BMLayerCollection *self)
{
PyObject *ret;
PyObject *item;
int index;
CustomData *data;
int tot, i;
BPY_BM_CHECK_OBJ(self);
data = bpy_bm_customdata_get(self->bm, self->htype);
index = CustomData_get_layer_index(data, self->type);
tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0;
ret = PyList_New(tot);
for (i = 0; tot-- > 0; index++) {
item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i);
PyList_SET_ITEM(ret, i++, item);
}
return ret;
}
HaloRen *RE_inithalo_particle(Render *re, ObjectRen *obr, DerivedMesh *dm, Material *ma,
const float vec[3], const float vec1[3],
const float *orco, const float *uvco, float hasize, float vectsize, int seed, const float pa_co[3])
{
const bool skip_load_image = (re->r.scemode & R_NO_IMAGE_LOAD) != 0;
HaloRen *har;
MTex *mtex;
float tin, tr, tg, tb, ta;
float xn, yn, zn, texvec[3], hoco[4], hoco1[4], in[3], tex[3], out[3];
int i, hasrgb;
if (hasize==0.0f) return NULL;
projectverto(vec, re->winmat, hoco);
if (hoco[3]==0.0f) return NULL;
if (vec1) {
projectverto(vec1, re->winmat, hoco1);
if (hoco1[3]==0.0f) return NULL;
}
har= RE_findOrAddHalo(obr, obr->tothalo++);
copy_v3_v3(har->co, vec);
har->hasize= hasize;
/* actual projectvert is done in function project_renderdata() because of parts/border/pano */
/* we do it here for sorting of halos */
zn= hoco[3];
har->xs= 0.5f*re->winx*(hoco[0]/zn);
har->ys= 0.5f*re->winy*(hoco[1]/zn);
har->zs= 0x7FFFFF*(hoco[2]/zn);
har->zBufDist = 0x7FFFFFFF*(hoco[2]/zn);
/* halovect */
if (vec1) {
har->type |= HA_VECT;
xn= har->xs - 0.5f*re->winx*(hoco1[0]/hoco1[3]);
yn= har->ys - 0.5f*re->winy*(hoco1[1]/hoco1[3]);
if (xn==0.0f || (xn==0.0f && yn==0.0f)) zn= 0.0;
else zn = atan2f(yn, xn);
har->sin = sinf(zn);
har->cos = cosf(zn);
zn= len_v3v3(vec1, vec)*0.5f;
har->hasize= vectsize*zn + (1.0f-vectsize)*hasize;
sub_v3_v3v3(har->no, vec, vec1);
normalize_v3(har->no);
}
if (ma->mode & MA_HALO_XALPHA) har->type |= HA_XALPHA;
har->alfa= ma->alpha;
har->r= ma->r;
har->g= ma->g;
har->b= ma->b;
har->add= (255.0f*ma->add);
har->mat= ma;
har->hard= ma->har;
har->seed= seed % 256;
if (ma->mode & MA_STAR) har->starpoints= ma->starc;
if (ma->mode & MA_HALO_LINES) har->linec= ma->linec;
if (ma->mode & MA_HALO_RINGS) har->ringc= ma->ringc;
if (ma->mode & MA_HALO_FLARE) har->flarec= ma->flarec;
if ((ma->mode & MA_HALOTEX) && ma->mtex[0])
har->tex= 1;
for (i=0; i<MAX_MTEX; i++)
if (ma->mtex[i] && (ma->septex & (1<<i))==0) {
mtex= ma->mtex[i];
copy_v3_v3(texvec, vec);
if (mtex->texco & TEXCO_NORM) {
;
}
else if (mtex->texco & TEXCO_OBJECT) {
if (mtex->object)
mul_m4_v3(mtex->object->imat_ren, texvec);
}
else if (mtex->texco & TEXCO_GLOB) {
copy_v3_v3(texvec, vec);
}
else if (mtex->texco & TEXCO_UV && uvco) {
int uv_index=CustomData_get_named_layer_index(&dm->faceData, CD_MTFACE, mtex->uvname);
if (uv_index<0)
uv_index=CustomData_get_active_layer_index(&dm->faceData, CD_MTFACE);
uv_index-=CustomData_get_layer_index(&dm->faceData, CD_MTFACE);
texvec[0]=2.0f*uvco[2*uv_index]-1.0f;
texvec[1]=2.0f*uvco[2*uv_index+1]-1.0f;
texvec[2]=0.0f;
}
else if (mtex->texco & TEXCO_PARTICLE) {
/* particle coordinates in range [0, 1] */
texvec[0] = 2.f * pa_co[0] - 1.f;
texvec[1] = 2.f * pa_co[1] - 1.f;
texvec[2] = pa_co[2];
}
else if (orco) {
copy_v3_v3(texvec, orco);
}
hasrgb = externtex(mtex, texvec, &tin, &tr, &tg, &tb, &ta, 0, re->pool, skip_load_image);
//yn= tin*mtex->colfac;
//zn= tin*mtex->alphafac;
if (mtex->mapto & MAP_COL) {
tex[0]=tr;
tex[1]=tg;
tex[2]=tb;
out[0]=har->r;
out[1]=har->g;
out[2]=har->b;
texture_rgb_blend(in, tex, out, tin, mtex->colfac, mtex->blendtype);
// zn= 1.0-yn;
//har->r= (yn*tr+ zn*ma->r);
//har->g= (yn*tg+ zn*ma->g);
//har->b= (yn*tb+ zn*ma->b);
har->r= in[0];
har->g= in[1];
har->b= in[2];
}
/* alpha returned, so let's use it instead of intensity */
if (hasrgb)
tin = ta;
if (mtex->mapto & MAP_ALPHA)
har->alfa = texture_value_blend(mtex->def_var, har->alfa, tin, mtex->alphafac, mtex->blendtype);
if (mtex->mapto & MAP_HAR)
har->hard = 1.0f+126.0f*texture_value_blend(mtex->def_var, ((float)har->hard)/127.0f, tin, mtex->hardfac, mtex->blendtype);
if (mtex->mapto & MAP_RAYMIRR)
har->hasize = 100.0f*texture_value_blend(mtex->def_var, har->hasize/100.0f, tin, mtex->raymirrfac, mtex->blendtype);
if (mtex->mapto & MAP_TRANSLU) {
float add = texture_value_blend(mtex->def_var, (float)har->add/255.0f, tin, mtex->translfac, mtex->blendtype);
CLAMP(add, 0.f, 1.f);
har->add = 255.0f*add;
}
/* now what on earth is this good for?? */
//if (mtex->texco & 16) {
// har->alfa= tin;
//}
}
har->pool = re->pool;
har->skip_load_image = (re->r.scemode & R_NO_IMAGE_LOAD) != 0;
return har;
}
static void do_multires_bake(MultiresBakeRender *bkr, Image* ima, MPassKnownData passKnownData,
MInitBakeData initBakeData, MApplyBakeData applyBakeData, MFreeBakeData freeBakeData)
{
DerivedMesh *dm= bkr->lores_dm;
ImBuf *ibuf= BKE_image_get_ibuf(ima, NULL);
const int lvl= bkr->lvl;
const int tot_face= dm->getNumFaces(dm);
MVert *mvert= dm->getVertArray(dm);
MFace *mface= dm->getFaceArray(dm);
MTFace *mtface= dm->getFaceDataArray(dm, CD_MTFACE);
float *pvtangent= NULL;
if(CustomData_get_layer_index(&dm->faceData, CD_TANGENT) == -1)
DM_add_tangent_layer(dm);
pvtangent= DM_get_face_data_layer(dm, CD_TANGENT);
if(tot_face > 0) { /* sanity check */
int f= 0;
MBakeRast bake_rast;
MResolvePixelData data={NULL};
data.mface= mface;
data.mvert= mvert;
data.mtface= mtface;
data.pvtangent= pvtangent;
data.precomputed_normals= dm->getFaceDataArray(dm, CD_NORMAL); /* don't strictly need this */
data.w= ibuf->x;
data.h= ibuf->y;
data.lores_dm= dm;
data.hires_dm= bkr->hires_dm;
data.lvl= lvl;
data.pass_data= passKnownData;
if(initBakeData)
data.bake_data= initBakeData(bkr, ima);
init_bake_rast(&bake_rast, ibuf, &data, flush_pixel);
for(f= 0; f<tot_face; f++) {
MTFace *mtfate= &mtface[f];
int verts[3][2], nr_tris, t;
if(multiresbake_test_break(bkr))
break;
if(mtfate->tpage!=ima)
continue;
data.face_index= f;
/* might support other forms of diagonal splits later on such as
split by shortest diagonal.*/
verts[0][0]=0;
verts[1][0]=1;
verts[2][0]=2;
verts[0][1]=0;
verts[1][1]=2;
verts[2][1]=3;
nr_tris= mface[f].v4!=0 ? 2 : 1;
for(t= 0; t<nr_tris; t++) {
data.i0= verts[0][t];
data.i1= verts[1][t];
data.i2 =verts[2][t];
bake_rasterize(&bake_rast, mtfate->uv[data.i0], mtfate->uv[data.i1], mtfate->uv[data.i2]);
}
bkr->baked_faces++;
if(bkr->do_update)
*bkr->do_update= 1;
if(bkr->progress)
*bkr->progress= ((float)bkr->baked_objects + (float)bkr->baked_faces / tot_face) / bkr->tot_obj;
}
if(applyBakeData)
applyBakeData(data.bake_data);
if(freeBakeData)
freeBakeData(data.bake_data);
}
}
static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *layer)
{
Mesh *me = ob->data;
CustomData *data= (me->edit_mesh)? &me->edit_mesh->fdata: &me->fdata;
void *actlayerdata, *rndlayerdata, *clonelayerdata, *stencillayerdata, *layerdata=layer->data;
int type= layer->type;
int index= CustomData_get_layer_index(data, type);
int i, actindex, rndindex, cloneindex, stencilindex;
/* ok, deleting a non-active layer needs to preserve the active layer indices.
to do this, we store a pointer to the .data member of both layer and the active layer,
(to detect if we're deleting the active layer or not), then use the active
layer data pointer to find where the active layer has ended up.
this is necassary because the deletion functions only support deleting the active
layer. */
actlayerdata = data->layers[CustomData_get_active_layer_index(data, type)].data;
rndlayerdata = data->layers[CustomData_get_render_layer_index(data, type)].data;
clonelayerdata = data->layers[CustomData_get_clone_layer_index(data, type)].data;
stencillayerdata = data->layers[CustomData_get_stencil_layer_index(data, type)].data;
CustomData_set_layer_active(data, type, layer - &data->layers[index]);
if(me->edit_mesh) {
EM_free_data_layer(me->edit_mesh, data, type);
}
else {
CustomData_free_layer_active(data, type, me->totface);
mesh_update_customdata_pointers(me);
}
if(!CustomData_has_layer(data, type) && (type == CD_MCOL && (ob->mode & OB_MODE_VERTEX_PAINT)))
ED_object_toggle_modes(C, OB_MODE_VERTEX_PAINT);
/* reconstruct active layer */
if (actlayerdata != layerdata) {
/* find index */
actindex = CustomData_get_layer_index(data, type);
for (i=actindex; i<data->totlayer; i++) {
if (data->layers[i].data == actlayerdata) {
actindex = i - actindex;
break;
}
}
/* set index */
CustomData_set_layer_active(data, type, actindex);
}
if (rndlayerdata != layerdata) {
/* find index */
rndindex = CustomData_get_layer_index(data, type);
for (i=rndindex; i<data->totlayer; i++) {
if (data->layers[i].data == rndlayerdata) {
rndindex = i - rndindex;
break;
}
}
/* set index */
CustomData_set_layer_render(data, type, rndindex);
}
if (clonelayerdata != layerdata) {
/* find index */
cloneindex = CustomData_get_layer_index(data, type);
for (i=cloneindex; i<data->totlayer; i++) {
if (data->layers[i].data == clonelayerdata) {
cloneindex = i - cloneindex;
break;
}
}
/* set index */
CustomData_set_layer_clone(data, type, cloneindex);
}
if (stencillayerdata != layerdata) {
/* find index */
stencilindex = CustomData_get_layer_index(data, type);
for (i=stencilindex; i<data->totlayer; i++) {
if (data->layers[i].data == stencillayerdata) {
stencilindex = i - stencilindex;
break;
}
}
/* set index */
CustomData_set_layer_stencil(data, type, stencilindex);
}
}
static void do_multires_bake(MultiresBakeRender *bkr, Image *ima, int require_tangent, MPassKnownData passKnownData,
MInitBakeData initBakeData, MApplyBakeData applyBakeData, MFreeBakeData freeBakeData)
{
DerivedMesh *dm = bkr->lores_dm;
const int lvl = bkr->lvl;
const int tot_face = dm->getNumTessFaces(dm);
if (tot_face > 0) {
MultiresBakeThread *handles;
MultiresBakeQueue queue;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
MVert *mvert = dm->getVertArray(dm);
MFace *mface = dm->getTessFaceArray(dm);
MTFace *mtface = dm->getTessFaceDataArray(dm, CD_MTFACE);
float *precomputed_normals = dm->getTessFaceDataArray(dm, CD_NORMAL);
float *pvtangent = NULL;
ListBase threads;
int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();
void *bake_data = NULL;
if (require_tangent) {
if (CustomData_get_layer_index(&dm->faceData, CD_TANGENT) == -1)
DM_add_tangent_layer(dm);
pvtangent = DM_get_tessface_data_layer(dm, CD_TANGENT);
}
/* all threads shares the same custom bake data */
if (initBakeData)
bake_data = initBakeData(bkr, ima);
if (tot_thread > 1)
BLI_init_threads(&threads, do_multires_bake_thread, tot_thread);
handles = MEM_callocN(tot_thread * sizeof(MultiresBakeThread), "do_multires_bake handles");
/* faces queue */
queue.cur_face = 0;
queue.tot_face = tot_face;
BLI_spin_init(&queue.spin);
/* fill in threads handles */
for (i = 0; i < tot_thread; i++) {
MultiresBakeThread *handle = &handles[i];
handle->bkr = bkr;
handle->image = ima;
handle->queue = &queue;
handle->data.mface = mface;
handle->data.mvert = mvert;
handle->data.mtface = mtface;
handle->data.pvtangent = pvtangent;
handle->data.precomputed_normals = precomputed_normals; /* don't strictly need this */
handle->data.w = ibuf->x;
handle->data.h = ibuf->y;
handle->data.lores_dm = dm;
handle->data.hires_dm = bkr->hires_dm;
handle->data.lvl = lvl;
handle->data.pass_data = passKnownData;
handle->data.bake_data = bake_data;
handle->data.ibuf = ibuf;
init_bake_rast(&handle->bake_rast, ibuf, &handle->data, flush_pixel);
if (tot_thread > 1)
BLI_insert_thread(&threads, handle);
}
/* run threads */
if (tot_thread > 1)
BLI_end_threads(&threads);
else
do_multires_bake_thread(&handles[0]);
BLI_spin_end(&queue.spin);
/* finalize baking */
if (applyBakeData)
applyBakeData(bake_data);
if (freeBakeData)
freeBakeData(bake_data);
BKE_image_release_ibuf(ima, ibuf, NULL);
}
}
bool BKE_mesh_uv_cdlayer_rename(Mesh *me, const char *old_name, const char *new_name, bool do_tessface)
{
CustomData *pdata, *ldata, *fdata;
if (me->edit_btmesh) {
pdata = &me->edit_btmesh->bm->pdata;
ldata = &me->edit_btmesh->bm->ldata;
/* No tessellated data in BMesh! */
fdata = NULL;
do_tessface = false;
}
else {
pdata = &me->pdata;
ldata = &me->ldata;
fdata = &me->fdata;
do_tessface = (do_tessface && fdata->totlayer);
}
{
const int pidx_start = CustomData_get_layer_index(pdata, CD_MTEXPOLY);
const int lidx_start = CustomData_get_layer_index(ldata, CD_MLOOPUV);
const int fidx_start = do_tessface ? CustomData_get_layer_index(fdata, CD_MTFACE) : -1;
int pidx = CustomData_get_named_layer(pdata, CD_MTEXPOLY, old_name);
int lidx = CustomData_get_named_layer(ldata, CD_MLOOPUV, old_name);
int fidx = do_tessface ? CustomData_get_named_layer(fdata, CD_MTFACE, old_name) : -1;
/* None of those cases should happen, in theory!
* Note this assume we have the same number of mtexpoly, mloopuv and mtface layers!
*/
if (pidx == -1) {
if (lidx == -1) {
if (fidx == -1) {
/* No layer found with this name! */
return false;
}
else {
lidx = fidx;
}
}
pidx = lidx;
}
else {
if (lidx == -1) {
lidx = pidx;
}
if (fidx == -1 && do_tessface) {
fidx = pidx;
}
}
#if 0
/* For now, we do not consider mismatch in indices (i.e. same name leading to (relative) different indices). */
else if (pidx != lidx) {
lidx = pidx;
}
#endif
/* Go back to absolute indices! */
pidx += pidx_start;
lidx += lidx_start;
if (fidx != -1)
fidx += fidx_start;
return BKE_mesh_uv_cdlayer_rename_index(me, pidx, lidx, fidx, new_name, do_tessface);
}
