Bastien Montagne
eed9c6fdcf
That was the main issue (in both T46455 and T46690), solved by 'flattening' those chains (v1 -> v2 ->v3 etc.) before calling `CDDM_merge_verts()`. Also added note to `CDDM_merge_verts()` that it does not support chained mapping, along with a basic assert that should catch most of those cases in future. The logic of 'following mapping' was also rather broken, making a special case here when using object-controlled offset is very weak. Further more, blindly following mapping in this case was far from ideal, this could end to merging vertices rather far from each other. To address this issue, we now always follow mapping, but only as long as 'final' vertex remains close enough from mapped one. Finally, the search of 'closest' vertex to merge with was also quite bad, would just pick the first one matching distance limit, instead of using the actual closest one - could lead to rather ugly geometry deformations in case one would use not-so-small merge threashold!
808 lines
26 KiB
C
808 lines
26 KiB
C
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2005 by the Blender Foundation.
|
|
* All rights reserved.
|
|
*
|
|
* Contributor(s): Daniel Dunbar
|
|
* Ton Roosendaal,
|
|
* Ben Batt,
|
|
* Brecht Van Lommel,
|
|
* Campbell Barton,
|
|
* Patrice Bertrand
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*
|
|
*/
|
|
|
|
/** \file blender/modifiers/intern/MOD_array.c
|
|
* \ingroup modifiers
|
|
*
|
|
* Array modifier: duplicates the object multiple times along an axis.
|
|
*/
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "BLI_math.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "DNA_curve_types.h"
|
|
#include "DNA_meshdata_types.h"
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_scene_types.h"
|
|
|
|
#include "BKE_cdderivedmesh.h"
|
|
#include "BKE_displist.h"
|
|
#include "BKE_curve.h"
|
|
#include "BKE_library_query.h"
|
|
#include "BKE_modifier.h"
|
|
|
|
#include "MOD_util.h"
|
|
|
|
#include "depsgraph_private.h"
|
|
|
|
/* Due to cyclic dependencies it's possible that curve used for
|
|
* deformation here is not evaluated at the time of evaluating
|
|
* this modifier.
|
|
*/
|
|
#define CYCLIC_DEPENDENCY_WORKAROUND
|
|
|
|
static void initData(ModifierData *md)
|
|
{
|
|
ArrayModifierData *amd = (ArrayModifierData *) md;
|
|
|
|
/* default to 2 duplicates distributed along the x-axis by an
|
|
* offset of 1 object-width
|
|
*/
|
|
amd->start_cap = amd->end_cap = amd->curve_ob = amd->offset_ob = NULL;
|
|
amd->count = 2;
|
|
zero_v3(amd->offset);
|
|
amd->scale[0] = 1;
|
|
amd->scale[1] = amd->scale[2] = 0;
|
|
amd->length = 0;
|
|
amd->merge_dist = 0.01;
|
|
amd->fit_type = MOD_ARR_FIXEDCOUNT;
|
|
amd->offset_type = MOD_ARR_OFF_RELATIVE;
|
|
amd->flags = 0;
|
|
}
|
|
|
|
static void copyData(ModifierData *md, ModifierData *target)
|
|
{
|
|
#if 0
|
|
ArrayModifierData *amd = (ArrayModifierData *) md;
|
|
ArrayModifierData *tamd = (ArrayModifierData *) target;
|
|
#endif
|
|
modifier_copyData_generic(md, target);
|
|
}
|
|
|
|
static void foreachObjectLink(
|
|
ModifierData *md, Object *ob,
|
|
ObjectWalkFunc walk, void *userData)
|
|
{
|
|
ArrayModifierData *amd = (ArrayModifierData *) md;
|
|
|
|
walk(userData, ob, &amd->start_cap, IDWALK_NOP);
|
|
walk(userData, ob, &amd->end_cap, IDWALK_NOP);
|
|
walk(userData, ob, &amd->curve_ob, IDWALK_NOP);
|
|
walk(userData, ob, &amd->offset_ob, IDWALK_NOP);
|
|
}
|
|
|
|
static void updateDepgraph(ModifierData *md, DagForest *forest,
|
|
struct Main *UNUSED(bmain),
|
|
struct Scene *UNUSED(scene),
|
|
Object *UNUSED(ob), DagNode *obNode)
|
|
{
|
|
ArrayModifierData *amd = (ArrayModifierData *) md;
|
|
|
|
if (amd->start_cap) {
|
|
DagNode *curNode = dag_get_node(forest, amd->start_cap);
|
|
|
|
dag_add_relation(forest, curNode, obNode,
|
|
DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Array Modifier");
|
|
}
|
|
if (amd->end_cap) {
|
|
DagNode *curNode = dag_get_node(forest, amd->end_cap);
|
|
|
|
dag_add_relation(forest, curNode, obNode,
|
|
DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Array Modifier");
|
|
}
|
|
if (amd->curve_ob) {
|
|
DagNode *curNode = dag_get_node(forest, amd->curve_ob);
|
|
curNode->eval_flags |= DAG_EVAL_NEED_CURVE_PATH;
|
|
|
|
dag_add_relation(forest, curNode, obNode,
|
|
DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Array Modifier");
|
|
}
|
|
if (amd->offset_ob) {
|
|
DagNode *curNode = dag_get_node(forest, amd->offset_ob);
|
|
|
|
dag_add_relation(forest, curNode, obNode,
|
|
DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Array Modifier");
|
|
}
|
|
}
|
|
|
|
static void updateDepsgraph(ModifierData *md,
|
|
struct Main *UNUSED(bmain),
|
|
struct Scene *scene,
|
|
Object *UNUSED(ob),
|
|
struct DepsNodeHandle *node)
|
|
{
|
|
ArrayModifierData *amd = (ArrayModifierData *)md;
|
|
if (amd->start_cap != NULL) {
|
|
DEG_add_object_relation(node, amd->start_cap, DEG_OB_COMP_TRANSFORM, "Hook Modifier Start Cap");
|
|
}
|
|
if (amd->end_cap != NULL) {
|
|
DEG_add_object_relation(node, amd->end_cap, DEG_OB_COMP_TRANSFORM, "Hook Modifier End Cap");
|
|
}
|
|
if (amd->curve_ob) {
|
|
DEG_add_object_relation(node, amd->end_cap, DEG_OB_COMP_GEOMETRY, "Hook Modifier Curve");
|
|
DEG_add_special_eval_flag(scene->depsgraph, &amd->curve_ob->id, DAG_EVAL_NEED_CURVE_PATH);
|
|
}
|
|
if (amd->offset_ob != NULL) {
|
|
DEG_add_object_relation(node, amd->offset_ob, DEG_OB_COMP_TRANSFORM, "Hook Modifier Offset");
|
|
}
|
|
}
|
|
|
|
static float vertarray_size(const MVert *mvert, int numVerts, int axis)
|
|
{
|
|
int i;
|
|
float min_co, max_co;
|
|
|
|
/* if there are no vertices, width is 0 */
|
|
if (numVerts == 0) return 0;
|
|
|
|
/* find the minimum and maximum coordinates on the desired axis */
|
|
min_co = max_co = mvert->co[axis];
|
|
mvert++;
|
|
for (i = 1; i < numVerts; ++i, ++mvert) {
|
|
if (mvert->co[axis] < min_co) min_co = mvert->co[axis];
|
|
if (mvert->co[axis] > max_co) max_co = mvert->co[axis];
|
|
}
|
|
|
|
return max_co - min_co;
|
|
}
|
|
|
|
BLI_INLINE float sum_v3(const float v[3])
|
|
{
|
|
return v[0] + v[1] + v[2];
|
|
}
|
|
|
|
/* Structure used for sorting vertices, when processing doubles */
|
|
typedef struct SortVertsElem {
|
|
int vertex_num; /* The original index of the vertex, prior to sorting */
|
|
float co[3]; /* Its coordinates */
|
|
float sum_co; /* sum_v3(co), just so we don't do the sum many times. */
|
|
} SortVertsElem;
|
|
|
|
|
|
static int svert_sum_cmp(const void *e1, const void *e2)
|
|
{
|
|
const SortVertsElem *sv1 = e1;
|
|
const SortVertsElem *sv2 = e2;
|
|
|
|
if (sv1->sum_co > sv2->sum_co) return 1;
|
|
else if (sv1->sum_co < sv2->sum_co) return -1;
|
|
else return 0;
|
|
}
|
|
|
|
static void svert_from_mvert(SortVertsElem *sv, const MVert *mv, const int i_begin, const int i_end)
|
|
{
|
|
int i;
|
|
for (i = i_begin; i < i_end; i++, sv++, mv++) {
|
|
sv->vertex_num = i;
|
|
copy_v3_v3(sv->co, mv->co);
|
|
sv->sum_co = sum_v3(mv->co);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Take as inputs two sets of verts, to be processed for detection of doubles and mapping.
|
|
* Each set of verts is defined by its start within mverts array and its num_verts;
|
|
* It builds a mapping for all vertices within source, to vertices within target, or -1 if no double found
|
|
* The int doubles_map[num_verts_source] array must have been allocated by caller.
|
|
*/
|
|
static void dm_mvert_map_doubles(
|
|
int *doubles_map,
|
|
const MVert *mverts,
|
|
const int target_start,
|
|
const int target_num_verts,
|
|
const int source_start,
|
|
const int source_num_verts,
|
|
const float dist)
|
|
{
|
|
const float dist3 = ((float)M_SQRT3 + 0.00005f) * dist; /* Just above sqrt(3) */
|
|
int i_source, i_target, i_target_low_bound, target_end, source_end;
|
|
SortVertsElem *sorted_verts_target, *sorted_verts_source;
|
|
SortVertsElem *sve_source, *sve_target, *sve_target_low_bound;
|
|
bool target_scan_completed;
|
|
|
|
target_end = target_start + target_num_verts;
|
|
source_end = source_start + source_num_verts;
|
|
|
|
/* build array of MVerts to be tested for merging */
|
|
sorted_verts_target = MEM_mallocN(sizeof(SortVertsElem) * target_num_verts, __func__);
|
|
sorted_verts_source = MEM_mallocN(sizeof(SortVertsElem) * source_num_verts, __func__);
|
|
|
|
/* Copy target vertices index and cos into SortVertsElem array */
|
|
svert_from_mvert(sorted_verts_target, mverts + target_start, target_start, target_end);
|
|
|
|
/* Copy source vertices index and cos into SortVertsElem array */
|
|
svert_from_mvert(sorted_verts_source, mverts + source_start, source_start, source_end);
|
|
|
|
/* sort arrays according to sum of vertex coordinates (sumco) */
|
|
qsort(sorted_verts_target, target_num_verts, sizeof(SortVertsElem), svert_sum_cmp);
|
|
qsort(sorted_verts_source, source_num_verts, sizeof(SortVertsElem), svert_sum_cmp);
|
|
|
|
sve_target_low_bound = sorted_verts_target;
|
|
i_target_low_bound = 0;
|
|
target_scan_completed = false;
|
|
|
|
/* Scan source vertices, in SortVertsElem sorted array, */
|
|
/* all the while maintaining the lower bound of possible doubles in target vertices */
|
|
for (i_source = 0, sve_source = sorted_verts_source;
|
|
i_source < source_num_verts;
|
|
i_source++, sve_source++)
|
|
{
|
|
int best_target_vertex = -1;
|
|
float best_dist_sq = dist * dist;
|
|
float sve_source_sumco;
|
|
|
|
/* If source has already been assigned to a target (in an earlier call, with other chunks) */
|
|
if (doubles_map[sve_source->vertex_num] != -1) {
|
|
continue;
|
|
}
|
|
|
|
/* If target fully scanned already, then all remaining source vertices cannot have a double */
|
|
if (target_scan_completed) {
|
|
doubles_map[sve_source->vertex_num] = -1;
|
|
continue;
|
|
}
|
|
|
|
sve_source_sumco = sum_v3(sve_source->co);
|
|
|
|
/* Skip all target vertices that are more than dist3 lower in terms of sumco */
|
|
/* and advance the overall lower bound, applicable to all remaining vertices as well. */
|
|
while ((i_target_low_bound < target_num_verts) &&
|
|
(sve_target_low_bound->sum_co < sve_source_sumco - dist3))
|
|
{
|
|
i_target_low_bound++;
|
|
sve_target_low_bound++;
|
|
}
|
|
/* If end of target list reached, then no more possible doubles */
|
|
if (i_target_low_bound >= target_num_verts) {
|
|
doubles_map[sve_source->vertex_num] = -1;
|
|
target_scan_completed = true;
|
|
continue;
|
|
}
|
|
/* Test target candidates starting at the low bound of possible doubles, ordered in terms of sumco */
|
|
i_target = i_target_low_bound;
|
|
sve_target = sve_target_low_bound;
|
|
|
|
/* i_target will scan vertices in the [v_source_sumco - dist3; v_source_sumco + dist3] range */
|
|
|
|
while ((i_target < target_num_verts) &&
|
|
(sve_target->sum_co <= sve_source_sumco + dist3))
|
|
{
|
|
/* Testing distance for candidate double in target */
|
|
/* v_target is within dist3 of v_source in terms of sumco; check real distance */
|
|
float dist_sq;
|
|
if ((dist_sq = len_squared_v3v3(sve_source->co, sve_target->co)) <= best_dist_sq) {
|
|
/* Potential double found */
|
|
best_dist_sq = dist_sq;
|
|
best_target_vertex = sve_target->vertex_num;
|
|
|
|
/* If target is already mapped, we only follow that mapping if final target remains
|
|
* close enough from current vert (otherwise no mapping at all).
|
|
* Note that if we later find another target closer than this one, then we check it. But if other
|
|
* potential targets are farther, then there will be no mapping at all for this source. */
|
|
while (best_target_vertex != -1 && !ELEM(doubles_map[best_target_vertex], -1, best_target_vertex)) {
|
|
if (compare_len_v3v3(mverts[sve_source->vertex_num].co,
|
|
mverts[doubles_map[best_target_vertex]].co,
|
|
dist))
|
|
{
|
|
best_target_vertex = doubles_map[best_target_vertex];
|
|
}
|
|
else {
|
|
best_target_vertex = -1;
|
|
}
|
|
}
|
|
}
|
|
i_target++;
|
|
sve_target++;
|
|
}
|
|
/* End of candidate scan: if none found then no doubles */
|
|
doubles_map[sve_source->vertex_num] = best_target_vertex;
|
|
}
|
|
|
|
MEM_freeN(sorted_verts_source);
|
|
MEM_freeN(sorted_verts_target);
|
|
}
|
|
|
|
|
|
static void dm_merge_transform(
|
|
DerivedMesh *result, DerivedMesh *cap_dm, float cap_offset[4][4],
|
|
unsigned int cap_verts_index, unsigned int cap_edges_index, int cap_loops_index, int cap_polys_index,
|
|
int cap_nverts, int cap_nedges, int cap_nloops, int cap_npolys)
|
|
{
|
|
int *index_orig;
|
|
int i;
|
|
MVert *mv;
|
|
MEdge *me;
|
|
MLoop *ml;
|
|
MPoly *mp;
|
|
|
|
/* needed for subsurf so arrays are allocated */
|
|
cap_dm->getVertArray(cap_dm);
|
|
cap_dm->getEdgeArray(cap_dm);
|
|
cap_dm->getLoopArray(cap_dm);
|
|
cap_dm->getPolyArray(cap_dm);
|
|
|
|
DM_copy_vert_data(cap_dm, result, 0, cap_verts_index, cap_nverts);
|
|
DM_copy_edge_data(cap_dm, result, 0, cap_edges_index, cap_nedges);
|
|
DM_copy_loop_data(cap_dm, result, 0, cap_loops_index, cap_nloops);
|
|
DM_copy_poly_data(cap_dm, result, 0, cap_polys_index, cap_npolys);
|
|
|
|
mv = CDDM_get_verts(result) + cap_verts_index;
|
|
|
|
for (i = 0; i < cap_nverts; i++, mv++) {
|
|
mul_m4_v3(cap_offset, mv->co);
|
|
/* Reset MVert flags for caps */
|
|
mv->flag = mv->bweight = 0;
|
|
}
|
|
|
|
/* adjust cap edge vertex indices */
|
|
me = CDDM_get_edges(result) + cap_edges_index;
|
|
for (i = 0; i < cap_nedges; i++, me++) {
|
|
me->v1 += cap_verts_index;
|
|
me->v2 += cap_verts_index;
|
|
}
|
|
|
|
/* adjust cap poly loopstart indices */
|
|
mp = CDDM_get_polys(result) + cap_polys_index;
|
|
for (i = 0; i < cap_npolys; i++, mp++) {
|
|
mp->loopstart += cap_loops_index;
|
|
}
|
|
|
|
/* adjust cap loop vertex and edge indices */
|
|
ml = CDDM_get_loops(result) + cap_loops_index;
|
|
for (i = 0; i < cap_nloops; i++, ml++) {
|
|
ml->v += cap_verts_index;
|
|
ml->e += cap_edges_index;
|
|
}
|
|
|
|
/* set origindex */
|
|
index_orig = result->getVertDataArray(result, CD_ORIGINDEX);
|
|
if (index_orig) {
|
|
copy_vn_i(index_orig + cap_verts_index, cap_nverts, ORIGINDEX_NONE);
|
|
}
|
|
|
|
index_orig = result->getEdgeDataArray(result, CD_ORIGINDEX);
|
|
if (index_orig) {
|
|
copy_vn_i(index_orig + cap_edges_index, cap_nedges, ORIGINDEX_NONE);
|
|
}
|
|
|
|
index_orig = result->getPolyDataArray(result, CD_ORIGINDEX);
|
|
if (index_orig) {
|
|
copy_vn_i(index_orig + cap_polys_index, cap_npolys, ORIGINDEX_NONE);
|
|
}
|
|
|
|
index_orig = result->getLoopDataArray(result, CD_ORIGINDEX);
|
|
if (index_orig) {
|
|
copy_vn_i(index_orig + cap_loops_index, cap_nloops, ORIGINDEX_NONE);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
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_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_mallocN(sizeof(int) * result_nverts, "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 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 */
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
/* 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);
|
|
/* 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;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
|
|
DerivedMesh *dm,
|
|
ModifierApplyFlag flag)
|
|
{
|
|
ArrayModifierData *amd = (ArrayModifierData *) md;
|
|
return arrayModifier_doArray(amd, md->scene, ob, dm, flag);
|
|
}
|
|
|
|
|
|
ModifierTypeInfo modifierType_Array = {
|
|
/* name */ "Array",
|
|
/* structName */ "ArrayModifierData",
|
|
/* structSize */ sizeof(ArrayModifierData),
|
|
/* type */ eModifierTypeType_Constructive,
|
|
/* flags */ eModifierTypeFlag_AcceptsMesh |
|
|
eModifierTypeFlag_SupportsMapping |
|
|
eModifierTypeFlag_SupportsEditmode |
|
|
eModifierTypeFlag_EnableInEditmode |
|
|
eModifierTypeFlag_AcceptsCVs,
|
|
|
|
/* copyData */ copyData,
|
|
/* deformVerts */ NULL,
|
|
/* deformMatrices */ NULL,
|
|
/* deformVertsEM */ NULL,
|
|
/* deformMatricesEM */ NULL,
|
|
/* applyModifier */ applyModifier,
|
|
/* applyModifierEM */ NULL,
|
|
/* initData */ initData,
|
|
/* requiredDataMask */ NULL,
|
|
/* freeData */ NULL,
|
|
/* isDisabled */ NULL,
|
|
/* updateDepgraph */ updateDepgraph,
|
|
/* updateDepsgraph */ updateDepsgraph,
|
|
/* dependsOnTime */ NULL,
|
|
/* dependsOnNormals */ NULL,
|
|
/* foreachObjectLink */ foreachObjectLink,
|
|
/* foreachIDLink */ NULL,
|
|
/* foreachTexLink */ NULL,
|
|
};
|