MOD_hook.c

Go to the documentation of this file.

/*
* $Id: MOD_hook.c 38300 2011-07-11 09:15:20Z blendix $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software  Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2005 by the Blender Foundation.
* All rights reserved.
*
* Contributor(s): Daniel Dunbar
*                 Ton Roosendaal,
*                 Ben Batt,
*                 Brecht Van Lommel,
*                 Campbell Barton
*
* ***** END GPL LICENSE BLOCK *****
*
*/

#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"

#include "BLI_math.h"
#include "BLI_utildefines.h"

#include "BKE_action.h"
#include "BKE_cdderivedmesh.h"
#include "BKE_modifier.h"
#include "BKE_deform.h"


#include "depsgraph_private.h"
#include "MEM_guardedalloc.h"

#include "MOD_util.h"

static void initData(ModifierData *md) 
{
        HookModifierData *hmd = (HookModifierData*) md;

        hmd->force= 1.0;
}

static void copyData(ModifierData *md, ModifierData *target)
{
        HookModifierData *hmd = (HookModifierData*) md;
        HookModifierData *thmd = (HookModifierData*) target;

        copy_v3_v3(thmd->cent, hmd->cent);
        thmd->falloff = hmd->falloff;
        thmd->force = hmd->force;
        thmd->object = hmd->object;
        thmd->totindex = hmd->totindex;
        thmd->indexar = MEM_dupallocN(hmd->indexar);
        memcpy(thmd->parentinv, hmd->parentinv, sizeof(hmd->parentinv));
        strncpy(thmd->name, hmd->name, 32);
        strncpy(thmd->subtarget, hmd->subtarget, 32);
}

