static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
bPoseChannel *pchan = BKE_pose_channel_find_name(hmd->object->pose, hmd->subtarget);
float dmat[4][4];
int i, *index_pt;
struct HookData_cb hd;
if (hmd->curfalloff == NULL) {
/* should never happen, but bad lib linking could cause it */
hmd->curfalloff = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
}
if (hmd->curfalloff) {
curvemapping_initialize(hmd->curfalloff);
}
/* Generic data needed for applying per-vertex calculations (initialize all members) */
hd.vertexCos = vertexCos;
modifier_get_vgroup(ob, dm, hmd->name, &hd.dvert, &hd.defgrp_index);
hd.curfalloff = hmd->curfalloff;
hd.falloff_type = hmd->falloff_type;
hd.falloff = (hmd->falloff_type == eHook_Falloff_None) ? 0.0f : hmd->falloff;
hd.falloff_sq = SQUARE(hd.falloff);
hd.fac_orig = hmd->force;
hd.use_falloff = (hd.falloff_sq != 0.0f);
hd.use_uniform = (hmd->flag & MOD_HOOK_UNIFORM_SPACE) != 0;
if (hd.use_uniform) {
copy_m3_m4(hd.mat_uniform, hmd->parentinv);
mul_v3_m3v3(hd.cent, hd.mat_uniform, hmd->cent);
}
else {
unit_m3(hd.mat_uniform); /* unused */
copy_v3_v3(hd.cent, hmd->cent);
}
/* get world-space matrix of target, corrected for the space the verts are in */
if (hmd->subtarget[0] && pchan) {
/* bone target if there's a matching pose-channel */
mul_m4_m4m4(dmat, hmd->object->obmat, pchan->pose_mat);
}
else {
/* just object target */
copy_m4_m4(dmat, hmd->object->obmat);
}
invert_m4_m4(ob->imat, ob->obmat);
mul_m4_series(hd.mat, ob->imat, dmat, hmd->parentinv);
/* --- done with 'hd' init --- */
/* Regarding index range checking below.
*
* This should always be true and I don't generally like
* "paranoid" style code like this, but old files can have
* indices that are out of range because old blender did
* not correct them on exit editmode. - zr
*/
if (hmd->force == 0.0f) {
/* do nothing, avoid annoying checks in the loop */
}
else if (hmd->indexar) { /* vertex indices? */
const int *origindex_ar;
/* if DerivedMesh is present and has original index data, use it */
if (dm && (origindex_ar = dm->getVertDataArray(dm, CD_ORIGINDEX))) {
for (i = 0, index_pt = hmd->indexar; i < hmd->totindex; i++, index_pt++) {
if (*index_pt < numVerts) {
int j;
for (j = 0; j < numVerts; j++) {
if (origindex_ar[j] == *index_pt) {
hook_co_apply(&hd, j);
}
}
}
}
}
else { /* missing dm or ORIGINDEX */
for (i = 0, index_pt = hmd->indexar; i < hmd->totindex; i++, index_pt++) {
if (*index_pt < numVerts) {
hook_co_apply(&hd, *index_pt);
}
}
}
}
else if (hd.dvert) { /* vertex group hook */
for (i = 0; i < numVerts; i++) {
hook_co_apply(&hd, i);
}
}
}
void clip_draw_main(const bContext *C, SpaceClip *sc, ARegion *ar)
{
MovieClip *clip = ED_space_clip_get_clip(sc);
Scene *scene = CTX_data_scene(C);
ImBuf *ibuf = NULL;
int width, height;
float zoomx, zoomy;
ED_space_clip_get_size(sc, &width, &height);
ED_space_clip_get_zoom(sc, ar, &zoomx, &zoomy);
/* if no clip, nothing to do */
if (!clip) {
ED_region_grid_draw(ar, zoomx, zoomy);
return;
}
if (sc->flag & SC_SHOW_STABLE) {
float smat[4][4], ismat[4][4];
ibuf = ED_space_clip_get_stable_buffer(sc, sc->loc, &sc->scale, &sc->angle);
if (ibuf) {
float translation[2];
float aspect = clip->tracking.camera.pixel_aspect;
if (width != ibuf->x)
mul_v2_v2fl(translation, sc->loc, (float)width / ibuf->x);
else
copy_v2_v2(translation, sc->loc);
BKE_tracking_stabilization_data_to_mat4(width, height, aspect,
translation, sc->scale, sc->angle, sc->stabmat);
unit_m4(smat);
smat[0][0] = 1.0f / width;
smat[1][1] = 1.0f / height;
invert_m4_m4(ismat, smat);
mul_m4_series(sc->unistabmat, smat, sc->stabmat, ismat);
}
}
else if ((sc->flag & SC_MUTE_FOOTAGE) == 0) {
ibuf = ED_space_clip_get_buffer(sc);
zero_v2(sc->loc);
sc->scale = 1.0f;
unit_m4(sc->stabmat);
unit_m4(sc->unistabmat);
}
if (ibuf) {
draw_movieclip_buffer(C, sc, ar, ibuf, width, height, zoomx, zoomy);
IMB_freeImBuf(ibuf);
}
else if (sc->flag & SC_MUTE_FOOTAGE) {
draw_movieclip_muted(ar, width, height, zoomx, zoomy);
}
else {
ED_region_grid_draw(ar, zoomx, zoomy);
}
if (width && height) {
draw_stabilization_border(sc, ar, width, height, zoomx, zoomy);
draw_tracking_tracks(sc, scene, ar, clip, width, height, zoomx, zoomy);
draw_distortion(sc, ar, clip, width, height, zoomx, zoomy);
}
}
static DerivedMesh *arrayModifier_doArray(
ArrayModifierData *amd,
Scene *scene, Object *ob, DerivedMesh *dm,
ModifierApplyFlag flag)
{
const float eps = 1e-6f;
const MVert *src_mvert;
MVert *mv, *mv_prev, *result_dm_verts;
MEdge *me;
MLoop *ml;
MPoly *mp;
int i, j, c, count;
float length = amd->length;
/* offset matrix */
float offset[4][4];
float scale[3];
bool offset_has_scale;
float current_offset[4][4];
float final_offset[4][4];
int *full_doubles_map = NULL;
int tot_doubles;
const bool use_merge = (amd->flags & MOD_ARR_MERGE) != 0;
const bool use_recalc_normals = (dm->dirty & DM_DIRTY_NORMALS) || use_merge;
const bool use_offset_ob = ((amd->offset_type & MOD_ARR_OFF_OBJ) && amd->offset_ob);
/* allow pole vertices to be used by many faces */
const bool with_follow = use_offset_ob;
int start_cap_nverts = 0, start_cap_nedges = 0, start_cap_npolys = 0, start_cap_nloops = 0;
int end_cap_nverts = 0, end_cap_nedges = 0, end_cap_npolys = 0, end_cap_nloops = 0;
int result_nverts = 0, result_nedges = 0, result_npolys = 0, result_nloops = 0;
int chunk_nverts, chunk_nedges, chunk_nloops, chunk_npolys;
int first_chunk_start, first_chunk_nverts, last_chunk_start, last_chunk_nverts;
DerivedMesh *result, *start_cap_dm = NULL, *end_cap_dm = NULL;
chunk_nverts = dm->getNumVerts(dm);
chunk_nedges = dm->getNumEdges(dm);
chunk_nloops = dm->getNumLoops(dm);
chunk_npolys = dm->getNumPolys(dm);
count = amd->count;
if (amd->start_cap && amd->start_cap != ob && amd->start_cap->type == OB_MESH) {
start_cap_dm = get_dm_for_modifier(amd->start_cap, flag);
if (start_cap_dm) {
start_cap_nverts = start_cap_dm->getNumVerts(start_cap_dm);
start_cap_nedges = start_cap_dm->getNumEdges(start_cap_dm);
start_cap_nloops = start_cap_dm->getNumLoops(start_cap_dm);
start_cap_npolys = start_cap_dm->getNumPolys(start_cap_dm);
}
}
if (amd->end_cap && amd->end_cap != ob && amd->end_cap->type == OB_MESH) {
end_cap_dm = get_dm_for_modifier(amd->end_cap, flag);
if (end_cap_dm) {
end_cap_nverts = end_cap_dm->getNumVerts(end_cap_dm);
end_cap_nedges = end_cap_dm->getNumEdges(end_cap_dm);
end_cap_nloops = end_cap_dm->getNumLoops(end_cap_dm);
end_cap_npolys = end_cap_dm->getNumPolys(end_cap_dm);
}
}
/* Build up offset array, cumulating all settings options */
unit_m4(offset);
src_mvert = dm->getVertArray(dm);
if (amd->offset_type & MOD_ARR_OFF_CONST)
add_v3_v3v3(offset[3], offset[3], amd->offset);
if (amd->offset_type & MOD_ARR_OFF_RELATIVE) {
for (j = 0; j < 3; j++)
offset[3][j] += amd->scale[j] * vertarray_size(src_mvert, chunk_nverts, j);
}
if (use_offset_ob) {
float obinv[4][4];
float result_mat[4][4];
if (ob)
invert_m4_m4(obinv, ob->obmat);
else
unit_m4(obinv);
mul_m4_series(result_mat, offset,
obinv, amd->offset_ob->obmat);
copy_m4_m4(offset, result_mat);
}
/* Check if there is some scaling. If scaling, then we will not translate mapping */
mat4_to_size(scale, offset);
offset_has_scale = !is_one_v3(scale);
if (amd->fit_type == MOD_ARR_FITCURVE && amd->curve_ob) {
Curve *cu = amd->curve_ob->data;
if (cu) {
#ifdef CYCLIC_DEPENDENCY_WORKAROUND
if (amd->curve_ob->curve_cache == NULL) {
BKE_displist_make_curveTypes(scene, amd->curve_ob, false);
}
#endif
if (amd->curve_ob->curve_cache && amd->curve_ob->curve_cache->path) {
float scale = mat4_to_scale(amd->curve_ob->obmat);
length = scale * amd->curve_ob->curve_cache->path->totdist;
}
}
}
/* calculate the maximum number of copies which will fit within the
* prescribed length */
if (amd->fit_type == MOD_ARR_FITLENGTH || amd->fit_type == MOD_ARR_FITCURVE) {
float dist = len_v3(offset[3]);
if (dist > eps) {
/* this gives length = first copy start to last copy end
* add a tiny offset for floating point rounding errors */
count = (length + eps) / dist;
}
else {
/* if the offset has no translation, just make one copy */
count = 1;
}
}
if (count < 1)
count = 1;
/* The number of verts, edges, loops, polys, before eventually merging doubles */
result_nverts = chunk_nverts * count + start_cap_nverts + end_cap_nverts;
result_nedges = chunk_nedges * count + start_cap_nedges + end_cap_nedges;
result_nloops = chunk_nloops * count + start_cap_nloops + end_cap_nloops;
result_npolys = chunk_npolys * count + start_cap_npolys + end_cap_npolys;
/* Initialize a result dm */
result = CDDM_from_template(dm, result_nverts, result_nedges, 0, result_nloops, result_npolys);
result_dm_verts = CDDM_get_verts(result);
if (use_merge) {
/* Will need full_doubles_map for handling merge */
full_doubles_map = MEM_mallocN(sizeof(int) * result_nverts, "mod array doubles map");
fill_vn_i(full_doubles_map, result_nverts, -1);
}
/* copy customdata to original geometry */
DM_copy_vert_data(dm, result, 0, 0, chunk_nverts);
DM_copy_edge_data(dm, result, 0, 0, chunk_nedges);
DM_copy_loop_data(dm, result, 0, 0, chunk_nloops);
DM_copy_poly_data(dm, result, 0, 0, chunk_npolys);
/* subsurf for eg wont have mesh data in the
* now add mvert/medge/mface layers */
if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
dm->copyVertArray(dm, result_dm_verts);
}
if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
dm->copyEdgeArray(dm, CDDM_get_edges(result));
}
if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
dm->copyLoopArray(dm, CDDM_get_loops(result));
dm->copyPolyArray(dm, CDDM_get_polys(result));
}
/* Remember first chunk, in case of cap merge */
first_chunk_start = 0;
first_chunk_nverts = chunk_nverts;
unit_m4(current_offset);
for (c = 1; c < count; c++) {
/* copy customdata to new geometry */
DM_copy_vert_data(result, result, 0, c * chunk_nverts, chunk_nverts);
DM_copy_edge_data(result, result, 0, c * chunk_nedges, chunk_nedges);
DM_copy_loop_data(result, result, 0, c * chunk_nloops, chunk_nloops);
DM_copy_poly_data(result, result, 0, c * chunk_npolys, chunk_npolys);
mv_prev = result_dm_verts;
mv = mv_prev + c * chunk_nverts;
/* recalculate cumulative offset here */
mul_m4_m4m4(current_offset, current_offset, offset);
/* apply offset to all new verts */
for (i = 0; i < chunk_nverts; i++, mv++, mv_prev++) {
mul_m4_v3(current_offset, mv->co);
/* We have to correct normals too, if we do not tag them as dirty! */
if (!use_recalc_normals) {
float no[3];
normal_short_to_float_v3(no, mv->no);
mul_mat3_m4_v3(current_offset, no);
normalize_v3(no);
normal_float_to_short_v3(mv->no, no);
}
}
/* adjust edge vertex indices */
me = CDDM_get_edges(result) + c * chunk_nedges;
for (i = 0; i < chunk_nedges; i++, me++) {
me->v1 += c * chunk_nverts;
me->v2 += c * chunk_nverts;
}
mp = CDDM_get_polys(result) + c * chunk_npolys;
for (i = 0; i < chunk_npolys; i++, mp++) {
mp->loopstart += c * chunk_nloops;
}
/* adjust loop vertex and edge indices */
ml = CDDM_get_loops(result) + c * chunk_nloops;
for (i = 0; i < chunk_nloops; i++, ml++) {
ml->v += c * chunk_nverts;
ml->e += c * chunk_nedges;
}
/* Handle merge between chunk n and n-1 */
if (use_merge && (c >= 1)) {
if (!offset_has_scale && (c >= 2)) {
/* Mapping chunk 3 to chunk 2 is a translation of mapping 2 to 1
* ... that is except if scaling makes the distance grow */
int k;
int this_chunk_index = c * chunk_nverts;
int prev_chunk_index = (c - 1) * chunk_nverts;
for (k = 0; k < chunk_nverts; k++, this_chunk_index++, prev_chunk_index++) {
int target = full_doubles_map[prev_chunk_index];
if (target != -1) {
target += chunk_nverts; /* translate mapping */
if (full_doubles_map[target] != -1) {
if (with_follow) {
target = full_doubles_map[target];
}
else {
/* The rule here is to not follow mapping to chunk N-2, which could be too far
* so if target vertex was itself mapped, then this vertex is not mapped */
target = -1;
}
}
}
full_doubles_map[this_chunk_index] = target;
}
}
else {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
(c - 1) * chunk_nverts,
chunk_nverts,
c * chunk_nverts,
chunk_nverts,
amd->merge_dist,
with_follow);
}
}
}
last_chunk_start = (count - 1) * chunk_nverts;
last_chunk_nverts = chunk_nverts;
copy_m4_m4(final_offset, current_offset);
if (use_merge && (amd->flags & MOD_ARR_MERGEFINAL) && (count > 1)) {
/* Merge first and last copies */
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
last_chunk_start,
last_chunk_nverts,
first_chunk_start,
first_chunk_nverts,
amd->merge_dist,
with_follow);
}
/* start capping */
if (start_cap_dm) {
float start_offset[4][4];
int start_cap_start = result_nverts - start_cap_nverts - end_cap_nverts;
invert_m4_m4(start_offset, offset);
dm_merge_transform(
result, start_cap_dm, start_offset,
result_nverts - start_cap_nverts - end_cap_nverts,
result_nedges - start_cap_nedges - end_cap_nedges,
result_nloops - start_cap_nloops - end_cap_nloops,
result_npolys - start_cap_npolys - end_cap_npolys,
start_cap_nverts, start_cap_nedges, start_cap_nloops, start_cap_npolys);
/* Identify doubles with first chunk */
if (use_merge) {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
first_chunk_start,
first_chunk_nverts,
start_cap_start,
start_cap_nverts,
amd->merge_dist,
false);
}
}
if (end_cap_dm) {
float end_offset[4][4];
int end_cap_start = result_nverts - end_cap_nverts;
mul_m4_m4m4(end_offset, current_offset, offset);
dm_merge_transform(
result, end_cap_dm, end_offset,
result_nverts - end_cap_nverts,
result_nedges - end_cap_nedges,
result_nloops - end_cap_nloops,
result_npolys - end_cap_npolys,
end_cap_nverts, end_cap_nedges, end_cap_nloops, end_cap_npolys);
/* Identify doubles with last chunk */
if (use_merge) {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
last_chunk_start,
last_chunk_nverts,
end_cap_start,
end_cap_nverts,
amd->merge_dist,
false);
}
}
/* done capping */
/* Handle merging */
tot_doubles = 0;
if (use_merge) {
for (i = 0; i < result_nverts; i++) {
if (full_doubles_map[i] != -1) {
if (i == full_doubles_map[i]) {
full_doubles_map[i] = -1;
}
else {
tot_doubles++;
}
}
}
if (tot_doubles > 0) {
result = CDDM_merge_verts(result, full_doubles_map, tot_doubles, CDDM_MERGE_VERTS_DUMP_IF_EQUAL);
}
MEM_freeN(full_doubles_map);
}
/* In case org dm has dirty normals, or we made some merging, mark normals as dirty in new dm!
* TODO: we may need to set other dirty flags as well?
*/
if (use_recalc_normals) {
result->dirty |= DM_DIRTY_NORMALS;
}
return result;
}
void BKE_texture_mapping_init(TexMapping *texmap)
{
float smat[4][4], rmat[4][4], tmat[4][4], proj[4][4], size[3];
if (texmap->projx == PROJ_X && texmap->projy == PROJ_Y && texmap->projz == PROJ_Z &&
is_zero_v3(texmap->loc) && is_zero_v3(texmap->rot) && is_one_v3(texmap->size))
{
unit_m4(texmap->mat);
texmap->flag |= TEXMAP_UNIT_MATRIX;
}
else {
/* axis projection */
zero_m4(proj);
proj[3][3] = 1.0f;
if (texmap->projx != PROJ_N)
proj[texmap->projx - 1][0] = 1.0f;
if (texmap->projy != PROJ_N)
proj[texmap->projy - 1][1] = 1.0f;
if (texmap->projz != PROJ_N)
proj[texmap->projz - 1][2] = 1.0f;
/* scale */
copy_v3_v3(size, texmap->size);
if (ELEM(texmap->type, TEXMAP_TYPE_TEXTURE, TEXMAP_TYPE_NORMAL)) {
/* keep matrix invertible */
if (fabsf(size[0]) < 1e-5f)
size[0] = signf(size[0]) * 1e-5f;
if (fabsf(size[1]) < 1e-5f)
size[1] = signf(size[1]) * 1e-5f;
if (fabsf(size[2]) < 1e-5f)
size[2] = signf(size[2]) * 1e-5f;
}
size_to_mat4(smat, texmap->size);
/* rotation */
eul_to_mat4(rmat, texmap->rot);
/* translation */
unit_m4(tmat);
copy_v3_v3(tmat[3], texmap->loc);
if (texmap->type == TEXMAP_TYPE_TEXTURE) {
/* to transform a texture, the inverse transform needs
* to be applied to the texture coordinate */
mul_m4_series(texmap->mat, tmat, rmat, smat);
invert_m4(texmap->mat);
}
else if (texmap->type == TEXMAP_TYPE_POINT) {
/* forward transform */
mul_m4_series(texmap->mat, tmat, rmat, smat);
}
else if (texmap->type == TEXMAP_TYPE_VECTOR) {
/* no translation for vectors */
mul_m4_m4m4(texmap->mat, rmat, smat);
}
else if (texmap->type == TEXMAP_TYPE_NORMAL) {
/* no translation for normals, and inverse transpose */
mul_m4_m4m4(texmap->mat, rmat, smat);
invert_m4(texmap->mat);
transpose_m4(texmap->mat);
}
/* projection last */
mul_m4_m4m4(texmap->mat, texmap->mat, proj);
texmap->flag &= ~TEXMAP_UNIT_MATRIX;
}
}
static void set_axis(Scene *scene,
Object *ob,
MovieClip *clip,
MovieTrackingObject *tracking_object,
MovieTrackingTrack *track,
char axis)
{
Object *camera = get_camera_with_movieclip(scene, clip);
const bool is_camera = (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;
bool flip = false;
float mat[4][4], vec[3], obmat[4][4], dvec[3];
BKE_object_to_mat4(ob, obmat);
BKE_tracking_get_camera_object_matrix(scene, camera, mat);
mul_v3_m4v3(vec, mat, track->bundle_pos);
copy_v3_v3(dvec, vec);
if (!is_camera) {
float imat[4][4];
object_solver_inverted_matrix(scene, ob, imat);
mul_v3_m4v3(vec, imat, vec);
invert_m4_m4(imat, obmat);
mul_v3_m4v3(dvec, imat, vec);
sub_v3_v3(vec, obmat[3]);
}
if (len_squared_v2(vec) < (1e-3f * 1e-3f)) {
return;
}
unit_m4(mat);
if (axis == 'X') {
if (fabsf(dvec[1]) < 1e-3f) {
flip = true;
mat[0][0] = -1.0f;
mat[0][1] = 0.0f;
mat[0][2] = 0.0f;
mat[1][0] = 0.0f;
mat[1][1] = -1.0f;
mat[1][2] = 0.0f;
mat[2][0] = 0.0f;
mat[2][1] = 0.0f;
mat[2][2] = 1.0f;
}
else {
copy_v3_v3(mat[0], vec);
if (is_camera || fabsf(vec[2]) < 1e-3f) {
mat[0][2] = 0.0f;
mat[2][0] = 0.0f;
mat[2][1] = 0.0f;
mat[2][2] = 1.0f;
cross_v3_v3v3(mat[1], mat[2], mat[0]);
}
else {
vec[2] = 0.0f;
cross_v3_v3v3(mat[1], mat[0], vec);
cross_v3_v3v3(mat[2], mat[0], mat[1]);
}
}
}
else {
if (fabsf(dvec[0]) < 1e-3f) {
flip = true;
mat[0][0] = -1.0f;
mat[0][1] = 0.0f;
mat[0][2] = 0.0f;
mat[1][0] = 0.0f;
mat[1][1] = -1.0f;
mat[1][2] = 0.0f;
mat[2][0] = 0.0f;
mat[2][1] = 0.0f;
mat[2][2] = 1.0f;
}
else {
copy_v3_v3(mat[1], vec);
if (is_camera || fabsf(vec[2]) < 1e-3f) {
mat[1][2] = 0.0f;
mat[2][0] = 0.0f;
mat[2][1] = 0.0f;
mat[2][2] = 1.0f;
cross_v3_v3v3(mat[0], mat[1], mat[2]);
}
else {
vec[2] = 0.0f;
cross_v3_v3v3(mat[0], vec, mat[1]);
cross_v3_v3v3(mat[2], mat[0], mat[1]);
}
}
}
normalize_v3(mat[0]);
normalize_v3(mat[1]);
normalize_v3(mat[2]);
if (is_camera) {
invert_m4(mat);
mul_m4_m4m4(mat, mat, obmat);
}
else {
if (!flip) {
float lmat[4][4], ilmat[4][4], rmat[3][3];
BKE_object_rot_to_mat3(ob, rmat, true);
invert_m3(rmat);
mul_m4_m4m3(mat, mat, rmat);
unit_m4(lmat);
copy_v3_v3(lmat[3], obmat[3]);
invert_m4_m4(ilmat, lmat);
mul_m4_series(mat, lmat, mat, ilmat, obmat);
}
else {
mul_m4_m4m4(mat, obmat, mat);
}
}
BKE_object_apply_mat4(ob, mat, 0, 0);
}
static DerivedMesh *arrayModifier_doArray(
ArrayModifierData *amd,
Scene *scene, Object *ob, DerivedMesh *dm,
ModifierApplyFlag flag)
{
const float eps = 1e-6f;
const MVert *src_mvert;
MVert *mv, *mv_prev, *result_dm_verts;
MEdge *me;
MLoop *ml;
MPoly *mp;
int i, j, c, count;
float length = amd->length;
/* offset matrix */
float offset[4][4];
float scale[3];
bool offset_has_scale;
float current_offset[4][4];
float final_offset[4][4];
int *full_doubles_map = NULL;
int tot_doubles;
const bool use_merge = (amd->flags & MOD_ARR_MERGE) != 0;
const bool use_recalc_normals = (dm->dirty & DM_DIRTY_NORMALS) || use_merge;
const bool use_offset_ob = ((amd->offset_type & MOD_ARR_OFF_OBJ) && amd->offset_ob);
int start_cap_nverts = 0, start_cap_nedges = 0, start_cap_npolys = 0, start_cap_nloops = 0;
int end_cap_nverts = 0, end_cap_nedges = 0, end_cap_npolys = 0, end_cap_nloops = 0;
int result_nverts = 0, result_nedges = 0, result_npolys = 0, result_nloops = 0;
int chunk_nverts, chunk_nedges, chunk_nloops, chunk_npolys;
int first_chunk_start, first_chunk_nverts, last_chunk_start, last_chunk_nverts;
DerivedMesh *result, *start_cap_dm = NULL, *end_cap_dm = NULL;
int *vgroup_start_cap_remap = NULL;
int vgroup_start_cap_remap_len = 0;
int *vgroup_end_cap_remap = NULL;
int vgroup_end_cap_remap_len = 0;
chunk_nverts = dm->getNumVerts(dm);
chunk_nedges = dm->getNumEdges(dm);
chunk_nloops = dm->getNumLoops(dm);
chunk_npolys = dm->getNumPolys(dm);
count = amd->count;
if (amd->start_cap && amd->start_cap != ob && amd->start_cap->type == OB_MESH) {
vgroup_start_cap_remap = BKE_object_defgroup_index_map_create(amd->start_cap, ob, &vgroup_start_cap_remap_len);
start_cap_dm = get_dm_for_modifier(amd->start_cap, flag);
if (start_cap_dm) {
start_cap_nverts = start_cap_dm->getNumVerts(start_cap_dm);
start_cap_nedges = start_cap_dm->getNumEdges(start_cap_dm);
start_cap_nloops = start_cap_dm->getNumLoops(start_cap_dm);
start_cap_npolys = start_cap_dm->getNumPolys(start_cap_dm);
}
}
if (amd->end_cap && amd->end_cap != ob && amd->end_cap->type == OB_MESH) {
vgroup_end_cap_remap = BKE_object_defgroup_index_map_create(amd->end_cap, ob, &vgroup_end_cap_remap_len);
end_cap_dm = get_dm_for_modifier(amd->end_cap, flag);
if (end_cap_dm) {
end_cap_nverts = end_cap_dm->getNumVerts(end_cap_dm);
end_cap_nedges = end_cap_dm->getNumEdges(end_cap_dm);
end_cap_nloops = end_cap_dm->getNumLoops(end_cap_dm);
end_cap_npolys = end_cap_dm->getNumPolys(end_cap_dm);
}
}
/* Build up offset array, cumulating all settings options */
unit_m4(offset);
src_mvert = dm->getVertArray(dm);
if (amd->offset_type & MOD_ARR_OFF_CONST) {
add_v3_v3(offset[3], amd->offset);
}
if (amd->offset_type & MOD_ARR_OFF_RELATIVE) {
float min[3], max[3];
const MVert *src_mv;
INIT_MINMAX(min, max);
for (src_mv = src_mvert, j = chunk_nverts; j--; src_mv++) {
minmax_v3v3_v3(min, max, src_mv->co);
}
for (j = 3; j--; ) {
offset[3][j] += amd->scale[j] * (max[j] - min[j]);
}
}
if (use_offset_ob) {
float obinv[4][4];
float result_mat[4][4];
if (ob)
invert_m4_m4(obinv, ob->obmat);
else
unit_m4(obinv);
mul_m4_series(result_mat, offset,
obinv, amd->offset_ob->obmat);
copy_m4_m4(offset, result_mat);
}
/* Check if there is some scaling. If scaling, then we will not translate mapping */
mat4_to_size(scale, offset);
offset_has_scale = !is_one_v3(scale);
if (amd->fit_type == MOD_ARR_FITCURVE && amd->curve_ob) {
Curve *cu = amd->curve_ob->data;
if (cu) {
#ifdef CYCLIC_DEPENDENCY_WORKAROUND
if (amd->curve_ob->curve_cache == NULL) {
BKE_displist_make_curveTypes(scene, amd->curve_ob, false);
}
#endif
if (amd->curve_ob->curve_cache && amd->curve_ob->curve_cache->path) {
float scale_fac = mat4_to_scale(amd->curve_ob->obmat);
length = scale_fac * amd->curve_ob->curve_cache->path->totdist;
}
}
}
/* calculate the maximum number of copies which will fit within the
* prescribed length */
if (amd->fit_type == MOD_ARR_FITLENGTH || amd->fit_type == MOD_ARR_FITCURVE) {
float dist = len_v3(offset[3]);
if (dist > eps) {
/* this gives length = first copy start to last copy end
* add a tiny offset for floating point rounding errors */
count = (length + eps) / dist + 1;
}
else {
/* if the offset has no translation, just make one copy */
count = 1;
}
}
if (count < 1)
count = 1;
/* The number of verts, edges, loops, polys, before eventually merging doubles */
result_nverts = chunk_nverts * count + start_cap_nverts + end_cap_nverts;
result_nedges = chunk_nedges * count + start_cap_nedges + end_cap_nedges;
result_nloops = chunk_nloops * count + start_cap_nloops + end_cap_nloops;
result_npolys = chunk_npolys * count + start_cap_npolys + end_cap_npolys;
/* Initialize a result dm */
result = CDDM_from_template(dm, result_nverts, result_nedges, 0, result_nloops, result_npolys);
result_dm_verts = CDDM_get_verts(result);
if (use_merge) {
/* Will need full_doubles_map for handling merge */
full_doubles_map = MEM_malloc_arrayN(result_nverts, sizeof(int), "mod array doubles map");
copy_vn_i(full_doubles_map, result_nverts, -1);
}
/* copy customdata to original geometry */
DM_copy_vert_data(dm, result, 0, 0, chunk_nverts);
DM_copy_edge_data(dm, result, 0, 0, chunk_nedges);
DM_copy_loop_data(dm, result, 0, 0, chunk_nloops);
DM_copy_poly_data(dm, result, 0, 0, chunk_npolys);
/* Subsurf for eg won't have mesh data in the custom data arrays.
* now add mvert/medge/mpoly layers. */
if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
dm->copyVertArray(dm, result_dm_verts);
}
if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
dm->copyEdgeArray(dm, CDDM_get_edges(result));
}
if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
dm->copyLoopArray(dm, CDDM_get_loops(result));
dm->copyPolyArray(dm, CDDM_get_polys(result));
}
/* Remember first chunk, in case of cap merge */
first_chunk_start = 0;
first_chunk_nverts = chunk_nverts;
unit_m4(current_offset);
for (c = 1; c < count; c++) {
/* copy customdata to new geometry */
DM_copy_vert_data(result, result, 0, c * chunk_nverts, chunk_nverts);
DM_copy_edge_data(result, result, 0, c * chunk_nedges, chunk_nedges);
DM_copy_loop_data(result, result, 0, c * chunk_nloops, chunk_nloops);
DM_copy_poly_data(result, result, 0, c * chunk_npolys, chunk_npolys);
mv_prev = result_dm_verts;
mv = mv_prev + c * chunk_nverts;
/* recalculate cumulative offset here */
mul_m4_m4m4(current_offset, current_offset, offset);
/* apply offset to all new verts */
for (i = 0; i < chunk_nverts; i++, mv++, mv_prev++) {
mul_m4_v3(current_offset, mv->co);
/* We have to correct normals too, if we do not tag them as dirty! */
if (!use_recalc_normals) {
float no[3];
normal_short_to_float_v3(no, mv->no);
mul_mat3_m4_v3(current_offset, no);
normalize_v3(no);
normal_float_to_short_v3(mv->no, no);
}
}
/* adjust edge vertex indices */
me = CDDM_get_edges(result) + c * chunk_nedges;
for (i = 0; i < chunk_nedges; i++, me++) {
me->v1 += c * chunk_nverts;
me->v2 += c * chunk_nverts;
}
mp = CDDM_get_polys(result) + c * chunk_npolys;
for (i = 0; i < chunk_npolys; i++, mp++) {
mp->loopstart += c * chunk_nloops;
}
/* adjust loop vertex and edge indices */
ml = CDDM_get_loops(result) + c * chunk_nloops;
for (i = 0; i < chunk_nloops; i++, ml++) {
ml->v += c * chunk_nverts;
ml->e += c * chunk_nedges;
}
/* Handle merge between chunk n and n-1 */
if (use_merge && (c >= 1)) {
if (!offset_has_scale && (c >= 2)) {
/* Mapping chunk 3 to chunk 2 is a translation of mapping 2 to 1
* ... that is except if scaling makes the distance grow */
int k;
int this_chunk_index = c * chunk_nverts;
int prev_chunk_index = (c - 1) * chunk_nverts;
for (k = 0; k < chunk_nverts; k++, this_chunk_index++, prev_chunk_index++) {
int target = full_doubles_map[prev_chunk_index];
if (target != -1) {
target += chunk_nverts; /* translate mapping */
while (target != -1 && !ELEM(full_doubles_map[target], -1, target)) {
/* If target is already mapped, we only follow that mapping if final target remains
* close enough from current vert (otherwise no mapping at all). */
if (compare_len_v3v3(result_dm_verts[this_chunk_index].co,
result_dm_verts[full_doubles_map[target]].co,
amd->merge_dist))
{
target = full_doubles_map[target];
}
else {
target = -1;
}
}
}
full_doubles_map[this_chunk_index] = target;
}
}
else {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
(c - 1) * chunk_nverts,
chunk_nverts,
c * chunk_nverts,
chunk_nverts,
amd->merge_dist);
}
}
}
/* handle UVs */
if (chunk_nloops > 0 && is_zero_v2(amd->uv_offset) == false) {
const int totuv = CustomData_number_of_layers(&result->loopData, CD_MLOOPUV);
for (i = 0; i < totuv; i++) {
MLoopUV *dmloopuv = CustomData_get_layer_n(&result->loopData, CD_MLOOPUV, i);
dmloopuv += chunk_nloops;
for (c = 1; c < count; c++) {
const float uv_offset[2] = {
amd->uv_offset[0] * (float)c,
amd->uv_offset[1] * (float)c,
};
int l_index = chunk_nloops;
for (; l_index-- != 0; dmloopuv++) {
dmloopuv->uv[0] += uv_offset[0];
dmloopuv->uv[1] += uv_offset[1];
}
}
}
}
last_chunk_start = (count - 1) * chunk_nverts;
last_chunk_nverts = chunk_nverts;
copy_m4_m4(final_offset, current_offset);
if (use_merge && (amd->flags & MOD_ARR_MERGEFINAL) && (count > 1)) {
/* Merge first and last copies */
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
last_chunk_start,
last_chunk_nverts,
first_chunk_start,
first_chunk_nverts,
amd->merge_dist);
}
/* start capping */
if (start_cap_dm) {
float start_offset[4][4];
int start_cap_start = result_nverts - start_cap_nverts - end_cap_nverts;
invert_m4_m4(start_offset, offset);
dm_merge_transform(
result, start_cap_dm, start_offset,
result_nverts - start_cap_nverts - end_cap_nverts,
result_nedges - start_cap_nedges - end_cap_nedges,
result_nloops - start_cap_nloops - end_cap_nloops,
result_npolys - start_cap_npolys - end_cap_npolys,
start_cap_nverts, start_cap_nedges, start_cap_nloops, start_cap_npolys,
vgroup_start_cap_remap, vgroup_start_cap_remap_len);
/* Identify doubles with first chunk */
if (use_merge) {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
first_chunk_start,
first_chunk_nverts,
start_cap_start,
start_cap_nverts,
amd->merge_dist);
}
}
if (end_cap_dm) {
float end_offset[4][4];
int end_cap_start = result_nverts - end_cap_nverts;
mul_m4_m4m4(end_offset, current_offset, offset);
dm_merge_transform(
result, end_cap_dm, end_offset,
result_nverts - end_cap_nverts,
result_nedges - end_cap_nedges,
result_nloops - end_cap_nloops,
result_npolys - end_cap_npolys,
end_cap_nverts, end_cap_nedges, end_cap_nloops, end_cap_npolys,
vgroup_end_cap_remap, vgroup_end_cap_remap_len);
/* Identify doubles with last chunk */
if (use_merge) {
dm_mvert_map_doubles(
full_doubles_map,
result_dm_verts,
last_chunk_start,
last_chunk_nverts,
end_cap_start,
end_cap_nverts,
amd->merge_dist);
}
}
/* done capping */
/* Handle merging */
tot_doubles = 0;
if (use_merge) {
for (i = 0; i < result_nverts; i++) {
int new_i = full_doubles_map[i];
if (new_i != -1) {
/* We have to follow chains of doubles (merge start/end especially is likely to create some),
* those are not supported at all by CDDM_merge_verts! */
while (!ELEM(full_doubles_map[new_i], -1, new_i)) {
new_i = full_doubles_map[new_i];
}
if (i == new_i) {
full_doubles_map[i] = -1;
}
else {
full_doubles_map[i] = new_i;
tot_doubles++;
}
}
}
if (tot_doubles > 0) {
result = CDDM_merge_verts(result, full_doubles_map, tot_doubles, CDDM_MERGE_VERTS_DUMP_IF_EQUAL);
}
MEM_freeN(full_doubles_map);
}
/* In case org dm has dirty normals, or we made some merging, mark normals as dirty in new dm!
* TODO: we may need to set other dirty flags as well?
*/
if (use_recalc_normals) {
result->dirty |= DM_DIRTY_NORMALS;
}
if (vgroup_start_cap_remap) {
MEM_freeN(vgroup_start_cap_remap);
}
if (vgroup_end_cap_remap) {
MEM_freeN(vgroup_end_cap_remap);
}
return result;
}
/**
* Iterates over ALL objects in the scene and all of its sets, including
* making all duplis(not only metas). Copies metas to mainb array.
* Computes bounding boxes for building BVH. */
static void init_meta(EvaluationContext *eval_ctx, PROCESS *process, Scene *scene, Object *ob)
{
Scene *sce_iter = scene;
Base *base;
Object *bob;
MetaBall *mb;
const MetaElem *ml;
float obinv[4][4], obmat[4][4];
unsigned int i;
int obnr, zero_size = 0;
char obname[MAX_ID_NAME];
SceneBaseIter iter;
copy_m4_m4(obmat, ob->obmat); /* to cope with duplicators from BKE_scene_base_iter_next */
invert_m4_m4(obinv, ob->obmat);
BLI_split_name_num(obname, &obnr, ob->id.name + 2, '.');
/* make main array */
BKE_scene_base_iter_next(eval_ctx, &iter, &sce_iter, 0, NULL, NULL);
while (BKE_scene_base_iter_next(eval_ctx, &iter, &sce_iter, 1, &base, &bob)) {
if (bob->type == OB_MBALL) {
zero_size = 0;
ml = NULL;
if (bob == ob && (base->flag & OB_FROMDUPLI) == 0) {
mb = ob->data;
if (mb->editelems) ml = mb->editelems->first;
else ml = mb->elems.first;
}
else {
char name[MAX_ID_NAME];
int nr;
BLI_split_name_num(name, &nr, bob->id.name + 2, '.');
if (STREQ(obname, name)) {
mb = bob->data;
if (mb->editelems) ml = mb->editelems->first;
else ml = mb->elems.first;
}
}
/* when metaball object has zero scale, then MetaElem to this MetaBall
* will not be put to mainb array */
if (has_zero_axis_m4(bob->obmat)) {
zero_size = 1;
}
else if (bob->parent) {
struct Object *pob = bob->parent;
while (pob) {
if (has_zero_axis_m4(pob->obmat)) {
zero_size = 1;
break;
}
pob = pob->parent;
}
}
if (zero_size) {
while (ml) {
ml = ml->next;
}
}
else {
while (ml) {
if (!(ml->flag & MB_HIDE)) {
float pos[4][4], rot[4][4];
float expx, expy, expz;
float tempmin[3], tempmax[3];
MetaElem *new_ml;
/* make a copy because of duplicates */
new_ml = BLI_memarena_alloc(process->pgn_elements, sizeof(MetaElem));
*(new_ml) = *ml;
new_ml->bb = BLI_memarena_alloc(process->pgn_elements, sizeof(BoundBox));
new_ml->mat = BLI_memarena_alloc(process->pgn_elements, 4 * 4 * sizeof(float));
new_ml->imat = BLI_memarena_alloc(process->pgn_elements, 4 * 4 * sizeof(float));
/* too big stiffness seems only ugly due to linear interpolation
* no need to have possibility for too big stiffness */
if (ml->s > 10.0f) new_ml->s = 10.0f;
else new_ml->s = ml->s;
/* if metaball is negative, set stiffness negative */
if (new_ml->flag & MB_NEGATIVE) new_ml->s = -new_ml->s;
/* Translation of MetaElem */
unit_m4(pos);
pos[3][0] = ml->x;
pos[3][1] = ml->y;
pos[3][2] = ml->z;
/* Rotation of MetaElem is stored in quat */
quat_to_mat4(rot, ml->quat);
/* basis object space -> world -> ml object space -> position -> rotation -> ml local space */
mul_m4_series((float(*)[4])new_ml->mat, obinv, bob->obmat, pos, rot);
/* ml local space -> basis object space */
invert_m4_m4((float(*)[4])new_ml->imat, (float(*)[4])new_ml->mat);
/* rad2 is inverse of squared radius */
new_ml->rad2 = 1 / (ml->rad * ml->rad);
/* initial dimensions = radius */
expx = ml->rad;
expy = ml->rad;
expz = ml->rad;
switch (ml->type) {
case MB_BALL:
break;
case MB_CUBE: /* cube is "expanded" by expz, expy and expx */
expz += ml->expz;
/* fall through */
case MB_PLANE: /* plane is "expanded" by expy and expx */
expy += ml->expy;
/* fall through */
case MB_TUBE: /* tube is "expanded" by expx */
expx += ml->expx;
break;
case MB_ELIPSOID: /* ellipsoid is "stretched" by exp* */
expx *= ml->expx;
expy *= ml->expy;
expz *= ml->expz;
break;
}
/* untransformed Bounding Box of MetaElem */
/* TODO, its possible the elem type has been changed and the exp* values can use a fallback */
copy_v3_fl3(new_ml->bb->vec[0], -expx, -expy, -expz); /* 0 */
copy_v3_fl3(new_ml->bb->vec[1], +expx, -expy, -expz); /* 1 */
copy_v3_fl3(new_ml->bb->vec[2], +expx, +expy, -expz); /* 2 */
copy_v3_fl3(new_ml->bb->vec[3], -expx, +expy, -expz); /* 3 */
copy_v3_fl3(new_ml->bb->vec[4], -expx, -expy, +expz); /* 4 */
copy_v3_fl3(new_ml->bb->vec[5], +expx, -expy, +expz); /* 5 */
copy_v3_fl3(new_ml->bb->vec[6], +expx, +expy, +expz); /* 6 */
copy_v3_fl3(new_ml->bb->vec[7], -expx, +expy, +expz); /* 7 */
/* transformation of Metalem bb */
for (i = 0; i < 8; i++)
mul_m4_v3((float(*)[4])new_ml->mat, new_ml->bb->vec[i]);
/* find max and min of transformed bb */
INIT_MINMAX(tempmin, tempmax);
for (i = 0; i < 8; i++) {
DO_MINMAX(new_ml->bb->vec[i], tempmin, tempmax);
}
/* set only point 0 and 6 - AABB of Metaelem */
copy_v3_v3(new_ml->bb->vec[0], tempmin);
copy_v3_v3(new_ml->bb->vec[6], tempmax);
/* add new_ml to mainb[] */
if (UNLIKELY(process->totelem == process->mem)) {
process->mem = process->mem * 2 + 10;
process->mainb = MEM_reallocN(process->mainb, sizeof(MetaElem *) * process->mem);
}
process->mainb[process->totelem++] = new_ml;
}
ml = ml->next;
}
}
}
}
/* compute AABB of all Metaelems */
if (process->totelem > 0) {
copy_v3_v3(process->allbb.min, process->mainb[0]->bb->vec[0]);
copy_v3_v3(process->allbb.max, process->mainb[0]->bb->vec[6]);
for (i = 1; i < process->totelem; i++)
make_box_union(process->mainb[i]->bb, &process->allbb, &process->allbb);
}
}
