static int mask_shape_key_insert_exec(bContext *C, wmOperator *UNUSED(op)) { Scene *scene = CTX_data_scene(C); const int frame = CFRA; Mask *mask = CTX_data_edit_mask(C); MaskLayer *masklay; bool changed = false; for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) { MaskLayerShape *masklay_shape; if (!ED_mask_layer_select_check(masklay)) { continue; } masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, frame); BKE_mask_layer_shape_from_mask(masklay, masklay_shape); changed = true; } if (changed) { WM_event_add_notifier(C, NC_MASK | ND_DATA, mask); DAG_id_tag_update(&mask->id, 0); return OPERATOR_FINISHED; } else { return OPERATOR_CANCELLED; } }
void ED_mask_layer_shape_auto_key(MaskLayer *masklay, const int frame) { MaskLayerShape *masklay_shape; masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, frame); BKE_mask_layer_shape_from_mask(masklay, masklay_shape); }
void MaskOperation::initExecution() { if (this->m_mask && this->m_rasterMaskHandles[0] == NULL) { if (this->m_rasterMaskHandleTot == 1) { this->m_rasterMaskHandles[0] = BKE_maskrasterize_handle_new(); BKE_maskrasterize_handle_init(this->m_rasterMaskHandles[0], this->m_mask, this->m_maskWidth, this->m_maskHeight, true, this->m_do_smooth, this->m_do_feather); } else { /* make a throw away copy of the mask */ const float frame = (float)this->m_frame_number - this->m_frame_shutter; const float frame_step = (this->m_frame_shutter * 2.0f) / this->m_rasterMaskHandleTot; float frame_iter = frame; Mask *mask_temp; mask_temp = BKE_mask_copy_nolib(this->m_mask); /* trick so we can get unkeyed edits to display */ { MaskLayer *masklay; MaskLayerShape *masklay_shape; for (masklay = (MaskLayer *)mask_temp->masklayers.first; masklay; masklay = masklay->next) { masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, this->m_frame_number); BKE_mask_layer_shape_from_mask(masklay, masklay_shape); } } for (unsigned int i = 0; i < this->m_rasterMaskHandleTot; i++) { this->m_rasterMaskHandles[i] = BKE_maskrasterize_handle_new(); /* re-eval frame info */ BKE_mask_evaluate(mask_temp, frame_iter, true); BKE_maskrasterize_handle_init(this->m_rasterMaskHandles[i], mask_temp, this->m_maskWidth, this->m_maskHeight, true, this->m_do_smooth, this->m_do_feather); frame_iter += frame_step; } BKE_mask_free_nolib(mask_temp); MEM_freeN(mask_temp); } } }
/* * - loop over selected shapekeys. * - find firstsel/lastsel pairs. * - move these into a temp list. * - re-key all the original shapes. * - copy unselected values back from the original. * - free the original. */ static int mask_shape_key_rekey_exec(bContext *C, wmOperator *op) { Scene *scene = CTX_data_scene(C); const int frame = CFRA; Mask *mask = CTX_data_edit_mask(C); MaskLayer *masklay; bool changed = false; const bool do_feather = RNA_boolean_get(op->ptr, "feather"); const bool do_location = RNA_boolean_get(op->ptr, "location"); for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) { if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) { continue; } /* we need at least one point selected here to bother re-interpolating */ if (!ED_mask_layer_select_check(masklay)) { continue; } if (masklay->splines_shapes.first) { MaskLayerShape *masklay_shape, *masklay_shape_next; MaskLayerShape *masklay_shape_lastsel = NULL; for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = masklay_shape_next) { MaskLayerShape *masklay_shape_a = NULL; MaskLayerShape *masklay_shape_b = NULL; masklay_shape_next = masklay_shape->next; /* find contiguous selections */ if (masklay_shape->flag & MASK_SHAPE_SELECT) { if (masklay_shape_lastsel == NULL) { masklay_shape_lastsel = masklay_shape; } if ((masklay_shape->next == NULL) || (((MaskLayerShape *)masklay_shape->next)->flag & MASK_SHAPE_SELECT) == 0) { masklay_shape_a = masklay_shape_lastsel; masklay_shape_b = masklay_shape; masklay_shape_lastsel = NULL; /* this will be freed below, step over selection */ masklay_shape_next = masklay_shape->next; } } /* we have a from<>to? - re-interpolate! */ if (masklay_shape_a && masklay_shape_b) { ListBase shapes_tmp = {NULL, NULL}; MaskLayerShape *masklay_shape_tmp; MaskLayerShape *masklay_shape_tmp_next; MaskLayerShape *masklay_shape_tmp_last = masklay_shape_b->next; MaskLayerShape *masklay_shape_tmp_rekey; /* move keys */ for (masklay_shape_tmp = masklay_shape_a; masklay_shape_tmp && (masklay_shape_tmp != masklay_shape_tmp_last); masklay_shape_tmp = masklay_shape_tmp_next) { masklay_shape_tmp_next = masklay_shape_tmp->next; BLI_remlink(&masklay->splines_shapes, masklay_shape_tmp); BLI_addtail(&shapes_tmp, masklay_shape_tmp); } /* re-key, note: cant modify the keys here since it messes uop */ for (masklay_shape_tmp = shapes_tmp.first; masklay_shape_tmp; masklay_shape_tmp = masklay_shape_tmp->next) { BKE_mask_layer_evaluate(masklay, masklay_shape_tmp->frame, true); masklay_shape_tmp_rekey = BKE_mask_layer_shape_verify_frame(masklay, masklay_shape_tmp->frame); BKE_mask_layer_shape_from_mask(masklay, masklay_shape_tmp_rekey); masklay_shape_tmp_rekey->flag = masklay_shape_tmp->flag & MASK_SHAPE_SELECT; } /* restore unselected points and free copies */ for (masklay_shape_tmp = shapes_tmp.first; masklay_shape_tmp; masklay_shape_tmp = masklay_shape_tmp_next) { /* restore */ int i_abs = 0; int i; MaskSpline *spline; MaskLayerShapeElem *shape_ele_src; MaskLayerShapeElem *shape_ele_dst; masklay_shape_tmp_next = masklay_shape_tmp->next; /* we know this exists, added above */ masklay_shape_tmp_rekey = BKE_mask_layer_shape_find_frame(masklay, masklay_shape_tmp->frame); shape_ele_src = (MaskLayerShapeElem *)masklay_shape_tmp->data; shape_ele_dst = (MaskLayerShapeElem *)masklay_shape_tmp_rekey->data; for (spline = masklay->splines.first; spline; spline = spline->next) { for (i = 0; i < spline->tot_point; i++) { MaskSplinePoint *point = &spline->points[i]; /* not especially efficient but makes this easier to follow */ SWAP(MaskLayerShapeElem, *shape_ele_src, *shape_ele_dst); if (MASKPOINT_ISSEL_ANY(point)) { if (do_location) { memcpy(shape_ele_dst->value, shape_ele_src->value, sizeof(float) * 6); } if (do_feather) { shape_ele_dst->value[6] = shape_ele_src->value[6]; } } shape_ele_src++; shape_ele_dst++; i_abs++; } } BKE_mask_layer_shape_free(masklay_shape_tmp); } changed = true; } } /* re-evaluate */ BKE_mask_layer_evaluate(masklay, frame, true); } } if (changed) { WM_event_add_notifier(C, NC_MASK | ND_DATA, mask); DAG_id_tag_update(&mask->id, 0); return OPERATOR_FINISHED; } else { return OPERATOR_CANCELLED; } }
static int mask_shape_key_feather_reset_exec(bContext *C, wmOperator *UNUSED(op)) { Scene *scene = CTX_data_scene(C); const int frame = CFRA; Mask *mask = CTX_data_edit_mask(C); MaskLayer *masklay; bool changed = false; for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) { if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) { continue; } if (masklay->splines_shapes.first) { MaskLayerShape *masklay_shape_reset; MaskLayerShape *masklay_shape; /* get the shapekey of the current state */ masklay_shape_reset = BKE_mask_layer_shape_alloc(masklay, frame); /* initialize from mask - as if inseting a keyframe */ BKE_mask_layer_shape_from_mask(masklay, masklay_shape_reset); for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = masklay_shape->next) { if (masklay_shape_reset->tot_vert == masklay_shape->tot_vert) { int i_abs = 0; int i; MaskSpline *spline; MaskLayerShapeElem *shape_ele_src; MaskLayerShapeElem *shape_ele_dst; shape_ele_src = (MaskLayerShapeElem *)masklay_shape_reset->data; shape_ele_dst = (MaskLayerShapeElem *)masklay_shape->data; for (spline = masklay->splines.first; spline; spline = spline->next) { for (i = 0; i < spline->tot_point; i++) { MaskSplinePoint *point = &spline->points[i]; if (MASKPOINT_ISSEL_ANY(point)) { /* TODO - nicer access here */ shape_ele_dst->value[6] = shape_ele_src->value[6]; } shape_ele_src++; shape_ele_dst++; i_abs++; } } } else { // printf("%s: skipping\n", __func__); } changed = true; } BKE_mask_layer_shape_free(masklay_shape_reset); } } if (changed) { WM_event_add_notifier(C, NC_MASK | ND_DATA, mask); DAG_id_tag_update(&mask->id, 0); return OPERATOR_FINISHED; } else { return OPERATOR_CANCELLED; } }