/* 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 */ /* specific cases */ bPoseChannel *pchan; bConstraint *con; } 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 (ID = %s, Path = %s)\n", id->name, 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 F-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; } /* ******************************************* */ /* KEYING SETS - EDITING API */ /* 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; } /* ******************************************* */ /* KEYING SETS - BUILTIN */ #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; #endif // XXX old keyingsets code based on adrcodes... to be restored in due course /* Macros for Declaring KeyingSets ------------------- */ /* A note about this system for declaring built-in Keying Sets: * One may ask, "What is the purpose of all of these macros and static arrays?" and * "Why not call the KeyingSets API defined in BKE_animsys.h?". The answer is two-fold. * * 1) Firstly, we use static arrays of struct definitions instead of function calls, as * it reduces the start-up overhead and allocated-memory footprint of Blender. If we called * the KeyingSets API to build these sets, the overhead of checking for unique names, allocating * memory for each and every path and KeyingSet, scattered around in RAM, all of which would increase * the startup time (which is totally unacceptable) and could lead to fragmentation+slower access times. * 2) Since we aren't using function calls, we need a nice way of defining these KeyingSets in a way which * is easily readable and less prone to breakage from changes to the underlying struct definitions. Further, * adding additional entries SHOULD NOT require custom code to be written to access these new entries/sets. * Therefore, here we have a system with nice, human-readable statements via macros, and static arrays which * are linked together using more special macros + struct definitions, allowing for such a generic + simple * initialisation function (init_builtin_keyingsets()) compared with that of something like the Nodes system. */ /* Struct type for declaring builtin KeyingSets in as entries in static arrays*/ typedef struct bBuiltinKeyingSet { KeyingSet ks; /* the KeyingSet to build */ int tot; /* the total number of paths defined */ KS_Path paths[64]; /* the paths for the KeyingSet to use */ } bBuiltinKeyingSet; /* WARNING: the following macros must be kept in sync with the * struct definitions in DNA_anim_types.h! */ /* macro for defining a builtin KeyingSet */ #define BI_KS_DEFINE(name, keyingflag) \ {NULL, NULL, {NULL, NULL}, name, KEYINGSET_BUILTIN, keyingflag} /* macro to start defining paths for a builtin KeyingSet */ #define BI_KS_PATHS_BEGIN(tot) \ tot, { /* macro to finish defining paths for a builtin KeyingSet */ #define BI_KS_PATHS_END \ } /* macro for defining a builtin KeyingSet's path */ #define BI_KSP_DEFINE(id_type, templates, prop_path, array_index, flag, groupflag) \ {NULL, NULL, NULL, "", id_type, templates, prop_path, array_index, flag, groupflag} /* ---- */ /* Struct type for finding all the arrays of builtin KeyingSets */ typedef struct bBuiltinKSContext { bBuiltinKeyingSet *bks; /* array of KeyingSet definitions */ int tot; /* number of KeyingSets in this array */ } bBuiltinKSContext; /* macro for defining builtin KeyingSet sets * NOTE: all the arrays of sets must follow this naming convention! */ #define BKSC_TEMPLATE(ctx_name) {&def_builtin_keyingsets_##ctx_name[0], sizeof(def_builtin_keyingsets_##ctx_name)/sizeof(bBuiltinKeyingSet)} /* 3D-View Builtin KeyingSets ------------------------ */ static bBuiltinKeyingSet def_builtin_keyingsets_v3d[] = { /* Simple Keying Sets ************************************* */ /* Keying Set - "Location" ---------- */ { /* KeyingSet Definition */ BI_KS_DEFINE("Location", 0), /* Path Definitions */ BI_KS_PATHS_BEGIN(1) BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "location", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME) BI_KS_PATHS_END }, /* Keying Set - "Rotation" ---------- */ { /* KeyingSet Definition */ BI_KS_DEFINE("Rotation", 0), /* Path Definitions */ BI_KS_PATHS_BEGIN(1) BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "rotation", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME) BI_KS_PATHS_END }, /* Keying Set - "Scaling" ---------- */ { /* KeyingSet Definition */ BI_KS_DEFINE("Scaling", 0), /* Path Definitions */ BI_KS_PATHS_BEGIN(1) BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "scale", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME) BI_KS_PATHS_END }, /* Compound Keying Sets *********************************** */ /* Keying Set - "LocRot" ---------- */ { /* KeyingSet Definition */ BI_KS_DEFINE("LocRot", 0), /* Path Definitions */ BI_KS_PATHS_BEGIN(2) BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "location", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME), BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "rotation", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME) BI_KS_PATHS_END }, /* Keying Set - "LocRotScale" ---------- */ { /* KeyingSet Definition */ BI_KS_DEFINE("LocRotScale", 0), /* Path Definitions */ BI_KS_PATHS_BEGIN(2) BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "location", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME), BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "rotation", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME), BI_KSP_DEFINE(ID_OB, KSP_TEMPLATE_OBJECT|KSP_TEMPLATE_PCHAN, "scale", 0, KSP_FLAG_WHOLE_ARRAY, KSP_GROUP_KSNAME) BI_KS_PATHS_END } }; /* All Builtin KeyingSets ------------------------ */ /* total number of builtin KeyingSet contexts */ #define MAX_BKSC_TYPES 1 /* array containing all the available builtin KeyingSets definition sets * - size of this is MAX_BKSC_TYPES+1 so that we don't smash the stack */ static bBuiltinKSContext def_builtin_keyingsets[MAX_BKSC_TYPES+1] = { BKSC_TEMPLATE(v3d) /* add more contexts above this line... */ }; /* ListBase of these KeyingSets chained up ready for usage */ static ListBase builtin_keyingsets = {NULL, NULL}; /* Utility API ------------------------ */ /* Link up all of the builtin Keying Sets when starting up Blender * This is called from WM_init() in wm_init_exit.c */ void init_builtin_keyingsets (void) { bBuiltinKSContext *bksc; bBuiltinKeyingSet *bks; int bksc_i, bks_i; /* loop over all the sets of KeyingSets, setting them up, and chaining them to the builtins list */ for (bksc_i= 0, bksc= &def_builtin_keyingsets[0]; bksc_i < MAX_BKSC_TYPES; bksc_i++, bksc++) { /* for each set definitions for a builtin KeyingSet, chain the paths to that KeyingSet and add */ for (bks_i= 0, bks= bksc->bks; bks_i < bksc->tot; bks_i++, bks++) { KeyingSet *ks= &bks->ks; KS_Path *ksp; int pIndex; /* loop over paths, linking them to the KeyingSet and each other */ for (pIndex= 0, ksp= &bks->paths[0]; pIndex < bks->tot; pIndex++, ksp++) BLI_addtail(&ks->paths, ksp); /* add KeyingSet to builtin sets list */ BLI_addtail(&builtin_keyingsets, ks); } } } /* ******************************************* */ /* KEYFRAME MODIFICATION */ /* mode for commonkey_modifykey */ enum { COMMONKEY_MODE_INSERT = 0, COMMONKEY_MODE_DELETE, } eCommonModifyKey_Modes; /* KeyingSet Menu Helpers ------------ */ /* Extract the maximum set of requirements from the KeyingSet */ static int keyingset_relative_get_templates (KeyingSet *ks) { KS_Path *ksp; int templates= 0; /* loop over the paths (could be slow to do for a number of KeyingSets)? */ for (ksp= ks->paths.first; ksp; ksp= ksp->next) { /* add the destination's templates to the set of templates required for the set */ templates |= ksp->templates; } return templates; } /* Check if context data is suitable for the given absolute Keying Set */ static short keyingset_context_ok_poll (bContext *C, KeyingSet *ks) { ScrArea *sa= CTX_wm_area(C); /* data retrieved from context depends on active editor */ if (sa == NULL) return 0; switch (sa->spacetype) { case SPACE_VIEW3D: { Object *obact= CTX_data_active_object(C); /* if in posemode, check if 'pose-channels' requested for in KeyingSet */ if ((obact && obact->pose) && (obact->flag & OB_POSEMODE)) { /* check for posechannels */ } else { /* check for selected object */ } } break; } return 1; } /* KeyingSet Context Operations ------------ */ /* Get list of data-sources from context (in 3D-View) for inserting keyframes using the given relative Keying Set */ static short commonkey_get_context_v3d_data (bContext *C, ListBase *dsources, KeyingSet *ks) { bCommonKeySrc *cks; Object *obact= CTX_data_active_object(C); int templates; short ok= 0; /* get the templates in use in this KeyingSet which we should supply data for */ templates = keyingset_relative_get_templates(ks); /* check if the active object is in PoseMode (i.e. only deal with bones) */ // TODO: check with the templates to see what we really need to store if ((obact && obact->pose) && (obact->flag & OB_POSEMODE)) { /* Pose Mode: Selected bones */ #if 0 //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) { // } //} #endif CTX_DATA_BEGIN(C, bPoseChannel*, pchan, selected_pchans) { /* add a new keying-source */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(dsources, cks); /* set necessary info */ cks->id= &obact->id; cks->pchan= pchan; if (templates & KSP_TEMPLATE_CONSTRAINT) cks->con= constraints_get_active(&pchan->constraints); ok= 1; } CTX_DATA_END; } else { /* Object Mode: Selected objects */ CTX_DATA_BEGIN(C, Base*, base, selected_bases) { Object *ob= base->object; /* add a new keying-source */ cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc"); BLI_addtail(dsources, cks); /* set necessary info */ cks->id= &ob->id; if (templates & KSP_TEMPLATE_CONSTRAINT) cks->con= constraints_get_active(&ob->constraints); ok= 1; } CTX_DATA_END; } /* return whether any data was extracted */ return ok; } /* 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) { ScrArea *sa= CTX_wm_area(C); /* for now, the active area is used to determine what set of contexts apply */ if (sa == NULL) return 0; switch (sa->spacetype) { case SPACE_VIEW3D: /* 3D-View: Selected Objects or Bones */ return commonkey_get_context_v3d_data(C, dsources, ks); } /* nothing happened */ return 0; } /* KeyingSet Operations (Insert/Delete Keyframes) ------------ */ /* 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 (bContext *C, 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); } /* send notifiers and set recalc-flags */ // TODO: hopefully this doesn't result in execessive flooding of the notifier stack if (C && ksp->id) { switch (GS(ksp->id->name)) { case ID_OB: /* Object (or Object-Related) Keyframes */ { Object *ob= (Object *)ksp->id; ob->recalc |= OB_RECALC; WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, ksp->id); } break; case ID_MA: /* Material Keyframes */ WM_event_add_notifier(C, NC_MATERIAL|ND_KEYS, ksp->id); break; } } } } else if (dsources && dsources->first) { /* for each one of the 'sources', resolve the template markers and expand arrays, then insert keyframes */ bCommonKeySrc *cks; /* for each 'source' for keyframe data, resolve each of the paths from the KeyingSet */ for (cks= dsources->first; cks; cks= cks->next) { /* for each path in KeyingSet, construct a path using the templates */ for (ksp= ks->paths.first; ksp; ksp= ksp->next) { DynStr *pathds= BLI_dynstr_new(); char *path = NULL; int arraylen, i; /* construct the path */ // FIXME: this currently only works with a few hardcoded cases if ((ksp->templates & KSP_TEMPLATE_PCHAN) && (cks->pchan)) { /* add basic pose-channel path access */ BLI_dynstr_append(pathds, "pose.pose_channels[\""); BLI_dynstr_append(pathds, cks->pchan->name); BLI_dynstr_append(pathds, "\"]"); } if ((ksp->templates & KSP_TEMPLATE_CONSTRAINT) && (cks->con)) { /* add basic constraint path access */ BLI_dynstr_append(pathds, "constraints[\""); BLI_dynstr_append(pathds, cks->con->name); BLI_dynstr_append(pathds, "\"]"); } { /* add property stored in KeyingSet Path */ if (BLI_dynstr_get_len(pathds)) BLI_dynstr_append(pathds, "."); BLI_dynstr_append(pathds, ksp->rna_path); /* convert to C-string */ path= BLI_dynstr_get_cstring(pathds); BLI_dynstr_free(pathds); } /* 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(cks->id, &id_ptr); if (RNA_path_resolve(&id_ptr, 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(cks->id, groupname, path, i, cfra, kflag); else if (mode == COMMONKEY_MODE_DELETE) success+= deletekey(cks->id, groupname, path, i, cfra, kflag); } /* free the path */ MEM_freeN(path); } /* send notifiers and set recalc-flags */ // TODO: hopefully this doesn't result in execessive flooding of the notifier stack if (C && cks->id) { switch (GS(cks->id->name)) { case ID_OB: /* Object (or Object-Related) Keyframes */ { Object *ob= (Object *)cks->id; ob->recalc |= OB_RECALC; WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, cks->id); } break; case ID_MA: /* Material Keyframes */ WM_event_add_notifier(C, NC_MATERIAL|ND_KEYS, cks->id); break; } } } } /* return the number of channels successfully affected */ 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 ------------------------ */ static int insert_key_exec (bContext *C, wmOperator *op) { ListBase dsources = {NULL, NULL}; Scene *scene= CTX_data_scene(C); KeyingSet *ks= NULL; int type= RNA_int_get(op->ptr, "type"); float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success; /* type is the Keying Set the user specified to use when calling the operator: * - type == 0: use scene's active Keying Set * - type > 0: use a user-defined Keying Set from the active scene * - type < 0: use a builtin Keying Set */ if (type == 0) type= scene->active_keyingset; if (type > 0) ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1); else ks= BLI_findlink(&builtin_keyingsets, -type-1); /* report failures */ if (ks == NULL) { BKE_report(op->reports, RPT_ERROR, "No active Keying Set"); return OPERATOR_CANCELLED; } /* get context info for relative Keying Sets */ if ((ks->flag & KEYINGSET_ABSOLUTE) == 0) { /* exit if no suitable data obtained */ if (commonkey_get_context_data(C, &dsources, ks) == 0) { BKE_report(op->reports, RPT_ERROR, "No suitable context info for active Keying Set"); return OPERATOR_CANCELLED; } } /* try to insert keyframes for the channels specified by KeyingSet */ success= commonkey_modifykey(C, &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"); /* free temp context-data if available */ if (dsources.first) { /* we assume that there is no extra data that needs to be freed from here... */ BLI_freelistN(&dsources); } /* 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; /* settings */ RNA_def_int(ot->srna, "type", 0, INT_MIN, INT_MAX, "Keying Set Number", "Index (determined internally) of the Keying Set to use", 0, 1); } /* Insert Key Operator (With Menu) ------------------------ */ /* XXX * This operator pops up a menu which sets gets the index of the keyingset to use, * setting the global settings, and calling the insert-keyframe operator using these * settings */ static int insert_key_menu_invoke (bContext *C, wmOperator *op, wmEvent *event) { Scene *scene= CTX_data_scene(C); KeyingSet *ks; uiMenuItem *head; int i = 0; head= uiPupMenuBegin("Insert Keyframe", 0); /* active Keying Set */ uiMenuItemIntO(head, "Active Keying Set", 0, "ANIM_OT_insert_keyframe_menu", "type", i++); uiMenuSeparator(head); /* user-defined Keying Sets * - these are listed in the order in which they were defined for the active scene */ for (ks= scene->keyingsets.first; ks; ks= ks->next) uiMenuItemIntO(head, ks->name, 0, "ANIM_OT_insert_keyframe_menu", "type", i++); uiMenuSeparator(head); /* builtin Keying Sets */ // XXX polling the entire list may lag i= -1; for (ks= builtin_keyingsets.first; ks; ks= ks->next) { /* only show KeyingSet if context is suitable */ if (keyingset_context_ok_poll(C, ks)) { uiMenuItemIntO(head, ks->name, 0, "ANIM_OT_insert_keyframe_menu", "type", i--); } } uiPupMenuEnd(C, head); return OPERATOR_CANCELLED; } void ANIM_OT_insert_keyframe_menu (wmOperatorType *ot) { /* identifiers */ ot->name= "Insert Keyframe"; ot->idname= "ANIM_OT_insert_keyframe_menu"; /* callbacks */ ot->invoke= insert_key_menu_invoke; ot->exec= insert_key_exec; ot->poll= ED_operator_areaactive; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; /* properties * - NOTE: here the type is int not enum, since many of the indicies here are determined dynamically */ RNA_def_int(ot->srna, "type", 0, INT_MIN, INT_MAX, "Keying Set Number", "Index (determined internally) of the Keying Set to use", 0, 1); } /* Delete Key Operator ------------------------ */ static int delete_key_exec (bContext *C, wmOperator *op) { ListBase dsources = {NULL, NULL}; Scene *scene= CTX_data_scene(C); KeyingSet *ks= NULL; int type= RNA_int_get(op->ptr, "type"); float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success; /* type is the Keying Set the user specified to use when calling the operator: * - type == 0: use scene's active Keying Set * - type > 0: use a user-defined Keying Set from the active scene * - type < 0: use a builtin Keying Set */ if (type == 0) type= scene->active_keyingset; if (type > 0) ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1); else ks= BLI_findlink(&builtin_keyingsets, -type-1); /* report failure */ if (ks == NULL) { BKE_report(op->reports, RPT_ERROR, "No active Keying Set"); return OPERATOR_CANCELLED; } /* get context info for relative Keying Sets */ if ((ks->flag & KEYINGSET_ABSOLUTE) == 0) { /* exit if no suitable data obtained */ if (commonkey_get_context_data(C, &dsources, ks) == 0) { BKE_report(op->reports, RPT_ERROR, "No suitable context info for active Keying Set"); return OPERATOR_CANCELLED; } } /* try to insert keyframes for the channels specified by KeyingSet */ success= commonkey_modifykey(C, &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"); /* free temp context-data if available */ if (dsources.first) { /* we assume that there is no extra data that needs to be freed from here... */ BLI_freelistN(&dsources); } /* 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; /* properties * - NOTE: here the type is int not enum, since many of the indicies here are determined dynamically */ RNA_def_int(ot->srna, "type", 0, INT_MIN, INT_MAX, "Keying Set Number", "Index (determined internally) of the Keying Set to use", 0, 1); } /* Delete Key Operator ------------------------ */ /* XXX WARNING: * This is currently just a basic operator, which work in 3d-view context on objects only. * Should this be kept? It does have advantages over a version which requires selecting a keyingset to use... * -- 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); 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; ot->exec= delete_key_old_exec; ot->poll= ED_operator_areaactive; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; } /* Insert Key Button Operator ------------------------ */ static int insert_key_button_exec (bContext *C, wmOperator *op) { Scene *scene= CTX_data_scene(C); PointerRNA ptr = {0}; PropertyRNA *prop= NULL; char *path; float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success= 0; int a, index, length, all= RNA_boolean_get(op->ptr, "all"); /* try to insert keyframe using property retrieved from UI */ uiAnimContextProperty(C, &ptr, &prop, &index); if(ptr.data && prop && RNA_property_animateable(ptr.data, prop)) { path= RNA_path_from_ID_to_property(&ptr, prop); if(path) { if(all) { length= RNA_property_array_length(&ptr, prop); if(length) index= 0; else length= 1; } else length= 1; for(a=0; aname= "Insert Keyframe"; ot->idname= "ANIM_OT_insert_keyframe_button"; /* callbacks */ ot->exec= insert_key_button_exec; ot->poll= modify_key_op_poll; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; /* properties */ RNA_def_boolean(ot->srna, "all", 1, "All", "Insert a keyframe for all element of the array."); } /* Delete Key Button Operator ------------------------ */ static int delete_key_button_exec (bContext *C, wmOperator *op) { Scene *scene= CTX_data_scene(C); PointerRNA ptr = {0}; PropertyRNA *prop= NULL; char *path; float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap short success= 0; int a, index, length, all= RNA_boolean_get(op->ptr, "all"); /* try to insert keyframe using property retrieved from UI */ uiAnimContextProperty(C, &ptr, &prop, &index); if(ptr.data && prop) { path= RNA_path_from_ID_to_property(&ptr, prop); if(path) { if(all) { length= RNA_property_array_length(&ptr, prop); if(length) index= 0; else length= 1; } else length= 1; for(a=0; aname= "Delete Keyframe"; ot->idname= "ANIM_OT_delete_keyframe_button"; /* callbacks */ ot->exec= delete_key_button_exec; ot->poll= modify_key_op_poll; /* flags */ ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; /* properties */ RNA_def_boolean(ot->srna, "all", 1, "All", "Delete keyfames from all elements of the array."); } /* ******************************************* */ /* KEYFRAME DETECTION */ /* --------------- API/Per-Datablock Handling ------------------- */ /* Checks whether an Action 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; } /* ************************************************** */