int nextLengthSubdivision(ToolSettings *toolsettings, BArcIterator *iter, int start, int end, float head[3], float p[3])
{
float lengthLimit = toolsettings->skgen_length_limit;
int same = 1;
int i;
i = start + 1;
while (i <= end)
{
float *vec0;
float *vec1;
IT_peek(iter, i - 1);
vec0 = iter->p;
IT_peek(iter, i);
vec1 = iter->p;
/* If lengthLimit hits the current segment */
if (len_v3v3(vec1, head) > lengthLimit)
{
if (same == 0)
{
float dv[3], off[3];
float a, b, c, f;
/* Solve quadratic distance equation */
sub_v3_v3v3(dv, vec1, vec0);
a = dot_v3v3(dv, dv);
sub_v3_v3v3(off, vec0, head);
b = 2 * dot_v3v3(dv, off);
c = dot_v3v3(off, off) - (lengthLimit * lengthLimit);
f = (-b + (float)sqrt(b * b - 4 * a * c)) / (2 * a);
//printf("a %f, b %f, c %f, f %f\n", a, b, c, f);
if (isnan(f) == 0 && f < 1.0f)
{
VECCOPY(p, dv);
mul_v3_fl(p, f);
add_v3_v3(p, vec0);
}
else
{
VECCOPY(p, vec1);
}
}
else
{
float dv[3];
sub_v3_v3v3(dv, vec1, vec0);
normalize_v3(dv);
VECCOPY(p, dv);
mul_v3_fl(p, lengthLimit);
add_v3_v3(p, head);
}
return i - 1; /* restart at lower bound */
}
else
{
i++;
same = 0; // Reset same
}
}
return -1;
}
static void cuboid_do(
CastModifierData *cmd, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
MDeformVert *dvert = NULL;
Object *ctrl_ob = NULL;
int i, defgrp_index;
bool has_radius = false;
short flag;
float fac = cmd->fac;
float facm = 1.0f - fac;
const float fac_orig = fac;
float min[3], max[3], bb[8][3];
float center[3] = {0.0f, 0.0f, 0.0f};
float mat[4][4], imat[4][4];
flag = cmd->flag;
ctrl_ob = cmd->object;
/* now we check which options the user wants */
/* 1) (flag was checked in the "if (ctrl_ob)" block above) */
/* 2) cmd->radius > 0.0f: only the vertices within this radius from
* the center of the effect should be deformed */
if (cmd->radius > FLT_EPSILON) has_radius = 1;
/* 3) if we were given a vertex group name,
* only those vertices should be affected */
modifier_get_vgroup(ob, dm, cmd->defgrp_name, &dvert, &defgrp_index);
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
invert_m4_m4(imat, ctrl_ob->obmat);
mul_m4_m4m4(mat, imat, ob->obmat);
invert_m4_m4(imat, mat);
}
invert_m4_m4(ob->imat, ob->obmat);
mul_v3_m4v3(center, ob->imat, ctrl_ob->obmat[3]);
}
if ((flag & MOD_CAST_SIZE_FROM_RADIUS) && has_radius) {
for (i = 0; i < 3; i++) {
min[i] = -cmd->radius;
max[i] = cmd->radius;
}
}
else if (!(flag & MOD_CAST_SIZE_FROM_RADIUS) && cmd->size > 0) {
for (i = 0; i < 3; i++) {
min[i] = -cmd->size;
max[i] = cmd->size;
}
}
else {
/* get bound box */
/* We can't use the object's bound box because other modifiers
* may have changed the vertex data. */
INIT_MINMAX(min, max);
/* Cast's center is the ob's own center in its local space,
* by default, but if the user defined a control object, we use
* its location, transformed to ob's local space. */
if (ctrl_ob) {
float vec[3];
/* let the center of the ctrl_ob be part of the bound box: */
minmax_v3v3_v3(min, max, center);
for (i = 0; i < numVerts; i++) {
sub_v3_v3v3(vec, vertexCos[i], center);
minmax_v3v3_v3(min, max, vec);
}
}
else {
for (i = 0; i < numVerts; i++) {
minmax_v3v3_v3(min, max, vertexCos[i]);
}
}
/* we want a symmetric bound box around the origin */
if (fabsf(min[0]) > fabsf(max[0])) max[0] = fabsf(min[0]);
if (fabsf(min[1]) > fabsf(max[1])) max[1] = fabsf(min[1]);
if (fabsf(min[2]) > fabsf(max[2])) max[2] = fabsf(min[2]);
min[0] = -max[0];
min[1] = -max[1];
min[2] = -max[2];
}
/* building our custom bounding box */
bb[0][0] = bb[2][0] = bb[4][0] = bb[6][0] = min[0];
bb[1][0] = bb[3][0] = bb[5][0] = bb[7][0] = max[0];
bb[0][1] = bb[1][1] = bb[4][1] = bb[5][1] = min[1];
bb[2][1] = bb[3][1] = bb[6][1] = bb[7][1] = max[1];
bb[0][2] = bb[1][2] = bb[2][2] = bb[3][2] = min[2];
bb[4][2] = bb[5][2] = bb[6][2] = bb[7][2] = max[2];
/* ready to apply the effect, one vertex at a time */
for (i = 0; i < numVerts; i++) {
int octant, coord;
float d[3], dmax, apex[3], fbb;
float tmp_co[3];
copy_v3_v3(tmp_co, vertexCos[i]);
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(mat, tmp_co);
}
else {
sub_v3_v3(tmp_co, center);
}
}
if (has_radius) {
if (fabsf(tmp_co[0]) > cmd->radius ||
fabsf(tmp_co[1]) > cmd->radius ||
fabsf(tmp_co[2]) > cmd->radius)
{
continue;
}
}
if (dvert) {
const float weight = defvert_find_weight(&dvert[i], defgrp_index);
if (weight == 0.0f) {
continue;
}
fac = fac_orig * weight;
facm = 1.0f - fac;
}
/* The algo used to project the vertices to their
* bounding box (bb) is pretty simple:
* for each vertex v:
* 1) find in which octant v is in;
* 2) find which outer "wall" of that octant is closer to v;
* 3) calculate factor (var fbb) to project v to that wall;
* 4) project. */
/* find in which octant this vertex is in */
octant = 0;
if (tmp_co[0] > 0.0f) octant += 1;
if (tmp_co[1] > 0.0f) octant += 2;
if (tmp_co[2] > 0.0f) octant += 4;
/* apex is the bb's vertex at the chosen octant */
copy_v3_v3(apex, bb[octant]);
/* find which bb plane is closest to this vertex ... */
d[0] = tmp_co[0] / apex[0];
d[1] = tmp_co[1] / apex[1];
d[2] = tmp_co[2] / apex[2];
/* ... (the closest has the higher (closer to 1) d value) */
dmax = d[0];
coord = 0;
if (d[1] > dmax) {
dmax = d[1];
coord = 1;
}
if (d[2] > dmax) {
/* dmax = d[2]; */ /* commented, we don't need it */
coord = 2;
}
/* ok, now we know which coordinate of the vertex to use */
if (fabsf(tmp_co[coord]) < FLT_EPSILON) /* avoid division by zero */
continue;
/* finally, this is the factor we wanted, to project the vertex
* to its bounding box (bb) */
fbb = apex[coord] / tmp_co[coord];
/* calculate the new vertex position */
if (flag & MOD_CAST_X)
tmp_co[0] = facm * tmp_co[0] + fac * tmp_co[0] * fbb;
if (flag & MOD_CAST_Y)
tmp_co[1] = facm * tmp_co[1] + fac * tmp_co[1] * fbb;
if (flag & MOD_CAST_Z)
tmp_co[2] = facm * tmp_co[2] + fac * tmp_co[2] * fbb;
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(imat, tmp_co);
}
else {
add_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vertexCos[i], tmp_co);
}
}
static DerivedMesh * cutEdges(ExplodeModifierData *emd, DerivedMesh *dm){
DerivedMesh *splitdm;
MFace *mf=NULL,*df1=NULL;
MFace *mface=dm->getFaceArray(dm);
MVert *dupve, *mv;
EdgeHash *edgehash;
EdgeHashIterator *ehi;
int totvert=dm->getNumVerts(dm);
int totface=dm->getNumFaces(dm);
int *facesplit = MEM_callocN(sizeof(int)*totface,"explode_facesplit");
int *vertpa = MEM_callocN(sizeof(int)*totvert,"explode_vertpa2");
int *facepa = emd->facepa;
int *fs, totesplit=0,totfsplit=0,curdupface=0;
int i,j,v1,v2,v3,v4,esplit, v[4], uv[4];
int numlayer;
edgehash= BLI_edgehash_new();
/* recreate vertpa from facepa calculation */
for (i=0,mf=mface; i<totface; i++,mf++) {
vertpa[mf->v1]=facepa[i];
vertpa[mf->v2]=facepa[i];
vertpa[mf->v3]=facepa[i];
if(mf->v4)
vertpa[mf->v4]=facepa[i];
}
/* mark edges for splitting and how to split faces */
for (i=0,mf=mface,fs=facesplit; i<totface; i++,mf++,fs++) {
v1=vertpa[mf->v1];
v2=vertpa[mf->v2];
v3=vertpa[mf->v3];
if(v1!=v2){
BLI_edgehash_insert(edgehash, mf->v1, mf->v2, NULL);
(*fs) |= 1;
}
if(v2!=v3){
BLI_edgehash_insert(edgehash, mf->v2, mf->v3, NULL);
(*fs) |= 2;
}
if(mf->v4){
v4=vertpa[mf->v4];
if(v3!=v4){
BLI_edgehash_insert(edgehash, mf->v3, mf->v4, NULL);
(*fs) |= 4;
}
if(v1!=v4){
BLI_edgehash_insert(edgehash, mf->v1, mf->v4, NULL);
(*fs) |= 8;
}
/* mark center vertex as a fake edge split */
if(*fs == 15)
BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
}
else {
(*fs) |= 16; /* mark face as tri */
if(v1!=v3){
BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
(*fs) |= 4;
}
}
}
/* count splits & create indexes for new verts */
ehi= BLI_edgehashIterator_new(edgehash);
totesplit=totvert;
for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(totesplit));
totesplit++;
}
BLI_edgehashIterator_free(ehi);
/* count new faces due to splitting */
for(i=0,fs=facesplit; i<totface; i++,fs++)
totfsplit += add_faces[*fs];
splitdm= CDDM_from_template(dm, totesplit, 0, totface+totfsplit);
numlayer = CustomData_number_of_layers(&splitdm->faceData, CD_MTFACE);
/* copy new faces & verts (is it really this painful with custom data??) */
for(i=0; i<totvert; i++){
MVert source;
MVert *dest;
dm->getVert(dm, i, &source);
dest = CDDM_get_vert(splitdm, i);
DM_copy_vert_data(dm, splitdm, i, i, 1);
*dest = source;
}
/* override original facepa (original pointer is saved in caller function) */
facepa= MEM_callocN(sizeof(int)*(totface+totfsplit),"explode_facepa");
//memcpy(facepa,emd->facepa,totface*sizeof(int));
emd->facepa=facepa;
/* create new verts */
ehi= BLI_edgehashIterator_new(edgehash);
for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
BLI_edgehashIterator_getKey(ehi, &i, &j);
esplit= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
mv=CDDM_get_vert(splitdm,j);
dupve=CDDM_get_vert(splitdm,esplit);
DM_copy_vert_data(splitdm,splitdm,j,esplit,1);
*dupve=*mv;
mv=CDDM_get_vert(splitdm,i);
add_v3_v3(dupve->co, mv->co);
mul_v3_fl(dupve->co, 0.5f);
}
BLI_edgehashIterator_free(ehi);
/* create new faces */
curdupface=0;//=totface;
//curdupin=totesplit;
for(i=0,fs=facesplit; i<totface; i++,fs++){
mf = dm->getFaceData(dm, i, CD_MFACE);
switch(*fs) {
case 3:
case 10:
case 11:
case 15:
SET_VERTS(1, 2, 3, 4)
break;
case 5:
case 6:
case 7:
SET_VERTS(2, 3, 4, 1)
break;
case 9:
case 13:
SET_VERTS(4, 1, 2, 3)
break;
case 12:
case 14:
SET_VERTS(3, 4, 1, 2)
break;
case 21:
case 23:
SET_VERTS(1, 2, 3, 4)
break;
case 19:
SET_VERTS(2, 3, 1, 4)
break;
case 22:
SET_VERTS(3, 1, 2, 4)
break;
}
switch(*fs) {
case 3:
case 6:
case 9:
case 12:
remap_faces_3_6_9_12(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
if(numlayer)
remap_uvs_3_6_9_12(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
break;
case 5:
case 10:
remap_faces_5_10(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
if(numlayer)
remap_uvs_5_10(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
break;
case 15:
remap_faces_15(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
if(numlayer)
remap_uvs_15(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
break;
case 7:
case 11:
case 13:
case 14:
remap_faces_7_11_13_14(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
if(numlayer)
remap_uvs_7_11_13_14(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
break;
case 19:
case 21:
case 22:
remap_faces_19_21_22(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
if(numlayer)
remap_uvs_19_21_22(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
break;
case 23:
remap_faces_23(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
if(numlayer)
remap_uvs_23(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
break;
case 0:
case 16:
df1 = get_dface(dm, splitdm, curdupface, i, mf);
facepa[curdupface] = vertpa[mf->v1];
if(df1->v4)
df1->flag |= ME_FACE_SEL;
else
df1->flag &= ~ME_FACE_SEL;
break;
}
curdupface += add_faces[*fs]+1;
}
for(i=0; i<curdupface; i++) {
mf = CDDM_get_face(splitdm, i);
test_index_face(mf, &splitdm->faceData, i, (mf->flag & ME_FACE_SEL ? 4 : 3));
}
BLI_edgehash_free(edgehash, NULL);
MEM_freeN(facesplit);
MEM_freeN(vertpa);
return splitdm;
}
/* Simple Weighted Smoothing
*
* (average of surrounding verts)
*/
static void smooth_iter__simple(
CorrectiveSmoothModifierData *csmd, DerivedMesh *dm,
float (*vertexCos)[3], unsigned int numVerts,
const float *smooth_weights,
unsigned int iterations)
{
const float lambda = csmd->lambda;
unsigned int i;
const unsigned int numEdges = (unsigned int)dm->getNumEdges(dm);
const MEdge *edges = dm->getEdgeArray(dm);
float *vertex_edge_count_div;
struct SmoothingData_Simple {
float delta[3];
} *smooth_data = MEM_callocN((size_t)numVerts * sizeof(*smooth_data), __func__);
vertex_edge_count_div = MEM_callocN((size_t)numVerts * sizeof(float), __func__);
/* calculate as floats to avoid int->float conversion in #smooth_iter */
for (i = 0; i < numEdges; i++) {
vertex_edge_count_div[edges[i].v1] += 1.0f;
vertex_edge_count_div[edges[i].v2] += 1.0f;
}
/* a little confusing, but we can include 'lambda' and smoothing weight
* here to avoid multiplying for every iteration */
if (smooth_weights == NULL) {
for (i = 0; i < numVerts; i++) {
vertex_edge_count_div[i] =
lambda * (vertex_edge_count_div[i] ? (1.0f / vertex_edge_count_div[i]) : 1.0f);
}
}
else {
for (i = 0; i < numVerts; i++) {
vertex_edge_count_div[i] =
smooth_weights[i] * lambda * (vertex_edge_count_div[i] ? (1.0f / vertex_edge_count_div[i]) : 1.0f);
}
}
/* -------------------------------------------------------------------- */
/* Main Smoothing Loop */
while (iterations--) {
for (i = 0; i < numEdges; i++) {
struct SmoothingData_Simple *sd_v1;
struct SmoothingData_Simple *sd_v2;
float edge_dir[3];
sub_v3_v3v3(edge_dir, vertexCos[edges[i].v2], vertexCos[edges[i].v1]);
sd_v1 = &smooth_data[edges[i].v1];
sd_v2 = &smooth_data[edges[i].v2];
add_v3_v3(sd_v1->delta, edge_dir);
sub_v3_v3(sd_v2->delta, edge_dir);
}
for (i = 0; i < numVerts; i++) {
struct SmoothingData_Simple *sd = &smooth_data[i];
madd_v3_v3fl(vertexCos[i], sd->delta, vertex_edge_count_div[i]);
/* zero for the next iteration (saves memset on entire array) */
memset(sd, 0, sizeof(*sd));
}
}
MEM_freeN(vertex_edge_count_div);
MEM_freeN(smooth_data);
}
static void correctivesmooth_modifier_do(
ModifierData *md, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], unsigned int numVerts,
struct BMEditMesh *em)
{
CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)md;
const bool force_delta_cache_update =
/* XXX, take care! if mesh data its self changes we need to forcefully recalculate deltas */
((csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO) &&
(((ID *)ob->data)->tag & LIB_TAG_ID_RECALC));
bool use_only_smooth = (csmd->flag & MOD_CORRECTIVESMOOTH_ONLY_SMOOTH) != 0;
MDeformVert *dvert = NULL;
int defgrp_index;
modifier_get_vgroup(ob, dm, csmd->defgrp_name, &dvert, &defgrp_index);
/* if rest bind_coords not are defined, set them (only run during bind) */
if ((csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) &&
/* signal to recalculate, whoever sets MUST also free bind coords */
(csmd->bind_coords_num == (unsigned int)-1))
{
BLI_assert(csmd->bind_coords == NULL);
csmd->bind_coords = MEM_dupallocN(vertexCos);
csmd->bind_coords_num = numVerts;
BLI_assert(csmd->bind_coords != NULL);
}
if (UNLIKELY(use_only_smooth)) {
smooth_verts(csmd, dm, dvert, defgrp_index, vertexCos, numVerts);
return;
}
if ((csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) && (csmd->bind_coords == NULL)) {
modifier_setError(md, "Bind data required");
goto error;
}
/* If the number of verts has changed, the bind is invalid, so we do nothing */
if (csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) {
if (csmd->bind_coords_num != numVerts) {
modifier_setError(md, "Bind vertex count mismatch: %u to %u", csmd->bind_coords_num, numVerts);
goto error;
}
}
else {
/* MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO */
if (ob->type != OB_MESH) {
modifier_setError(md, "Object is not a mesh");
goto error;
}
else {
unsigned int me_numVerts = (unsigned int)((em) ? em->bm->totvert : ((Mesh *)ob->data)->totvert);
if (me_numVerts != numVerts) {
modifier_setError(md, "Original vertex count mismatch: %u to %u", me_numVerts, numVerts);
goto error;
}
}
}
/* check to see if our deltas are still valid */
if (!csmd->delta_cache || (csmd->delta_cache_num != numVerts) || force_delta_cache_update) {
const float (*rest_coords)[3];
bool is_rest_coords_alloc = false;
if (csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) {
/* caller needs to do sanity check here */
csmd->bind_coords_num = numVerts;
rest_coords = (const float (*)[3])csmd->bind_coords;
}
else {
int me_numVerts;
rest_coords = (const float (*)[3]) ((em) ?
BKE_editmesh_vertexCos_get_orco(em, &me_numVerts) :
BKE_mesh_vertexCos_get(ob->data, &me_numVerts));
BLI_assert((unsigned int)me_numVerts == numVerts);
is_rest_coords_alloc = true;
}
#ifdef DEBUG_TIME
TIMEIT_START(corrective_smooth_deltas);
#endif
calc_deltas(csmd, dm, dvert, defgrp_index, rest_coords, numVerts);
#ifdef DEBUG_TIME
TIMEIT_END(corrective_smooth_deltas);
#endif
if (is_rest_coords_alloc) {
MEM_freeN((void *)rest_coords);
}
}
if (csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) {
/* this could be a check, but at this point it _must_ be valid */
BLI_assert(csmd->bind_coords_num == numVerts && csmd->delta_cache);
}
#ifdef DEBUG_TIME
TIMEIT_START(corrective_smooth);
#endif
/* do the actual delta mush */
smooth_verts(csmd, dm, dvert, defgrp_index, vertexCos, numVerts);
{
unsigned int i;
float (*tangent_spaces)[3][3];
/* calloc, since values are accumulated */
tangent_spaces = MEM_callocN((size_t)numVerts * sizeof(float[3][3]), __func__);
calc_tangent_spaces(dm, vertexCos, tangent_spaces);
for (i = 0; i < numVerts; i++) {
float delta[3];
#ifdef USE_TANGENT_CALC_INLINE
calc_tangent_ortho(tangent_spaces[i]);
#endif
mul_v3_m3v3(delta, tangent_spaces[i], csmd->delta_cache[i]);
add_v3_v3(vertexCos[i], delta);
}
MEM_freeN(tangent_spaces);
}
#ifdef DEBUG_TIME
TIMEIT_END(corrective_smooth);
#endif
return;
/* when the modifier fails to execute */
error:
MEM_SAFE_FREE(csmd->delta_cache);
csmd->delta_cache_num = 0;
}
static void do_texture_effector(EffectorCache *eff, EffectorData *efd, EffectedPoint *point, float *total_force)
{
TexResult result[4];
float tex_co[3], strength, force[3];
float nabla = eff->pd->tex_nabla;
int hasrgb;
short mode = eff->pd->tex_mode;
bool scene_color_manage;
if (!eff->pd->tex)
return;
result[0].nor = result[1].nor = result[2].nor = result[3].nor = NULL;
strength= eff->pd->f_strength * efd->falloff;
copy_v3_v3(tex_co, point->loc);
if (eff->pd->flag & PFIELD_TEX_2D) {
float fac=-dot_v3v3(tex_co, efd->nor);
madd_v3_v3fl(tex_co, efd->nor, fac);
}
if (eff->pd->flag & PFIELD_TEX_OBJECT) {
mul_m4_v3(eff->ob->imat, tex_co);
}
scene_color_manage = BKE_scene_check_color_management_enabled(eff->scene);
hasrgb = multitex_ext(eff->pd->tex, tex_co, NULL, NULL, 0, result, NULL, scene_color_manage, false);
if (hasrgb && mode==PFIELD_TEX_RGB) {
force[0] = (0.5f - result->tr) * strength;
force[1] = (0.5f - result->tg) * strength;
force[2] = (0.5f - result->tb) * strength;
}
else {
strength/=nabla;
tex_co[0] += nabla;
multitex_ext(eff->pd->tex, tex_co, NULL, NULL, 0, result+1, NULL, scene_color_manage, false);
tex_co[0] -= nabla;
tex_co[1] += nabla;
multitex_ext(eff->pd->tex, tex_co, NULL, NULL, 0, result+2, NULL, scene_color_manage, false);
tex_co[1] -= nabla;
tex_co[2] += nabla;
multitex_ext(eff->pd->tex, tex_co, NULL, NULL, 0, result+3, NULL, scene_color_manage, false);
if (mode == PFIELD_TEX_GRAD || !hasrgb) { /* if we don't have rgb fall back to grad */
/* generate intensity if texture only has rgb value */
if (hasrgb & TEX_RGB) {
int i;
for (i=0; i<4; i++)
result[i].tin = (1.0f / 3.0f) * (result[i].tr + result[i].tg + result[i].tb);
}
force[0] = (result[0].tin - result[1].tin) * strength;
force[1] = (result[0].tin - result[2].tin) * strength;
force[2] = (result[0].tin - result[3].tin) * strength;
}
else { /*PFIELD_TEX_CURL*/
float dbdy, dgdz, drdz, dbdx, dgdx, drdy;
dbdy = result[2].tb - result[0].tb;
dgdz = result[3].tg - result[0].tg;
drdz = result[3].tr - result[0].tr;
dbdx = result[1].tb - result[0].tb;
dgdx = result[1].tg - result[0].tg;
drdy = result[2].tr - result[0].tr;
force[0] = (dbdy - dgdz) * strength;
force[1] = (drdz - dbdx) * strength;
force[2] = (dgdx - drdy) * strength;
}
}
if (eff->pd->flag & PFIELD_TEX_2D) {
float fac = -dot_v3v3(force, efd->nor);
madd_v3_v3fl(force, efd->nor, fac);
}
add_v3_v3(total_force, force);
}
int voxeldatatex(struct Tex *tex, const float texvec[3], struct TexResult *texres)
{
VoxelData *vd = tex->vd;
float co[3], offset[3] = {0.5, 0.5, 0.5}, a;
int retval = (vd->data_type == TEX_VD_RGBA_PREMUL) ? TEX_RGB : TEX_INT;
int depth = (vd->data_type == TEX_VD_RGBA_PREMUL) ? 4 : 1;
int ch;
if (vd->dataset == NULL) {
texres->tin = 0.0f;
return 0;
}
/* scale lookup from 0.0-1.0 (original location) to -1.0, 1.0, consistent with image texture tex coords */
/* in implementation this works backwards, bringing sample locations from -1.0, 1.0
* to the range 0.0, 1.0, before looking up in the voxel structure. */
copy_v3_v3(co, texvec);
mul_v3_fl(co, 0.5f);
add_v3_v3(co, offset);
/* co is now in the range 0.0, 1.0 */
switch (vd->extend) {
case TEX_CLIP:
{
if ((co[0] < 0.f || co[0] > 1.f) || (co[1] < 0.f || co[1] > 1.f) || (co[2] < 0.f || co[2] > 1.f)) {
texres->tin = 0.f;
return retval;
}
break;
}
case TEX_REPEAT:
{
co[0] = co[0] - floorf(co[0]);
co[1] = co[1] - floorf(co[1]);
co[2] = co[2] - floorf(co[2]);
break;
}
case TEX_EXTEND:
{
CLAMP(co[0], 0.f, 1.f);
CLAMP(co[1], 0.f, 1.f);
CLAMP(co[2], 0.f, 1.f);
break;
}
}
for (ch = 0; ch < depth; ch++) {
float *dataset = vd->dataset + ch*vd->resol[0]*vd->resol[1]*vd->resol[2];
float *result = &texres->tin;
if (vd->data_type == TEX_VD_RGBA_PREMUL) {
switch (ch) {
case 0:
result = &texres->tr;
break;
case 1:
result = &texres->tg;
break;
case 2:
result = &texres->tb;
break;
}
}
switch (vd->interp_type) {
case TEX_VD_NEARESTNEIGHBOR:
*result = BLI_voxel_sample_nearest(dataset, vd->resol, co);
break;
case TEX_VD_LINEAR:
*result = BLI_voxel_sample_trilinear(dataset, vd->resol, co);
break;
case TEX_VD_QUADRATIC:
*result = BLI_voxel_sample_triquadratic(dataset, vd->resol, co);
break;
case TEX_VD_TRICUBIC_CATROM:
case TEX_VD_TRICUBIC_BSPLINE:
*result = BLI_voxel_sample_tricubic(dataset, vd->resol, co, (vd->interp_type == TEX_VD_TRICUBIC_BSPLINE));
break;
}
}
a = texres->tin;
texres->tin *= vd->int_multiplier;
BRICONT;
if (vd->data_type == TEX_VD_RGBA_PREMUL) {
/* unmultiply */
if (a>0.001f) {
texres->tr /= a;
texres->tg /= a;
texres->tb /= a;
}
texres->talpha = 1;
}
else {
texres->tr = texres->tin;
texres->tg = texres->tin;
texres->tb = texres->tin;
}
texres->ta = texres->tin;
BRICONTRGB;
return retval;
}
static void createFacepa(ExplodeModifierData *emd,
ParticleSystemModifierData *psmd,
DerivedMesh *dm)
{
ParticleSystem *psys = psmd->psys;
MFace *fa = NULL, *mface = NULL;
MVert *mvert = NULL;
ParticleData *pa;
KDTree *tree;
RNG *rng;
float center[3], co[3];
int *facepa = NULL, *vertpa = NULL, totvert = 0, totface = 0, totpart = 0;
int i, p, v1, v2, v3, v4 = 0;
mvert = dm->getVertArray(dm);
mface = dm->getTessFaceArray(dm);
totface = dm->getNumTessFaces(dm);
totvert = dm->getNumVerts(dm);
totpart = psmd->psys->totpart;
rng = BLI_rng_new_srandom(psys->seed);
if (emd->facepa)
MEM_freeN(emd->facepa);
facepa = emd->facepa = MEM_callocN(sizeof(int) * totface, "explode_facepa");
vertpa = MEM_callocN(sizeof(int) * totvert, "explode_vertpa");
/* initialize all faces & verts to no particle */
for (i = 0; i < totface; i++)
facepa[i] = totpart;
for (i = 0; i < totvert; i++)
vertpa[i] = totpart;
/* set protected verts */
if (emd->vgroup) {
MDeformVert *dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
if (dvert) {
const int defgrp_index = emd->vgroup - 1;
for (i = 0; i < totvert; i++, dvert++) {
float val = BLI_rng_get_float(rng);
val = (1.0f - emd->protect) * val + emd->protect * 0.5f;
if (val < defvert_find_weight(dvert, defgrp_index))
vertpa[i] = -1;
}
}
}
/* make tree of emitter locations */
tree = BLI_kdtree_new(totpart);
for (p = 0, pa = psys->particles; p < totpart; p++, pa++) {
psys_particle_on_emitter(psmd, psys->part->from, pa->num, pa->num_dmcache, pa->fuv, pa->foffset, co, NULL, NULL, NULL, NULL, NULL);
BLI_kdtree_insert(tree, p, co);
}
BLI_kdtree_balance(tree);
/* set face-particle-indexes to nearest particle to face center */
for (i = 0, fa = mface; i < totface; i++, fa++) {
add_v3_v3v3(center, mvert[fa->v1].co, mvert[fa->v2].co);
add_v3_v3(center, mvert[fa->v3].co);
if (fa->v4) {
add_v3_v3(center, mvert[fa->v4].co);
mul_v3_fl(center, 0.25);
}
else
mul_v3_fl(center, 1.0f / 3.0f);
p = BLI_kdtree_find_nearest(tree, center, NULL);
v1 = vertpa[fa->v1];
v2 = vertpa[fa->v2];
v3 = vertpa[fa->v3];
if (fa->v4)
v4 = vertpa[fa->v4];
if (v1 >= 0 && v2 >= 0 && v3 >= 0 && (fa->v4 == 0 || v4 >= 0))
facepa[i] = p;
if (v1 >= 0) vertpa[fa->v1] = p;
if (v2 >= 0) vertpa[fa->v2] = p;
if (v3 >= 0) vertpa[fa->v3] = p;
if (fa->v4 && v4 >= 0) vertpa[fa->v4] = p;
}
if (vertpa) MEM_freeN(vertpa);
BLI_kdtree_free(tree);
BLI_rng_free(rng);
}
void BKE_displist_normals_add(ListBase *lb)
{
DispList *dl = NULL;
float *vdata, *ndata, nor[3];
float *v1, *v2, *v3, *v4;
float *n1, *n2, *n3, *n4;
int a, b, p1, p2, p3, p4;
dl = lb->first;
while (dl) {
if (dl->type == DL_INDEX3) {
if (dl->nors == NULL) {
dl->nors = MEM_callocN(sizeof(float) * 3, "dlnors");
if (dl->flag & DL_BACK_CURVE) {
dl->nors[2] = -1.0f;
}
else {
dl->nors[2] = 1.0f;
}
}
}
else if (dl->type == DL_SURF) {
if (dl->nors == NULL) {
dl->nors = MEM_callocN(sizeof(float) * 3 * dl->nr * dl->parts, "dlnors");
vdata = dl->verts;
ndata = dl->nors;
for (a = 0; a < dl->parts; a++) {
if (BKE_displist_surfindex_get(dl, a, &b, &p1, &p2, &p3, &p4) == 0)
break;
v1 = vdata + 3 * p1;
n1 = ndata + 3 * p1;
v2 = vdata + 3 * p2;
n2 = ndata + 3 * p2;
v3 = vdata + 3 * p3;
n3 = ndata + 3 * p3;
v4 = vdata + 3 * p4;
n4 = ndata + 3 * p4;
for (; b < dl->nr; b++) {
normal_quad_v3(nor, v1, v3, v4, v2);
add_v3_v3(n1, nor);
add_v3_v3(n2, nor);
add_v3_v3(n3, nor);
add_v3_v3(n4, nor);
v2 = v1; v1 += 3;
v4 = v3; v3 += 3;
n2 = n1; n1 += 3;
n4 = n3; n3 += 3;
}
}
a = dl->parts * dl->nr;
v1 = ndata;
while (a--) {
normalize_v3(v1);
v1 += 3;
}
}
}
dl = dl->next;
}
}
/* calculates offset for co, based on fractal, sphere or smooth settings */
static void alter_co(BMesh *bm, BMVert *v, BMEdge *UNUSED(origed), const SubDParams *params, float perc,
BMVert *vsta, BMVert *vend)
{
float tvec[3], prev_co[3], fac;
float *co = NULL;
int i, totlayer = CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY);
BM_vert_normal_update_all(v);
co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, params->origkey);
copy_v3_v3(co, v->co);
copy_v3_v3(prev_co, co);
if (UNLIKELY(params->use_sphere)) { /* subdivide sphere */
normalize_v3(co);
mul_v3_fl(co, params->smooth);
}
else if (params->use_smooth) {
/* we calculate an offset vector vec1[], to be added to *co */
float len, nor[3], nor1[3], nor2[3], val;
sub_v3_v3v3(nor, vsta->co, vend->co);
len = 0.5f * normalize_v3(nor);
copy_v3_v3(nor1, vsta->no);
copy_v3_v3(nor2, vend->no);
/* cosine angle */
fac = dot_v3v3(nor, nor1);
mul_v3_v3fl(tvec, nor1, fac);
/* cosine angle */
fac = -dot_v3v3(nor, nor2);
madd_v3_v3fl(tvec, nor2, fac);
/* falloff for multi subdivide */
val = fabsf(1.0f - 2.0f * fabsf(0.5f - perc));
switch (params->smooth_falloff) {
case SUBD_FALLOFF_SMOOTH:
val = 3.0f * val * val - 2.0f * val * val * val;
break;
case SUBD_FALLOFF_SPHERE:
val = sqrtf(2.0f * val - val * val);
break;
case SUBD_FALLOFF_ROOT:
val = sqrtf(val);
break;
case SUBD_FALLOFF_SHARP:
val = val * val;
break;
case SUBD_FALLOFF_LIN:
break;
default:
BLI_assert(0);
}
mul_v3_fl(tvec, params->smooth * val * len);
add_v3_v3(co, tvec);
}
if (params->use_fractal) {
float len = len_v3v3(vsta->co, vend->co);
float normal[3] = {0.0f, 0.0f, 0.0f}, co2[3], base1[3], base2[3];
fac = params->fractal * len;
mid_v3_v3v3(normal, vsta->no, vend->no);
ortho_basis_v3v3_v3(base1, base2, normal);
add_v3_v3v3(co2, v->co, params->fractal_ofs);
mul_v3_fl(co2, 10.0f);
tvec[0] = fac * (BLI_gTurbulence(1.0, co2[0], co2[1], co2[2], 15, 0, 2) - 0.5f);
tvec[1] = fac * (BLI_gTurbulence(1.0, co2[1], co2[0], co2[2], 15, 0, 2) - 0.5f);
tvec[2] = fac * (BLI_gTurbulence(1.0, co2[1], co2[2], co2[0], 15, 0, 2) - 0.5f);
/* add displacement */
madd_v3_v3fl(co, normal, tvec[0]);
madd_v3_v3fl(co, base1, tvec[1] * (1.0f - params->along_normal));
madd_v3_v3fl(co, base2, tvec[2] * (1.0f - params->along_normal));
}
/* apply the new difference to the rest of the shape keys,
* note that this doesn't take rotations into account, we _could_ support
* this by getting the normals and coords for each shape key and
* re-calculate the smooth value for each but this is quite involved.
* for now its ok to simply apply the difference IMHO - campbell */
sub_v3_v3v3(tvec, prev_co, co);
for (i = 0; i < totlayer; i++) {
if (params->origkey != i) {
co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, i);
sub_v3_v3(co, tvec);
}
}
}
static void meshdeformModifier_do(
ModifierData *md, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
MeshDeformModifierData *mmd = (MeshDeformModifierData *) md;
struct Mesh *me = (mmd->object) ? mmd->object->data : NULL;
BMEditMesh *em = me ? me->edit_btmesh : NULL;
DerivedMesh *tmpdm, *cagedm;
MDeformVert *dvert = NULL;
MDefInfluence *influences;
int *offsets;
float imat[4][4], cagemat[4][4], iobmat[4][4], icagemat[3][3], cmat[4][4];
float weight, totweight, fac, co[3], (*dco)[3], (*bindcagecos)[3];
int a, b, totvert, totcagevert, defgrp_index;
float (*cagecos)[3];
if (!mmd->object || (!mmd->bindcagecos && !mmd->bindfunc))
return;
/* get cage derivedmesh */
if (em) {
tmpdm = editbmesh_get_derived_cage_and_final(md->scene, ob, em, &cagedm, 0);
if (tmpdm)
tmpdm->release(tmpdm);
}
else
cagedm = mmd->object->derivedFinal;
/* if we don't have one computed, use derivedmesh from data
* without any modifiers */
if (!cagedm) {
cagedm = get_dm(mmd->object, NULL, NULL, NULL, 0);
if (cagedm)
cagedm->needsFree = 1;
}
if (!cagedm) {
modifier_setError(md, "Cannot get mesh from cage object");
return;
}
/* compute matrices to go in and out of cage object space */
invert_m4_m4(imat, mmd->object->obmat);
mult_m4_m4m4(cagemat, imat, ob->obmat);
mult_m4_m4m4(cmat, mmd->bindmat, cagemat);
invert_m4_m4(iobmat, cmat);
copy_m3_m4(icagemat, iobmat);
/* bind weights if needed */
if (!mmd->bindcagecos) {
static int recursive = 0;
/* progress bar redraw can make this recursive .. */
if (!recursive) {
recursive = 1;
mmd->bindfunc(md->scene, mmd, (float *)vertexCos, numVerts, cagemat);
recursive = 0;
}
}
/* verify we have compatible weights */
totvert = numVerts;
totcagevert = cagedm->getNumVerts(cagedm);
if (mmd->totvert != totvert) {
modifier_setError(md, "Verts changed from %d to %d", mmd->totvert, totvert);
cagedm->release(cagedm);
return;
}
else if (mmd->totcagevert != totcagevert) {
modifier_setError(md, "Cage verts changed from %d to %d", mmd->totcagevert, totcagevert);
cagedm->release(cagedm);
return;
}
else if (mmd->bindcagecos == NULL) {
modifier_setError(md, "Bind data missing");
cagedm->release(cagedm);
return;
}
cagecos = MEM_callocN(sizeof(*cagecos) * totcagevert, "meshdeformModifier vertCos");
/* setup deformation data */
cagedm->getVertCos(cagedm, cagecos);
influences = mmd->bindinfluences;
offsets = mmd->bindoffsets;
bindcagecos = (float(*)[3])mmd->bindcagecos;
dco = MEM_callocN(sizeof(*dco) * totcagevert, "MDefDco");
for (a = 0; a < totcagevert; a++) {
/* get cage vertex in world space with binding transform */
copy_v3_v3(co, cagecos[a]);
if (G.debug_value != 527) {
mul_m4_v3(mmd->bindmat, co);
/* compute difference with world space bind coord */
sub_v3_v3v3(dco[a], co, bindcagecos[a]);
}
else
copy_v3_v3(dco[a], co);
}
modifier_get_vgroup(ob, dm, mmd->defgrp_name, &dvert, &defgrp_index);
/* do deformation */
fac = 1.0f;
for (b = 0; b < totvert; b++) {
if (mmd->flag & MOD_MDEF_DYNAMIC_BIND)
if (!mmd->dynverts[b])
continue;
if (dvert) {
fac = defvert_find_weight(&dvert[b], defgrp_index);
if (mmd->flag & MOD_MDEF_INVERT_VGROUP) {
fac = 1.0f - fac;
}
if (fac <= 0.0f) {
continue;
}
}
if (mmd->flag & MOD_MDEF_DYNAMIC_BIND) {
/* transform coordinate into cage's local space */
mul_v3_m4v3(co, cagemat, vertexCos[b]);
totweight = meshdeform_dynamic_bind(mmd, dco, co);
}
else {
totweight = 0.0f;
zero_v3(co);
for (a = offsets[b]; a < offsets[b + 1]; a++) {
weight = influences[a].weight;
madd_v3_v3fl(co, dco[influences[a].vertex], weight);
totweight += weight;
}
}
if (totweight > 0.0f) {
mul_v3_fl(co, fac / totweight);
mul_m3_v3(icagemat, co);
if (G.debug_value != 527)
add_v3_v3(vertexCos[b], co);
else
copy_v3_v3(vertexCos[b], co);
}
}
/* release cage derivedmesh */
MEM_freeN(dco);
MEM_freeN(cagecos);
cagedm->release(cagedm);
}
static void do_nla(Scene *scene, Object *ob, int blocktype)
{
bPose *tpose= NULL;
Key *key= NULL;
ListBase tchanbase={NULL, NULL}, chanbase={NULL, NULL};
bActionStrip *strip, *striplast=NULL, *stripfirst=NULL;
float striptime, frametime, length, actlength;
float blendfac, stripframe;
float scene_cfra= BKE_curframe(scene);
int doit, dostride;
if(blocktype==ID_AR) {
copy_pose(&tpose, ob->pose, 1);
rest_pose(ob->pose); // potentially destroying current not-keyed pose
}
else {
key= ob_get_key(ob);
}
/* check on extend to left or right, when no strip is hit by 'cfra' */
for (strip=ob->nlastrips.first; strip; strip=strip->next) {
/* escape loop on a hit */
if( scene_cfra >= strip->start && scene_cfra <= strip->end + 0.1f) /* note 0.1 comes back below */
break;
if(scene_cfra < strip->start) {
if(stripfirst==NULL)
stripfirst= strip;
else if(stripfirst->start > strip->start)
stripfirst= strip;
}
else if(scene_cfra > strip->end) {
if(striplast==NULL)
striplast= strip;
else if(striplast->end < strip->end)
striplast= strip;
}
}
if(strip==NULL) { /* extend */
if(striplast)
scene_cfra= striplast->end;
else if(stripfirst)
scene_cfra= stripfirst->start;
}
/* and now go over all strips */
for (strip=ob->nlastrips.first; strip; strip=strip->next){
doit=dostride= 0;
if (strip->act && !(strip->flag & ACTSTRIP_MUTE)) { /* so theres an action */
/* Determine if the current frame is within the strip's range */
length = strip->end-strip->start;
actlength = strip->actend-strip->actstart;
striptime = (scene_cfra-(strip->start)) / length;
stripframe = (scene_cfra-(strip->start)) ;
if (striptime>=0.0){
if(blocktype==ID_AR)
rest_pose(tpose);
/* To handle repeat, we add 0.1 frame extra to make sure the last frame is included */
if (striptime < 1.0f + 0.1f/length) {
/* Handle path */
if ((strip->flag & ACTSTRIP_USESTRIDE) && (blocktype==ID_AR) && (ob->ipoflag & OB_DISABLE_PATH)==0){
Object *parent= get_parent_path(ob);
if (parent) {
Curve *cu = parent->data;
float ctime, pdist;
if (cu->flag & CU_PATH){
/* Ensure we have a valid path */
if(cu->path==NULL || cu->path->data==NULL) makeDispListCurveTypes(scene, parent, 0);
if(cu->path) {
/* Find the position on the path */
ctime= bsystem_time(scene, ob, scene_cfra, 0.0);
if(calc_ipo_spec(cu->ipo, CU_SPEED, &ctime)==0) {
/* correct for actions not starting on zero */
ctime= (ctime - strip->actstart)/cu->pathlen;
CLAMP(ctime, 0.0, 1.0);
}
pdist = ctime*cu->path->totdist;
if(tpose && strip->stridechannel[0]) {
striptime= stridechannel_frame(parent, ob->size[0], strip, cu->path, pdist, tpose->stride_offset);
}
else {
if (strip->stridelen) {
striptime = pdist / strip->stridelen;
striptime = (float)fmod (striptime+strip->actoffs, 1.0);
}
else
striptime = 0;
}
frametime = (striptime * actlength) + strip->actstart;
frametime= bsystem_time(scene, ob, frametime, 0.0);
if(blocktype==ID_AR) {
extract_pose_from_action (tpose, strip->act, frametime);
}
else if(blocktype==ID_OB) {
extract_ipochannels_from_action(&tchanbase, &ob->id, strip->act, "Object", frametime);
if(key)
extract_ipochannels_from_action(&tchanbase, &key->id, strip->act, "Shape", frametime);
}
doit=dostride= 1;
}
}
}
}
/* To handle repeat, we add 0.1 frame extra to make sure the last frame is included */
else {
/* Mod to repeat */
if(strip->repeat!=1.0f) {
float cycle= striptime*strip->repeat;
striptime = (float)fmod (cycle, 1.0f + 0.1f/length);
cycle-= striptime;
if(blocktype==ID_AR)
cyclic_offs_bone(ob, tpose, strip, cycle);
}
frametime = (striptime * actlength) + strip->actstart;
frametime= nla_time(scene, frametime, (float)strip->repeat);
if(blocktype==ID_AR) {
extract_pose_from_action (tpose, strip->act, frametime);
}
else if(blocktype==ID_OB) {
extract_ipochannels_from_action(&tchanbase, &ob->id, strip->act, "Object", frametime);
if(key)
extract_ipochannels_from_action(&tchanbase, &key->id, strip->act, "Shape", frametime);
}
doit=1;
}
}
/* Handle extend */
else {
if (strip->flag & ACTSTRIP_HOLDLASTFRAME){
/* we want the strip to hold on the exact fraction of the repeat value */
frametime = actlength * (strip->repeat-(int)strip->repeat);
if(frametime<=0.000001f) frametime= actlength; /* rounding errors... */
frametime= bsystem_time(scene, ob, frametime+strip->actstart, 0.0);
if(blocktype==ID_AR)
extract_pose_from_action (tpose, strip->act, frametime);
else if(blocktype==ID_OB) {
extract_ipochannels_from_action(&tchanbase, &ob->id, strip->act, "Object", frametime);
if(key)
extract_ipochannels_from_action(&tchanbase, &key->id, strip->act, "Shape", frametime);
}
/* handle cycle hold */
if(strip->repeat!=1.0f) {
if(blocktype==ID_AR)
cyclic_offs_bone(ob, tpose, strip, strip->repeat-1.0f);
}
doit=1;
}
}
/* Handle blendin & blendout */
if (doit){
/* Handle blendin */
if (strip->blendin>0.0 && stripframe<=strip->blendin && scene_cfra>=strip->start){
blendfac = stripframe/strip->blendin;
}
else if (strip->blendout>0.0 && stripframe>=(length-strip->blendout) && scene_cfra<=strip->end){
blendfac = (length-stripframe)/(strip->blendout);
}
else
blendfac = 1;
if(blocktype==ID_AR) {/* Blend this pose with the accumulated pose */
/* offset bone, for matching cycles */
blend_pose_offset_bone (strip, ob->pose, tpose, blendfac, strip->mode);
blend_poses (ob->pose, tpose, blendfac, strip->mode);
if(dostride)
blend_pose_strides (ob->pose, tpose, blendfac, strip->mode);
}
else {
blend_ipochannels(&chanbase, &tchanbase, blendfac, strip->mode);
BLI_freelistN(&tchanbase);
}
}
}
}
}
if(blocktype==ID_OB) {
execute_ipochannels(&chanbase);
}
else if(blocktype==ID_AR) {
/* apply stride offset to object */
add_v3_v3(ob->obmat[3], ob->pose->stride_offset);
}
/* free */
if (tpose)
free_pose(tpose);
if(chanbase.first)
BLI_freelistN(&chanbase);
}
static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, float par_space_mat[][4], int level, int animated)
{
Object *ob, *ob_iter;
Base *base = NULL;
DupliObject *dob;
DerivedMesh *dm;
Mesh *me= par->data;
MLoopUV *mloopuv;
MPoly *mpoly, *mp;
MLoop *mloop;
MVert *mvert;
float pmat[4][4], imat[3][3], (*orco)[3] = NULL, w;
int lay, oblay, totface, a;
Scene *sce = NULL;
Group *group = NULL;
GroupObject *go = NULL;
BMEditMesh *em;
float ob__obmat[4][4]; /* needed for groups where the object matrix needs to be modified */
/* simple preventing of too deep nested groups */
if (level>MAX_DUPLI_RECUR) return;
copy_m4_m4(pmat, par->obmat);
em = me->edit_btmesh;
if (em) {
dm= editbmesh_get_derived_cage(scene, par, em, CD_MASK_BAREMESH);
}
else {
dm = mesh_get_derived_deform(scene, par, CD_MASK_BAREMESH);
}
totface= dm->getNumPolys(dm);
mpoly= dm->getPolyArray(dm);
mloop= dm->getLoopArray(dm);
mvert= dm->getVertArray(dm);
if (G.rendering) {
orco= (float(*)[3])get_mesh_orco_verts(par);
transform_mesh_orco_verts(me, orco, me->totvert, 0);
mloopuv= me->mloopuv;
}
else {
orco= NULL;
mloopuv= NULL;
}
/* having to loop on scene OR group objects is NOT FUN */
if (GS(id->name) == ID_SCE) {
sce = (Scene *)id;
lay= sce->lay;
base= sce->base.first;
}
else {
group = (Group *)id;
lay= group->layer;
go = group->gobject.first;
}
/* Start looping on Scene OR Group objects */
while (base || go) {
if (sce) {
ob_iter= base->object;
oblay = base->lay;
}
else {
ob_iter= go->ob;
oblay = ob_iter->lay;
}
if (lay & oblay && scene->obedit!=ob_iter) {
ob=ob_iter->parent;
while (ob) {
if (ob==par) {
ob = ob_iter;
/* End Scene/Group object loop, below is generic */
/* par_space_mat - only used for groups so we can modify the space dupli's are in
* when par_space_mat is NULL ob->obmat can be used instead of ob__obmat
*/
if (par_space_mat)
mult_m4_m4m4(ob__obmat, par_space_mat, ob->obmat);
else
copy_m4_m4(ob__obmat, ob->obmat);
copy_m3_m4(imat, ob->parentinv);
/* mballs have a different dupli handling */
if (ob->type!=OB_MBALL) ob->flag |= OB_DONE; /* doesnt render */
for (a=0, mp= mpoly; a<totface; a++, mp++) {
int mv1;
int mv2;
int mv3;
/* int mv4; */ /* UNUSED */
float *v1;
float *v2;
float *v3;
/* float *v4; */ /* UNUSED */
float cent[3], quat[4], mat[3][3], mat3[3][3], tmat[4][4], obmat[4][4];
MLoop *loopstart= mloop + mp->loopstart;
if (mp->totloop < 3) {
/* highly unlikely but to be safe */
continue;
}
else {
v1= mvert[(mv1= loopstart[0].v)].co;
v2= mvert[(mv2= loopstart[1].v)].co;
v3= mvert[(mv3= loopstart[2].v)].co;
#if 0
if (mp->totloop > 3) {
v4= mvert[(mv4= loopstart[3].v)].co;
}
#endif
}
/* translation */
mesh_calc_poly_center(mp, loopstart, mvert, cent);
mul_m4_v3(pmat, cent);
sub_v3_v3v3(cent, cent, pmat[3]);
add_v3_v3(cent, ob__obmat[3]);
copy_m4_m4(obmat, ob__obmat);
copy_v3_v3(obmat[3], cent);
/* rotation */
tri_to_quat( quat,v1, v2, v3);
quat_to_mat3( mat,quat);
/* scale */
if (par->transflag & OB_DUPLIFACES_SCALE) {
float size= mesh_calc_poly_area(mp, loopstart, mvert, NULL);
size= sqrtf(size) * par->dupfacesca;
mul_m3_fl(mat, size);
}
copy_m3_m3(mat3, mat);
mul_m3_m3m3(mat, imat, mat3);
copy_m4_m4(tmat, obmat);
mul_m4_m4m3(obmat, tmat, mat);
dob= new_dupli_object(lb, ob, obmat, par->lay, a, OB_DUPLIFACES, animated);
if (G.rendering) {
w= 1.0f / (float)mp->totloop;
if (orco) {
int j;
for (j = 0; j < mpoly->totloop; j++) {
madd_v3_v3fl(dob->orco, orco[loopstart[j].v], w);
}
}
if (mloopuv) {
int j;
for (j = 0; j < mpoly->totloop; j++) {
madd_v2_v2fl(dob->orco, mloopuv[loopstart[j].v].uv, w);
}
}
}
if (ob->transflag & OB_DUPLI) {
float tmpmat[4][4];
copy_m4_m4(tmpmat, ob->obmat);
copy_m4_m4(ob->obmat, obmat); /* pretend we are really this mat */
object_duplilist_recursive((ID *)id, scene, ob, lb, ob->obmat, level+1, animated);
copy_m4_m4(ob->obmat, tmpmat);
}
}
break;
}
ob= ob->parent;
}
}
if (sce) base= base->next; /* scene loop */
else go= go->next; /* group loop */
}
if (orco)
MEM_freeN(orco);
dm->release(dm);
}
static void sphere_do(
CastModifierData *cmd, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
MDeformVert *dvert = NULL;
Object *ctrl_ob = NULL;
int i, defgrp_index;
int has_radius = 0;
short flag, type;
float fac, facm, len = 0.0f;
float vec[3], center[3] = {0.0f, 0.0f, 0.0f};
float mat[4][4], imat[4][4];
fac = cmd->fac;
facm = 1.0f - fac;
flag = cmd->flag;
type = cmd->type; /* projection type: sphere or cylinder */
if (type == MOD_CAST_TYPE_CYLINDER)
flag &= ~MOD_CAST_Z;
ctrl_ob = cmd->object;
/* spherify's center is {0, 0, 0} (the ob's own center in its local
* space), by default, but if the user defined a control object,
* we use its location, transformed to ob's local space */
if (ctrl_ob) {
if(flag & MOD_CAST_USE_OB_TRANSFORM) {
invert_m4_m4(ctrl_ob->imat, ctrl_ob->obmat);
mul_m4_m4m4(mat, ob->obmat, ctrl_ob->imat);
invert_m4_m4(imat, mat);
}
invert_m4_m4(ob->imat, ob->obmat);
mul_v3_m4v3(center, ob->imat, ctrl_ob->obmat[3]);
}
/* now we check which options the user wants */
/* 1) (flag was checked in the "if (ctrl_ob)" block above) */
/* 2) cmd->radius > 0.0f: only the vertices within this radius from
* the center of the effect should be deformed */
if (cmd->radius > FLT_EPSILON) has_radius = 1;
/* 3) if we were given a vertex group name,
* only those vertices should be affected */
modifier_get_vgroup(ob, dm, cmd->defgrp_name, &dvert, &defgrp_index);
if(flag & MOD_CAST_SIZE_FROM_RADIUS) {
len = cmd->radius;
}
else {
len = cmd->size;
}
if(len <= 0) {
for (i = 0; i < numVerts; i++) {
len += len_v3v3(center, vertexCos[i]);
}
len /= numVerts;
if (len == 0.0f) len = 10.0f;
}
/* ready to apply the effect, one vertex at a time;
* tiny optimization: the code is separated (with parts repeated)
* in two possible cases:
* with or w/o a vgroup. With lots of if's in the code below,
* further optimizations are possible, if needed */
if (dvert) { /* with a vgroup */
float fac_orig = fac;
for (i = 0; i < numVerts; i++) {
MDeformWeight *dw = NULL;
int j;
float tmp_co[3];
copy_v3_v3(tmp_co, vertexCos[i]);
if(ctrl_ob) {
if(flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(mat, tmp_co);
} else {
sub_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vec, tmp_co);
if (type == MOD_CAST_TYPE_CYLINDER)
vec[2] = 0.0f;
if (has_radius) {
if (len_v3(vec) > cmd->radius) continue;
}
for (j = 0; j < dvert[i].totweight; ++j) {
if(dvert[i].dw[j].def_nr == defgrp_index) {
dw = &dvert[i].dw[j];
break;
}
}
if (!dw) continue;
fac = fac_orig * dw->weight;
facm = 1.0f - fac;
normalize_v3(vec);
if (flag & MOD_CAST_X)
tmp_co[0] = fac*vec[0]*len + facm*tmp_co[0];
if (flag & MOD_CAST_Y)
tmp_co[1] = fac*vec[1]*len + facm*tmp_co[1];
if (flag & MOD_CAST_Z)
tmp_co[2] = fac*vec[2]*len + facm*tmp_co[2];
if(ctrl_ob) {
if(flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(imat, tmp_co);
} else {
add_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vertexCos[i], tmp_co);
}
return;
}
/* no vgroup */
for (i = 0; i < numVerts; i++) {
float tmp_co[3];
copy_v3_v3(tmp_co, vertexCos[i]);
if(ctrl_ob) {
if(flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(mat, tmp_co);
} else {
sub_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vec, tmp_co);
if (type == MOD_CAST_TYPE_CYLINDER)
vec[2] = 0.0f;
if (has_radius) {
if (len_v3(vec) > cmd->radius) continue;
}
normalize_v3(vec);
if (flag & MOD_CAST_X)
tmp_co[0] = fac*vec[0]*len + facm*tmp_co[0];
if (flag & MOD_CAST_Y)
tmp_co[1] = fac*vec[1]*len + facm*tmp_co[1];
if (flag & MOD_CAST_Z)
tmp_co[2] = fac*vec[2]*len + facm*tmp_co[2];
if(ctrl_ob) {
if(flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(imat, tmp_co);
} else {
add_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vertexCos[i], tmp_co);
}
}
/* For ease of use, I've also introduced a 'reflection' and 'reflection color' parameter, which isn't
* physically correct. This works as an RGB tint/gain on out-scattered light, but doesn't affect the light
* that is transmitted through the volume. While having wavelength dependent absorption/scattering is more correct,
* it also makes it harder to control the overall look of the volume since coloring the outscattered light results
* in the inverse color being transmitted through the rest of the volume.
*/
static void volumeintegrate(struct ShadeInput *shi, float col[4], const float co[3], const float endco[3])
{
float radiance[3] = {0.f, 0.f, 0.f};
float tr[3] = {1.f, 1.f, 1.f};
float p[3] = {co[0], co[1], co[2]};
float step_vec[3] = {endco[0] - co[0], endco[1] - co[1], endco[2] - co[2]};
const float stepsize = shi->mat->vol.stepsize;
float t0 = 0.f;
float pt0 = t0;
float t1 = normalize_v3(step_vec); /* returns vector length */
t0 += stepsize * ((shi->mat->vol.stepsize_type == MA_VOL_STEP_CONSTANT) ? 0.5f : BLI_thread_frand(shi->thread));
p[0] += t0 * step_vec[0];
p[1] += t0 * step_vec[1];
p[2] += t0 * step_vec[2];
mul_v3_fl(step_vec, stepsize);
for (; t0 < t1; pt0 = t0, t0 += stepsize) {
const float density = vol_get_density(shi, p);
if (density > 0.00001f) {
float scatter_col[3] = {0.f, 0.f, 0.f}, emit_col[3];
const float stepd = (t0 - pt0) * density;
/* transmittance component (alpha) */
vol_get_transmittance_seg(shi, tr, stepsize, co, density);
if (t0 > t1 * 0.25f) {
/* only use depth cutoff after we've traced a little way into the volume */
if (rgb_to_luma_y(tr) < shi->mat->vol.depth_cutoff) break;
}
vol_get_emission(shi, emit_col, p);
if (shi->obi->volume_precache) {
float p2[3];
p2[0] = p[0] + (step_vec[0] * 0.5f);
p2[1] = p[1] + (step_vec[1] * 0.5f);
p2[2] = p[2] + (step_vec[2] * 0.5f);
vol_get_precached_scattering(&R, shi, scatter_col, p2);
}
else
vol_get_scattering(shi, scatter_col, p, shi->view);
radiance[0] += stepd * tr[0] * (emit_col[0] + scatter_col[0]);
radiance[1] += stepd * tr[1] * (emit_col[1] + scatter_col[1]);
radiance[2] += stepd * tr[2] * (emit_col[2] + scatter_col[2]);
}
add_v3_v3(p, step_vec);
}
/* multiply original color (from behind volume) with transmittance over entire distance */
mul_v3_v3v3(col, tr, col);
add_v3_v3(col, radiance);
/* alpha <-- transmission luminance */
col[3] = 1.0f - rgb_to_luma_y(tr);
}
/**
* This method computes the Laplacian Matrix and Differential Coordinates for all vertex in the mesh.
* The Linear system is LV = d
* Where L is Laplacian Matrix, V as the vertexes in Mesh, d is the differential coordinates
* The Laplacian Matrix is computes as a
* Lij = sum(Wij) (if i == j)
* Lij = Wij (if i != j)
* Wij is weight between vertex Vi and vertex Vj, we use cotangent weight
*
* The Differential Coordinate is computes as a
* di = Vi * sum(Wij) - sum(Wij * Vj)
* Where :
* di is the Differential Coordinate i
* sum (Wij) is the sum of all weights between vertex Vi and its vertexes neighbors (Vj)
* sum (Wij * Vj) is the sum of the product between vertex neighbor Vj and weight Wij for all neighborhood.
*
* This Laplacian Matrix is described in the paper:
* Desbrun M. et.al, Implicit fairing of irregular meshes using diffusion and curvature flow, SIGGRAPH '99, pag 317-324,
* New York, USA
*
* The computation of Laplace Beltrami operator on Hybrid Triangle/Quad Meshes is described in the paper:
* Pinzon A., Romero E., Shape Inflation With an Adapted Laplacian Operator For Hybrid Quad/Triangle Meshes,
* Conference on Graphics Patterns and Images, SIBGRAPI, 2013
*
* The computation of Differential Coordinates is described in the paper:
* Sorkine, O. Laplacian Surface Editing. Proceedings of the EUROGRAPHICS/ACM SIGGRAPH Symposium on Geometry Processing,
* 2004. p. 179-188.
*/
static void initLaplacianMatrix(LaplacianSystem *sys)
{
float v1[3], v2[3], v3[3], v4[3], no[3];
float w2, w3, w4;
int i, j, fi;
bool has_4_vert;
unsigned int idv1, idv2, idv3, idv4;
for (fi = 0; fi < sys->total_faces; fi++) {
const unsigned int *vidf = sys->faces[fi];
idv1 = vidf[0];
idv2 = vidf[1];
idv3 = vidf[2];
idv4 = vidf[3];
has_4_vert = vidf[3] ? 1 : 0;
if (has_4_vert) {
normal_quad_v3(no, sys->co[idv1], sys->co[idv2], sys->co[idv3], sys->co[idv4]);
add_v3_v3(sys->no[idv4], no);
i = 4;
}
else {
normal_tri_v3(no, sys->co[idv1], sys->co[idv2], sys->co[idv3]);
i = 3;
}
add_v3_v3(sys->no[idv1], no);
add_v3_v3(sys->no[idv2], no);
add_v3_v3(sys->no[idv3], no);
for (j = 0; j < i; j++) {
idv1 = vidf[j];
idv2 = vidf[(j + 1) % i];
idv3 = vidf[(j + 2) % i];
idv4 = has_4_vert ? vidf[(j + 3) % i] : 0;
copy_v3_v3(v1, sys->co[idv1]);
copy_v3_v3(v2, sys->co[idv2]);
copy_v3_v3(v3, sys->co[idv3]);
if (has_4_vert) {
copy_v3_v3(v4, sys->co[idv4]);
}
if (has_4_vert) {
w2 = (cotan_weight(v4, v1, v2) + cotan_weight(v3, v1, v2)) / 2.0f;
w3 = (cotan_weight(v2, v3, v1) + cotan_weight(v4, v1, v3)) / 2.0f;
w4 = (cotan_weight(v2, v4, v1) + cotan_weight(v3, v4, v1)) / 2.0f;
sys->delta[idv1][0] -= v4[0] * w4;
sys->delta[idv1][1] -= v4[1] * w4;
sys->delta[idv1][2] -= v4[2] * w4;
nlRightHandSideAdd(0, idv1, -v4[0] * w4);
nlRightHandSideAdd(1, idv1, -v4[1] * w4);
nlRightHandSideAdd(2, idv1, -v4[2] * w4);
nlMatrixAdd(idv1, idv4, -w4);
}
else {
w2 = cotan_weight(v3, v1, v2);
w3 = cotan_weight(v2, v3, v1);
w4 = 0.0f;
}
sys->delta[idv1][0] += v1[0] * (w2 + w3 + w4);
sys->delta[idv1][1] += v1[1] * (w2 + w3 + w4);
sys->delta[idv1][2] += v1[2] * (w2 + w3 + w4);
sys->delta[idv1][0] -= v2[0] * w2;
sys->delta[idv1][1] -= v2[1] * w2;
sys->delta[idv1][2] -= v2[2] * w2;
sys->delta[idv1][0] -= v3[0] * w3;
sys->delta[idv1][1] -= v3[1] * w3;
sys->delta[idv1][2] -= v3[2] * w3;
nlMatrixAdd(idv1, idv2, -w2);
nlMatrixAdd(idv1, idv3, -w3);
nlMatrixAdd(idv1, idv1, w2 + w3 + w4);
}
}
}
int get_effector_data(EffectorCache *eff, EffectorData *efd, EffectedPoint *point, int real_velocity)
{
float cfra = eff->scene->r.cfra;
int ret = 0;
if (eff->pd && eff->pd->shape==PFIELD_SHAPE_SURFACE && eff->surmd) {
/* closest point in the object surface is an effector */
float vec[3];
/* using velocity corrected location allows for easier sliding over effector surface */
copy_v3_v3(vec, point->vel);
mul_v3_fl(vec, point->vel_to_frame);
add_v3_v3(vec, point->loc);
ret = closest_point_on_surface(eff->surmd, vec, efd->loc, efd->nor, real_velocity ? efd->vel : NULL);
efd->size = 0.0f;
}
else if (eff->pd && eff->pd->shape==PFIELD_SHAPE_POINTS) {
if (eff->ob->derivedFinal) {
DerivedMesh *dm = eff->ob->derivedFinal;
dm->getVertCo(dm, *efd->index, efd->loc);
dm->getVertNo(dm, *efd->index, efd->nor);
mul_m4_v3(eff->ob->obmat, efd->loc);
mul_mat3_m4_v3(eff->ob->obmat, efd->nor);
normalize_v3(efd->nor);
efd->size = 0.0f;
/**/
ret = 1;
}
}
else if (eff->psys) {
ParticleData *pa = eff->psys->particles + *efd->index;
ParticleKey state;
/* exclude the particle itself for self effecting particles */
if (eff->psys == point->psys && *efd->index == point->index) {
/* pass */
}
else {
ParticleSimulationData sim= {NULL};
sim.scene= eff->scene;
sim.ob= eff->ob;
sim.psys= eff->psys;
/* TODO: time from actual previous calculated frame (step might not be 1) */
state.time = cfra - 1.0f;
ret = psys_get_particle_state(&sim, *efd->index, &state, 0);
/* TODO */
//if (eff->pd->forcefiled == PFIELD_HARMONIC && ret==0) {
// if (pa->dietime < eff->psys->cfra)
// eff->flag |= PE_VELOCITY_TO_IMPULSE;
//}
copy_v3_v3(efd->loc, state.co);
/* rather than use the velocity use rotated x-axis (defaults to velocity) */
efd->nor[0] = 1.f;
efd->nor[1] = efd->nor[2] = 0.f;
mul_qt_v3(state.rot, efd->nor);
if (real_velocity)
copy_v3_v3(efd->vel, state.vel);
efd->size = pa->size;
}
}
else {
/* use center of object for distance calculus */
const Object *ob = eff->ob;
/* use z-axis as normal*/
normalize_v3_v3(efd->nor, ob->obmat[2]);
if (eff->pd && eff->pd->shape == PFIELD_SHAPE_PLANE) {
float temp[3], translate[3];
sub_v3_v3v3(temp, point->loc, ob->obmat[3]);
project_v3_v3v3(translate, temp, efd->nor);
/* for vortex the shape chooses between old / new force */
if (eff->pd->forcefield == PFIELD_VORTEX)
add_v3_v3v3(efd->loc, ob->obmat[3], translate);
else /* normally efd->loc is closest point on effector xy-plane */
sub_v3_v3v3(efd->loc, point->loc, translate);
}
else {
copy_v3_v3(efd->loc, ob->obmat[3]);
}
if (real_velocity)
copy_v3_v3(efd->vel, eff->velocity);
efd->size = 0.0f;
ret = 1;
}
if (ret) {
sub_v3_v3v3(efd->vec_to_point, point->loc, efd->loc);
efd->distance = len_v3(efd->vec_to_point);
/* rest length for harmonic effector, will have to see later if this could be extended to other effectors */
if (eff->pd && eff->pd->forcefield == PFIELD_HARMONIC && eff->pd->f_size)
mul_v3_fl(efd->vec_to_point, (efd->distance-eff->pd->f_size)/efd->distance);
if (eff->flag & PE_USE_NORMAL_DATA) {
copy_v3_v3(efd->vec_to_point2, efd->vec_to_point);
copy_v3_v3(efd->nor2, efd->nor);
}
else {
/* for some effectors we need the object center every time */
sub_v3_v3v3(efd->vec_to_point2, point->loc, eff->ob->obmat[3]);
normalize_v3_v3(efd->nor2, eff->ob->obmat[2]);
}
}
return ret;
}
static void rotateDifferentialCoordinates(LaplacianSystem *sys)
{
float alpha, beta, gamma;
float pj[3], ni[3], di[3];
float uij[3], dun[3], e2[3], pi[3], fni[3], vn[4][3];
int i, j, lvin, num_fni, k, fi;
int *fidn;
for (i = 0; i < sys->total_verts; i++) {
copy_v3_v3(pi, sys->co[i]);
copy_v3_v3(ni, sys->no[i]);
k = sys->unit_verts[i];
copy_v3_v3(pj, sys->co[k]);
sub_v3_v3v3(uij, pj, pi);
mul_v3_v3fl(dun, ni, dot_v3v3(uij, ni));
sub_v3_v3(uij, dun);
normalize_v3(uij);
cross_v3_v3v3(e2, ni, uij);
copy_v3_v3(di, sys->delta[i]);
alpha = dot_v3v3(ni, di);
beta = dot_v3v3(uij, di);
gamma = dot_v3v3(e2, di);
pi[0] = nlGetVariable(0, i);
pi[1] = nlGetVariable(1, i);
pi[2] = nlGetVariable(2, i);
zero_v3(ni);
num_fni = 0;
num_fni = sys->ringf_map[i].count;
for (fi = 0; fi < num_fni; fi++) {
const unsigned int *vin;
fidn = sys->ringf_map[i].indices;
vin = sys->faces[fidn[fi]];
lvin = vin[3] ? 4 : 3;
for (j = 0; j < lvin; j++) {
vn[j][0] = nlGetVariable(0, vin[j]);
vn[j][1] = nlGetVariable(1, vin[j]);
vn[j][2] = nlGetVariable(2, vin[j]);
if (vin[j] == sys->unit_verts[i]) {
copy_v3_v3(pj, vn[j]);
}
}
if (lvin == 3) {
normal_tri_v3(fni, vn[0], vn[1], vn[2]);
}
else if (lvin == 4) {
normal_quad_v3(fni, vn[0], vn[1], vn[2], vn[3]);
}
add_v3_v3(ni, fni);
}
normalize_v3(ni);
sub_v3_v3v3(uij, pj, pi);
mul_v3_v3fl(dun, ni, dot_v3v3(uij, ni));
sub_v3_v3(uij, dun);
normalize_v3(uij);
cross_v3_v3v3(e2, ni, uij);
fni[0] = alpha * ni[0] + beta * uij[0] + gamma * e2[0];
fni[1] = alpha * ni[1] + beta * uij[1] + gamma * e2[1];
fni[2] = alpha * ni[2] + beta * uij[2] + gamma * e2[2];
if (len_squared_v3(fni) > FLT_EPSILON) {
nlRightHandSideSet(0, i, fni[0]);
nlRightHandSideSet(1, i, fni[1]);
nlRightHandSideSet(2, i, fni[2]);
}
else {
nlRightHandSideSet(0, i, sys->delta[i][0]);
nlRightHandSideSet(1, i, sys->delta[i][1]);
nlRightHandSideSet(2, i, sys->delta[i][2]);
}
}
}
static void do_physical_effector(EffectorCache *eff, EffectorData *efd, EffectedPoint *point, float *total_force)
{
PartDeflect *pd = eff->pd;
RNG *rng = pd->rng;
float force[3] = {0, 0, 0};
float temp[3];
float fac;
float strength = pd->f_strength;
float damp = pd->f_damp;
float noise_factor = pd->f_noise;
if (noise_factor > 0.0f) {
strength += wind_func(rng, noise_factor);
if (ELEM(pd->forcefield, PFIELD_HARMONIC, PFIELD_DRAG))
damp += wind_func(rng, noise_factor);
}
copy_v3_v3(force, efd->vec_to_point);
switch (pd->forcefield) {
case PFIELD_WIND:
copy_v3_v3(force, efd->nor);
mul_v3_fl(force, strength * efd->falloff);
break;
case PFIELD_FORCE:
normalize_v3(force);
mul_v3_fl(force, strength * efd->falloff);
break;
case PFIELD_VORTEX:
/* old vortex force */
if (pd->shape == PFIELD_SHAPE_POINT) {
cross_v3_v3v3(force, efd->nor, efd->vec_to_point);
normalize_v3(force);
mul_v3_fl(force, strength * efd->distance * efd->falloff);
}
else {
/* new vortex force */
cross_v3_v3v3(temp, efd->nor2, efd->vec_to_point2);
mul_v3_fl(temp, strength * efd->falloff);
cross_v3_v3v3(force, efd->nor2, temp);
mul_v3_fl(force, strength * efd->falloff);
madd_v3_v3fl(temp, point->vel, -point->vel_to_sec);
add_v3_v3(force, temp);
}
break;
case PFIELD_MAGNET:
if (eff->pd->shape == PFIELD_SHAPE_POINT)
/* magnetic field of a moving charge */
cross_v3_v3v3(temp, efd->nor, efd->vec_to_point);
else
copy_v3_v3(temp, efd->nor);
normalize_v3(temp);
mul_v3_fl(temp, strength * efd->falloff);
cross_v3_v3v3(force, point->vel, temp);
mul_v3_fl(force, point->vel_to_sec);
break;
case PFIELD_HARMONIC:
mul_v3_fl(force, -strength * efd->falloff);
copy_v3_v3(temp, point->vel);
mul_v3_fl(temp, -damp * 2.0f * sqrtf(fabsf(strength)) * point->vel_to_sec);
add_v3_v3(force, temp);
break;
case PFIELD_CHARGE:
mul_v3_fl(force, point->charge * strength * efd->falloff);
break;
case PFIELD_LENNARDJ:
fac = pow((efd->size + point->size) / efd->distance, 6.0);
fac = - fac * (1.0f - fac) / efd->distance;
/* limit the repulsive term drastically to avoid huge forces */
fac = ((fac>2.0f) ? 2.0f : fac);
mul_v3_fl(force, strength * fac);
break;
case PFIELD_BOID:
/* Boid field is handled completely in boids code. */
return;
case PFIELD_TURBULENCE:
if (pd->flag & PFIELD_GLOBAL_CO) {
copy_v3_v3(temp, point->loc);
}
else {
add_v3_v3v3(temp, efd->vec_to_point2, efd->nor2);
}
force[0] = -1.0f + 2.0f * BLI_gTurbulence(pd->f_size, temp[0], temp[1], temp[2], 2, 0, 2);
force[1] = -1.0f + 2.0f * BLI_gTurbulence(pd->f_size, temp[1], temp[2], temp[0], 2, 0, 2);
force[2] = -1.0f + 2.0f * BLI_gTurbulence(pd->f_size, temp[2], temp[0], temp[1], 2, 0, 2);
mul_v3_fl(force, strength * efd->falloff);
break;
case PFIELD_DRAG:
copy_v3_v3(force, point->vel);
fac = normalize_v3(force) * point->vel_to_sec;
strength = MIN2(strength, 2.0f);
damp = MIN2(damp, 2.0f);
mul_v3_fl(force, -efd->falloff * fac * (strength * fac + damp));
break;
case PFIELD_SMOKEFLOW:
zero_v3(force);
if (pd->f_source) {
float density;
if ((density = smoke_get_velocity_at(pd->f_source, point->loc, force)) >= 0.0f) {
float influence = strength * efd->falloff;
if (pd->flag & PFIELD_SMOKE_DENSITY)
influence *= density;
mul_v3_fl(force, influence);
/* apply flow */
madd_v3_v3fl(total_force, point->vel, -pd->f_flow * influence);
}
}
break;
}
if (pd->flag & PFIELD_DO_LOCATION) {
madd_v3_v3fl(total_force, force, 1.0f/point->vel_to_sec);
if (ELEM(pd->forcefield, PFIELD_HARMONIC, PFIELD_DRAG, PFIELD_SMOKEFLOW)==0 && pd->f_flow != 0.0f) {
madd_v3_v3fl(total_force, point->vel, -pd->f_flow * efd->falloff);
}
}
if (point->ave)
zero_v3(point->ave);
if (pd->flag & PFIELD_DO_ROTATION && point->ave && point->rot) {
float xvec[3] = {1.0f, 0.0f, 0.0f};
float dave[3];
mul_qt_v3(point->rot, xvec);
cross_v3_v3v3(dave, xvec, force);
if (pd->f_flow != 0.0f) {
madd_v3_v3fl(dave, point->ave, -pd->f_flow * efd->falloff);
}
add_v3_v3(point->ave, dave);
}
}
static void laplaciansmoothModifier_do(
LaplacianSmoothModifierData *smd, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
LaplacianSystem *sys;
MDeformVert *dvert = NULL;
MDeformVert *dv = NULL;
float w, wpaint;
int i, iter;
int defgrp_index;
DM_ensure_tessface(dm);
sys = init_laplacian_system(dm->getNumEdges(dm), dm->getNumTessFaces(dm), numVerts);
if (!sys) {
return;
}
sys->mfaces = dm->getTessFaceArray(dm);
sys->medges = dm->getEdgeArray(dm);
sys->vertexCos = vertexCos;
sys->min_area = 0.00001f;
modifier_get_vgroup(ob, dm, smd->defgrp_name, &dvert, &defgrp_index);
sys->vert_centroid[0] = 0.0f;
sys->vert_centroid[1] = 0.0f;
sys->vert_centroid[2] = 0.0f;
for (iter = 0; iter < smd->repeat; iter++) {
memset_laplacian_system(sys, 0);
nlNewContext();
sys->context = nlGetCurrent();
nlSolverParameteri(NL_NB_VARIABLES, numVerts);
nlSolverParameteri(NL_LEAST_SQUARES, NL_TRUE);
nlSolverParameteri(NL_NB_ROWS, numVerts);
nlSolverParameteri(NL_NB_RIGHT_HAND_SIDES, 3);
init_laplacian_matrix(sys);
nlBegin(NL_SYSTEM);
for (i = 0; i < numVerts; i++) {
nlSetVariable(0, i, vertexCos[i][0]);
nlSetVariable(1, i, vertexCos[i][1]);
nlSetVariable(2, i, vertexCos[i][2]);
if (iter == 0) {
add_v3_v3(sys->vert_centroid, vertexCos[i]);
}
}
if (iter == 0 && numVerts > 0) {
mul_v3_fl(sys->vert_centroid, 1.0f / (float)numVerts);
}
nlBegin(NL_MATRIX);
dv = dvert;
for (i = 0; i < numVerts; i++) {
nlRightHandSideAdd(0, i, vertexCos[i][0]);
nlRightHandSideAdd(1, i, vertexCos[i][1]);
nlRightHandSideAdd(2, i, vertexCos[i][2]);
if (dv) {
wpaint = defvert_find_weight(dv, defgrp_index);
dv++;
}
else {
wpaint = 1.0f;
}
if (sys->zerola[i] == 0) {
if (smd->flag & MOD_LAPLACIANSMOOTH_NORMALIZED) {
w = sys->vweights[i];
sys->vweights[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda) * wpaint / w;
w = sys->vlengths[i];
sys->vlengths[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda_border) * wpaint * 2.0f / w;
if (sys->numNeEd[i] == sys->numNeFa[i]) {
nlMatrixAdd(i, i, 1.0f + fabsf(smd->lambda) * wpaint);
}
else {
nlMatrixAdd(i, i, 1.0f + fabsf(smd->lambda_border) * wpaint * 2.0f);
}
}
else {
w = sys->vweights[i] * sys->ring_areas[i];
sys->vweights[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda) * wpaint / (4.0f * w);
w = sys->vlengths[i];
sys->vlengths[i] = (w == 0.0f) ? 0.0f : -fabsf(smd->lambda_border) * wpaint * 2.0f / w;
if (sys->numNeEd[i] == sys->numNeFa[i]) {
nlMatrixAdd(i, i, 1.0f + fabsf(smd->lambda) * wpaint / (4.0f * sys->ring_areas[i]));
}
else {
nlMatrixAdd(i, i, 1.0f + fabsf(smd->lambda_border) * wpaint * 2.0f);
}
}
}
else {
nlMatrixAdd(i, i, 1.0f);
}
}
fill_laplacian_matrix(sys);
nlEnd(NL_MATRIX);
nlEnd(NL_SYSTEM);
if (nlSolveAdvanced(NULL, NL_TRUE)) {
validate_solution(sys, smd->flag, smd->lambda, smd->lambda_border);
}
nlDeleteContext(sys->context);
sys->context = NULL;
}
delete_laplacian_system(sys);
}
/* 0 == do center, 1 == center new, 2 == center cursor */
void ED_armature_origin_set(Scene *scene, Object *ob, float cursor[3], int centermode, int around)
{
Object *obedit = scene->obedit; // XXX get from context
EditBone *ebone;
bArmature *arm = ob->data;
float cent[3];
/* Put the armature into editmode */
if (ob != obedit) {
ED_armature_to_edit(ob);
obedit = NULL; /* we cant use this so behave as if there is no obedit */
}
/* Find the centerpoint */
if (centermode == 2) {
copy_v3_v3(cent, cursor);
invert_m4_m4(ob->imat, ob->obmat);
mul_m4_v3(ob->imat, cent);
}
else {
if (around == V3D_CENTROID) {
int total = 0;
zero_v3(cent);
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
total += 2;
add_v3_v3(cent, ebone->head);
add_v3_v3(cent, ebone->tail);
}
if (total) {
mul_v3_fl(cent, 1.0f / (float)total);
}
}
else {
float min[3], max[3];
INIT_MINMAX(min, max);
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
minmax_v3v3_v3(min, max, ebone->head);
minmax_v3v3_v3(min, max, ebone->tail);
}
mid_v3_v3v3(cent, min, max);
}
}
/* Do the adjustments */
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
sub_v3_v3(ebone->head, cent);
sub_v3_v3(ebone->tail, cent);
}
/* Turn the list into an armature */
if (obedit == NULL) {
ED_armature_from_edit(ob);
ED_armature_edit_free(ob);
}
/* Adjust object location for new centerpoint */
if (centermode && obedit == NULL) {
mul_mat3_m4_v3(ob->obmat, cent); /* ommit translation part */
add_v3_v3(ob->loc, cent);
}
}
static int flyEnd(bContext *C, FlyInfo *fly)
{
RegionView3D *rv3d = fly->rv3d;
View3D *v3d = fly->v3d;
float upvec[3];
if (fly->state == FLY_RUNNING)
return OPERATOR_RUNNING_MODAL;
#ifdef NDOF_FLY_DEBUG
puts("\n-- fly end --");
#endif
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), fly->timer);
ED_region_draw_cb_exit(fly->ar->type, fly->draw_handle_pixel);
rv3d->dist = fly->dist_backup;
if (fly->state == FLY_CANCEL) {
/* Revert to original view? */
if (fly->persp_backup == RV3D_CAMOB) { /* a camera view */
Object *ob_back;
ob_back = (fly->root_parent) ? fly->root_parent : fly->v3d->camera;
/* store the original camera loc and rot */
BKE_object_tfm_restore(ob_back, fly->obtfm);
DAG_id_tag_update(&ob_back->id, OB_RECALC_OB);
}
else {
/* Non Camera we need to reset the view back to the original location bacause the user canceled*/
copy_qt_qt(rv3d->viewquat, fly->rot_backup);
rv3d->persp = fly->persp_backup;
}
/* always, is set to zero otherwise */
copy_v3_v3(rv3d->ofs, fly->ofs_backup);
}
else if (fly->persp_backup == RV3D_CAMOB) { /* camera */
DAG_id_tag_update(fly->root_parent ? &fly->root_parent->id : &v3d->camera->id, OB_RECALC_OB);
/* always, is set to zero otherwise */
copy_v3_v3(rv3d->ofs, fly->ofs_backup);
}
else { /* not camera */
/* Apply the fly mode view */
/* restore the dist */
float mat[3][3];
upvec[0] = upvec[1] = 0;
upvec[2] = fly->dist_backup; /* x and y are 0 */
copy_m3_m4(mat, rv3d->viewinv);
mul_m3_v3(mat, upvec);
add_v3_v3(rv3d->ofs, upvec);
/* Done with correcting for the dist */
}
if (fly->is_ortho_cam) {
((Camera *)fly->v3d->camera->data)->type = CAM_ORTHO;
}
rv3d->rflag &= ~RV3D_NAVIGATING;
//XXX2.5 BIF_view3d_previewrender_signal(fly->sa, PR_DBASE|PR_DISPRECT); /* not working at the moment not sure why */
if (fly->obtfm)
MEM_freeN(fly->obtfm);
if (fly->ndof)
MEM_freeN(fly->ndof);
if (fly->state == FLY_CONFIRM) {
MEM_freeN(fly);
return OPERATOR_FINISHED;
}
MEM_freeN(fly);
return OPERATOR_CANCELLED;
}
/* Edge-Length Weighted Smoothing
*/
static void smooth_iter__length_weight(
CorrectiveSmoothModifierData *csmd, DerivedMesh *dm,
float (*vertexCos)[3], unsigned int numVerts,
const float *smooth_weights,
unsigned int iterations)
{
const float eps = FLT_EPSILON * 10.0f;
const unsigned int numEdges = (unsigned int)dm->getNumEdges(dm);
/* note: the way this smoothing method works, its approx half as strong as the simple-smooth,
* and 2.0 rarely spikes, double the value for consistent behavior. */
const float lambda = csmd->lambda * 2.0f;
const MEdge *edges = dm->getEdgeArray(dm);
float *vertex_edge_count;
unsigned int i;
struct SmoothingData_Weighted {
float delta[3];
float edge_length_sum;
} *smooth_data = MEM_callocN((size_t)numVerts * sizeof(*smooth_data), __func__);
/* calculate as floats to avoid int->float conversion in #smooth_iter */
vertex_edge_count = MEM_callocN((size_t)numVerts * sizeof(float), __func__);
for (i = 0; i < numEdges; i++) {
vertex_edge_count[edges[i].v1] += 1.0f;
vertex_edge_count[edges[i].v2] += 1.0f;
}
/* -------------------------------------------------------------------- */
/* Main Smoothing Loop */
while (iterations--) {
for (i = 0; i < numEdges; i++) {
struct SmoothingData_Weighted *sd_v1;
struct SmoothingData_Weighted *sd_v2;
float edge_dir[3];
float edge_dist;
sub_v3_v3v3(edge_dir, vertexCos[edges[i].v2], vertexCos[edges[i].v1]);
edge_dist = len_v3(edge_dir);
/* weight by distance */
mul_v3_fl(edge_dir, edge_dist);
sd_v1 = &smooth_data[edges[i].v1];
sd_v2 = &smooth_data[edges[i].v2];
add_v3_v3(sd_v1->delta, edge_dir);
sub_v3_v3(sd_v2->delta, edge_dir);
sd_v1->edge_length_sum += edge_dist;
sd_v2->edge_length_sum += edge_dist;
}
if (smooth_weights == NULL) {
/* fast-path */
for (i = 0; i < numVerts; i++) {
struct SmoothingData_Weighted *sd = &smooth_data[i];
/* divide by sum of all neighbour distances (weighted) and amount of neighbours, (mean average) */
const float div = sd->edge_length_sum * vertex_edge_count[i];
if (div > eps) {
#if 0
/* first calculate the new location */
mul_v3_fl(sd->delta, 1.0f / div);
/* then interpolate */
madd_v3_v3fl(vertexCos[i], sd->delta, lambda);
#else
/* do this in one step */
madd_v3_v3fl(vertexCos[i], sd->delta, lambda / div);
#endif
}
/* zero for the next iteration (saves memset on entire array) */
memset(sd, 0, sizeof(*sd));
}
}
else {
for (i = 0; i < numVerts; i++) {
struct SmoothingData_Weighted *sd = &smooth_data[i];
const float div = sd->edge_length_sum * vertex_edge_count[i];
if (div > eps) {
const float lambda_w = lambda * smooth_weights[i];
madd_v3_v3fl(vertexCos[i], sd->delta, lambda_w / div);
}
memset(sd, 0, sizeof(*sd));
}
}
}
MEM_freeN(vertex_edge_count);
MEM_freeN(smooth_data);
}
static int flyApply(bContext *C, FlyInfo *fly)
{
#define FLY_ROTATE_FAC 2.5f /* more is faster */
#define FLY_ZUP_CORRECT_FAC 0.1f /* amount to correct per step */
#define FLY_ZUP_CORRECT_ACCEL 0.05f /* increase upright momentum each step */
/* fly mode - Shift+F
* a fly loop where the user can move move the view as if they are flying
*/
RegionView3D *rv3d = fly->rv3d;
ARegion *ar = fly->ar;
float mat[3][3]; /* 3x3 copy of the view matrix so we can move along the view axis */
float dvec[3] = {0, 0, 0}; /* this is the direction thast added to the view offset per redraw */
/* Camera Uprighting variables */
float upvec[3] = {0, 0, 0}; /* stores the view's up vector */
float moffset[2]; /* mouse offset from the views center */
float tmp_quat[4]; /* used for rotating the view */
// int cent_orig[2], /* view center */
//XXX- can avoid using // cent[2], /* view center modified */
int xmargin, ymargin; /* x and y margin are define the safe area where the mouses movement wont rotate the view */
#ifdef NDOF_FLY_DEBUG
{
static unsigned int iteration = 1;
printf("fly timer %d\n", iteration++);
}
#endif
xmargin = ar->winx / 20.0f;
ymargin = ar->winy / 20.0f;
// UNUSED
// cent_orig[0] = ar->winrct.xmin + ar->winx / 2;
// cent_orig[1] = ar->winrct.ymin + ar->winy / 2;
{
/* mouse offset from the center */
moffset[0] = fly->mval[0] - ar->winx / 2;
moffset[1] = fly->mval[1] - ar->winy / 2;
/* enforce a view margin */
if (moffset[0] > xmargin) moffset[0] -= xmargin;
else if (moffset[0] < -xmargin) moffset[0] += xmargin;
else moffset[0] = 0;
if (moffset[1] > ymargin) moffset[1] -= ymargin;
else if (moffset[1] < -ymargin) moffset[1] += ymargin;
else moffset[1] = 0;
/* scale the mouse movement by this value - scales mouse movement to the view size
* moffset[0] / (ar->winx-xmargin * 2) - window size minus margin (same for y)
*
* the mouse moves isn't linear */
if (moffset[0]) {
moffset[0] /= ar->winx - (xmargin * 2);
moffset[0] *= fabsf(moffset[0]);
}
if (moffset[1]) {
moffset[1] /= ar->winy - (ymargin * 2);
moffset[1] *= fabsf(moffset[1]);
}
/* Should we redraw? */
if ((fly->speed != 0.0f) ||
moffset[0] || moffset[1] ||
(fly->zlock != FLY_AXISLOCK_STATE_OFF) ||
(fly->xlock != FLY_AXISLOCK_STATE_OFF) ||
dvec[0] || dvec[1] || dvec[2])
{
float dvec_tmp[3];
/* time how fast it takes for us to redraw,
* this is so simple scenes don't fly too fast */
double time_current;
float time_redraw;
float time_redraw_clamped;
#ifdef NDOF_FLY_DRAW_TOOMUCH
fly->redraw = 1;
#endif
time_current = PIL_check_seconds_timer();
time_redraw = (float)(time_current - fly->time_lastdraw);
time_redraw_clamped = min_ff(0.05f, time_redraw); /* clamp redraw time to avoid jitter in roll correction */
fly->time_lastdraw = time_current;
/* Scale the time to use shift to scale the speed down- just like
* shift slows many other areas of blender down */
if (fly->use_precision)
fly->speed = fly->speed * (1.0f - time_redraw_clamped);
copy_m3_m4(mat, rv3d->viewinv);
if (fly->pan_view == true) {
/* pan only */
dvec_tmp[0] = -moffset[0];
dvec_tmp[1] = -moffset[1];
dvec_tmp[2] = 0;
if (fly->use_precision) {
dvec_tmp[0] *= 0.1f;
dvec_tmp[1] *= 0.1f;
}
mul_m3_v3(mat, dvec_tmp);
mul_v3_fl(dvec_tmp, time_redraw * 200.0f * fly->grid);
}
else {
float roll; /* similar to the angle between the camera's up and the Z-up,
* but its very rough so just roll */
/* rotate about the X axis- look up/down */
if (moffset[1]) {
upvec[0] = 1;
upvec[1] = 0;
upvec[2] = 0;
mul_m3_v3(mat, upvec);
/* Rotate about the relative up vec */
axis_angle_to_quat(tmp_quat, upvec, (float)moffset[1] * time_redraw * -FLY_ROTATE_FAC);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
if (fly->xlock != FLY_AXISLOCK_STATE_OFF)
fly->xlock = FLY_AXISLOCK_STATE_ACTIVE; /* check for rotation */
if (fly->zlock != FLY_AXISLOCK_STATE_OFF)
fly->zlock = FLY_AXISLOCK_STATE_ACTIVE;
fly->xlock_momentum = 0.0f;
}
/* rotate about the Y axis- look left/right */
if (moffset[0]) {
/* if we're upside down invert the moffset */
upvec[0] = 0.0f;
upvec[1] = 1.0f;
upvec[2] = 0.0f;
mul_m3_v3(mat, upvec);
if (upvec[2] < 0.0f)
moffset[0] = -moffset[0];
/* make the lock vectors */
if (fly->zlock) {
upvec[0] = 0.0f;
upvec[1] = 0.0f;
upvec[2] = 1.0f;
}
else {
upvec[0] = 0.0f;
upvec[1] = 1.0f;
upvec[2] = 0.0f;
mul_m3_v3(mat, upvec);
}
/* Rotate about the relative up vec */
axis_angle_to_quat(tmp_quat, upvec, (float)moffset[0] * time_redraw * FLY_ROTATE_FAC);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
if (fly->xlock != FLY_AXISLOCK_STATE_OFF)
fly->xlock = FLY_AXISLOCK_STATE_ACTIVE; /* check for rotation */
if (fly->zlock != FLY_AXISLOCK_STATE_OFF)
fly->zlock = FLY_AXISLOCK_STATE_ACTIVE;
}
if (fly->zlock == FLY_AXISLOCK_STATE_ACTIVE) {
upvec[0] = 1.0f;
upvec[1] = 0.0f;
upvec[2] = 0.0f;
mul_m3_v3(mat, upvec);
/* make sure we have some z rolling */
if (fabsf(upvec[2]) > 0.00001f) {
roll = upvec[2] * 5.0f;
upvec[0] = 0.0f; /* rotate the view about this axis */
upvec[1] = 0.0f;
upvec[2] = 1.0f;
mul_m3_v3(mat, upvec);
/* Rotate about the relative up vec */
axis_angle_to_quat(tmp_quat, upvec,
roll * time_redraw_clamped * fly->zlock_momentum * FLY_ZUP_CORRECT_FAC);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
fly->zlock_momentum += FLY_ZUP_CORRECT_ACCEL;
}
else {
fly->zlock = FLY_AXISLOCK_STATE_IDLE; /* don't check until the view rotates again */
fly->zlock_momentum = 0.0f;
}
}
/* only apply xcorrect when mouse isn't applying x rot */
if (fly->xlock == FLY_AXISLOCK_STATE_ACTIVE && moffset[1] == 0) {
upvec[0] = 0;
upvec[1] = 0;
upvec[2] = 1;
mul_m3_v3(mat, upvec);
/* make sure we have some z rolling */
if (fabsf(upvec[2]) > 0.00001f) {
roll = upvec[2] * -5.0f;
upvec[0] = 1.0f; /* rotate the view about this axis */
upvec[1] = 0.0f;
upvec[2] = 0.0f;
mul_m3_v3(mat, upvec);
/* Rotate about the relative up vec */
axis_angle_to_quat(tmp_quat, upvec, roll * time_redraw_clamped * fly->xlock_momentum * 0.1f);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
fly->xlock_momentum += 0.05f;
}
else {
fly->xlock = FLY_AXISLOCK_STATE_IDLE; /* see above */
fly->xlock_momentum = 0.0f;
}
}
if (fly->axis == -1) {
/* pause */
zero_v3(dvec_tmp);
}
else if (!fly->use_freelook) {
/* Normal operation */
/* define dvec, view direction vector */
zero_v3(dvec_tmp);
/* move along the current axis */
dvec_tmp[fly->axis] = 1.0f;
mul_m3_v3(mat, dvec_tmp);
}
else {
normalize_v3_v3(dvec_tmp, fly->dvec_prev);
if (fly->speed < 0.0f) {
negate_v3(dvec_tmp);
}
}
mul_v3_fl(dvec_tmp, fly->speed * time_redraw * 0.25f);
}
/* impose a directional lag */
interp_v3_v3v3(dvec, dvec_tmp, fly->dvec_prev, (1.0f / (1.0f + (time_redraw * 5.0f))));
if (rv3d->persp == RV3D_CAMOB) {
Object *lock_ob = fly->root_parent ? fly->root_parent : fly->v3d->camera;
if (lock_ob->protectflag & OB_LOCK_LOCX) dvec[0] = 0.0;
if (lock_ob->protectflag & OB_LOCK_LOCY) dvec[1] = 0.0;
if (lock_ob->protectflag & OB_LOCK_LOCZ) dvec[2] = 0.0;
}
add_v3_v3(rv3d->ofs, dvec);
if (rv3d->persp == RV3D_CAMOB) {
const bool do_rotate = ((fly->xlock != FLY_AXISLOCK_STATE_OFF) ||
(fly->zlock != FLY_AXISLOCK_STATE_OFF) ||
((moffset[0] || moffset[1]) && !fly->pan_view));
const bool do_translate = (fly->speed != 0.0f || fly->pan_view);
flyMoveCamera(C, rv3d, fly, do_rotate, do_translate);
}
}
else {
/* we're not redrawing but we need to update the time else the view will jump */
fly->time_lastdraw = PIL_check_seconds_timer();
}
/* end drawing */
copy_v3_v3(fly->dvec_prev, dvec);
}
return OPERATOR_FINISHED;
}
static void sphere_do(
CastModifierData *cmd, Object *ob, DerivedMesh *dm,
float (*vertexCos)[3], int numVerts)
{
MDeformVert *dvert = NULL;
Object *ctrl_ob = NULL;
int i, defgrp_index;
bool has_radius = false;
short flag, type;
float len = 0.0f;
float fac = cmd->fac;
float facm = 1.0f - fac;
const float fac_orig = fac;
float vec[3], center[3] = {0.0f, 0.0f, 0.0f};
float mat[4][4], imat[4][4];
flag = cmd->flag;
type = cmd->type; /* projection type: sphere or cylinder */
if (type == MOD_CAST_TYPE_CYLINDER)
flag &= ~MOD_CAST_Z;
ctrl_ob = cmd->object;
/* spherify's center is {0, 0, 0} (the ob's own center in its local
* space), by default, but if the user defined a control object,
* we use its location, transformed to ob's local space */
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
invert_m4_m4(imat, ctrl_ob->obmat);
mul_m4_m4m4(mat, imat, ob->obmat);
invert_m4_m4(imat, mat);
}
invert_m4_m4(ob->imat, ob->obmat);
mul_v3_m4v3(center, ob->imat, ctrl_ob->obmat[3]);
}
/* now we check which options the user wants */
/* 1) (flag was checked in the "if (ctrl_ob)" block above) */
/* 2) cmd->radius > 0.0f: only the vertices within this radius from
* the center of the effect should be deformed */
if (cmd->radius > FLT_EPSILON) has_radius = 1;
/* 3) if we were given a vertex group name,
* only those vertices should be affected */
modifier_get_vgroup(ob, dm, cmd->defgrp_name, &dvert, &defgrp_index);
if (flag & MOD_CAST_SIZE_FROM_RADIUS) {
len = cmd->radius;
}
else {
len = cmd->size;
}
if (len <= 0) {
for (i = 0; i < numVerts; i++) {
len += len_v3v3(center, vertexCos[i]);
}
len /= numVerts;
if (len == 0.0f) len = 10.0f;
}
for (i = 0; i < numVerts; i++) {
float tmp_co[3];
copy_v3_v3(tmp_co, vertexCos[i]);
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(mat, tmp_co);
}
else {
sub_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vec, tmp_co);
if (type == MOD_CAST_TYPE_CYLINDER)
vec[2] = 0.0f;
if (has_radius) {
if (len_v3(vec) > cmd->radius) continue;
}
if (dvert) {
const float weight = defvert_find_weight(&dvert[i], defgrp_index);
if (weight == 0.0f) {
continue;
}
fac = fac_orig * weight;
facm = 1.0f - fac;
}
normalize_v3(vec);
if (flag & MOD_CAST_X)
tmp_co[0] = fac * vec[0] * len + facm * tmp_co[0];
if (flag & MOD_CAST_Y)
tmp_co[1] = fac * vec[1] * len + facm * tmp_co[1];
if (flag & MOD_CAST_Z)
tmp_co[2] = fac * vec[2] * len + facm * tmp_co[2];
if (ctrl_ob) {
if (flag & MOD_CAST_USE_OB_TRANSFORM) {
mul_m4_v3(imat, tmp_co);
}
else {
add_v3_v3(tmp_co, center);
}
}
copy_v3_v3(vertexCos[i], tmp_co);
}
}
static void walkEvent(bContext *C, wmOperator *op, WalkInfo *walk, const wmEvent *event)
{
if (event->type == TIMER && event->customdata == walk->timer) {
walk->redraw = true;
}
else if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
#ifdef USE_TABLET_SUPPORT
if (walk->is_cursor_first) {
/* wait until we get the 'warp' event */
if ((walk->center_mval[0] == event->mval[0]) &&
(walk->center_mval[1] == event->mval[1]))
{
walk->is_cursor_first = false;
}
else {
/* note, its possible the system isn't giving us the warp event
* ideally we shouldn't have to worry about this, see: T45361 */
wmWindow *win = CTX_wm_window(C);
WM_cursor_warp(win,
walk->ar->winrct.xmin + walk->center_mval[0],
walk->ar->winrct.ymin + walk->center_mval[1]);
}
return;
}
if ((walk->is_cursor_absolute == false) && WM_event_is_absolute(event)) {
walk->is_cursor_absolute = true;
copy_v2_v2_int(walk->prev_mval, event->mval);
copy_v2_v2_int(walk->center_mval, event->mval);
/* without this we can't turn 180d */
CLAMP_MIN(walk->mouse_speed, 4.0f);
}
#endif /* USE_TABLET_SUPPORT */
walk->moffset[0] += event->mval[0] - walk->prev_mval[0];
walk->moffset[1] += event->mval[1] - walk->prev_mval[1];
copy_v2_v2_int(walk->prev_mval, event->mval);
if ((walk->center_mval[0] != event->mval[0]) ||
(walk->center_mval[1] != event->mval[1]))
{
walk->redraw = true;
#ifdef USE_TABLET_SUPPORT
if (walk->is_cursor_absolute) {
/* pass */
}
else
#endif
if (wm_event_is_last_mousemove(event)) {
wmWindow *win = CTX_wm_window(C);
#ifdef __APPLE__
if ((abs(walk->prev_mval[0] - walk->center_mval[0]) > walk->center_mval[0] / 2) ||
(abs(walk->prev_mval[1] - walk->center_mval[1]) > walk->center_mval[1] / 2))
#endif
{
WM_cursor_warp(win,
walk->ar->winrct.xmin + walk->center_mval[0],
walk->ar->winrct.ymin + walk->center_mval[1]);
copy_v2_v2_int(walk->prev_mval, walk->center_mval);
}
}
}
}
else if (event->type == NDOF_MOTION) {
/* do these automagically get delivered? yes. */
// puts("ndof motion detected in walk mode!");
// static const char *tag_name = "3D mouse position";
const wmNDOFMotionData *incoming_ndof = event->customdata;
switch (incoming_ndof->progress) {
case P_STARTING:
/* start keeping track of 3D mouse position */
#ifdef NDOF_WALK_DEBUG
puts("start keeping track of 3D mouse position");
#endif
/* fall-through */
case P_IN_PROGRESS:
/* update 3D mouse position */
#ifdef NDOF_WALK_DEBUG
putchar('.'); fflush(stdout);
#endif
if (walk->ndof == NULL) {
// walk->ndof = MEM_mallocN(sizeof(wmNDOFMotionData), tag_name);
walk->ndof = MEM_dupallocN(incoming_ndof);
// walk->ndof = malloc(sizeof(wmNDOFMotionData));
}
else {
memcpy(walk->ndof, incoming_ndof, sizeof(wmNDOFMotionData));
}
break;
case P_FINISHING:
/* stop keeping track of 3D mouse position */
#ifdef NDOF_WALK_DEBUG
puts("stop keeping track of 3D mouse position");
#endif
if (walk->ndof) {
MEM_freeN(walk->ndof);
// free(walk->ndof);
walk->ndof = NULL;
}
/* update the time else the view will jump when 2D mouse/timer resume */
walk->time_lastdraw = PIL_check_seconds_timer();
break;
default:
break; /* should always be one of the above 3 */
}
}
/* handle modal keymap first */
else if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case WALK_MODAL_CANCEL:
walk->state = WALK_CANCEL;
break;
case WALK_MODAL_CONFIRM:
walk->state = WALK_CONFIRM;
break;
case WALK_MODAL_ACCELERATE:
base_speed *= 1.0f + (walk->is_slow ? 0.01f : 0.1f);
break;
case WALK_MODAL_DECELERATE:
base_speed /= 1.0f + (walk->is_slow ? 0.01f : 0.1f);
break;
/* implement WASD keys */
case WALK_MODAL_DIR_FORWARD:
walk->active_directions |= WALK_BIT_FORWARD;
break;
case WALK_MODAL_DIR_BACKWARD:
walk->active_directions |= WALK_BIT_BACKWARD;
break;
case WALK_MODAL_DIR_LEFT:
walk->active_directions |= WALK_BIT_LEFT;
break;
case WALK_MODAL_DIR_RIGHT:
walk->active_directions |= WALK_BIT_RIGHT;
break;
case WALK_MODAL_DIR_UP:
walk->active_directions |= WALK_BIT_UP;
break;
case WALK_MODAL_DIR_DOWN:
walk->active_directions |= WALK_BIT_DOWN;
break;
case WALK_MODAL_DIR_FORWARD_STOP:
walk->active_directions &= ~WALK_BIT_FORWARD;
break;
case WALK_MODAL_DIR_BACKWARD_STOP:
walk->active_directions &= ~WALK_BIT_BACKWARD;
break;
case WALK_MODAL_DIR_LEFT_STOP:
walk->active_directions &= ~WALK_BIT_LEFT;
break;
case WALK_MODAL_DIR_RIGHT_STOP:
walk->active_directions &= ~WALK_BIT_RIGHT;
break;
case WALK_MODAL_DIR_UP_STOP:
walk->active_directions &= ~WALK_BIT_UP;
break;
case WALK_MODAL_DIR_DOWN_STOP:
walk->active_directions &= ~WALK_BIT_DOWN;
break;
case WALK_MODAL_FAST_ENABLE:
walk->is_fast = true;
break;
case WALK_MODAL_FAST_DISABLE:
walk->is_fast = false;
break;
case WALK_MODAL_SLOW_ENABLE:
walk->is_slow = true;
break;
case WALK_MODAL_SLOW_DISABLE:
walk->is_slow = false;
break;
#define JUMP_SPEED_MIN 1.0f
#define JUMP_TIME_MAX 0.2f /* s */
#define JUMP_SPEED_MAX sqrtf(2.0f * walk->gravity * walk->jump_height)
case WALK_MODAL_JUMP_STOP:
if (walk->gravity_state == WALK_GRAVITY_STATE_JUMP) {
float t;
/* delta time */
t = (float)(PIL_check_seconds_timer() - walk->teleport.initial_time);
/* reduce the veolocity, if JUMP wasn't hold for long enough */
t = min_ff(t, JUMP_TIME_MAX);
walk->speed_jump = JUMP_SPEED_MIN + t * (JUMP_SPEED_MAX - JUMP_SPEED_MIN) / JUMP_TIME_MAX;
/* when jumping, duration is how long it takes before we start going down */
walk->teleport.duration = getVelocityZeroTime(walk->gravity, walk->speed_jump);
/* no more increase of jump speed */
walk->gravity_state = WALK_GRAVITY_STATE_ON;
}
break;
case WALK_MODAL_JUMP:
if ((walk->navigation_mode == WALK_MODE_GRAVITY) &&
(walk->gravity_state == WALK_GRAVITY_STATE_OFF) &&
(walk->teleport.state == WALK_TELEPORT_STATE_OFF))
{
/* no need to check for ground,
* walk->gravity wouldn't be off
* if we were over a hole */
walk->gravity_state = WALK_GRAVITY_STATE_JUMP;
walk->speed_jump = JUMP_SPEED_MAX;
walk->teleport.initial_time = PIL_check_seconds_timer();
copy_v3_v3(walk->teleport.origin, walk->rv3d->viewinv[3]);
/* using previous vec because WASD keys are not called when SPACE is */
copy_v2_v2(walk->teleport.direction, walk->dvec_prev);
/* when jumping, duration is how long it takes before we start going down */
walk->teleport.duration = getVelocityZeroTime(walk->gravity, walk->speed_jump);
}
break;
case WALK_MODAL_TELEPORT:
{
float loc[3], nor[3];
float distance;
bool ret = walk_ray_cast(C, walk->rv3d, walk, loc, nor, &distance);
/* in case we are teleporting middle way from a jump */
walk->speed_jump = 0.0f;
if (ret) {
WalkTeleport *teleport = &walk->teleport;
teleport->state = WALK_TELEPORT_STATE_ON;
teleport->initial_time = PIL_check_seconds_timer();
teleport->duration = U.walk_navigation.teleport_time;
teleport->navigation_mode = walk->navigation_mode;
walk_navigation_mode_set(C, op, walk, WALK_MODE_FREE);
copy_v3_v3(teleport->origin, walk->rv3d->viewinv[3]);
/* stop the camera from a distance (camera height) */
normalize_v3(nor);
mul_v3_fl(nor, walk->view_height);
add_v3_v3(loc, nor);
sub_v3_v3v3(teleport->direction, loc, teleport->origin);
}
else {
walk->teleport.state = WALK_TELEPORT_STATE_OFF;
}
break;
}
#undef JUMP_SPEED_MAX
#undef JUMP_TIME_MAX
#undef JUMP_SPEED_MIN
case WALK_MODAL_TOGGLE:
if (walk->navigation_mode == WALK_MODE_GRAVITY) {
walk_navigation_mode_set(C, op, walk, WALK_MODE_FREE);
}
else { /* WALK_MODE_FREE */
walk_navigation_mode_set(C, op, walk, WALK_MODE_GRAVITY);
}
break;
}
}
}
/* calculates offset for co, based on fractal, sphere or smooth settings */
static void alter_co(BMVert *v, BMEdge *UNUSED(origed), const SubDParams *params, float perc,
BMVert *vsta, BMVert *vend)
{
float tvec[3], prev_co[3], fac;
float *co = BM_ELEM_CD_GET_VOID_P(v, params->shape_info.cd_vert_shape_offset_tmp);
int i;
BM_vert_normal_update_all(v);
copy_v3_v3(co, v->co);
copy_v3_v3(prev_co, co);
if (UNLIKELY(params->use_sphere)) { /* subdivide sphere */
normalize_v3(co);
mul_v3_fl(co, params->smooth);
}
else if (params->use_smooth) {
/* we calculate an offset vector vec1[], to be added to *co */
float len, nor[3], nor1[3], nor2[3], val;
sub_v3_v3v3(nor, vsta->co, vend->co);
len = 0.5f * normalize_v3(nor);
copy_v3_v3(nor1, vsta->no);
copy_v3_v3(nor2, vend->no);
/* cosine angle */
fac = dot_v3v3(nor, nor1);
mul_v3_v3fl(tvec, nor1, fac);
/* cosine angle */
fac = -dot_v3v3(nor, nor2);
madd_v3_v3fl(tvec, nor2, fac);
/* falloff for multi subdivide */
val = fabsf(1.0f - 2.0f * fabsf(0.5f - perc));
val = bmesh_subd_falloff_calc(params->smooth_falloff, val);
if (params->use_smooth_even) {
val *= BM_vert_calc_shell_factor(v);
}
mul_v3_fl(tvec, params->smooth * val * len);
add_v3_v3(co, tvec);
}
if (params->use_fractal) {
const float len = len_v3v3(vsta->co, vend->co);
float normal[3], co2[3], base1[3], base2[3];
fac = params->fractal * len;
mid_v3_v3v3(normal, vsta->no, vend->no);
ortho_basis_v3v3_v3(base1, base2, normal);
add_v3_v3v3(co2, v->co, params->fractal_ofs);
mul_v3_fl(co2, 10.0f);
tvec[0] = fac * (BLI_gTurbulence(1.0, co2[0], co2[1], co2[2], 15, 0, 2) - 0.5f);
tvec[1] = fac * (BLI_gTurbulence(1.0, co2[1], co2[0], co2[2], 15, 0, 2) - 0.5f);
tvec[2] = fac * (BLI_gTurbulence(1.0, co2[1], co2[2], co2[0], 15, 0, 2) - 0.5f);
/* add displacement */
madd_v3_v3fl(co, normal, tvec[0]);
madd_v3_v3fl(co, base1, tvec[1] * (1.0f - params->along_normal));
madd_v3_v3fl(co, base2, tvec[2] * (1.0f - params->along_normal));
}
/* apply the new difference to the rest of the shape keys,
* note that this doesn't take rotations into account, we _could_ support
* this by getting the normals and coords for each shape key and
* re-calculate the smooth value for each but this is quite involved.
* for now its ok to simply apply the difference IMHO - campbell */
sub_v3_v3v3(tvec, prev_co, co);
if (params->shape_info.totlayer > 1) {
/* skip the last layer since its the temp */
i = params->shape_info.totlayer - 1;
co = BM_ELEM_CD_GET_VOID_P(v, params->shape_info.cd_vert_shape_offset);
while (i--) {
BLI_assert(co != BM_ELEM_CD_GET_VOID_P(v, params->shape_info.cd_vert_shape_offset_tmp));
sub_v3_v3(co += 3, tvec);
}
}
}
static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
{
#define WALK_ROTATE_FAC 2.2f /* more is faster */
#define WALK_TOP_LIMIT DEG2RADF(85.0f)
#define WALK_BOTTOM_LIMIT DEG2RADF(-80.0f)
#define WALK_MOVE_SPEED base_speed
#define WALK_BOOST_FACTOR ((void)0, walk->speed_factor)
/* walk mode - Ctrl+Shift+F
* a walk loop where the user can move move the view as if they are in a walk game
*/
RegionView3D *rv3d = walk->rv3d;
ARegion *ar = walk->ar;
float mat[3][3]; /* 3x3 copy of the view matrix so we can move along the view axis */
float dvec[3] = {0.0f, 0.0f, 0.0f}; /* this is the direction that's added to the view offset per redraw */
/* Camera Uprighting variables */
float upvec[3] = {0.0f, 0.0f, 0.0f}; /* stores the view's up vector */
int moffset[2]; /* mouse offset from the views center */
float tmp_quat[4]; /* used for rotating the view */
#ifdef NDOF_WALK_DEBUG
{
static unsigned int iteration = 1;
printf("walk timer %d\n", iteration++);
}
#endif
{
/* mouse offset from the center */
copy_v2_v2_int(moffset, walk->moffset);
/* apply moffset so we can re-accumulate */
walk->moffset[0] = 0;
walk->moffset[1] = 0;
/* revert mouse */
if (walk->is_reversed) {
moffset[1] = -moffset[1];
}
/* Should we redraw? */
if ((walk->active_directions) ||
moffset[0] || moffset[1] ||
walk->teleport.state == WALK_TELEPORT_STATE_ON ||
walk->gravity_state != WALK_GRAVITY_STATE_OFF)
{
float dvec_tmp[3];
/* time how fast it takes for us to redraw,
* this is so simple scenes don't walk too fast */
double time_current;
float time_redraw;
#ifdef NDOF_WALK_DRAW_TOOMUCH
walk->redraw = 1;
#endif
time_current = PIL_check_seconds_timer();
time_redraw = (float)(time_current - walk->time_lastdraw);
walk->time_lastdraw = time_current;
/* base speed in m/s */
walk->speed = WALK_MOVE_SPEED;
if (walk->is_fast) {
walk->speed *= WALK_BOOST_FACTOR;
}
else if (walk->is_slow) {
walk->speed *= 1.0f / WALK_BOOST_FACTOR;
}
copy_m3_m4(mat, rv3d->viewinv);
{
/* rotate about the X axis- look up/down */
if (moffset[1]) {
float angle;
float y;
/* relative offset */
y = (float) moffset[1] / ar->winy;
/* speed factor */
y *= WALK_ROTATE_FAC;
/* user adjustement factor */
y *= walk->mouse_speed;
/* clamp the angle limits */
/* it ranges from 90.0f to -90.0f */
angle = -asinf(rv3d->viewmat[2][2]);
if (angle > WALK_TOP_LIMIT && y > 0.0f)
y = 0.0f;
else if (angle < WALK_BOTTOM_LIMIT && y < 0.0f)
y = 0.0f;
copy_v3_fl3(upvec, 1.0f, 0.0f, 0.0f);
mul_m3_v3(mat, upvec);
/* Rotate about the relative up vec */
axis_angle_to_quat(tmp_quat, upvec, -y);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
}
/* rotate about the Y axis- look left/right */
if (moffset[0]) {
float x;
/* if we're upside down invert the moffset */
copy_v3_fl3(upvec, 0.0f, 1.0f, 0.0f);
mul_m3_v3(mat, upvec);
if (upvec[2] < 0.0f)
moffset[0] = -moffset[0];
/* relative offset */
x = (float) moffset[0] / ar->winx;
/* speed factor */
x *= WALK_ROTATE_FAC;
/* user adjustement factor */
x *= walk->mouse_speed;
copy_v3_fl3(upvec, 0.0f, 0.0f, 1.0f);
/* Rotate about the relative up vec */
axis_angle_normalized_to_quat(tmp_quat, upvec, x);
mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
}
}
/* WASD - 'move' translation code */
if ((walk->active_directions) &&
(walk->gravity_state == WALK_GRAVITY_STATE_OFF))
{
short direction;
zero_v3(dvec);
if ((walk->active_directions & WALK_BIT_FORWARD) ||
(walk->active_directions & WALK_BIT_BACKWARD))
{
direction = 0;
if ((walk->active_directions & WALK_BIT_FORWARD))
direction += 1;
if ((walk->active_directions & WALK_BIT_BACKWARD))
direction -= 1;
copy_v3_fl3(dvec_tmp, 0.0f, 0.0f, direction);
mul_m3_v3(mat, dvec_tmp);
if (walk->navigation_mode == WALK_MODE_GRAVITY) {
dvec_tmp[2] = 0.0f;
}
normalize_v3(dvec_tmp);
add_v3_v3(dvec, dvec_tmp);
}
if ((walk->active_directions & WALK_BIT_LEFT) ||
(walk->active_directions & WALK_BIT_RIGHT))
{
direction = 0;
if ((walk->active_directions & WALK_BIT_LEFT))
direction += 1;
if ((walk->active_directions & WALK_BIT_RIGHT))
direction -= 1;
dvec_tmp[0] = direction * rv3d->viewinv[0][0];
dvec_tmp[1] = direction * rv3d->viewinv[0][1];
dvec_tmp[2] = 0.0f;
normalize_v3(dvec_tmp);
add_v3_v3(dvec, dvec_tmp);
}
if ((walk->active_directions & WALK_BIT_UP) ||
(walk->active_directions & WALK_BIT_DOWN))
{
if (walk->navigation_mode == WALK_MODE_FREE) {
direction = 0;
if ((walk->active_directions & WALK_BIT_UP))
direction -= 1;
if ((walk->active_directions & WALK_BIT_DOWN))
direction = 1;
copy_v3_fl3(dvec_tmp, 0.0f, 0.0f, direction);
add_v3_v3(dvec, dvec_tmp);
}
}
/* apply movement */
mul_v3_fl(dvec, walk->speed * time_redraw);
}
/* stick to the floor */
if (walk->navigation_mode == WALK_MODE_GRAVITY &&
ELEM(walk->gravity_state,
WALK_GRAVITY_STATE_OFF,
WALK_GRAVITY_STATE_START))
{
bool ret;
float ray_distance;
float difference = -100.0f;
float fall_distance;
ret = walk_floor_distance_get(C, rv3d, walk, dvec, &ray_distance);
if (ret) {
difference = walk->view_height - ray_distance;
}
/* the distance we would fall naturally smoothly enough that we
* can manually drop the object without activating gravity */
fall_distance = time_redraw * walk->speed * WALK_BOOST_FACTOR;
if (fabsf(difference) < fall_distance) {
/* slope/stairs */
dvec[2] -= difference;
/* in case we switched from FREE to GRAVITY too close to the ground */
if (walk->gravity_state == WALK_GRAVITY_STATE_START)
walk->gravity_state = WALK_GRAVITY_STATE_OFF;
}
else {
/* hijack the teleport variables */
walk->teleport.initial_time = PIL_check_seconds_timer();
walk->gravity_state = WALK_GRAVITY_STATE_ON;
walk->teleport.duration = 0.0f;
copy_v3_v3(walk->teleport.origin, walk->rv3d->viewinv[3]);
copy_v2_v2(walk->teleport.direction, dvec);
}
}
/* Falling or jumping) */
if (ELEM(walk->gravity_state, WALK_GRAVITY_STATE_ON, WALK_GRAVITY_STATE_JUMP)) {
float t;
float z_cur, z_new;
bool ret;
float ray_distance, difference = -100.0f;
/* delta time */
t = (float)(PIL_check_seconds_timer() - walk->teleport.initial_time);
/* keep moving if we were moving */
copy_v2_v2(dvec, walk->teleport.direction);
z_cur = walk->rv3d->viewinv[3][2];
z_new = walk->teleport.origin[2] - getFreeFallDistance(walk->gravity, t) * walk->grid;
/* jump */
z_new += t * walk->speed_jump * walk->grid;
/* duration is the jump duration */
if (t > walk->teleport.duration) {
/* check to see if we are landing */
ret = walk_floor_distance_get(C, rv3d, walk, dvec, &ray_distance);
if (ret) {
difference = walk->view_height - ray_distance;
}
if (difference > 0.0f) {
/* quit falling, lands at "view_height" from the floor */
dvec[2] -= difference;
walk->gravity_state = WALK_GRAVITY_STATE_OFF;
walk->speed_jump = 0.0f;
}
else {
/* keep falling */
dvec[2] = z_cur - z_new;
}
}
else {
/* keep going up (jump) */
dvec[2] = z_cur - z_new;
}
}
/* Teleport */
else if (walk->teleport.state == WALK_TELEPORT_STATE_ON) {
float t; /* factor */
float new_loc[3];
float cur_loc[3];
/* linear interpolation */
t = (float)(PIL_check_seconds_timer() - walk->teleport.initial_time);
t /= walk->teleport.duration;
/* clamp so we don't go past our limit */
if (t >= 1.0f) {
t = 1.0f;
walk->teleport.state = WALK_TELEPORT_STATE_OFF;
walk_navigation_mode_set(C, op, walk, walk->teleport.navigation_mode);
}
mul_v3_v3fl(new_loc, walk->teleport.direction, t);
add_v3_v3(new_loc, walk->teleport.origin);
copy_v3_v3(cur_loc, walk->rv3d->viewinv[3]);
sub_v3_v3v3(dvec, cur_loc, new_loc);
}
if (rv3d->persp == RV3D_CAMOB) {
Object *lock_ob = ED_view3d_cameracontrol_object_get(walk->v3d_camera_control);
if (lock_ob->protectflag & OB_LOCK_LOCX) dvec[0] = 0.0f;
if (lock_ob->protectflag & OB_LOCK_LOCY) dvec[1] = 0.0f;
if (lock_ob->protectflag & OB_LOCK_LOCZ) dvec[2] = 0.0f;
}
/* scale the movement to the scene size */
mul_v3_v3fl(dvec_tmp, dvec, walk->grid);
add_v3_v3(rv3d->ofs, dvec_tmp);
if (rv3d->persp == RV3D_CAMOB) {
const bool do_rotate = (moffset[0] || moffset[1]);
const bool do_translate = (walk->speed != 0.0f);
walkMoveCamera(C, walk, do_rotate, do_translate);
}
}
else {
/* we're not redrawing but we need to update the time else the view will jump */
walk->time_lastdraw = PIL_check_seconds_timer();
}
/* end drawing */
copy_v3_v3(walk->dvec_prev, dvec);
}
return OPERATOR_FINISHED;
#undef WALK_ROTATE_FAC
#undef WALK_ZUP_CORRECT_FAC
#undef WALK_ZUP_CORRECT_ACCEL
#undef WALK_SMOOTH_FAC
#undef WALK_TOP_LIMIT
#undef WALK_BOTTOM_LIMIT
#undef WALK_MOVE_SPEED
#undef WALK_BOOST_FACTOR
}
static DerivedMesh * explodeMesh(ExplodeModifierData *emd,
ParticleSystemModifierData *psmd, Scene *scene, Object *ob,
DerivedMesh *to_explode)
{
DerivedMesh *explode, *dm=to_explode;
MFace *mf= NULL, *mface;
/* ParticleSettings *part=psmd->psys->part; */ /* UNUSED */
ParticleSimulationData sim= {NULL};
ParticleData *pa=NULL, *pars=psmd->psys->particles;
ParticleKey state, birth;
EdgeHash *vertpahash;
EdgeHashIterator *ehi;
float *vertco= NULL, imat[4][4];
float rot[4];
float cfra;
/* float timestep; */
int *facepa=emd->facepa;
int totdup=0,totvert=0,totface=0,totpart=0;
int i, j, v, mindex=0;
MTFace *mtface = NULL, *mtf;
totface= dm->getNumFaces(dm);
totvert= dm->getNumVerts(dm);
mface= dm->getFaceArray(dm);
totpart= psmd->psys->totpart;
sim.scene= scene;
sim.ob= ob;
sim.psys= psmd->psys;
sim.psmd= psmd;
/* timestep= psys_get_timestep(&sim); */
//if(part->flag & PART_GLOB_TIME)
cfra= BKE_curframe(scene);
//else
// cfra=bsystem_time(scene, ob,(float)scene->r.cfra,0.0);
/* hash table for vertice <-> particle relations */
vertpahash= BLI_edgehash_new();
for (i=0; i<totface; i++) {
/* do mindex + totvert to ensure the vertex index to be the first
* with BLI_edgehashIterator_getKey */
if(facepa[i]==totpart || cfra < (pars+facepa[i])->time)
mindex = totvert+totpart;
else
mindex = totvert+facepa[i];
mf= &mface[i];
/* set face vertices to exist in particle group */
BLI_edgehash_insert(vertpahash, mf->v1, mindex, NULL);
BLI_edgehash_insert(vertpahash, mf->v2, mindex, NULL);
BLI_edgehash_insert(vertpahash, mf->v3, mindex, NULL);
if(mf->v4)
BLI_edgehash_insert(vertpahash, mf->v4, mindex, NULL);
}
/* make new vertice indexes & count total vertices after duplication */
ehi= BLI_edgehashIterator_new(vertpahash);
for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(totdup));
totdup++;
}
BLI_edgehashIterator_free(ehi);
/* the final duplicated vertices */
explode= CDDM_from_template(dm, totdup, 0,totface);
mtface = CustomData_get_layer_named(&explode->faceData, CD_MTFACE, emd->uvname);
/*dupvert= CDDM_get_verts(explode);*/
/* getting back to object space */
invert_m4_m4(imat,ob->obmat);
psmd->psys->lattice = psys_get_lattice(&sim);
/* duplicate & displace vertices */
ehi= BLI_edgehashIterator_new(vertpahash);
for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
MVert source;
MVert *dest;
/* get particle + vertex from hash */
BLI_edgehashIterator_getKey(ehi, &j, &i);
i -= totvert;
v= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
dm->getVert(dm, j, &source);
dest = CDDM_get_vert(explode,v);
DM_copy_vert_data(dm,explode,j,v,1);
*dest = source;
if(i!=totpart) {
/* get particle */
pa= pars+i;
psys_get_birth_coordinates(&sim, pa, &birth, 0, 0);
state.time=cfra;
psys_get_particle_state(&sim, i, &state, 1);
vertco=CDDM_get_vert(explode,v)->co;
mul_m4_v3(ob->obmat,vertco);
sub_v3_v3(vertco, birth.co);
/* apply rotation, size & location */
sub_qt_qtqt(rot, state.rot, birth.rot);
mul_qt_v3(rot, vertco);
if(emd->flag & eExplodeFlag_PaSize)
mul_v3_fl(vertco,pa->size);
add_v3_v3(vertco, state.co);
mul_m4_v3(imat, vertco);
}
}
BLI_edgehashIterator_free(ehi);
/*map new vertices to faces*/
for (i=0; i<totface; i++) {
MFace source;
int orig_v4;
if(facepa[i]!=totpart)
{
pa=pars+facepa[i];
if(pa->alive==PARS_UNBORN && (emd->flag&eExplodeFlag_Unborn)==0) continue;
if(pa->alive==PARS_ALIVE && (emd->flag&eExplodeFlag_Alive)==0) continue;
if(pa->alive==PARS_DEAD && (emd->flag&eExplodeFlag_Dead)==0) continue;
}
dm->getFace(dm,i,&source);
mf=CDDM_get_face(explode,i);
orig_v4 = source.v4;
if(facepa[i]!=totpart && cfra < pa->time)
mindex = totvert+totpart;
else
mindex = totvert+facepa[i];
source.v1 = edgecut_get(vertpahash, source.v1, mindex);
source.v2 = edgecut_get(vertpahash, source.v2, mindex);
source.v3 = edgecut_get(vertpahash, source.v3, mindex);
if(source.v4)
source.v4 = edgecut_get(vertpahash, source.v4, mindex);
DM_copy_face_data(dm,explode,i,i,1);
*mf = source;
/* override uv channel for particle age */
if(mtface) {
float age = (cfra - pa->time)/pa->lifetime;
/* Clamp to this range to avoid flipping to the other side of the coordinates. */
CLAMP(age, 0.001f, 0.999f);
mtf = mtface + i;
mtf->uv[0][0] = mtf->uv[1][0] = mtf->uv[2][0] = mtf->uv[3][0] = age;
mtf->uv[0][1] = mtf->uv[1][1] = mtf->uv[2][1] = mtf->uv[3][1] = 0.5f;
}
test_index_face(mf, &explode->faceData, i, (orig_v4 ? 4 : 3));
}
/* cleanup */
BLI_edgehash_free(vertpahash, NULL);
/* finalization */
CDDM_calc_edges(explode);
CDDM_calc_normals(explode);
if(psmd->psys->lattice){
end_latt_deform(psmd->psys->lattice);
psmd->psys->lattice= NULL;
}
return explode;
}
static void setNearestAxis3d(TransInfo *t)
{
float zfac;
float mvec[3], axis[3], proj[3];
float len[3];
int i, icoord[2];
/* calculate mouse movement */
mvec[0] = (float)(t->mval[0] - t->con.imval[0]);
mvec[1] = (float)(t->mval[1] - t->con.imval[1]);
mvec[2] = 0.0f;
/* we need to correct axis length for the current zoomlevel of view,
this to prevent projected values to be clipped behind the camera
and to overflow the short integers.
The formula used is a bit stupid, just a simplification of the substraction
of two 2D points 30 pixels apart (that's the last factor in the formula) after
projecting them with window_to_3d_delta and then get the length of that vector.
*/
zfac= t->persmat[0][3]*t->center[0]+ t->persmat[1][3]*t->center[1]+ t->persmat[2][3]*t->center[2]+ t->persmat[3][3];
zfac = len_v3(t->persinv[0]) * 2.0f/t->ar->winx * zfac * 30.0f;
for (i = 0; i<3; i++) {
VECCOPY(axis, t->con.mtx[i]);
mul_v3_fl(axis, zfac);
/* now we can project to get window coordinate */
add_v3_v3(axis, t->con.center);
projectIntView(t, axis, icoord);
axis[0] = (float)(icoord[0] - t->center2d[0]);
axis[1] = (float)(icoord[1] - t->center2d[1]);
axis[2] = 0.0f;
if (normalize_v3(axis) != 0.0f) {
project_v3_v3v3(proj, mvec, axis);
sub_v3_v3v3(axis, mvec, proj);
len[i] = normalize_v3(axis);
}
else {
len[i] = 10000000000.0f;
}
}
if (len[0] <= len[1] && len[0] <= len[2]) {
if (t->modifiers & MOD_CONSTRAINT_PLANE) {
t->con.mode |= (CON_AXIS1|CON_AXIS2);
sprintf(t->con.text, " locking %s X axis", t->spacename);
}
else {
t->con.mode |= CON_AXIS0;
sprintf(t->con.text, " along %s X axis", t->spacename);
}
}
else if (len[1] <= len[0] && len[1] <= len[2]) {
if (t->modifiers & MOD_CONSTRAINT_PLANE) {
t->con.mode |= (CON_AXIS0|CON_AXIS2);
sprintf(t->con.text, " locking %s Y axis", t->spacename);
}
else {
t->con.mode |= CON_AXIS1;
sprintf(t->con.text, " along %s Y axis", t->spacename);
}
}
else if (len[2] <= len[1] && len[2] <= len[0]) {
if (t->modifiers & MOD_CONSTRAINT_PLANE) {
t->con.mode |= (CON_AXIS0|CON_AXIS1);
sprintf(t->con.text, " locking %s Z axis", t->spacename);
}
else {
t->con.mode |= CON_AXIS2;
sprintf(t->con.text, " along %s Z axis", t->spacename);
}
}
}