griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merging r58148 through r58165 from trunk into soc-2013-depsgraph_mt

Browse Source
This commit is contained in:
Sergey Sharybin
2013-07-11 08:25:37 +00:00
parent e3a604b233 991459d0ce
commit ac0638f681
18 changed files with 169 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
intern/cycles/kernel/kernel_camera.h
View File

@@ -166,6 +166,12 @@ __device void camera_sample_panorama(KernelGlobals *kg, float raster_x, float ra
ray->D = panorama_to_direction(kg, Pcamera.x, Pcamera.y);
/* indicates ray should not receive any light, outside of the lens */
if(is_zero(ray->D)) {
ray->t = 0.0f;
return;
}
/* modify ray for depth of field */
float aperturesize = kernel_data.cam.aperturesize;
@@ -186,12 +192,6 @@ __device void camera_sample_panorama(KernelGlobals *kg, float raster_x, float ra
ray->D = normalize(Pfocus - ray->P);
}
/* indicates ray should not receive any light, outside of the lens */
if(is_zero(ray->D)) {
ray->t = 0.0f;
return;
}
/* transform ray from camera to world */
Transform cameratoworld = kernel_data.cam.cameratoworld;

3
intern/cycles/render/graph.cpp
View File

@@ -347,8 +347,9 @@ void ShaderGraph::remove_unneeded_nodes()
if(tonode->special_type == SHADER_SPECIAL_TYPE_AUTOCONVERT) {
bool all_links_removed = true;
vector<ShaderInput*> links = tonode->outputs[0]->links;
foreach(ShaderInput *autoin, tonode->outputs[0]->links) {
foreach(ShaderInput *autoin, links) {
if(autoin->default_value == ShaderInput::NONE)
all_links_removed = false;
else

7
source/blender/blenkernel/intern/scene.c
View File

@@ -685,12 +685,9 @@ void BKE_scene_set_background(Main *bmain, Scene *scene)
}
}
/* sort baselist */
DAG_scene_relations_rebuild(bmain, scene);
/* ensure dags are built for sets */
/* sort baselist for scene and sets */
for (sce = scene; sce; sce = sce->set)
DAG_scene_relations_update(bmain, sce);
DAG_scene_relations_rebuild(bmain, sce);
/* copy layers and flags from bases to objects */
for (base = scene->base.first; base; base = base->next) {

15
source/blender/blenkernel/intern/unit.c
View File

@@ -95,6 +95,11 @@ typedef struct bUnitDef {
#define B_UNIT_DEF_SUPPRESS 1 /* Use for units that are not used enough to be translated into for common use */
#define B_UNIT_DEF_TENTH 2 /* Display a unit even if its value is 0.1, eg 0.1mm instead of 100um */
/* workaround encoding issue with "µm", bug [#36090] */
#define B_UNIT_CHAR_MICRO "\xb5"
#define UM B_UNIT_CHAR_MICRO"m"
#define US B_UNIT_CHAR_MICRO"s"
/* define a single unit */
typedef struct bUnitCollection {
struct bUnitDef *units;
@@ -116,7 +121,7 @@ static struct bUnitDef buMetricLenDef[] = {
{"decimeter", "decimeters", "dm", NULL, "10 Centimeters", UN_SC_DM, 0.0, B_UNIT_DEF_SUPPRESS},
{"centimeter", "centimeters", "cm", NULL, "Centimeters", UN_SC_CM, 0.0, B_UNIT_DEF_NONE},
{"millimeter", "millimeters", "mm", NULL, "Millimeters", UN_SC_MM, 0.0, B_UNIT_DEF_NONE | B_UNIT_DEF_TENTH},
{"micrometer", "micrometers", "µm", "um", "Micrometers", UN_SC_UM, 0.0, B_UNIT_DEF_NONE}, // micron too?
{"micrometer", "micrometers", UM, "um", "Micrometers", UN_SC_UM, 0.0, B_UNIT_DEF_NONE}, // micron too?
/* These get displayed because of float precision problems in the transform header,
* could work around, but for now probably people wont use these */
@@ -149,7 +154,7 @@ static struct bUnitDef buMetricAreaDef[] = {
{"square decimeter", "square decimetees", "dm²", "dm2", "Square Decimeters", UN_SC_DM * UN_SC_DM, 0.0, B_UNIT_DEF_SUPPRESS},
{"square centimeter", "square centimeters", "cm²", "cm2", "Square Centimeters", UN_SC_CM * UN_SC_CM, 0.0, B_UNIT_DEF_NONE},
{"square millimeter", "square millimeters", "mm²", "mm2", "Square Millimeters", UN_SC_MM * UN_SC_MM, 0.0, B_UNIT_DEF_NONE | B_UNIT_DEF_TENTH},
{"square micrometer", "square micrometers", "µm²", "um2", "Square Micrometers", UN_SC_UM * UN_SC_UM, 0.0, B_UNIT_DEF_NONE},
{"square micrometer", "square micrometers", UM"²", "um2", "Square Micrometers", UN_SC_UM * UN_SC_UM, 0.0, B_UNIT_DEF_NONE},
{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
};
static struct bUnitCollection buMetricAreaCollection = {buMetricAreaDef, 3, 0, sizeof(buMetricAreaDef) / sizeof(bUnitDef)};
@@ -175,7 +180,7 @@ static struct bUnitDef buMetricVolDef[] = {
{"cubic decimeter", "cubic decimeters", "dm³", "dm3", "Cubic Decimeters", UN_SC_DM * UN_SC_DM * UN_SC_DM, 0.0, B_UNIT_DEF_SUPPRESS},
{"cubic centimeter", "cubic centimeters", "cm³", "cm3", "Cubic Centimeters", UN_SC_CM * UN_SC_CM * UN_SC_CM, 0.0, B_UNIT_DEF_NONE},
{"cubic millimeter", "cubic millimeters", "mm³", "mm3", "Cubic Millimeters", UN_SC_MM * UN_SC_MM * UN_SC_MM, 0.0, B_UNIT_DEF_NONE | B_UNIT_DEF_TENTH},
{"cubic micrometer", "cubic micrometers", "µm³", "um3", "Cubic Micrometers", UN_SC_UM * UN_SC_UM * UN_SC_UM, 0.0, B_UNIT_DEF_NONE},
{"cubic micrometer", "cubic micrometers", UM"³", "um3", "Cubic Micrometers", UN_SC_UM * UN_SC_UM * UN_SC_UM, 0.0, B_UNIT_DEF_NONE},
{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
};
static struct bUnitCollection buMetricVolCollection = {buMetricVolDef, 3, 0, sizeof(buMetricVolDef) / sizeof(bUnitDef)};
@@ -253,7 +258,7 @@ static struct bUnitDef buNaturalTimeDef[] = {
{"minute", "minutes", "min", "m", "Minutes", 60.0, 0.0, B_UNIT_DEF_NONE},
{"second", "seconds", "sec", "s", "Seconds", 1.0, 0.0, B_UNIT_DEF_NONE}, /* base unit */
{"millisecond", "milliseconds", "ms", NULL, "Milliseconds", 0.001, 0.0, B_UNIT_DEF_NONE},
{"microsecond", "microseconds", "µs", "us", "Microseconds", 0.000001, 0.0, B_UNIT_DEF_NONE},
{"microsecond", "microseconds", US, "us", "Microseconds", 0.000001, 0.0, B_UNIT_DEF_NONE},
{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
};
static struct bUnitCollection buNaturalTimeCollection = {buNaturalTimeDef, 3, 0, sizeof(buNaturalTimeDef) / sizeof(bUnitDef)};
@@ -273,7 +278,7 @@ static struct bUnitDef buCameraLenDef[] = {
{"decimeter", "decimeters", "dm", NULL, "10 Centimeters", UN_SC_HM, 0.0, B_UNIT_DEF_SUPPRESS},
{"centimeter", "centimeters", "cm", NULL, "Centimeters", UN_SC_DAM, 0.0, B_UNIT_DEF_SUPPRESS},
{"millimeter", "millimeters", "mm", NULL, "Millimeters", UN_SC_M, 0.0, B_UNIT_DEF_NONE},
{"micrometer", "micrometers", "µm", "um", "Micrometers", UN_SC_MM, 0.0, B_UNIT_DEF_SUPPRESS}, // micron too?
{"micrometer", "micrometers", UM, "um", "Micrometers", UN_SC_MM, 0.0, B_UNIT_DEF_SUPPRESS}, // micron too?
{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
};
static struct bUnitCollection buCameraLenCollection = {buCameraLenDef, 3, 0, sizeof(buCameraLenDef) / sizeof(bUnitDef)};

11
source/blender/blenlib/intern/math_matrix.c
View File

@@ -1207,16 +1207,19 @@ void mat4_to_size(float size[3], float mat[4][4])
float mat3_to_scale(float mat[3][3])
{
/* unit length vector */
float unit_vec[3] = {0.577350269189626f, 0.577350269189626f, 0.577350269189626f};
float unit_vec[3];
copy_v3_fl(unit_vec, 0.577350269189626f);
mul_m3_v3(mat, unit_vec);
return len_v3(unit_vec);
}
float mat4_to_scale(float mat[4][4])
{
float tmat[3][3];
copy_m3_m4(tmat, mat);
return mat3_to_scale(tmat);
/* unit length vector */
float unit_vec[3];
copy_v3_fl(unit_vec, 0.577350269189626f);
mul_mat3_m4_v3(mat, unit_vec);
return len_v3(unit_vec);
}
void mat3_to_rot_size(float rot[3][3], float size[3], float mat3[3][3])

28
source/blender/bmesh/intern/bmesh_construct.c
View File

@@ -890,6 +890,24 @@ static BMFace *bm_mesh_copy_new_face(BMesh *bm_new, BMesh *bm_old,
return f_new;
}
void BM_mesh_copy_init_customdata(BMesh *bm_dst, BMesh *bm_src, const BMAllocTemplate *allocsize)
{
if (allocsize == NULL) {
allocsize = &bm_mesh_allocsize_default;
}
CustomData_copy(&bm_src->vdata, &bm_dst->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_src->edata, &bm_dst->edata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_src->ldata, &bm_dst->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_src->pdata, &bm_dst->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_bmesh_init_pool(&bm_dst->vdata, allocsize->totvert, BM_VERT);
CustomData_bmesh_init_pool(&bm_dst->edata, allocsize->totedge, BM_EDGE);
CustomData_bmesh_init_pool(&bm_dst->ldata, allocsize->totloop, BM_LOOP);
CustomData_bmesh_init_pool(&bm_dst->pdata, allocsize->totface, BM_FACE);
}
BMesh *BM_mesh_copy(BMesh *bm_old)
{
BMesh *bm_new;
@@ -908,15 +926,7 @@ BMesh *BM_mesh_copy(BMesh *bm_old)
/* allocate a bmesh */
bm_new = BM_mesh_create(&allocsize);
CustomData_copy(&bm_old->vdata, &bm_new->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_old->edata, &bm_new->edata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_old->ldata, &bm_new->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_copy(&bm_old->pdata, &bm_new->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
CustomData_bmesh_init_pool(&bm_new->vdata, allocsize.totvert, BM_VERT);
CustomData_bmesh_init_pool(&bm_new->edata, allocsize.totedge, BM_EDGE);
CustomData_bmesh_init_pool(&bm_new->ldata, allocsize.totloop, BM_LOOP);
CustomData_bmesh_init_pool(&bm_new->pdata, allocsize.totface, BM_FACE);
BM_mesh_copy_init_customdata(bm_new, bm_old, &allocsize);
vtable = MEM_mallocN(sizeof(BMVert *) * bm_old->totvert, "BM_mesh_copy vtable");
etable = MEM_mallocN(sizeof(BMEdge *) * bm_old->totedge, "BM_mesh_copy etable");

3
source/blender/bmesh/intern/bmesh_construct.h
View File

@@ -27,6 +27,8 @@
* \ingroup bmesh
*/
struct BMAllocTemplate;
BMFace *BM_face_create_quad_tri_v(BMesh *bm,
BMVert **verts, int len,
const BMFace *example, const bool no_double);
@@ -50,6 +52,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type);
void BM_elem_attrs_copy(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target);
void BM_mesh_copy_init_customdata(BMesh *bm_dst, BMesh *bm_src, const struct BMAllocTemplate *allocsize);
BMesh *BM_mesh_copy(BMesh *bm_old);
char BM_face_flag_from_mflag(const char mflag);

14
source/blender/bmesh/intern/bmesh_core.c
View File

@@ -210,7 +210,7 @@ static BMLoop *bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge
return l;
}
BMFace *BM_face_copy(BMesh *bm, BMFace *f,
BMFace *BM_face_copy(BMesh *bm_dst, BMesh *bm_src, BMFace *f,
const bool copy_verts, const bool copy_edges)
{
BMVert **verts = BLI_array_alloca(verts, f->len);
@@ -221,11 +221,13 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f,
BMFace *f_copy;
int i;
BLI_assert((bm_dst == bm_src) || (copy_verts && copy_edges));
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
i = 0;
do {
if (copy_verts) {
verts[i] = BM_vert_create(bm, l_iter->v->co, l_iter->v, 0);
verts[i] = BM_vert_create(bm_dst, l_iter->v->co, l_iter->v, 0);
}
else {
verts[i] = l_iter->v;
@@ -248,7 +250,7 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f,
v1 = verts[(i + 1) % f->len];
}
edges[i] = BM_edge_create(bm, v1, v2, l_iter->e, 0);
edges[i] = BM_edge_create(bm_dst, v1, v2, l_iter->e, 0);
}
else {
edges[i] = l_iter->e;
@@ -256,14 +258,14 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f,
i++;
} while ((l_iter = l_iter->next) != l_first);
f_copy = BM_face_create(bm, verts, edges, f->len, BM_CREATE_SKIP_CD);
f_copy = BM_face_create(bm_dst, verts, edges, f->len, BM_CREATE_SKIP_CD);
BM_elem_attrs_copy(bm, bm, f, f_copy);
BM_elem_attrs_copy(bm_src, bm_dst, f, f_copy);
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
l_copy = BM_FACE_FIRST_LOOP(f_copy);
do {
BM_elem_attrs_copy(bm, bm, l_iter, l_copy);
BM_elem_attrs_copy(bm_src, bm_dst, l_iter, l_copy);
l_copy = l_copy->next;
} while ((l_iter = l_iter->next) != l_first);

2
source/blender/bmesh/intern/bmesh_core.h
View File

@@ -27,7 +27,7 @@
* \ingroup bmesh
*/
BMFace *BM_face_copy(BMesh *bm, BMFace *f,
BMFace *BM_face_copy(BMesh *bm_dst, BMesh *bm_src, BMFace *f,
const bool copy_verts, const bool copy_edges);
typedef enum eBMCreateFlag {

68
source/blender/bmesh/intern/bmesh_interp.c
View File

@@ -429,32 +429,32 @@ static void bm_loop_flip_disp(float source_axis_x[3], float source_axis_y[3],
disp[1] = (mat[0][0] * b[1] - b[0] * mat[1][0]) / d;
}
static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *l_dst, BMFace *f_src)
{
MDisps *mdisps;
const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
MDisps *md_dst;
float d, v1[3], v2[3], v3[3], v4[3] = {0.0f, 0.0f, 0.0f}, e1[3], e2[3];
int ix, res;
float axis_x[3], axis_y[3];
if (cd_loop_mdisp_offset == -1)
return;
/* ignore 2-edged faces */
if (UNLIKELY(target->f->len < 3))
if (UNLIKELY(l_dst->f->len < 3))
return;
md_dst = BM_ELEM_CD_GET_VOID_P(l_dst, cd_loop_mdisp_offset);
compute_mdisp_quad(l_dst, v1, v2, v3, v4, e1, e2);
if (!CustomData_has_layer(&bm->ldata, CD_MDISPS))
return;
mdisps = CustomData_bmesh_get(&bm->ldata, target->head.data, CD_MDISPS);
compute_mdisp_quad(target, v1, v2, v3, v4, e1, e2);
/* if no disps data allocate a new grid, the size of the first grid in source. */
if (!mdisps->totdisp) {
MDisps *md2 = CustomData_bmesh_get(&bm->ldata, BM_FACE_FIRST_LOOP(source)->head.data, CD_MDISPS);
/* if no disps data allocate a new grid, the size of the first grid in f_src. */
if (!md_dst->totdisp) {
MDisps *md_src = BM_ELEM_CD_GET_VOID_P(BM_FACE_FIRST_LOOP(f_src), cd_loop_mdisp_offset);
mdisps->totdisp = md2->totdisp;
mdisps->level = md2->level;
if (mdisps->totdisp) {
mdisps->disps = MEM_callocN(sizeof(float) * 3 * mdisps->totdisp,
"mdisp->disps in bmesh_loop_intern_mdisps");
md_dst->totdisp = md_src->totdisp;
md_dst->level = md_src->level;
if (md_dst->totdisp) {
md_dst->disps = MEM_callocN(sizeof(float) * 3 * md_dst->totdisp, __func__);
}
else {
return;
@@ -463,7 +463,7 @@ static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
mdisp_axis_from_quad(v1, v2, v3, v4, axis_x, axis_y);
res = (int)sqrt(mdisps->totdisp);
res = (int)sqrt(md_dst->totdisp);
d = 1.0f / (float)(res - 1);
#pragma omp parallel for if (res > 3)
for (ix = 0; ix < res; ix++) {
@@ -487,18 +487,17 @@ static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
mul_v3_fl(co, x);
add_v3_v3(co, co1);
l_iter = l_first = BM_FACE_FIRST_LOOP(source);
l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
do {
float x2, y2;
MDisps *md1, *md2;
MDisps *md_src;
float src_axis_x[3], src_axis_y[3];
md1 = CustomData_bmesh_get(&bm->ldata, target->head.data, CD_MDISPS);
md2 = CustomData_bmesh_get(&bm->ldata, l_iter->head.data, CD_MDISPS);
md_src = BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_mdisp_offset);
if (mdisp_in_mdispquad(target, l_iter, co, &x2, &y2, res, src_axis_x, src_axis_y)) {
old_mdisps_bilinear(md1->disps[iy * res + ix], md2->disps, res, (float)x2, (float)y2);
bm_loop_flip_disp(src_axis_x, src_axis_y, axis_x, axis_y, md1->disps[iy * res + ix]);
if (mdisp_in_mdispquad(l_dst, l_iter, co, &x2, &y2, res, src_axis_x, src_axis_y)) {
old_mdisps_bilinear(md_dst->disps[iy * res + ix], md_src->disps, res, (float)x2, (float)y2);
bm_loop_flip_disp(src_axis_x, src_axis_y, axis_x, axis_y, md_dst->disps[iy * res + ix]);
break;
}
@@ -513,16 +512,17 @@ static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *target, BMFace *source)
*/
void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
{
const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
BMLoop *l;
BMIter liter;
if (!CustomData_has_layer(&bm->ldata, CD_MDISPS))
if (cd_loop_mdisp_offset == -1)
return;
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
MDisps *mdp = CustomData_bmesh_get(&bm->ldata, l->prev->head.data, CD_MDISPS);
MDisps *mdl = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
MDisps *mdn = CustomData_bmesh_get(&bm->ldata, l->next->head.data, CD_MDISPS);
MDisps *mdp = BM_ELEM_CD_GET_VOID_P(l->prev, cd_loop_mdisp_offset);
MDisps *mdl = BM_ELEM_CD_GET_VOID_P(l, cd_loop_mdisp_offset);
MDisps *mdn = BM_ELEM_CD_GET_VOID_P(l->next, cd_loop_mdisp_offset);
float co1[3];
int sides;
int y;
@@ -551,7 +551,7 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
}
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
MDisps *mdl1 = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
MDisps *mdl1 = BM_ELEM_CD_GET_VOID_P(l, cd_loop_mdisp_offset);
MDisps *mdl2;
float co1[3], co2[3], co[3];
int sides;
@@ -575,9 +575,9 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
continue;
if (l->radial_next->v == l->v)
mdl2 = CustomData_bmesh_get(&bm->ldata, l->radial_next->head.data, CD_MDISPS);
mdl2 = BM_ELEM_CD_GET_VOID_P(l->radial_next, cd_loop_mdisp_offset);
else
mdl2 = CustomData_bmesh_get(&bm->ldata, l->radial_next->next->head.data, CD_MDISPS);
mdl2 = BM_ELEM_CD_GET_VOID_P(l->radial_next->next, cd_loop_mdisp_offset);
sides = (int)sqrt(mdl1->totdisp);
for (y = 0; y < sides; y++) {
@@ -663,9 +663,7 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
}
if (do_multires) {
if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
bm_loop_interp_mdisps(bm, target, source);
}
bm_loop_interp_mdisps(bm, target, source);
}
}

2
source/blender/bmesh/intern/bmesh_mesh.c
View File

@@ -240,7 +240,7 @@ void BM_mesh_clear(BMesh *bm)
bm_mempool_init(bm, &bm_mesh_allocsize_default);
bm->stackdepth = 1;
bm->totflags = 1;
bm->totflags = 0;
CustomData_reset(&bm->vdata);
CustomData_reset(&bm->edata);

6
source/blender/bmesh/intern/bmesh_mods.c
View File

@@ -345,7 +345,7 @@ BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **r_l
/* do we have a multires layer? */
if (has_mdisp) {
f_tmp = BM_face_copy(bm, f, false, false);
f_tmp = BM_face_copy(bm, bm, f, false, false);
}
#ifdef USE_BMESH_HOLES
@@ -414,7 +414,7 @@ BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, float cos[
BLI_assert(v1 != v2);
f_tmp = BM_face_copy(bm, f, true, true);
f_tmp = BM_face_copy(bm, bm, f, true, true);
if (!r_l)
r_l = &l_dummy;
@@ -662,7 +662,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float perce
/* flag existing faces so we can differentiate oldfaces from new faces */
for (i = 0; i < BLI_array_count(oldfaces); i++) {
BM_ELEM_API_FLAG_ENABLE(oldfaces[i], _FLAG_OVERLAP);
oldfaces[i] = BM_face_copy(bm, oldfaces[i], true, true);
oldfaces[i] = BM_face_copy(bm, bm, oldfaces[i], true, true);
BM_ELEM_API_FLAG_DISABLE(oldfaces[i], _FLAG_OVERLAP);
}
}

6
source/blender/bmesh/intern/bmesh_operators.c
View File

@@ -1248,7 +1248,7 @@ static void bmo_flag_layer_free(BMesh *bm)
/* now go through and memcpy all the flag */
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
void *oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
ele->oflags = BLI_mempool_alloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
@@ -1264,7 +1264,7 @@ static void bmo_flag_layer_free(BMesh *bm)
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
void *oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
ele->oflags = BLI_mempool_alloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
@@ -1280,7 +1280,7 @@ static void bmo_flag_layer_free(BMesh *bm)
BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
void *oldflags = ele->oflags;
ele->oflags = BLI_mempool_calloc(newpool);
ele->oflags = BLI_mempool_alloc(newpool);
memcpy(ele->oflags, oldflags, new_totflags_size);
BM_elem_index_set(ele, i); /* set_inline */
BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);

159
source/blender/editors/transform/transform.c
View File

@@ -59,7 +59,6 @@
#include "BLI_string.h"
#include "BLI_ghash.h"
#include "BLI_linklist.h"
#include "BLI_smallhash.h"
#include "BKE_nla.h"
#include "BKE_bmesh.h"
@@ -4995,8 +4994,7 @@ static bool createEdgeSlideVerts(TransInfo *t)
TransDataEdgeSlideVert *sv_array;
int sv_tot;
BMBVHTree *btree;
/* BMVert -> sv_array index */
SmallHash table;
int *sv_table; /* BMVert -> sv_array index */
EdgeSlideData *sld = MEM_callocN(sizeof(*sld), "sld");
View3D *v3d = NULL;
RegionView3D *rv3d = NULL;
@@ -5014,6 +5012,17 @@ static bool createEdgeSlideVerts(TransInfo *t)
rv3d = t->ar ? t->ar->regiondata : NULL;
}
if ((t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT) &&
/* don't do this at all for non-basis shape keys, too easy to
* accidentally break uv maps or vertex colors then */
(bm->shapenr <= 1))
{
sld->use_origfaces = true;
}
else {
sld->use_origfaces = false;
}
sld->is_proportional = true;
sld->curr_sv_index = 0;
sld->flipped_vtx = FALSE;
@@ -5025,11 +5034,7 @@ static bool createEdgeSlideVerts(TransInfo *t)
else {
ED_view3d_ob_project_mat_get(rv3d, t->obedit, projectMat);
}
BLI_smallhash_init(&sld->vhash);
BLI_smallhash_init(&sld->origfaces);
BLI_smallhash_init(&table);
/*ensure valid selection*/
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
@@ -5063,20 +5068,26 @@ static bool createEdgeSlideVerts(TransInfo *t)
}
}
sv_table = MEM_mallocN(sizeof(*sv_table) * bm->totvert, __func__);
j = 0;
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BM_elem_flag_enable(v, BM_ELEM_TAG);
BLI_smallhash_insert(&table, (uintptr_t)v, SET_INT_IN_POINTER(j));
sv_table[i] = j;
j += 1;
}
else {
BM_elem_flag_disable(v, BM_ELEM_TAG);
sv_table[i] = -1;
}
BM_elem_index_set(v, i); /* set_inline */
}
bm->elem_index_dirty &= ~BM_VERT;
if (!j) {
MEM_freeN(sld);
MEM_freeN(sv_table);
return false;
}
@@ -5173,9 +5184,9 @@ static bool createEdgeSlideVerts(TransInfo *t)
BMEdge *e_prev;
/* XXX, 'sv' will initialize multiple times, this is suspicious. see [#34024] */
BLI_assert(BLI_smallhash_haskey(&table, (uintptr_t)v) != false);
BLI_assert(v != NULL);
sv = sv_array + GET_INT_FROM_POINTER(BLI_smallhash_lookup(&table, (uintptr_t)v));
BLI_assert(sv_table[BM_elem_index_get(v)] != -1);
sv = &sv_array[sv_table[BM_elem_index_get(v)]];
sv->v = v;
copy_v3_v3(sv->v_co_orig, v->co);
sv->loop_nr = loop_nr;
@@ -5199,9 +5210,9 @@ static bool createEdgeSlideVerts(TransInfo *t)
e = get_other_edge(v, e);
if (!e) {
BLI_assert(BLI_smallhash_haskey(&table, (uintptr_t)v) != false);
BLI_assert(v != NULL);
sv = sv_array + GET_INT_FROM_POINTER(BLI_smallhash_lookup(&table, (uintptr_t)v));
BLI_assert(sv_table[BM_elem_index_get(v)] != -1);
sv = &sv_array[sv_table[BM_elem_index_get(v)]];
sv->v = v;
copy_v3_v3(sv->v_co_orig, v->co);
sv->loop_nr = loop_nr;
@@ -5268,7 +5279,6 @@ static bool createEdgeSlideVerts(TransInfo *t)
loop_nr++;
}
/* use for visibility checks */
use_btree_disp = (v3d && t->obedit->dt > OB_WIRE && v3d->drawtype > OB_WIRE);
@@ -5316,8 +5326,8 @@ static bool createEdgeSlideVerts(TransInfo *t)
continue;
}
BLI_assert(BLI_smallhash_haskey(&table, (uintptr_t)v) != false);
j = GET_INT_FROM_POINTER(BLI_smallhash_lookup(&table, (uintptr_t)v));
BLI_assert(sv_table[BM_elem_index_get(v)] != -1);
j = sv_table[BM_elem_index_get(v)];
if (sv_array[j].v_b) {
ED_view3d_project_float_v3_m4(ar, sv_array[j].v_b->co, sco_b, projectMat);
@@ -5364,33 +5374,29 @@ static bool createEdgeSlideVerts(TransInfo *t)
bmesh_edit_begin(bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
if (sld->use_origfaces) {
sld->origfaces = BLI_ghash_ptr_new(__func__);
sld->bm_origfaces = BM_mesh_create(&bm_mesh_allocsize_default);
/* we need to have matching customdata */
BM_mesh_copy_init_customdata(sld->bm_origfaces, bm, NULL);
}
/*create copies of faces for customdata projection*/
sv_array = sld->sv;
for (i = 0; i < sld->totsv; i++, sv_array++) {
BMIter fiter, liter;
BMIter fiter;
BMFace *f;
BMLoop *l;
BM_ITER_ELEM (f, &fiter, sv_array->v, BM_FACES_OF_VERT) {
if (!BLI_smallhash_haskey(&sld->origfaces, (uintptr_t)f)) {
BMFace *copyf = BM_face_copy(bm, f, true, true);
BM_face_select_set(bm, copyf, false);
BM_elem_flag_enable(copyf, BM_ELEM_HIDDEN);
BM_ITER_ELEM (l, &liter, copyf, BM_LOOPS_OF_FACE) {
BM_vert_select_set(bm, l->v, false);
BM_elem_flag_enable(l->v, BM_ELEM_HIDDEN);
BM_edge_select_set(bm, l->e, false);
BM_elem_flag_enable(l->e, BM_ELEM_HIDDEN);
}
BLI_smallhash_insert(&sld->origfaces, (uintptr_t)f, copyf);
if (sld->use_origfaces) {
BM_ITER_ELEM (f, &fiter, sv_array->v, BM_FACES_OF_VERT) {
if (!BLI_ghash_haskey(sld->origfaces, f)) {
BMFace *f_copy = BM_face_copy(sld->bm_origfaces, bm, f, true, true);
BLI_ghash_insert(sld->origfaces, f, f_copy);
}
}
}
BLI_smallhash_insert(&sld->vhash, (uintptr_t)sv_array->v, sv_array);
/* switch a/b if loop direction is different from global direction */
l_nr = sv_array->loop_nr;
if (dot_v3v3(loop_dir[l_nr], mval_dir) < 0.0f) {
@@ -5402,9 +5408,8 @@ static bool createEdgeSlideVerts(TransInfo *t)
if (rv3d)
calcNonProportionalEdgeSlide(t, sld, mval);
sld->origfaces_init = true;
sld->em = em;
/*zero out start*/
zero_v2(mval_start);
@@ -5422,16 +5427,13 @@ static bool createEdgeSlideVerts(TransInfo *t)
t->customData = sld;
BLI_smallhash_release(&table);
MEM_freeN(sv_table);
if (btree) {
BKE_bmbvh_free(btree);
}
MEM_freeN(loop_dir);
MEM_freeN(loop_maxdist);
/* arrays are dirty from copying faces: EDBM_index_arrays_free */
EDBM_update_generic(em, false, true);
return true;
}
@@ -5442,17 +5444,10 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
BMEditMesh *em = sld->em;
int i;
if (!em)
return;
if (!(t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT))
if (sld->use_origfaces == false) {
return;
}
/* don't do this at all for non-basis shape keys, too easy to
* accidentally break uv maps or vertex colors then */
if (em->bm->shapenr > 1)
return;
for (i = 0, sv = sld->sv; i < sld->totsv; sv++, i++) {
BMIter fiter;
BMLoop *l;
@@ -5460,15 +5455,8 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
BM_ITER_ELEM (l, &fiter, sv->v, BM_LOOPS_OF_VERT) {
BMFace *f_copy; /* the copy of 'f' */
BMFace *f_copy_flip; /* the copy of 'f' or detect if we need to flip to the shorter side. */
bool is_sel, is_hide;
/* the face attributes of the copied face will get
* copied over, so its necessary to save the selection
* and hidden state*/
is_sel = BM_elem_flag_test(l->f, BM_ELEM_SELECT) != 0;
is_hide = BM_elem_flag_test(l->f, BM_ELEM_HIDDEN) != 0;
f_copy = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l->f);
f_copy = BLI_ghash_lookup(sld->origfaces, l->f);
/* project onto copied projection face */
f_copy_flip = f_copy;
@@ -5482,12 +5470,12 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
if (sld->perc < 0.0f) {
if (BM_vert_in_face(l_ed_sel->radial_next->f, sv->v_b)) {
f_copy_flip = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l_ed_sel->radial_next->f);
f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_ed_sel->radial_next->f);
}
}
else if (sld->perc > 0.0f) {
if (BM_vert_in_face(l_ed_sel->radial_next->f, sv->v_a)) {
f_copy_flip = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l_ed_sel->radial_next->f);
f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_ed_sel->radial_next->f);
}
}
@@ -5573,7 +5561,7 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
l_adj = l;
}
f_copy_flip = BLI_smallhash_lookup(&sld->origfaces, (uintptr_t)l_adj->f);
f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_adj->f);
}
}
}
@@ -5590,36 +5578,23 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
}
/* make sure face-attributes are correct (e.g. MTexPoly) */
BM_elem_attrs_copy(em->bm, em->bm, f_copy, l->f);
/* restore selection and hidden flags */
BM_face_select_set(em->bm, l->f, is_sel);
if (!is_hide) {
/* this check is a workaround for bug, see note - [#30735],
* without this edge can be hidden and selected */
BM_elem_hide_set(em->bm, l->f, is_hide);
}
BM_elem_attrs_copy(sld->bm_origfaces, em->bm, f_copy, l->f);
}
}
}
void freeEdgeSlideTempFaces(EdgeSlideData *sld)
{
if (sld->origfaces_init) {
SmallHashIter hiter;
BMFace *copyf;
copyf = BLI_smallhash_iternew(&sld->origfaces, &hiter, NULL);
for (; copyf; copyf = BLI_smallhash_iternext(&hiter, NULL)) {
BM_face_verts_kill(sld->em->bm, copyf);
if (sld->use_origfaces) {
if (sld->bm_origfaces) {
BM_mesh_free(sld->bm_origfaces);
sld->bm_origfaces = NULL;
}
BLI_smallhash_release(&sld->origfaces);
sld->origfaces_init = false;
/* arrays are dirty from removing faces: EDBM_index_arrays_free */
EDBM_update_generic(sld->em, FALSE, TRUE);
if (sld->origfaces) {
BLI_ghash_free(sld->origfaces, NULL, NULL);
sld->origfaces = NULL;
}
}
}
@@ -5628,30 +5603,12 @@ void freeEdgeSlideVerts(TransInfo *t)
{
EdgeSlideData *sld = t->customData;
#if 0 /*BMESH_TODO*/
if (me->drawflag & ME_DRAWEXTRA_EDGELEN) {
TransDataEdgeSlideVert *sv;
LinkNode *look = sld->vertlist;
GHash *vertgh = sld->vhash;
while (look) {
sv = BLI_ghash_lookup(vertgh, (EditVert *)look->link);
if (sv != NULL) {
sv->v_a->f &= !SELECT;
sv->v_b->f &= !SELECT;
}
look = look->next;
}
}
#endif
if (!sld)
return;
freeEdgeSlideTempFaces(sld);
bmesh_edit_end(sld->em->bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
BLI_smallhash_release(&sld->vhash);
MEM_freeN(sld->sv);
MEM_freeN(sld);

6
source/blender/editors/transform/transform.h
View File

@@ -201,14 +201,14 @@ typedef struct EdgeSlideData {
TransDataEdgeSlideVert *sv;
int totsv;
struct SmallHash vhash;
struct SmallHash origfaces;
struct GHash *origfaces;
int mval_start[2], mval_end[2];
struct BMEditMesh *em;
/* flag that is set when origfaces is initialized */
bool origfaces_init;
bool use_origfaces;
struct BMesh *bm_origfaces;
float perc;

6
source/blender/imbuf/intern/tiff.c
View File

@@ -532,6 +532,7 @@ ImBuf *imb_loadtiff(unsigned char *mem, size_t size, int flags, char colorspace[
int level;
short spp;
int ib_depth;
int found;
/* check whether or not we have a TIFF file */
if (size < IMB_TIFF_NCB) {
@@ -575,10 +576,11 @@ ImBuf *imb_loadtiff(unsigned char *mem, size_t size, int flags, char colorspace[
if (spp == 4) {
unsigned short extra, *extraSampleTypes;
TIFFGetField(image, TIFFTAG_EXTRASAMPLES, &extra, &extraSampleTypes);
found = TIFFGetField(image, TIFFTAG_EXTRASAMPLES, &extra, &extraSampleTypes);
if (extraSampleTypes[0] == EXTRASAMPLE_ASSOCALPHA)
if (found && (extraSampleTypes[0] == EXTRASAMPLE_ASSOCALPHA)) {
ibuf->flags |= IB_alphamode_premul;
}
}
}

2
source/blender/python/bmesh/bmesh_py_types.c
View File

@@ -1616,7 +1616,7 @@ static PyObject *bpy_bmface_copy(BPy_BMFace *self, PyObject *args, PyObject *kw)
return NULL;
}
f_cpy = BM_face_copy(bm, self->f, do_verts, do_edges);
f_cpy = BM_face_copy(bm, bm, self->f, do_verts, do_edges);
if (f_cpy) {
return BPy_BMFace_CreatePyObject(bm, f_cpy);

10
source/blender/render/intern/source/convertblender.c
View File

@@ -5403,12 +5403,10 @@ void RE_Database_Preprocess(Render *re)
volume_precache(re);
}
if (re->test_break(re->tbh)) {
re->i.convertdone = TRUE;
re->i.convertdone = TRUE;
if (re->test_break(re->tbh))
RE_Database_Free(re);
}
else
re->i.convertdone = TRUE;
re->i.infostr = NULL;
re->stats_draw(re->sdh, &re->i);
@@ -5858,6 +5856,7 @@ void RE_Database_FromScene_Vectors(Render *re, Main *bmain, Scene *sce, unsigned
/* free dbase and make the future one */
strandsurface= re->strandsurface;
memset(&re->strandsurface, 0, sizeof(ListBase));
re->i.convertdone = TRUE;
RE_Database_Free(re);
re->strandsurface= strandsurface;
@@ -5873,6 +5872,7 @@ void RE_Database_FromScene_Vectors(Render *re, Main *bmain, Scene *sce, unsigned
/* free dbase and make the real one */
strandsurface= re->strandsurface;
memset(&re->strandsurface, 0, sizeof(ListBase));
re->i.convertdone = TRUE;
RE_Database_Free(re);
re->strandsurface= strandsurface;