static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
{
        HookModifierData *hmd = (HookModifierData *)md;
        CustomDataMask dataMask = 0;

        /* ask for vertexgroups if we need them */
        if(hmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
        if(hmd->indexar) dataMask |= CD_MASK_ORIGINDEX;

        return dataMask;
}

static void freeData(ModifierData *md)
{
        HookModifierData *hmd = (HookModifierData*) md;

        if (hmd->indexar) MEM_freeN(hmd->indexar);
}

static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
{
        HookModifierData *hmd = (HookModifierData*) md;

        return !hmd->object;
}

static void foreachObjectLink(
                                           ModifierData *md, Object *ob,
        void (*walk)(void *userData, Object *ob, Object **obpoin),
                   void *userData)
{
        HookModifierData *hmd = (HookModifierData*) md;

        walk(userData, ob, &hmd->object);
}

static void updateDepgraph(ModifierData *md, DagForest *forest,
                                                struct Scene *UNUSED(scene),
                                                Object *UNUSED(ob),
                                                DagNode *obNode)
{
        HookModifierData *hmd = (HookModifierData*) md;

        if (hmd->object) {
                DagNode *curNode = dag_get_node(forest, hmd->object);
                
                if (hmd->subtarget[0])
                        dag_add_relation(forest, curNode, obNode, DAG_RL_OB_DATA|DAG_RL_DATA_DATA, "Hook Modifier");
                else
                        dag_add_relation(forest, curNode, obNode, DAG_RL_OB_DATA, "Hook Modifier");
        }
}

static float hook_falloff(float *co_1, float *co_2, const float falloff_squared, float fac)
{
        if(falloff_squared) {
                float len_squared = len_squared_v3v3(co_1, co_2);
                if(len_squared > falloff_squared) {
                        return 0.0f;
                }
                else if(len_squared > 0.0f) {
                        return fac * (1.0f - (len_squared / falloff_squared));
                }
        }

        return fac;
}

static void deformVerts(ModifierData *md, Object *ob,
                                                DerivedMesh *dm,
                                                float (*vertexCos)[3],
                                                int numVerts,
                                                int UNUSED(useRenderParams),
                                                int UNUSED(isFinalCalc))
{
        HookModifierData *hmd = (HookModifierData*) md;
        bPoseChannel *pchan= get_pose_channel(hmd->object->pose, hmd->subtarget);
        float vec[3], mat[4][4], dmat[4][4];
        int i, *index_pt;
        const float falloff_squared= hmd->falloff * hmd->falloff; /* for faster comparisons */
        
        MDeformVert *dvert;
        int defgrp_index, max_dvert;
        
        /* get world-space matrix of target, corrected for the space the verts are in */
        if (hmd->subtarget[0] && pchan) {
                /* bone target if there's a matching pose-channel */
                mul_m4_m4m4(dmat, pchan->pose_mat, hmd->object->obmat);
        }
        else {
                /* just object target */
                copy_m4_m4(dmat, hmd->object->obmat);
        }
        invert_m4_m4(ob->imat, ob->obmat);
        mul_serie_m4(mat, ob->imat, dmat, hmd->parentinv,
                         NULL, NULL, NULL, NULL, NULL);

        modifier_get_vgroup(ob, dm, hmd->name, &dvert, &defgrp_index);
        max_dvert = (dvert)? numVerts: 0;

        /* Regarding index range checking below.
         *
         * This should always be true and I don't generally like 
         * "paranoid" style code like this, but old files can have
         * indices that are out of range because old blender did
         * not correct them on exit editmode. - zr
         */
        
        if(hmd->force == 0.0f) {
                /* do nothing, avoid annoying checks in the loop */
        }
        else if(hmd->indexar) { /* vertex indices? */
                const float fac_orig= hmd->force;
                float fac;
                const int *origindex_ar;

                /* if DerivedMesh is present and has original index data,
                * use it
                */
                if(dm && (origindex_ar= dm->getVertDataArray(dm, CD_ORIGINDEX))) {
                        for(i= 0, index_pt= hmd->indexar; i < hmd->totindex; i++, index_pt++) {
                                if(*index_pt < numVerts) {
                                        int j;

                                        for(j = 0; j < numVerts; j++) {
                                                if(origindex_ar[j] == *index_pt) {
                                                        float *co = vertexCos[j];
                                                        if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
                                                                if(dvert)
                                                                        fac *= defvert_find_weight(dvert+j, defgrp_index);

                                                                if(fac) {
                                                                        mul_v3_m4v3(vec, mat, co);
                                                                        interp_v3_v3v3(co, co, vec, fac);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                else { /* missing dm or ORIGINDEX */
                        for(i= 0, index_pt= hmd->indexar; i < hmd->totindex; i++, index_pt++) {
                                if(*index_pt < numVerts) {
                                        float *co = vertexCos[*index_pt];
                                        if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
                                                if(dvert)
                                                        fac *= defvert_find_weight(dvert+(*index_pt), defgrp_index);

                                                if(fac) {
                                                        mul_v3_m4v3(vec, mat, co);
                                                        interp_v3_v3v3(co, co, vec, fac);
                                                }
                                        }
                                }
                        }
                }
        }
        else if(dvert) {        /* vertex group hook */
                const float fac_orig= hmd->force;

                for(i = 0; i < max_dvert; i++, dvert++) {
                        float fac;
                        float *co = vertexCos[i];

                        if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
                                fac *= defvert_find_weight(dvert, defgrp_index);
                                if(fac) {
                                        mul_v3_m4v3(vec, mat, co);
                                        interp_v3_v3v3(co, co, vec, fac);
                                }
                        }
                }
        }
}

static void deformVertsEM(
                                           ModifierData *md, Object *ob, struct EditMesh *editData,
           DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
{
        DerivedMesh *dm = derivedData;

        if(!derivedData) dm = CDDM_from_editmesh(editData, ob->data);

        deformVerts(md, ob, dm, vertexCos, numVerts, 0, 0);

        if(!derivedData) dm->release(dm);
}


ModifierTypeInfo modifierType_Hook = {
        /* name */              "Hook",
        /* structName */        "HookModifierData",
        /* structSize */        sizeof(HookModifierData),
        /* type */              eModifierTypeType_OnlyDeform,
        /* flags */             eModifierTypeFlag_AcceptsCVs
                                                        | eModifierTypeFlag_SupportsEditmode,
        /* copyData */          copyData,
        /* deformVerts */       deformVerts,
        /* deformMatrices */    NULL,
        /* deformVertsEM */     deformVertsEM,
        /* deformMatricesEM */  NULL,
        /* applyModifier */     NULL,
        /* applyModifierEM */   NULL,
        /* initData */          initData,
        /* requiredDataMask */  requiredDataMask,
        /* freeData */          freeData,
        /* isDisabled */        isDisabled,
        /* updateDepgraph */    updateDepgraph,
        /* dependsOnTime */     NULL,
        /* dependsOnNormals */  NULL,
        /* foreachObjectLink */ foreachObjectLink,
        /* foreachIDLink */     NULL,
};