Differential D2889 Diff 9435 source/blender/editors/transform/transform_conversions.c

Changeset View

Standalone View

source/blender/editors/transform/transform_conversions.c

Context not available.
	}	}
	#endif	#endif
	}	}
		/* set cache flag to dirty */
		BKE_gpencil_batch_cache_dirty(gpd);
	}	}

	static void posttrans_mask_clean(Mask *mask)	static void posttrans_mask_clean(Mask *mask)
Context not available.
	static void createTransGPencil(bContext C, TransInfo t)	static void createTransGPencil(bContext C, TransInfo t)
	{	{
	bGPdata *gpd = ED_gpencil_data_get_active(C);	bGPdata *gpd = ED_gpencil_data_get_active(C);
		bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
		Object *obact = CTX_data_active_object(C);
	bGPDlayer *gpl;	bGPDlayer *gpl;
	TransData *td = NULL;	TransData *td = NULL;
	float mtx[3][3], smtx[3][3];	float mtx[3][3], smtx[3][3];
Context not available.
	const bool is_prop_edit = (t->flag & T_PROP_EDIT) != 0;	const bool is_prop_edit = (t->flag & T_PROP_EDIT) != 0;
	const bool is_prop_edit_connected = (t->flag & T_PROP_CONNECTED) != 0;	const bool is_prop_edit_connected = (t->flag & T_PROP_CONNECTED) != 0;

		/* current edit grease pencil object */
		t->obedit = obact;

	/* == Grease Pencil Strokes to Transform Data ==	/* == Grease Pencil Strokes to Transform Data ==
	* Grease Pencil stroke points can be a mixture of 2D (screen-space),	* Grease Pencil stroke points can be a mixture of 2D (screen-space),
	* or 3D coordinates. However, they're always saved as 3D points.	* or 3D coordinates. However, they're always saved as 3D points.
Context not available.
	for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {	for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
	/* only editable and visible layers are considered */	/* only editable and visible layers are considered */
	if (gpencil_layer_is_editable(gpl) && (gpl->actframe != NULL)) {	if (gpencil_layer_is_editable(gpl) && (gpl->actframe != NULL)) {
	bGPDframe *gpf = gpl->actframe;	bGPDframe *gpf;
	bGPDstroke *gps;	bGPDstroke *gps;
		bGPDframe *init_gpf = gpl->actframe;
		if (is_multiedit) {
		init_gpf = gpl->frames.first;
		}

	for (gps = gpf->strokes.first; gps; gps = gps->next) {	for (gpf = init_gpf; gpf; gpf = gpf->next) {
	/* skip strokes that are invalid for current view */	if ((gpf == gpl->actframe) \|\| ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
	if (ED_gpencil_stroke_can_use(C, gps) == false) {
	continue;
	}
	/* check if the color is editable */
	if (ED_gpencil_stroke_color_use(gpl, gps) == false) {
	continue;
	}

	if (is_prop_edit) {	for (gps = gpf->strokes.first; gps; gps = gps->next) {
	/* Proportional Editing... */	/* skip strokes that are invalid for current view */
	if (is_prop_edit_connected) {	if (ED_gpencil_stroke_can_use(C, gps) == false) {
	/* connected only - so only if selected */	continue;
	if (gps->flag & GP_STROKE_SELECT)	}
	t->total += gps->totpoints;	/* check if the color is editable */
	}	if (ED_gpencil_stroke_color_use(gpl, gps) == false) {
	else {	continue;
	/* everything goes - connection status doesn't matter */	}
	t->total += gps->totpoints;
	}	if (is_prop_edit) {
	}	/* Proportional Editing... */
	else {	if (is_prop_edit_connected) {
	/* only selected stroke points are considered */	/* connected only - so only if selected */
	if (gps->flag & GP_STROKE_SELECT) {	if (gps->flag & GP_STROKE_SELECT)
	bGPDspoint *pt;	t->total += gps->totpoints;
	int i;	}
		else {
	// TODO: 2D vs 3D?	/* everything goes - connection status doesn't matter */
	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {	t->total += gps->totpoints;
	if (pt->flag & GP_SPOINT_SELECT)	}
	t->total++;	}
		else {
		/* only selected stroke points are considered */
		if (gps->flag & GP_STROKE_SELECT) {
		bGPDspoint *pt;
		int i;

		// TODO: 2D vs 3D?
		for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
		if (pt->flag & GP_SPOINT_SELECT)
		t->total++;
		}
		}
	}	}
	}	}
	}	}
		/* if not multiedit out of loop */
		if (!is_multiedit) {
		break;
		}
	}	}
	}	}
	}	}
