/* Testing code for 2.5 animation system * Copyright 2009, Joshua Leung */ #include #include #include #include #include #include "MEM_guardedalloc.h" #include "BLI_blenlib.h" #include "BLI_arithb.h" #include "BLI_dynstr.h" #include "DNA_anim_types.h" #include "DNA_action_types.h" #include "DNA_armature_types.h" #include "DNA_constraint_types.h" #include "DNA_key_types.h" #include "DNA_object_types.h" #include "DNA_material_types.h" #include "DNA_scene_types.h" #include "DNA_userdef_types.h" #include "DNA_windowmanager_types.h" #include "BKE_animsys.h" #include "BKE_action.h" #include "BKE_constraint.h" #include "BKE_fcurve.h" #include "BKE_utildefines.h" #include "BKE_context.h" #include "BKE_report.h" #include "BKE_key.h" #include "BKE_material.h" #include "ED_anim_api.h" #include "ED_keyframing.h" #include "ED_keyframes_edit.h" #include "ED_screen.h" #include "ED_util.h" #include "UI_interface.h" #include "WM_api.h" #include "WM_types.h" #include "RNA_access.h" #include "RNA_define.h" #include "RNA_types.h" /* ************************************************** */ /* LOCAL TYPES AND DEFINES */ /* ----------- Common KeyData Sources ------------ */ /* temporary struct to gather data combos to keyframe */ typedef struct bCommonKeySrc { struct bCommonKeySrc *next, *prev; /* general data/destination-source settings */ ID *id; /* id-block this comes from */ char *rna_path; /* base path to use */ // xxx.... maybe we don't need this? /* specific cases */ bPoseChannel *pchan; /* only needed when doing recalcs... */ } bCommonKeySrc; /* ******************************************* */ /* Animation Data Validation */ /* Get (or add relevant data to be able to do so) F-Curve from the Active Action, * for the given Animation Data block. This assumes that all the destinations are valid. */ FCurve *verify_fcurve (ID *id, const char group[], const char rna_path[], const int array_index, short add) { AnimData *adt; bAction *act; bActionGroup *grp; FCurve *fcu; /* sanity checks */ if ELEM(NULL, id, rna_path) return NULL; /* init animdata if none available yet */ adt= BKE_animdata_from_id(id); if ((adt == NULL) && (add)) adt= BKE_id_add_animdata(id); if (adt == NULL) { /* if still none (as not allowed to add, or ID doesn't have animdata for some reason) */ return NULL; } /* init action if none available yet */ // TODO: need some wizardry to handle NLA stuff correct if ((adt->action == NULL) && (add)) adt->action= add_empty_action("Action"); act= adt->action; /* try to find f-curve matching for this setting * - add if not found and allowed to add one * TODO: add auto-grouping support? how this works will need to be resolved */ if (act) fcu= list_find_fcurve(&act->curves, rna_path, array_index); else fcu= NULL; if ((fcu == NULL) && (add)) { /* use default settings to make a F-Curve */ fcu= MEM_callocN(sizeof(FCurve), "FCurve"); fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED); if (act->curves.first==NULL) fcu->flag |= FCURVE_ACTIVE; /* first one added active */ /* store path - make copy, and store that */ fcu->rna_path= BLI_strdupn(rna_path, strlen(rna_path)); fcu->array_index= array_index; /* if a group name has been provided, try to add or find a group, then add F-Curve to it */ if (group) { /* try to find group */ grp= action_groups_find_named(act, group); /* no matching groups, so add one */ if (grp == NULL) { /* Add a new group, and make it active */ grp= MEM_callocN(sizeof(bActionGroup), "bActionGroup"); grp->flag = AGRP_SELECTED; BLI_snprintf(grp->name, 64, group); BLI_addtail(&act->groups, grp); BLI_uniquename(&act->groups, grp, "Group", offsetof(bActionGroup, name), 64); } /* add F-Curve to group */ action_groups_add_channel(act, grp, fcu); } else { /* just add F-Curve to end of Action's list */ BLI_addtail(&act->curves, fcu); } } /* return the F-Curve */ return fcu; } /* ************************************************** */ /* KEYFRAME INSERTION */ /* -------------- BezTriple Insertion -------------------- */ /* threshold for inserting keyframes - threshold here should be good enough for now, but should become userpref */ #define BEZT_INSERT_THRESH 0.00001f /* Binary search algorithm for finding where to insert BezTriple. (for use by insert_bezt_icu) * Returns the index to insert at (data already at that index will be offset if replace is 0) */ static int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short *replace) { int start=0, end=arraylen; int loopbreaker= 0, maxloop= arraylen * 2; /* initialise replace-flag first */ *replace= 0; /* sneaky optimisations (don't go through searching process if...): * - keyframe to be added is to be added out of current bounds * - keyframe to be added would replace one of the existing ones on bounds */ if ((arraylen <= 0) || (array == NULL)) { printf("Warning: binarysearch_bezt_index() encountered invalid array \n"); return 0; } else { /* check whether to add before/after/on */ float framenum; /* 'First' Keyframe (when only one keyframe, this case is used) */ framenum= array[0].vec[1][0]; if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) { *replace = 1; return 0; } else if (frame < framenum) return 0; /* 'Last' Keyframe */ framenum= array[(arraylen-1)].vec[1][0]; if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) { *replace= 1; return (arraylen - 1); } else if (frame > framenum) return arraylen; } /* most of the time, this loop is just to find where to put it * 'loopbreaker' is just here to prevent infinite loops */ for (loopbreaker=0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) { /* compute and get midpoint */ int mid = start + ((end - start) / 2); /* we calculate the midpoint this way to avoid int overflows... */ float midfra= array[mid].vec[1][0]; /* check if exactly equal to midpoint */ if (IS_EQT(frame, midfra, BEZT_INSERT_THRESH)) { *replace = 1; return mid; } /* repeat in upper/lower half */ if (frame > midfra) start= mid + 1; else if (frame < midfra) end= mid - 1; } /* print error if loop-limit exceeded */ if (loopbreaker == (maxloop-1)) { printf("Error: binarysearch_bezt_index() was taking too long \n"); // include debug info printf("\tround = %d: start = %d, end = %d, arraylen = %d \n", loopbreaker, start, end, arraylen); } /* not found, so return where to place it */ return start; } /* This function adds a given BezTriple to an F-Curve. It will allocate * memory for the array if needed, and will insert the BezTriple into a * suitable place in chronological order. * * NOTE: any recalculate of the F-Curve that needs to be done will need to * be done by the caller. */ int insert_bezt_fcurve (FCurve *fcu, BezTriple *bezt) { BezTriple *newb; int i= 0; if (fcu->bezt) { short replace = -1; i = binarysearch_bezt_index(fcu->bezt, bezt->vec[1][0], fcu->totvert, &replace); if (replace) { /* sanity check: 'i' may in rare cases exceed arraylen */ // FIXME: do not overwrite handletype if just replacing...? if ((i >= 0) && (i < fcu->totvert)) *(fcu->bezt + i) = *bezt; } else { /* add new */ newb= MEM_callocN((fcu->totvert+1)*sizeof(BezTriple), "beztriple"); /* add the beztriples that should occur before the beztriple to be pasted (originally in ei->icu) */ if (i > 0) memcpy(newb, fcu->bezt, i*sizeof(BezTriple)); /* add beztriple to paste at index i */ *(newb + i)= *bezt; /* add the beztriples that occur after the beztriple to be pasted (originally in icu) */ if (i < fcu->totvert) memcpy(newb+i+1, fcu->bezt+i, (fcu->totvert-i)*sizeof(BezTriple)); /* replace (+ free) old with new */ MEM_freeN(fcu->bezt); fcu->bezt= newb; fcu->totvert++; } } else { // TODO: need to check for old sample-data now... fcu->bezt= MEM_callocN(sizeof(BezTriple), "beztriple"); *(fcu->bezt)= *bezt; fcu->totvert= 1; } /* we need to return the index, so that some tools which do post-processing can * detect where we added the BezTriple in the array */ return i; } /* This function is a wrapper for insert_bezt_icu, and should be used when * adding a new keyframe to a curve, when the keyframe doesn't exist anywhere * else yet. * * 'fast' - is only for the python API where importing BVH's would take an extreamly long time. */ void insert_vert_fcurve (FCurve *fcu, float x, float y, short fast) { BezTriple beztr; int a; /* set all three points, for nicer start position */ memset(&beztr, 0, sizeof(BezTriple)); beztr.vec[0][0]= x; beztr.vec[0][1]= y; beztr.vec[1][0]= x; beztr.vec[1][1]= y; beztr.vec[2][0]= x; beztr.vec[2][1]= y; beztr.ipo= U.ipo_new; /* use default interpolation mode here... */ beztr.f1= beztr.f2= beztr.f3= SELECT; beztr.h1= beztr.h2= HD_AUTO; // XXX what about when we replace an old one? /* add temp beztriple to keyframes */ a= insert_bezt_fcurve(fcu, &beztr); /* what if 'a' is a negative index? * for now, just exit to prevent any segfaults */ if (a < 0) return; /* don't recalculate handles if fast is set * - this is a hack to make importers faster * - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations) */ if (!fast) calchandles_fcurve(fcu); /* set handletype and interpolation */ if (fcu->totvert > 2) { BezTriple *bezt= (fcu->bezt + a); char h1, h2; /* set handles (autohandles by default) */ h1= h2= HD_AUTO; if (a > 0) h1= (bezt-1)->h2; if (a < fcu->totvert-1) h2= (bezt+1)->h1; bezt->h1= h1; bezt->h2= h2; /* set interpolation from previous (if available) */ if (a > 0) bezt->ipo= (bezt-1)->ipo; else if (a < fcu->totvert-1) bezt->ipo= (bezt+1)->ipo; /* don't recalculate handles if fast is set * - this is a hack to make importers faster * - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations) */ if (!fast) calchandles_fcurve(fcu); } } /* -------------- 'Smarter' Keyframing Functions -------------------- */ /* return codes for new_key_needed */ enum { KEYNEEDED_DONTADD = 0, KEYNEEDED_JUSTADD, KEYNEEDED_DELPREV, KEYNEEDED_DELNEXT } eKeyNeededStatus; /* This helper function determines whether a new keyframe is needed */ /* Cases where keyframes should not be added: * 1. Keyframe to be added bewteen two keyframes with similar values * 2. Keyframe to be added on frame where two keyframes are already situated * 3. Keyframe lies at point that intersects the linear line between two keyframes */ static short new_key_needed (FCurve *fcu, float cFrame, float nValue) { BezTriple *bezt=NULL, *prev=NULL; int totCount, i; float valA = 0.0f, valB = 0.0f; /* safety checking */ if (fcu == NULL) return KEYNEEDED_JUSTADD; totCount= fcu->totvert; if (totCount == 0) return KEYNEEDED_JUSTADD; /* loop through checking if any are the same */ bezt= fcu->bezt; for (i=0; ivec[1][0]; beztVal= bezt->vec[1][1]; if (prev) { /* there is a keyframe before the one currently being examined */ /* get previous time+value */ prevPosi= prev->vec[1][0]; prevVal= prev->vec[1][1]; /* keyframe to be added at point where there are already two similar points? */ if (IS_EQ(prevPosi, cFrame) && IS_EQ(beztPosi, cFrame) && IS_EQ(beztPosi, prevPosi)) { return KEYNEEDED_DONTADD; } /* keyframe between prev+current points ? */ if ((prevPosi <= cFrame) && (cFrame <= beztPosi)) { /* is the value of keyframe to be added the same as keyframes on either side ? */ if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal)) { return KEYNEEDED_DONTADD; } else { float realVal; /* get real value of curve at that point */ realVal= evaluate_fcurve(fcu, cFrame); /* compare whether it's the same as proposed */ if (IS_EQ(realVal, nValue)) return KEYNEEDED_DONTADD; else return KEYNEEDED_JUSTADD; } } /* new keyframe before prev beztriple? */ if (cFrame < prevPosi) { /* A new keyframe will be added. However, whether the previous beztriple * stays around or not depends on whether the values of previous/current * beztriples and new keyframe are the same. */ if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal)) return KEYNEEDED_DELNEXT; else return KEYNEEDED_JUSTADD; } } else { /* just add a keyframe if there's only one keyframe * and the new one occurs before the exisiting one does. */ if ((cFrame < beztPosi) && (totCount==1)) return KEYNEEDED_JUSTADD; } /* continue. frame to do not yet passed (or other conditions not met) */ if (i < (totCount-1)) { prev= bezt; bezt++; } else break; } /* Frame in which to add a new-keyframe occurs after all other keys * -> If there are at least two existing keyframes, then if the values of the * last two keyframes and the new-keyframe match, the last existing keyframe * gets deleted as it is no longer required. * -> Otherwise, a keyframe is just added. 1.0 is added so that fake-2nd-to-last * keyframe is not equal to last keyframe. */ bezt= (fcu->bezt + (fcu->totvert - 1)); valA= bezt->vec[1][1]; if (prev) valB= prev->vec[1][1]; else valB= bezt->vec[1][1] + 1.0f; if (IS_EQ(valA, nValue) && IS_EQ(valA, valB)) return KEYNEEDED_DELPREV; else return KEYNEEDED_JUSTADD; } /* ------------------ RNA Data-Access Functions ------------------ */ /* Try to read value using RNA-properties obtained already */ static float setting_get_rna_value (PointerRNA *ptr, PropertyRNA *prop, int index) { float value= 0.0f; switch (RNA_property_type(ptr, prop)) { case PROP_BOOLEAN: if (RNA_property_array_length(ptr, prop)) value= (float)RNA_property_boolean_get_index(ptr, prop, index); else value= (float)RNA_property_boolean_get(ptr, prop); break; case PROP_INT: if (RNA_property_array_length(ptr, prop)) value= (float)RNA_property_int_get_index(ptr, prop, index); else value= (float)RNA_property_int_get(ptr, prop); break; case PROP_FLOAT: if (RNA_property_array_length(ptr, prop)) value= RNA_property_float_get_index(ptr, prop, index); else value= RNA_property_float_get(ptr, prop); break; case PROP_ENUM: value= (float)RNA_property_enum_get(ptr, prop); break; default: break; } return value; } /* ------------------ 'Visual' Keyframing Functions ------------------ */ /* internal status codes for visualkey_can_use */ enum { VISUALKEY_NONE = 0, VISUALKEY_LOC, VISUALKEY_ROT, }; /* This helper function determines if visual-keyframing should be used when * inserting keyframes for the given channel. As visual-keyframing only works * on Object and Pose-Channel blocks, this should only get called for those * blocktypes, when using "standard" keying but 'Visual Keying' option in Auto-Keying * settings is on. */ static short visualkey_can_use (PointerRNA *ptr, PropertyRNA *prop) { bConstraint *con= NULL; short searchtype= VISUALKEY_NONE; char *identifier= NULL; /* validate data */ // TODO: this check is probably not needed, but it won't hurt if (ELEM3(NULL, ptr, ptr->data, prop)) return 0; /* get first constraint and determine type of keyframe constraints to check for * - constraints can be on either Objects or PoseChannels, so we only check if the * ptr->type is RNA_Object or RNA_PoseChannel, which are the RNA wrapping-info for * those structs, allowing us to identify the owner of the data */ if (ptr->type == &RNA_Object) { /* Object */ Object *ob= (Object *)ptr->data; con= ob->constraints.first; identifier= (char *)RNA_property_identifier(ptr, prop); } else if (ptr->type == &RNA_PoseChannel) { /* Pose Channel */ bPoseChannel *pchan= (bPoseChannel *)ptr->data; con= pchan->constraints.first; identifier= (char *)RNA_property_identifier(ptr, prop); } /* check if any data to search using */ if (ELEM(NULL, con, identifier)) return 0; /* location or rotation identifiers only... */ if (strstr(identifier, "location")) searchtype= VISUALKEY_LOC; else if (strstr(identifier, "rotation")) searchtype= VISUALKEY_ROT; else { printf("visualkey_can_use() failed: identifier - '%s' \n", identifier); return 0; } /* only search if a searchtype and initial constraint are available */ if (searchtype && con) { for (; con; con= con->next) { /* only consider constraint if it is not disabled, and has influence */ if (con->flag & CONSTRAINT_DISABLE) continue; if (con->enforce == 0.0f) continue; /* some constraints may alter these transforms */ switch (con->type) { /* multi-transform constraints */ case CONSTRAINT_TYPE_CHILDOF: return 1; case CONSTRAINT_TYPE_TRANSFORM: return 1; case CONSTRAINT_TYPE_FOLLOWPATH: return 1; case CONSTRAINT_TYPE_KINEMATIC: return 1; /* single-transform constraits */ case CONSTRAINT_TYPE_TRACKTO: if (searchtype==VISUALKEY_ROT) return 1; break; case CONSTRAINT_TYPE_ROTLIMIT: if (searchtype==VISUALKEY_ROT) return 1; break; case CONSTRAINT_TYPE_LOCLIMIT: if (searchtype==VISUALKEY_LOC) return 1; break; case CONSTRAINT_TYPE_ROTLIKE: if (searchtype==VISUALKEY_ROT) return 1; break; case CONSTRAINT_TYPE_DISTLIMIT: if (searchtype==VISUALKEY_LOC) return 1; break; case CONSTRAINT_TYPE_LOCLIKE: if (searchtype==VISUALKEY_LOC) return 1; break; case CONSTRAINT_TYPE_LOCKTRACK: if (searchtype==VISUALKEY_ROT) return 1; break; case CONSTRAINT_TYPE_MINMAX: if (searchtype==VISUALKEY_LOC) return 1; break; default: break; } } } /* when some condition is met, this function returns, so here it can be 0 */ return 0; } /* This helper function extracts the value to use for visual-keyframing * In the event that it is not possible to perform visual keying, try to fall-back * to using the default method. Assumes that all data it has been passed is valid. */ static float visualkey_get_value (PointerRNA *ptr, PropertyRNA *prop, int array_index) { char *identifier= (char *)RNA_property_identifier(ptr, prop); /* handle for Objects or PoseChannels only * - constraints can be on either Objects or PoseChannels, so we only check if the * ptr->type is RNA_Object or RNA_PoseChannel, which are the RNA wrapping-info for * those structs, allowing us to identify the owner of the data * - assume that array_index will be sane */ if (ptr->type == &RNA_Object) { Object *ob= (Object *)ptr->data; /* parented objects are not supported, as the effects of the parent * are included in the matrix, which kindof beats the point */ if (ob->parent == NULL) { /* only Location or Rotation keyframes are supported now */ if (strstr(identifier, "location")) { return ob->obmat[3][array_index]; } else if (strstr(identifier, "rotation")) { float eul[3]; Mat4ToEul(ob->obmat, eul); return eul[array_index]; } } } else if (ptr->type == &RNA_PoseChannel) { Object *ob= (Object *)ptr->id.data; /* we assume that this is always set, and is an object */ bPoseChannel *pchan= (bPoseChannel *)ptr->data; float tmat[4][4]; /* Although it is not strictly required for this particular space conversion, * arg1 must not be null, as there is a null check for the other conversions to * be safe. Therefore, the active object is passed here, and in many cases, this * will be what owns the pose-channel that is getting this anyway. */ Mat4CpyMat4(tmat, pchan->pose_mat); constraint_mat_convertspace(ob, pchan, tmat, CONSTRAINT_SPACE_POSE, CONSTRAINT_SPACE_LOCAL); /* Loc, Rot/Quat keyframes are supported... */ if (strstr(identifier, "location")) { /* only use for non-connected bones */ if ((pchan->bone->parent) && !(pchan->bone->flag & BONE_CONNECTED)) return tmat[3][array_index]; else if (pchan->bone->parent == NULL) return tmat[3][array_index]; } else if (strstr(identifier, "euler_rotation")) { float eul[3]; /* euler-rotation test before standard rotation, as standard rotation does quats */ Mat4ToEul(tmat, eul); return eul[array_index]; } else if (strstr(identifier, "rotation")) { float trimat[3][3], quat[4]; Mat3CpyMat4(trimat, tmat); Mat3ToQuat_is_ok(trimat, quat); return quat[array_index]; } } /* as the function hasn't returned yet, read value from system in the default way */ return setting_get_rna_value(ptr, prop, array_index); } /* ------------------------- Insert Key API ------------------------- */ /* Main Keyframing API call: * Use this when validation of necessary animation data isn't necessary as it * already exists. It will insert a keyframe using the current value being keyframed. * * The flag argument is used for special settings that alter the behaviour of * the keyframe insertion. These include the 'visual' keyframing modes, quick refresh, * and extra keyframe filtering. */ short insertkey (ID *id, const char group[], const char rna_path[], int array_index, float cfra, short flag) { PointerRNA id_ptr, ptr; PropertyRNA *prop; FCurve *fcu; /* validate pointer first - exit if failure*/ RNA_id_pointer_create(id, &id_ptr); if (RNA_path_resolve(&id_ptr, rna_path, &ptr, &prop) == 0 || prop == NULL) { printf("Insert Key: Could not insert keyframe, as RNA Path is invalid for the given ID (%s)\n", rna_path); return 0; } /* get F-Curve */ fcu= verify_fcurve(id, group, rna_path, array_index, 1); /* only continue if we have an F-Curve to add keyframe to */ if (fcu) { float curval= 0.0f; /* set additional flags for the F-Curve (i.e. only integer values) */ if (RNA_property_type(&ptr, prop) != PROP_FLOAT) fcu->flag |= FCURVE_INT_VALUES; /* apply special time tweaking */ // XXX check on this stuff... if (GS(id->name) == ID_OB) { //Object *ob= (Object *)id; /* apply NLA-scaling (if applicable) */ //cfra= get_action_frame(ob, cfra); /* ancient time-offset cruft */ //if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) { // /* actually frametofloat calc again! */ // cfra-= give_timeoffset(ob)*scene->r.framelen; //} } /* obtain value to give keyframe */ if ( (flag & INSERTKEY_MATRIX) && (visualkey_can_use(&ptr, prop)) ) { /* visual-keying is only available for object and pchan datablocks, as * it works by keyframing using a value extracted from the final matrix * instead of using the kt system to extract a value. */ curval= visualkey_get_value(&ptr, prop, array_index); } else { /* read value from system */ curval= setting_get_rna_value(&ptr, prop, array_index); } /* only insert keyframes where they are needed */ if (flag & INSERTKEY_NEEDED) { short insert_mode; /* check whether this curve really needs a new keyframe */ insert_mode= new_key_needed(fcu, cfra, curval); /* insert new keyframe at current frame */ if (insert_mode) insert_vert_fcurve(fcu, cfra, curval, (flag & INSERTKEY_FAST)); /* delete keyframe immediately before/after newly added */ switch (insert_mode) { case KEYNEEDED_DELPREV: delete_fcurve_key(fcu, fcu->totvert-2, 1); break; case KEYNEEDED_DELNEXT: delete_fcurve_key(fcu, 1, 1); break; } /* only return success if keyframe added */ if (insert_mode) return 1; } else { /* just insert keyframe */ insert_vert_fcurve(fcu, cfra, curval, (flag & INSERTKEY_FAST)); /* return success */ return 1; } } /* return failure */ return 0; } /* ************************************************** */ /* KEYFRAME DELETION */ /* Main Keyframing API call: * Use this when validation of necessary animation data isn't necessary as it * already exists. It will delete a keyframe at the current frame. * * The flag argument is used for special settings that alter the behaviour of * the keyframe deletion. These include the quick refresh options. */ short deletekey (ID *id, const char group[], const char rna_path[], int array_index, float cfra, short flag) { AnimData *adt; FCurve *fcu; /* get F-Curve * Note: here is one of the places where we don't want new Action + F-Curve added! * so 'add' var must be 0 */ /* we don't check the validity of the path here yet, but it should be ok... */ fcu= verify_fcurve(id, group, rna_path, array_index, 0); adt= BKE_animdata_from_id(id); /* only continue if we have an ipo-curve to remove keyframes from */ if (adt && adt->action && fcu) { bAction *act= adt->action; short found = -1; int i; /* apply special time tweaking */ if (GS(id->name) == ID_OB) { //Object *ob= (Object *)id; /* apply NLA-scaling (if applicable) */ // cfra= get_action_frame(ob, cfra); /* ancient time-offset cruft */ //if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) { // /* actually frametofloat calc again! */ // cfra-= give_timeoffset(ob)*scene->r.framelen; //} } /* try to find index of beztriple to get rid of */ i = binarysearch_bezt_index(fcu->bezt, cfra, fcu->totvert, &found); if (found) { /* delete the key at the index (will sanity check + do recalc afterwards) */ delete_fcurve_key(fcu, i, 1); /* Only delete curve too if there are no points (we don't need to check for drivers, as they're kept separate) */ if (fcu->totvert == 0) { BLI_remlink(&act->curves, fcu); free_fcurve(fcu); } /* return success */ return 1; } } /* return failure */ return 0; } /* ******************************************* */ /* KEYINGSETS */ /* Operators ------------------------------------------- */ /* These operators are only provided for scripting/macro usage, not for direct * calling from the UI since they wrap some of the data-access API code for these * (defined in blenkernel) which have quite a few properties. */ /* ----- */ static int keyingset_add_destination_exec (bContext *C, wmOperator *op) { PointerRNA ptr; KeyingSet *ks= NULL; ID *id= NULL; char rna_path[256], group_name[64]; // xxx short groupmode=0, flag=0; int array_index=0; /* get settings from operator properties */ ptr = RNA_pointer_get(op->ptr, "keyingset"); if (ptr.data) ks= (KeyingSet *)ptr.data; ptr = RNA_pointer_get(op->ptr, "id"); if (ptr.data) id= (ID *)ptr.data; groupmode= RNA_enum_get(op->ptr, "grouping_method"); RNA_string_get(op->ptr, "group_name", group_name); RNA_string_get(op->ptr, "rna_path", rna_path); array_index= RNA_int_get(op->ptr, "array_index"); if (RNA_boolean_get(op->ptr, "entire_array")) flag |= KSP_FLAG_WHOLE_ARRAY; /* if enough args are provided, call API method */ if (ks) { BKE_keyingset_add_destination(ks, id, group_name, rna_path, array_index, flag, groupmode); return OPERATOR_FINISHED; } else { BKE_report(op->reports, RPT_ERROR, "Keying Set could not be added."); return OPERATOR_CANCELLED; } } void ANIM_OT_keyingset_add_destination (wmOperatorType *ot) { // XXX: this is also defined in rna_animation.c static EnumPropertyItem prop_mode_grouping_items[] = { {KSP_GROUP_NAMED, "NAMED", "Named Group", ""}, {KSP_GROUP_NONE, "NONE", "None", ""}, {KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""}, {0, NULL, NULL, NULL}}; /* identifiers */ ot->name= "Add Keying Set Destination"; ot->idname= "ANIM_OT_keyingset_add_destination"; /* callbacks */ ot->exec= keyingset_add_destination_exec; ot->poll= ED_operator_scene_editable; /* props */ /* pointers */ // xxx - do we want to directly expose these? RNA_def_pointer_runtime(ot->srna, "keyingset", &RNA_KeyingSet, "Keying Set", "Keying Set to add destination to."); RNA_def_pointer_runtime(ot->srna, "id", &RNA_ID, "ID", "ID-block for the destination."); /* grouping */ RNA_def_enum(ot->srna, "grouping_method", prop_mode_grouping_items, KSP_GROUP_NAMED, "Grouping Method", "Method used to define which Group-name to use."); RNA_def_string(ot->srna, "group_name", "", 64, "Group Name", "Name of Action Group to assign destination to (only if grouping mode is to use this name)."); /* rna-path */ RNA_def_string(ot->srna, "rna_path", "", 256, "RNA-Path", "RNA-Path to destination property."); // xxx hopefully this is long enough RNA_def_int(ot->srna, "array_index", 0, 0, INT_MAX, "Array Index", "If applicable, the index ", 0, INT_MAX); /* flags */ RNA_def_boolean(ot->srna, "entire_array", 1, "Entire Array", "hen an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used."); } /* ----- */ static int keyingset_add_new_exec (bContext *C, wmOperator *op) { Scene *sce= CTX_data_scene(C); KeyingSet *ks= NULL; short flag=0, keyingflag=0; char name[64]; /* get settings from operator properties */ RNA_string_get(op->ptr, "name", name); if (RNA_boolean_get(op->ptr, "absolute")) flag |= KEYINGSET_ABSOLUTE; if (RNA_boolean_get(op->ptr, "insertkey_needed")) keyingflag |= INSERTKEY_NEEDED; if (RNA_boolean_get(op->ptr, "insertkey_visual")) keyingflag |= INSERTKEY_MATRIX; /* call the API func, and set the active keyingset index */ ks= BKE_keyingset_add(&sce->keyingsets, name, flag, keyingflag); if (ks) { sce->active_keyingset= BLI_countlist(&sce->keyingsets); return OPERATOR_FINISHED; } else { BKE_report(op->reports, RPT_ERROR, "Keying Set could not be added."); return OPERATOR_CANCELLED; } } void ANIM_OT_keyingset_add_new (wmOperatorType *ot) { /* identifiers */ ot->name= "Add Keying Set"; ot->idname= "ANIM_OT_keyingset_add_new"; /* callbacks */ ot->exec= keyingset_add_new_exec; ot->poll= ED_operator_scene_editable; /* props */ /* name */ RNA_def_string(ot->srna, "name", "KeyingSet", 64, "Name", "Name of Keying Set"); /* flags */ RNA_def_boolean(ot->srna, "absolute", 1, "Absolute", "Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)"); /* keying flags */ RNA_def_boolean(ot->srna, "insertkey_needed", 0, "Insert Keyframes - Only Needed", "Only insert keyframes where they're needed in the relevant F-Curves."); RNA_def_boolean(ot->srna, "insertkey_visual", 0, "Insert Keyframes - Visual", "Insert keyframes based on 'visual transforms'."); } /* UI API --------------------------------------------- */ /* Build menu-string of available keying-sets (allocates memory for string) * NOTE: mode must not be longer than 64 chars */ char *ANIM_build_keyingsets_menu (ListBase *list, short for_edit) { DynStr *pupds= BLI_dynstr_new(); KeyingSet *ks; char buf[64]; char *str; int i; /* add title first */ BLI_dynstr_append(pupds, "Keying Sets%t|"); /* add dummy entries for none-active */ if (for_edit) { BLI_dynstr_append(pupds, "Add New%x-1|"); BLI_dynstr_append(pupds, " %x0|"); } else BLI_dynstr_append(pupds, "%x0|"); /* loop through keyingsets, adding them */ for (ks=list->first, i=1; ks; ks=ks->next, i++) { if (for_edit == 0) BLI_dynstr_append(pupds, "KS: "); BLI_dynstr_append(pupds, ks->name); BLI_snprintf( buf, 64, "%%x%d%s", i, ((ks->next)?"|":"") ); BLI_dynstr_append(pupds, buf); } /* convert to normal MEM_malloc'd string */ str= BLI_dynstr_get_cstring(pupds); BLI_dynstr_free(pupds); return str; } /* ******************************************* */ /* KEYFRAME MODIFICATION */ /* mode for commonkey_modifykey */ enum { COMMONKEY_MODE_INSERT = 0, COMMONKEY_MODE_DELETE, } eCommonModifyKey_Modes; #if 0 // XXX old keyingsets code based on adrcodes... to be restored in due course /* --------- KeyingSet Adrcode Getters ------------ */ /* initialise a channel-getter storage */ static void ks_adrcodegetter_init (bKS_AdrcodeGetter *kag, bKeyingSet *ks, bCommonKeySrc *cks) { /* error checking */ if (kag == NULL) return; if (ELEM(NULL, ks, cks)) { /* set invalid settings that won't cause harm */ kag->ks= NULL; kag->cks= NULL; kag->index= -2; kag->tot= 0; } else { /* store settings */ kag->ks= ks; kag->cks= cks; /* - index is -1, as that allows iterators to return first element * - tot is chan_num by default, but may get overriden if -1 is encountered (for extension-type getters) */ kag->index= -1; kag->tot= ks->chan_num; } } /* 'default' channel-getter that will be used when iterating through keyingset's channels * - iteration will stop when adrcode <= 0 is encountered, so we use that as escape */ static short ks_getnextadrcode_default (bKS_AdrcodeGetter *kag) { bKeyingSet *ks= (kag)? kag->ks : NULL; /* error checking */ if (ELEM(NULL, kag, ks)) return 0; if (kag->tot <= 0) return 0; kag->index++; if ((kag->index < 0) || (kag->index >= kag->tot)) return 0; /* return the adrcode stored at index then */ return ks->adrcodes[kag->index]; } /* add map flag (for MTex channels, as certain ones need special offset) */ static short ks_getnextadrcode_addmap (bKS_AdrcodeGetter *kag) { short adrcode= ks_getnextadrcode_default(kag); /* if there was an adrcode returned, assume that kag stuff is set ok */ if (adrcode) { bCommonKeySrc *cks= kag->cks; bKeyingSet *ks= kag->ks; if (ELEM3(ks->blocktype, ID_MA, ID_LA, ID_WO)) { switch (adrcode) { case MAP_OFS_X: case MAP_OFS_Y: case MAP_OFS_Z: case MAP_SIZE_X: case MAP_SIZE_Y: case MAP_SIZE_Z: case MAP_R: case MAP_G: case MAP_B: case MAP_DVAR: case MAP_COLF: case MAP_NORF: case MAP_VARF: case MAP_DISP: adrcode += cks->map; break; } } } /* adrcode must be returned! */ return adrcode; } /* extend posechannel keyingsets with rotation info (when KAG_CHAN_EXTEND is encountered) * - iteration will stop when adrcode <= 0 is encountered, so we use that as escape * - when we encounter KAG_CHAN_EXTEND as adrcode, start returning our own */ static short ks_getnextadrcode_pchanrot (bKS_AdrcodeGetter *kag) { /* hardcoded adrcode channels used here only * - length is keyed-channels + 1 (last item must be 0 to escape) */ static short quat_adrcodes[5] = {AC_QUAT_W, AC_QUAT_X, AC_QUAT_Y, AC_QUAT_Z, 0}; static short eul_adrcodes[4] = {AC_EUL_X, AC_EUL_Y, AC_EUL_Z, 0}; /* useful variables */ bKeyingSet *ks= (kag)? kag->ks : NULL; bCommonKeySrc *cks= (kag) ? kag->cks : NULL; short index, adrcode; /* error checking */ if (ELEM3(NULL, kag, ks, cks)) return 0; if (ks->chan_num <= 0) return 0; /* get index * - if past the last item (kag->tot), return stuff from our static arrays * - otherwise, just keep returning stuff from the keyingset (but check out for -1!) */ kag->index++; if (kag->index < 0) return 0; /* normal (static stuff) */ if (kag->index < kag->tot) { /* get adrcode, and return if not KAG_CHAN_EXTEND (i.e. point for start of iteration) */ adrcode= ks->adrcodes[kag->index]; if (adrcode != KAG_CHAN_EXTEND) return adrcode; else kag->tot= kag->index; } /* based on current rotation-mode * - index can be at most 5, if we are to prevent segfaults */ index= kag->index - kag->tot; if ((index < 0) || (index > 5)) return 0; if (cks->pchan && cks->pchan->rotmode) return eul_adrcodes[index]; else return quat_adrcodes[index]; } /* ------------- KeyingSet Defines ------------ */ /* Note: these must all be named with the defks_* prefix, otherwise the template macro will not work! */ /* macro for defining keyingset contexts */ #define KSC_TEMPLATE(ctx_name) {&defks_##ctx_name[0], NULL, sizeof(defks_##ctx_name)/sizeof(bKeyingSet)} /* --- */ /* check if option not available for deleting keys */ static short incl_non_del_keys (bKeyingSet *ks, const char mode[]) { /* as optimisation, assume that it is sufficient to check only first letter * of mode (int comparison should be faster than string!) */ //if (strcmp(mode, "Delete")==0) if (mode && mode[0]=='D') return 0; return 1; } /* Object KeyingSets ------ */ /* check if include shapekey entry */ static short incl_v3d_ob_shapekey (bKeyingSet *ks, const char mode[]) { //Object *ob= (G.obedit)? (G.obedit) : (OBACT); // XXX Object *ob= NULL; char *newname= NULL; if(ob==NULL) return 0; /* not available for delete mode */ if (strcmp(mode, "Delete")==0) return 0; /* check if is geom object that can get shapekeys */ switch (ob->type) { /* geometry? */ case OB_MESH: newname= "Mesh"; break; case OB_CURVE: newname= "Curve"; break; case OB_SURF: newname= "Surface"; break; case OB_LATTICE: newname= "Lattice"; break; /* not geometry! */ default: return 0; } /* if ks is shapekey entry (this could be callled for separator before too!) */ if (ks->flag == -3) BLI_strncpy(ks->name, newname, sizeof(ks->name)); /* if it gets here, it's ok */ return 1; } /* array for object keyingset defines */ bKeyingSet defks_v3d_object[] = { /* include_cb, adrcode-getter, name, blocktype, flag, chan_num, adrcodes */ {NULL, "Loc", ID_OB, 0, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}}, {NULL, "Rot", ID_OB, 0, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}}, {NULL, "Scale", ID_OB, 0, 3, {OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "LocRot", ID_OB, 0, 6, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z, OB_ROT_X,OB_ROT_Y,OB_ROT_Z}}, {NULL, "LocScale", ID_OB, 0, 6, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z, OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}}, {NULL, "LocRotScale", ID_OB, 0, 9, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z, OB_ROT_X,OB_ROT_Y,OB_ROT_Z, OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}}, {NULL, "RotScale", ID_OB, 0, 6, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z, OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}}, {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator {incl_non_del_keys, "VisualLoc", ID_OB, INSERTKEY_MATRIX, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}}, {incl_non_del_keys, "VisualRot", ID_OB, INSERTKEY_MATRIX, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}}, {incl_non_del_keys, "VisualLocRot", ID_OB, INSERTKEY_MATRIX, 6, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z, OB_ROT_X,OB_ROT_Y,OB_ROT_Z}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Layer", ID_OB, 0, 1, {OB_LAY}}, // icky option... {NULL, "Available", ID_OB, -2, 0, {0}}, {incl_v3d_ob_shapekey, "%l%l", 0, -1, 0, {0}}, // separator (linked to shapekey entry) {incl_v3d_ob_shapekey, "", ID_OB, -3, 0, {0}} }; /* PoseChannel KeyingSets ------ */ /* array for posechannel keyingset defines */ bKeyingSet defks_v3d_pchan[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "Loc", ID_PO, 0, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}}, {NULL, "Rot", ID_PO, COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}}, {NULL, "Scale", ID_PO, 0, 3, {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "LocRot", ID_PO, COMMONKEY_PCHANROT, 4, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z, KAG_CHAN_EXTEND}}, {NULL, "LocScale", ID_PO, 0, 6, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z, AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}}, {NULL, "LocRotScale", ID_PO, COMMONKEY_PCHANROT, 7, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, KAG_CHAN_EXTEND}}, {NULL, "RotScale", ID_PO, 0, 4, {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, KAG_CHAN_EXTEND}}, {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator {incl_non_del_keys, "VisualLoc", ID_PO, INSERTKEY_MATRIX, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}}, {incl_non_del_keys, "VisualRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}}, {incl_non_del_keys, "VisualLocRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 4, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z, KAG_CHAN_EXTEND}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_PO, -2, 0, {0}} }; /* Material KeyingSets ------ */ /* array for material keyingset defines */ bKeyingSet defks_buts_shading_mat[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "RGB", ID_MA, 0, 3, {MA_COL_R,MA_COL_G,MA_COL_B}}, {NULL, "Alpha", ID_MA, 0, 1, {MA_ALPHA}}, {NULL, "Halo Size", ID_MA, 0, 1, {MA_HASIZE}}, {NULL, "Mode", ID_MA, 0, 1, {MA_MODE}}, // evil bitflags {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "All Color", ID_MA, 0, 18, {MA_COL_R,MA_COL_G,MA_COL_B, MA_ALPHA,MA_HASIZE, MA_MODE, MA_SPEC_R,MA_SPEC_G,MA_SPEC_B, MA_REF,MA_EMIT,MA_AMB,MA_SPEC,MA_HARD, MA_MODE,MA_TRANSLU,MA_ADD}}, {NULL, "All Mirror", ID_MA, 0, 5, {MA_RAYM,MA_FRESMIR,MA_FRESMIRI, MA_FRESTRA,MA_FRESTRAI}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Ofs", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}}, {NULL, "Size", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}}, {NULL, "All Mapping", ID_MA, COMMONKEY_ADDMAP, 14, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z, MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z, MAP_R,MAP_G,MAP_B,MAP_DVAR, MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_MA, -2, 0, {0}} }; /* World KeyingSets ------ */ /* array for world keyingset defines */ bKeyingSet defks_buts_shading_wo[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "Zenith RGB", ID_WO, 0, 3, {WO_ZEN_R,WO_ZEN_G,WO_ZEN_B}}, {NULL, "Horizon RGB", ID_WO, 0, 3, {WO_HOR_R,WO_HOR_G,WO_HOR_B}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Mist", ID_WO, 0, 4, {WO_MISI,WO_MISTDI,WO_MISTSTA,WO_MISTHI}}, {NULL, "Stars", ID_WO, 0, 5, {WO_STAR_R,WO_STAR_G,WO_STAR_B,WO_STARDIST,WO_STARSIZE}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Ofs", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}}, {NULL, "Size", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}}, {NULL, "All Mapping", ID_WO, COMMONKEY_ADDMAP, 14, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z, MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z, MAP_R,MAP_G,MAP_B,MAP_DVAR, MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_WO, -2, 0, {0}} }; /* Lamp KeyingSets ------ */ /* array for lamp keyingset defines */ bKeyingSet defks_buts_shading_la[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "RGB", ID_LA, 0, 3, {LA_COL_R,LA_COL_G,LA_COL_B}}, {NULL, "Energy", ID_LA, 0, 1, {LA_ENERGY}}, {NULL, "Spot Size", ID_LA, 0, 1, {LA_SPOTSI}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Ofs", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}}, {NULL, "Size", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}}, {NULL, "All Mapping", ID_LA, COMMONKEY_ADDMAP, 14, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z, MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z, MAP_R,MAP_G,MAP_B,MAP_DVAR, MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_LA, -2, 0, {0}} }; /* Texture KeyingSets ------ */ /* array for texture keyingset defines */ bKeyingSet defks_buts_shading_tex[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "Clouds", ID_TE, 0, 5, {TE_NSIZE,TE_NDEPTH,TE_NTYPE, TE_MG_TYP,TE_N_BAS1}}, {NULL, "Marble", ID_TE, 0, 7, {TE_NSIZE,TE_NDEPTH,TE_NTYPE, TE_TURB,TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}}, {NULL, "Stucci", ID_TE, 0, 5, {TE_NSIZE,TE_NTYPE,TE_TURB, TE_MG_TYP,TE_N_BAS1}}, {NULL, "Wood", ID_TE, 0, 6, {TE_NSIZE,TE_NTYPE,TE_TURB, TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}}, {NULL, "Magic", ID_TE, 0, 2, {TE_NDEPTH,TE_TURB}}, {NULL, "Blend", ID_TE, 0, 1, {TE_MG_TYP}}, {NULL, "Musgrave", ID_TE, 0, 6, {TE_MG_TYP,TE_MGH,TE_MG_LAC, TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN}}, {NULL, "Voronoi", ID_TE, 0, 9, {TE_VNW1,TE_VNW2,TE_VNW3,TE_VNW4, TE_VNMEXP,TE_VN_DISTM,TE_VN_COLT, TE_ISCA,TE_NSIZE}}, {NULL, "Distorted Noise", ID_TE, 0, 4, {TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN,TE_DISTA}}, {NULL, "Color Filter", ID_TE, 0, 5, {TE_COL_R,TE_COL_G,TE_COL_B,TE_BRIGHT,TE_CONTRA}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_TE, -2, 0, {0}} }; /* Object Buttons KeyingSets ------ */ /* check if include particles entry */ static short incl_buts_ob (bKeyingSet *ks, const char mode[]) { //Object *ob= OBACT; // xxx Object *ob= NULL; /* only if object is mesh type */ if(ob==NULL) return 0; return (ob->type == OB_MESH); } /* array for texture keyingset defines */ bKeyingSet defks_buts_object[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {incl_buts_ob, "Surface Damping", ID_OB, 0, 1, {OB_PD_SDAMP}}, {incl_buts_ob, "Random Damping", ID_OB, 0, 1, {OB_PD_RDAMP}}, {incl_buts_ob, "Permeability", ID_OB, 0, 1, {OB_PD_PERM}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Force Strength", ID_OB, 0, 1, {OB_PD_FSTR}}, {NULL, "Force Falloff", ID_OB, 0, 1, {OB_PD_FFALL}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_OB, -2, 0, {0}} // this will include ob-transforms too! }; /* Camera Buttons KeyingSets ------ */ /* check if include internal-renderer entry */ static short incl_buts_cam1 (bKeyingSet *ks, const char mode[]) { Scene *scene= NULL; // FIXME this will cause a crash, but we need an extra arg first! /* only if renderer is internal renderer */ return (scene->r.renderer==R_INTERN); } /* check if include external-renderer entry */ static short incl_buts_cam2 (bKeyingSet *ks, const char mode[]) { Scene *scene= NULL; // FIXME this will cause a crash, but we need an extra arg first! /* only if renderer is internal renderer */ return (scene->r.renderer!=R_INTERN); } /* array for camera keyingset defines */ bKeyingSet defks_buts_cam[] = { /* include_cb, name, blocktype, flag, chan_num, adrcodes */ {NULL, "Lens", ID_CA, 0, 1, {CAM_LENS}}, {NULL, "Clipping", ID_CA, 0, 2, {CAM_STA,CAM_END}}, {NULL, "Focal Distance", ID_CA, 0, 1, {CAM_YF_FDIST}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {incl_buts_cam2, "Aperture", ID_CA, 0, 1, {CAM_YF_APERT}}, {incl_buts_cam1, "Viewplane Shift", ID_CA, 0, 2, {CAM_SHIFT_X,CAM_SHIFT_Y}}, {NULL, "%l", 0, -1, 0, {0}}, // separator {NULL, "Available", ID_CA, -2, 0, {0}} }; /* --- */ /* Keying Context Defines - Must keep in sync with enumeration (eKS_Contexts) */ bKeyingContext ks_contexts[] = { KSC_TEMPLATE(v3d_object), KSC_TEMPLATE(v3d_pchan), KSC_TEMPLATE(buts_shading_mat), KSC_TEMPLATE(buts_shading_wo), KSC_TEMPLATE(buts_shading_la), KSC_TEMPLATE(buts_shading_tex), KSC_TEMPLATE(buts_object), KSC_TEMPLATE(buts_cam) }; /* Keying Context Enumeration - Must keep in sync with definitions*/ typedef enum eKS_Contexts { KSC_V3D_OBJECT = 0, KSC_V3D_PCHAN, KSC_BUTS_MAT, KSC_BUTS_WO, KSC_BUTS_LA, KSC_BUTS_TEX, KSC_BUTS_OB, KSC_BUTS_CAM, /* make sure this last one remains untouched! */ KSC_TOT_TYPES } eKS_Contexts; /* ---------------- KeyingSet Tools ------------------- */ /* helper for commonkey_context_get() - get keyingsets for 3d-view */ static void commonkey_context_getv3d (const bContext *C, ListBase *sources, bKeyingContext **ksc) { Scene *scene= CTX_data_scene(C); Object *ob; IpoCurve *icu; if ((OBACT) && (OBACT->flag & OB_POSEMODE)) { bPoseChannel *pchan; /* pose-level */ ob= OBACT; *ksc= &ks_contexts[KSC_V3D_PCHAN]; // XXX //set_pose_keys(ob); /* sets pchan->flag to POSE_KEY if bone selected, and clears if not */ /* loop through posechannels */ for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) { if (pchan->flag & POSE_KEY) { bCommonKeySrc *cks; /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set id-block to key to, and action */ cks->id= (ID *)ob; cks->act= ob->action; /* set pchan */ cks->pchan= pchan; cks->actname= pchan->name; } } } else { /* object-level */ *ksc= &ks_contexts[KSC_V3D_OBJECT]; /* loop through bases */ // XXX but we're only supposed to do this on editable ones, not just selected ones! CTX_DATA_BEGIN(C, Base*, base, selected_bases) { bCommonKeySrc *cks; /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set id-block to key to */ ob= base->object; cks->id= (ID *)ob; } CTX_DATA_END; } } /* helper for commonkey_context_get() - get keyingsets for buttons window */ static void commonkey_context_getsbuts (const bContext *C, ListBase *sources, bKeyingContext **ksc) { #if 0 // XXX dunno what's the future of this stuff... bCommonKeySrc *cks; /* check on tab-type */ switch (G.buts->mainb) { case CONTEXT_SHADING: /* ------------- Shading buttons ---------------- */ /* subtabs include "Material", "Texture", "Lamp", "World"*/ switch (G.buts->tab[CONTEXT_SHADING]) { case TAB_SHADING_MAT: /* >------------- Material Tab -------------< */ { Material *ma= editnode_get_active_material(G.buts->lockpoin); if (ma) { /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set data */ cks->id= (ID *)ma; cks->ipo= ma->ipo; cks->map= texchannel_to_adrcode(ma->texact); /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_MAT]; return; } } break; case TAB_SHADING_WORLD: /* >------------- World Tab -------------< */ { World *wo= G.buts->lockpoin; if (wo) { /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set data */ cks->id= (ID *)wo; cks->ipo= wo->ipo; cks->map= texchannel_to_adrcode(wo->texact); /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_WO]; return; } } break; case TAB_SHADING_LAMP: /* >------------- Lamp Tab -------------< */ { Lamp *la= G.buts->lockpoin; if (la) { /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set data */ cks->id= (ID *)la; cks->ipo= la->ipo; cks->map= texchannel_to_adrcode(la->texact); /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_LA]; return; } } break; case TAB_SHADING_TEX: /* >------------- Texture Tab -------------< */ { Tex *tex= G.buts->lockpoin; if (tex) { /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set data */ cks->id= (ID *)tex; cks->ipo= tex->ipo; /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_TEX]; return; } } break; } break; case CONTEXT_OBJECT: /* ------------- Object buttons ---------------- */ { Object *ob= OBACT; if (ob) { /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set id-block to key to */ cks->id= (ID *)ob; cks->ipo= ob->ipo; /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_OB]; return; } } break; case CONTEXT_EDITING: /* ------------- Editing buttons ---------------- */ { Object *ob= OBACT; if ((ob) && (ob->type==OB_CAMERA) && (G.buts->lockpoin)) { /* >---------------- camera buttons ---------------< */ Camera *ca= G.buts->lockpoin; /* add new keyframing destination */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(sources, cks); /* set id-block to key to */ cks->id= (ID *)ca; cks->ipo= ca->ipo; /* set keyingsets */ *ksc= &ks_contexts[KSC_BUTS_CAM]; return; } } break; } #endif // XXX end of buttons stuff to port... /* if nothing happened... */ *ksc= NULL; } #endif // XXX old keyingsets code based on adrcodes... to be restored in due course #if 0 // XXX new relative keyingsets code /* Check if context data is suitable for the given absolute Keying Set */ static short keyingset_context_ok_poll (bContext *C, KeyingSet *ks) { return 1; } /* Get list of data-sources from context for inserting keyframes using the given relative Keying Set */ static short commonkey_get_context_data (bContext *C, ListBase *dsources, KeyingSet *ks) { } #endif // XXX new relative keyingsets code /* Given a KeyingSet and context info (if required), modify keyframes for the channels specified * by the KeyingSet. This takes into account many of the different combinations of using KeyingSets. * Returns the number of channels that keyframes were added to */ static int commonkey_modifykey (ListBase *dsources, KeyingSet *ks, short mode, float cfra) { KS_Path *ksp; int kflag=0, success= 0; char *groupname= NULL; /* get flags to use */ if (mode == COMMONKEY_MODE_INSERT) { /* use KeyingSet's flags as base */ kflag= ks->keyingflag; /* suppliment with info from the context */ if (IS_AUTOKEY_FLAG(AUTOMATKEY)) kflag |= INSERTKEY_MATRIX; if (IS_AUTOKEY_FLAG(INSERTNEEDED)) kflag |= INSERTKEY_NEEDED; // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE; } else if (mode == COMMONKEY_MODE_DELETE) kflag= 0; /* check if the KeyingSet is absolute or not (i.e. does it requires sources info) */ if (ks->flag & KEYINGSET_ABSOLUTE) { /* Absolute KeyingSets are simpler to use, as all the destination info has already been * provided by the user, and is stored, ready to use, in the KeyingSet paths. */ for (ksp= ks->paths.first; ksp; ksp= ksp->next) { int arraylen, i; /* get pointer to name of group to add channels to */ if (ksp->groupmode == KSP_GROUP_NONE) groupname= NULL; else if (ksp->groupmode == KSP_GROUP_KSNAME) groupname= ks->name; else groupname= ksp->group; /* init arraylen and i - arraylen should be greater than i so that * normal non-array entries get keyframed correctly */ i= ksp->array_index; arraylen= i+1; /* get length of array if whole array option is enabled */ if (ksp->flag & KSP_FLAG_WHOLE_ARRAY) { PointerRNA id_ptr, ptr; PropertyRNA *prop; RNA_id_pointer_create(ksp->id, &id_ptr); if (RNA_path_resolve(&id_ptr, ksp->rna_path, &ptr, &prop) && prop) arraylen= RNA_property_array_length(&ptr, prop); } /* for each possible index, perform operation * - assume that arraylen is greater than index */ for (; i < arraylen; i++) { /* action to take depends on mode */ if (mode == COMMONKEY_MODE_INSERT) success+= insertkey(ksp->id, groupname, ksp->rna_path, i, cfra, kflag); else if (mode == COMMONKEY_MODE_DELETE) success+= deletekey(ksp->id, groupname, ksp->rna_path, i, cfra, kflag); } // TODO: set recalc tags on the ID? } } #if 0 // XXX still need to figure out how to get such keyingsets working else if (dsources) { /* for each one of the 'sources', resolve the template markers and expand arrays, then insert keyframes */ bCommonKeySrc *cks; char *path = NULL; int index=0, tot=0; /* for each 'source' for keyframe data, resolve each of the paths from the KeyingSet */ for (cks= dsources->first; cks; cks= cks->next) { } } #endif // XXX still need to figure out how to get such return success; } /* Polling callback for use with ANIM_*_keyframe() operators * This is based on the standard ED_operator_areaactive callback, * except that it does special checks for a few spacetypes too... */ static int modify_key_op_poll(bContext *C) { ScrArea *sa= CTX_wm_area(C); Scene *scene= CTX_data_scene(C); /* if no area or active scene */ if (ELEM(NULL, sa, scene)) return 0; /* if Outliner, only allow in DataBlocks view */ if (sa->spacetype == SPACE_OUTLINER) { SpaceOops *so= (SpaceOops *)CTX_wm_space_data(C); if ((so->outlinevis != SO_DATABLOCKS)) return 0; } /* TODO: checks for other space types can be added here */ /* should be fine */ return 1; } /* Insert Key Operator ------------------------ */ /* NOTE: * This is one of the 'simpler new-style' Insert Keyframe operators which relies on Keying Sets. * For now, these are absolute Keying Sets only, so there is very little context info involved. * * -- Joshua Leung, Feb 2009 */ static int insert_key_exec (bContext *C, wmOperator *op) { ListBase dsources = {NULL, NULL}; Scene *scene= CTX_data_scene(C); KeyingSet *ks= NULL; float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success; /* try to get KeyingSet */ if (scene->active_keyingset > 0) ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1); /* report failure */ if (ks == NULL) { BKE_report(op->reports, RPT_ERROR, "No active Keying Set"); return OPERATOR_CANCELLED; } /* try to insert keyframes for the channels specified by KeyingSet */ success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_INSERT, cfra); printf("KeyingSet '%s' - Successfully added %d Keyframes \n", ks->name, success); /* report failure? */ if (success == 0) BKE_report(op->reports, RPT_WARNING, "Keying Set failed to insert any keyframes"); /* send updates */ ED_anim_dag_flush_update(C); /* for now, only send ND_KEYS for KeyingSets */ WM_event_add_notifier(C, ND_KEYS, NULL); return OPERATOR_FINISHED; } void ANIM_OT_insert_keyframe (wmOperatorType *ot) { /* identifiers */ ot->name= "Insert Keyframe"; ot->idname= "ANIM_OT_insert_keyframe"; /* callbacks */ ot->exec= insert_key_exec; ot->poll= modify_key_op_poll; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; } /* Delete Key Operator ------------------------ */ /* NOTE: * This is one of the 'simpler new-style' Insert Keyframe operators which relies on Keying Sets. * For now, these are absolute Keying Sets only, so there is very little context info involved. * * -- Joshua Leung, Feb 2009 */ static int delete_key_exec (bContext *C, wmOperator *op) { ListBase dsources = {NULL, NULL}; Scene *scene= CTX_data_scene(C); KeyingSet *ks= NULL; float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success; /* try to get KeyingSet */ if (scene->active_keyingset > 0) ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1); /* report failure */ if (ks == NULL) { BKE_report(op->reports, RPT_ERROR, "No active Keying Set"); return OPERATOR_CANCELLED; } /* try to insert keyframes for the channels specified by KeyingSet */ success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_DELETE, cfra); printf("KeyingSet '%s' - Successfully removed %d Keyframes \n", ks->name, success); /* report failure? */ if (success == 0) BKE_report(op->reports, RPT_WARNING, "Keying Set failed to remove any keyframes"); /* send updates */ ED_anim_dag_flush_update(C); /* for now, only send ND_KEYS for KeyingSets */ WM_event_add_notifier(C, ND_KEYS, NULL); return OPERATOR_FINISHED; } void ANIM_OT_delete_keyframe (wmOperatorType *ot) { /* identifiers */ ot->name= "Delete Keyframe"; ot->idname= "ANIM_OT_delete_keyframe"; /* callbacks */ ot->exec= delete_key_exec; ot->poll= modify_key_op_poll; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; } /* Insert Key Operator ------------------------ */ /* XXX WARNING: * This is currently just a basic operator, which work in 3d-view context on objects/bones only * and will insert keyframes for a few settings only. This is until it becomes clear how * to separate (or not) the process for RNA-path creation between context + keyingsets. * * -- Joshua Leung, Jan 2009 */ /* defines for basic insert-key testing operator */ // XXX this will definitely be replaced EnumPropertyItem prop_insertkey_types[] = { {0, "KEYINGSET", "Active KeyingSet", ""}, {1, "OBLOC", "Object Location", ""}, {2, "OBROT", "Object Rotation", ""}, {3, "OBSCALE", "Object Scale", ""}, {4, "MAT_COL", "Active Material - Color", ""}, {5, "PCHANLOC", "Pose-Channel Location", ""}, {6, "PCHANROT", "Pose-Channel Rotation", ""}, {7, "PCHANSCALE", "Pose-Channel Scale", ""}, {0, NULL, NULL, NULL} }; static int insert_key_old_invoke (bContext *C, wmOperator *op, wmEvent *event) { Object *ob= CTX_data_active_object(C); uiMenuItem *head; if (ob == NULL) return OPERATOR_CANCELLED; head= uiPupMenuBegin("Insert Keyframe", 0); /* active keyingset */ uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 0); /* selective inclusion */ if ((ob->pose) && (ob->flag & OB_POSEMODE)) { /* bone types */ uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 5); uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 6); uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 7); } else { /* object types */ uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 1); uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 2); uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 3); uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 4); } uiPupMenuEnd(C, head); return OPERATOR_CANCELLED; } static int insert_key_old_exec (bContext *C, wmOperator *op) { Scene *scene= CTX_data_scene(C); short mode= RNA_enum_get(op->ptr, "type"); float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap /* for now, handle 'active keyingset' one separately */ if (mode == 0) { ListBase dsources = {NULL, NULL}; KeyingSet *ks= NULL; short success; /* try to get KeyingSet */ if (scene->active_keyingset > 0) ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1); /* report failure */ if (ks == NULL) { BKE_report(op->reports, RPT_ERROR, "No active Keying Set"); return OPERATOR_CANCELLED; } /* try to insert keyframes for the channels specified by KeyingSet */ success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_INSERT, cfra); printf("KeyingSet '%s' - Successfully added %d Keyframes \n", ks->name, success); /* report failure? */ if (success == 0) BKE_report(op->reports, RPT_WARNING, "Keying Set failed to insert any keyframes"); } else { // more comprehensive tests will be needed CTX_DATA_BEGIN(C, Base*, base, selected_bases) { Object *ob= base->object; ID *id= (ID *)ob; short success= 0; /* check which keyframing mode chosen for this object */ if (mode < 4) { /* object-based keyframes */ switch (mode) { case 4: /* color of active material (only for geometry...) */ // NOTE: this is just a demo... but ideally we'd go through materials instead of active one only so reference stays same // XXX no group for now success+= insertkey(id, NULL, "active_material.diffuse_color", 0, cfra, 0); success+= insertkey(id, NULL, "active_material.diffuse_color", 1, cfra, 0); success+= insertkey(id, NULL, "active_material.diffuse_color", 2, cfra, 0); break; case 3: /* object scale */ success+= insertkey(id, "Object Transforms", "scale", 0, cfra, 0); success+= insertkey(id, "Object Transforms", "scale", 1, cfra, 0); success+= insertkey(id, "Object Transforms", "scale", 2, cfra, 0); break; case 2: /* object rotation */ success+= insertkey(id, "Object Transforms", "rotation", 0, cfra, 0); success+= insertkey(id, "Object Transforms", "rotation", 1, cfra, 0); success+= insertkey(id, "Object Transforms", "rotation", 2, cfra, 0); break; default: /* object location */ success+= insertkey(id, "Object Transforms", "location", 0, cfra, 0); success+= insertkey(id, "Object Transforms", "location", 1, cfra, 0); success+= insertkey(id, "Object Transforms", "location", 2, cfra, 0); break; } ob->recalc |= OB_RECALC_OB; } else if ((ob->pose) && (ob->flag & OB_POSEMODE)) { /* PoseChannel based keyframes */ bPoseChannel *pchan; for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) { /* only if selected */ if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) { char buf[512]; switch (mode) { case 7: /* pchan scale */ sprintf(buf, "pose.pose_channels[\"%s\"].scale", pchan->name); success+= insertkey(id, pchan->name, buf, 0, cfra, 0); success+= insertkey(id, pchan->name, buf, 1, cfra, 0); success+= insertkey(id, pchan->name, buf, 2, cfra, 0); break; case 6: /* pchan rotation */ if (pchan->rotmode == PCHAN_ROT_QUAT) { sprintf(buf, "pose.pose_channels[\"%s\"].rotation", pchan->name); success+= insertkey(id, pchan->name, buf, 0, cfra, 0); success+= insertkey(id, pchan->name, buf, 1, cfra, 0); success+= insertkey(id, pchan->name, buf, 2, cfra, 0); success+= insertkey(id, pchan->name, buf, 3, cfra, 0); } else { sprintf(buf, "pose.pose_channels[\"%s\"].euler_rotation", pchan->name); success+= insertkey(id, pchan->name, buf, 0, cfra, 0); success+= insertkey(id, pchan->name, buf, 1, cfra, 0); success+= insertkey(id, pchan->name, buf, 2, cfra, 0); } break; default: /* pchan location */ sprintf(buf, "pose.pose_channels[\"%s\"].location", pchan->name); success+= insertkey(id, pchan->name, buf, 0, cfra, 0); success+= insertkey(id, pchan->name, buf, 1, cfra, 0); success+= insertkey(id, pchan->name, buf, 2, cfra, 0); break; } } } ob->recalc |= OB_RECALC_OB; } printf("Ob '%s' - Successfully added %d Keyframes \n", id->name+2, success); } CTX_DATA_END; } /* send updates */ ED_anim_dag_flush_update(C); if (mode == 0) /* for now, only send ND_KEYS for KeyingSets */ WM_event_add_notifier(C, ND_KEYS, NULL); else if (mode == 4) /* material color requires different notifiers */ WM_event_add_notifier(C, NC_MATERIAL|ND_KEYS, NULL); else WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, NULL); return OPERATOR_FINISHED; } void ANIM_OT_insert_keyframe_old (wmOperatorType *ot) { PropertyRNA *prop; /* identifiers */ ot->name= "Insert Keyframe"; ot->idname= "ANIM_OT_insert_keyframe_old"; /* callbacks */ ot->invoke= insert_key_old_invoke; ot->exec= insert_key_old_exec; ot->poll= ED_operator_areaactive; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; /* properties */ // XXX update this for the latest RNA stuff styles... prop= RNA_def_property(ot->srna, "type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, prop_insertkey_types); } /* Delete Key Operator ------------------------ */ /* XXX WARNING: * This is currently just a basic operator, which work in 3d-view context on objects only. * -- Joshua Leung, Jan 2009 */ static int delete_key_old_exec (bContext *C, wmOperator *op) { Scene *scene= CTX_data_scene(C); float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap // XXX more comprehensive tests will be needed CTX_DATA_BEGIN(C, Base*, base, selected_bases) { Object *ob= base->object; ID *id= (ID *)ob; FCurve *fcu, *fcn; short success= 0; /* loop through all curves in animdata and delete keys on this frame */ if (ob->adt) { AnimData *adt= ob->adt; bAction *act= adt->action; for (fcu= act->curves.first; fcu; fcu= fcn) { fcn= fcu->next; success+= deletekey(id, NULL, fcu->rna_path, fcu->array_index, cfra, 0); } } printf("Ob '%s' - Successfully removed %d keyframes \n", id->name+2, success); ob->recalc |= OB_RECALC_OB; } CTX_DATA_END; /* send updates */ ED_anim_dag_flush_update(C); // XXX what if it was a material keyframe? WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, NULL); return OPERATOR_FINISHED; } void ANIM_OT_delete_keyframe_old (wmOperatorType *ot) { /* identifiers */ ot->name= "Delete Keyframe"; ot->idname= "ANIM_OT_delete_keyframe_old"; /* callbacks */ ot->invoke= WM_operator_confirm; // XXX we will need our own one eventually, to cope with the dynamic menus... ot->exec= delete_key_old_exec; ot->poll= ED_operator_areaactive; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; } /* ******************************************* */ /* KEYFRAME DETECTION */ /* --------------- API/Per-Datablock Handling ------------------- */ /* Checks whether an IPO-block has a keyframe for a given frame * Since we're only concerned whether a keyframe exists, we can simply loop until a match is found... */ short action_frame_has_keyframe (bAction *act, float frame, short filter) { FCurve *fcu; /* can only find if there is data */ if (act == NULL) return 0; /* if only check non-muted, check if muted */ if ((filter & ANIMFILTER_KEYS_MUTED) || (act->flag & ACT_MUTED)) return 0; /* loop over F-Curves, using binary-search to try to find matches * - this assumes that keyframes are only beztriples */ for (fcu= act->curves.first; fcu; fcu= fcu->next) { /* only check if there are keyframes (currently only of type BezTriple) */ if (fcu->bezt && fcu->totvert) { /* we either include all regardless of muting, or only non-muted */ if ((filter & ANIMFILTER_KEYS_MUTED) || (fcu->flag & FCURVE_MUTED)==0) { short replace = -1; int i = binarysearch_bezt_index(fcu->bezt, frame, fcu->totvert, &replace); /* binarysearch_bezt_index will set replace to be 0 or 1 * - obviously, 1 represents a match */ if (replace) { /* sanity check: 'i' may in rare cases exceed arraylen */ if ((i >= 0) && (i < fcu->totvert)) return 1; } } } } /* nothing found */ return 0; } /* Checks whether an Object has a keyframe for a given frame */ short object_frame_has_keyframe (Object *ob, float frame, short filter) { /* error checking */ if (ob == NULL) return 0; /* check own animation data - specifically, the action it contains */ if ((ob->adt) && (ob->adt->action)) { if (action_frame_has_keyframe(ob->adt->action, frame, filter)) return 1; } /* try shapekey keyframes (if available, and allowed by filter) */ if ( !(filter & ANIMFILTER_KEYS_LOCAL) && !(filter & ANIMFILTER_KEYS_NOSKEY) ) { Key *key= ob_get_key(ob); /* shapekeys can have keyframes ('Relative Shape Keys') * or depend on time (old 'Absolute Shape Keys') */ /* 1. test for relative (with keyframes) */ if (id_frame_has_keyframe((ID *)key, frame, filter)) return 1; /* 2. test for time */ // TODO... yet to be implemented (this feature may evolve before then anyway) } /* try materials */ if ( !(filter & ANIMFILTER_KEYS_LOCAL) && !(filter & ANIMFILTER_KEYS_NOMAT) ) { /* if only active, then we can skip a lot of looping */ if (filter & ANIMFILTER_KEYS_ACTIVE) { Material *ma= give_current_material(ob, (ob->actcol + 1)); /* we only retrieve the active material... */ if (id_frame_has_keyframe((ID *)ma, frame, filter)) return 1; } else { int a; /* loop over materials */ for (a=0; atotcol; a++) { Material *ma= give_current_material(ob, a+1); if (id_frame_has_keyframe((ID *)ma, frame, filter)) return 1; } } } /* nothing found */ return 0; } /* --------------- API ------------------- */ /* Checks whether a keyframe exists for the given ID-block one the given frame */ short id_frame_has_keyframe (ID *id, float frame, short filter) { /* sanity checks */ if (id == NULL) return 0; /* perform special checks for 'macro' types */ switch (GS(id->name)) { case ID_OB: /* object */ return object_frame_has_keyframe((Object *)id, frame, filter); break; case ID_SCE: /* scene */ // XXX TODO... for now, just use 'normal' behaviour // break; default: /* 'normal type' */ { AnimData *adt= BKE_animdata_from_id(id); /* only check keyframes in active action */ if (adt) return action_frame_has_keyframe(adt->action, frame, filter); } break; } /* no keyframe found */ return 0; } /* ************************************************** */