Context not available.
	float diff_mat[4][4];	float diff_mat[4][4];
	float inverse_diff_mat[4][4];	float inverse_diff_mat[4][4];

	/* calculate difference matrix if parent object */	bGPDframe *init_gpf = gpl->actframe;
	if (gpl->parent != NULL) {	if (is_multiedit) {
	ED_gpencil_parent_location(gpl, diff_mat);	init_gpf = gpl->frames.first;
	/* undo matrix */
	invert_m4_m4(inverse_diff_mat, diff_mat);
	}	}

		/* calculate difference matrix */
		ED_gpencil_parent_location(obact, gpd, gpl, diff_mat);
		/* undo matrix */
		invert_m4_m4(inverse_diff_mat, diff_mat);

	/* Make a new frame to work on if the layer's frame and the current scene frame don't match up	/* Make a new frame to work on if the layer's frame and the current scene frame don't match up
	* - This is useful when animating as it saves that "uh-oh" moment when you realize you've	* - This is useful when animating as it saves that "uh-oh" moment when you realize you've
	* spent too much time editing the wrong frame...	* spent too much time editing the wrong frame...
	*/	*/
	if (gpf->framenum != cfra) {	// XXX: should this be allowed when framelock is enabled?
		if ((gpf->framenum != cfra) && (!is_multiedit)) {
	gpf = BKE_gpencil_frame_addcopy(gpl, cfra);	gpf = BKE_gpencil_frame_addcopy(gpl, cfra);
	/* in some weird situations (framelock enabled) return NULL */	/* in some weird situations (framelock enabled) return NULL */
	if (gpf == NULL) {	if (gpf == NULL) {
	continue;	continue;
	}	}
	}	}

	/* Loop over strokes, adding TransData for points as needed... */	/* Loop over strokes, adding TransData for points as needed... */
	for (gps = gpf->strokes.first; gps; gps = gps->next) {	for (gpf = init_gpf; gpf; gpf = gpf->next) {
	TransData *head = td;	if ((gpf == gpl->actframe) \|\| ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
	TransData *tail = td;	for (gps = gpf->strokes.first; gps; gps = gps->next) {
	bool stroke_ok;	TransData *head = td;
		TransData *tail = td;
	/* skip strokes that are invalid for current view */	bool stroke_ok;
	if (ED_gpencil_stroke_can_use(C, gps) == false) {
	continue;	/* skip strokes that are invalid for current view */
	}	if (ED_gpencil_stroke_can_use(C, gps) == false) {
	/* check if the color is editable */	continue;
	if (ED_gpencil_stroke_color_use(gpl, gps) == false) {	}
	continue;	/* check if the color is editable */
	}	if (ED_gpencil_stroke_color_use(gpl, gps) == false) {
	/* What we need to include depends on proportional editing settings... */	continue;
	if (is_prop_edit) {	}
	if (is_prop_edit_connected) {	/* What we need to include depends on proportional editing settings... */
	/* A) "Connected" - Only those in selected strokes */
	stroke_ok = (gps->flag & GP_STROKE_SELECT) != 0;
	}
	else {
	/* B) All points, always */
	stroke_ok = true;
	}
	}
	else {
	/* C) Only selected points in selected strokes */
	stroke_ok = (gps->flag & GP_STROKE_SELECT) != 0;
	}

	/* Do stroke... */
	if (stroke_ok && gps->totpoints) {
	bGPDspoint *pt;
	int i;

	#if 0 /* XXX: this isn't needed anymore; cannot calculate center this way or is_prop_edit breaks */
	const float ninv = 1.0f / gps->totpoints;
	float center[3] = {0.0f};

	/* compute midpoint of stroke */
	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
	madd_v3_v3v3fl(center, center, &pt->x, ninv);
	}
	#endif

	/* add all necessary points... */
	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
	bool point_ok;

	/* include point? */
	if (is_prop_edit) {	if (is_prop_edit) {
	/* Always all points in strokes that get included */	if (is_prop_edit_connected) {
	point_ok = true;	/* A) "Connected" - Only those in selected strokes */
		stroke_ok = (gps->flag & GP_STROKE_SELECT) != 0;
		}
		else {
		/* B) All points, always */
		stroke_ok = true;
		}
	}	}
	else {	else {
	/* Only selected points in selected strokes */	/* C) Only selected points in selected strokes */
	point_ok = (pt->flag & GP_SPOINT_SELECT) != 0;	stroke_ok = (gps->flag & GP_STROKE_SELECT) != 0;
	}	}

	/* do point... */	/* Do stroke... */
	if (point_ok) {	if (stroke_ok && gps->totpoints) {
	copy_v3_v3(td->iloc, &pt->x);	bGPDspoint *pt;
	copy_v3_v3(td->center, &pt->x); // XXX: what about t->around == local?	int i;

	td->loc = &pt->x;	#if 0 /* XXX: this isn't needed anymore; cannot calculate center this way or is_prop_edit breaks */
		const float ninv = 1.0f / gps->totpoints;
	td->flag = 0;	float center[3] = { 0.0f };

	if (pt->flag & GP_SPOINT_SELECT)	/* compute midpoint of stroke */
	td->flag \|= TD_SELECTED;	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
		madd_v3_v3v3fl(center, center, &pt->x, ninv);
	/* for other transform modes (e.g. shrink-fatten), need to additional data */
	if (t->mode == TFM_GPENCIL_SHRINKFATTEN) {
	td->val = &pt->pressure;
	td->ival = pt->pressure;
	}	}
		#endif
	/* screenspace needs special matrices... */
	if ((gps->flag & (GP_STROKE_3DSPACE \| GP_STROKE_2DSPACE \| GP_STROKE_2DIMAGE)) == 0) {	/* add all necessary points... */
	/* screenspace */	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
	td->protectflag = OB_LOCK_LOCZ \| OB_LOCK_ROTZ \| OB_LOCK_SCALEZ;	bool point_ok;

	/* apply parent transformations */	/* include point? */
	if (gpl->parent == NULL) {	if (is_prop_edit) {
	copy_m3_m4(td->smtx, t->persmat);	/* Always all points in strokes that get included */
	copy_m3_m4(td->mtx, t->persinv);	point_ok = true;
	unit_m3(td->axismtx);
	}	}
	else {	else {
	/* apply matrix transformation relative to parent */	/* Only selected points in selected strokes */
	copy_m3_m4(td->smtx, inverse_diff_mat); /* final position */	point_ok = (pt->flag & GP_SPOINT_SELECT) != 0;
	copy_m3_m4(td->mtx, diff_mat); /* display position */
	copy_m3_m4(td->axismtx, diff_mat); /* axis orientation */
	}	}
	}
	else {	/* do point... */
	/* configure 2D dataspace points so that they don't play up... */	if (point_ok) {
	if (gps->flag & (GP_STROKE_2DSPACE \| GP_STROKE_2DIMAGE)) {	copy_v3_v3(td->iloc, &pt->x);
	td->protectflag = OB_LOCK_LOCZ \| OB_LOCK_ROTZ \| OB_LOCK_SCALEZ;	copy_v3_v3(td->center, &pt->x); // XXX: what about t->around == local?
	// XXX: matrices may need to be different?
	}	td->loc = &pt->x;

	/* apply parent transformations */	td->flag = 0;
	if (gpl->parent == NULL) {
	copy_m3_m3(td->smtx, smtx);	if (pt->flag & GP_SPOINT_SELECT)
	copy_m3_m3(td->mtx, mtx);	td->flag \|= TD_SELECTED;
	unit_m3(td->axismtx); // XXX?
	}	/* for other transform modes (e.g. shrink-fatten), need to additional data */
	else {	if (t->mode == TFM_GPENCIL_SHRINKFATTEN) {
	/* apply matrix transformation relative to parent */	td->val = &pt->pressure;
	copy_m3_m4(td->smtx, inverse_diff_mat); /* final position */	td->ival = pt->pressure;
	copy_m3_m4(td->mtx, diff_mat); /* display position */	}
	copy_m3_m4(td->axismtx, diff_mat); /* axis orientation */
		/* screenspace needs special matrices... */
		if ((gps->flag & (GP_STROKE_3DSPACE \| GP_STROKE_2DSPACE \| GP_STROKE_2DIMAGE)) == 0) {
		/* screenspace */
		td->protectflag = OB_LOCK_LOCZ \| OB_LOCK_ROTZ \| OB_LOCK_SCALEZ;

		/* apply matrix transformation relative to parent */
		copy_m3_m4(td->smtx, inverse_diff_mat); /* final position */
		copy_m3_m4(td->mtx, diff_mat); /* display position */
		copy_m3_m4(td->axismtx, diff_mat); /* axis orientation */
		}
		else {
		/* configure 2D dataspace points so that they don't play up... */
		if (gps->flag & (GP_STROKE_2DSPACE \| GP_STROKE_2DIMAGE)) {
		td->protectflag = OB_LOCK_LOCZ \| OB_LOCK_ROTZ \| OB_LOCK_SCALEZ;
		// XXX: matrices may need to be different?
		}

		/* apply parent transformations */
		copy_m3_m4(td->smtx, inverse_diff_mat); /* final position */
		copy_m3_m4(td->mtx, diff_mat); /* display position */
		copy_m3_m4(td->axismtx, diff_mat); /* axis orientation */
		}
		/* Triangulation must be calculated again, so save the stroke for recalc function */
		td->extra = gps;

		td++;
		tail++;
	}	}
	}	}
	/* Triangulation must be calculated again, so save the stroke for recalc function */
	td->extra = gps;

	td++;	/* March over these points, and calculate the proportional editing distances */
	tail++;	if (is_prop_edit && (head != tail)) {
		/* XXX: for now, we are similar enough that this works... */
		calc_distanceCurveVerts(head, tail - 1);
		}
	}	}
	}	}
		}
	/* March over these points, and calculate the proportional editing distances */	/* if not multiedit out of loop */
	if (is_prop_edit && (head != tail)) {	if (!is_multiedit) {
	/* XXX: for now, we are similar enough that this works... */	break;
	calc_distanceCurveVerts(head, tail - 1);
	}
	}	}
	}	}
	}	}
Context not available.