Differential D3845 Diff 12330 source/blender/editors/curve/editcurve_select.c

Changeset View

Standalone View

source/blender/editors/curve/editcurve_select.c

Show All 32 Lines
#include "DNA_scene_types.h"		#include "DNA_scene_types.h"

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

#include "BLI_bitmap.h"		#include "BLI_bitmap.h"
#include "BLI_math.h"		#include "BLI_math.h"
#include "BLI_rand.h"		#include "BLI_rand.h"
#include "BLI_heap.h"		#include "BLI_heap.h"
		#include "BLI_kdtree.h"

#include "BKE_context.h"		#include "BKE_context.h"
#include "BKE_curve.h"		#include "BKE_curve.h"
#include "BKE_fcurve.h"		#include "BKE_fcurve.h"
#include "BKE_layer.h"		#include "BKE_layer.h"
#include "BKE_report.h"		#include "BKE_report.h"

#include "WM_api.h"		#include "WM_api.h"
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 Lines	void ED_curve_nurb_deselect_all(Nurb *nu)
else if (nu->bp) {		else if (nu->bp) {
BPoint *bp;		BPoint *bp;
for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {		for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {
bp->f1 &= ~SELECT;		bp->f1 &= ~SELECT;
}		}
}		}
}		}

		int ED_curve_select_count(View3D v3d, struct EditNurb editnurb)
		dfelintoUnsubmitted Not Done Inline Actions Why is this not a static function? Are you planning to use this from a different file? dfelinto: Why is this not a static function? Are you planning to use this from a different file?
		zazizizouAuthorUnsubmitted Not Done Inline Actions I was following the style of the neighbouring functions, e.g. `bool ED_curve_select_check`. But maybe all similar functions should be static? zazizizou: I was following the style of the neighbouring functions, e.g. `bool ED_curve_select_check`. But…
		{
		int sel = 0;
		dfelintoUnsubmitted Done Inline Actions Code style, loose this extra line. dfelinto: Code style, loose this extra line.
		Nurb *nu;

		for (nu = editnurb->nurbs.first; nu; nu = nu->next) {
		sel += ED_curve_nurb_select_count(v3d, nu);
		}

		return sel;
		}

bool ED_curve_select_check(View3D v3d, struct EditNurb editnurb)		bool ED_curve_select_check(View3D v3d, struct EditNurb editnurb)
{		{
Nurb *nu;		Nurb *nu;

for (nu = editnurb->nurbs.first; nu; nu = nu->next) {		for (nu = editnurb->nurbs.first; nu; nu = nu->next) {
if (ED_curve_nurb_select_check(v3d, nu)) {		if (ED_curve_nurb_select_check(v3d, nu)) {
return true;		return true;
}		}
▲ Show 20 Lines • Show All 1,040 Lines • ▼ Show 20 Lines


/* -------------------------------------------------------------------- */		/* -------------------------------------------------------------------- */
/* Select Similar */		/* Select Similar */

/** \name Select Similar		/** \name Select Similar
* \{ */		* \{ */

enum {
SIM_CMP_EQ = 0,
SIM_CMP_GT,
SIM_CMP_LT,
};

static const EnumPropertyItem curve_prop_similar_compare_types[] = {		static const EnumPropertyItem curve_prop_similar_compare_types[] = {
{SIM_CMP_EQ, "EQUAL", 0, "Equal", ""},		{SIM_CMP_EQ, "EQUAL", 0, "Equal", ""},
{SIM_CMP_GT, "GREATER", 0, "Greater", ""},		{SIM_CMP_GT, "GREATER", 0, "Greater", ""},
{SIM_CMP_LT, "LESS", 0, "Less", ""},		{SIM_CMP_LT, "LESS", 0, "Less", ""},

{0, NULL, 0, NULL, NULL}		{0, NULL, 0, NULL, NULL}
};		};

▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines	for (nu = editnurb->first; nu; nu = nu->next) {
else {		else {
curve_select_similar_direction__bp(nu, dir, angle_cos);		curve_select_similar_direction__bp(nu, dir, angle_cos);
}		}
}		}

return true;		return true;
}		}

static void curve_select_similar_radius__bezt(Nurb *nu, float radius_ref, int compare, float thresh)		static void curve_nurb_get_selected_radius_in_tree(const Nurb nu, KDTree tree)
{		{
		if (nu->type == CU_BEZIER) {
BezTriple *bezt;		BezTriple *bezt;
int i;		int i;
		int tree_index = 0;

for (i = nu->pntsu, bezt = nu->bezt; i--; bezt++) {		for (i = nu->pntsu, bezt = nu->bezt; i--; bezt++) {
if (!bezt->hide) {		if (!bezt->hide && bezt->f1 & SELECT) {
if (curve_select_similar_cmp_fl(bezt->radius - radius_ref, thresh, compare)) {		float radius_ref = bezt->radius;
select_beztriple(bezt, SELECT, SELECT, VISIBLE);		float dummy[3] = {radius_ref, 0.0f, 0.0f};
		BLI_kdtree_insert(tree, tree_index++, dummy);
}		}
}		}
}		}
}		else {

static void curve_select_similar_radius__bp(Nurb *nu, float radius_ref, int compare, float thresh)
{
BPoint *bp;		BPoint *bp;
int i;		int i;
		int tree_index=0;

for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {		for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {
if (!bp->hide) {		if (!bp->hide && bp->f1 & SELECT) {
if (curve_select_similar_cmp_fl(bp->radius - radius_ref, thresh, compare)) {		float radius_ref = bp->radius;
select_bpoint(bp, SELECT, SELECT, VISIBLE);		float dummy[3] = {radius_ref, 0.0f, 0.0f};
		BLI_kdtree_insert(tree, tree_index++, dummy);
}		}
}		}
}		}
}		}

static bool curve_select_similar_radius(ListBase editnurb, Curve cu, float compare, float thresh)		static bool curve_select_similar_radius_multi(const Nurb nu, const KDTree tree, const float thresh, const int compare)
{		{
Nurb nu, act_nu;		bool changed = false;
void *act_vert;		if (nu->type == CU_BEZIER) {
float radius_ref;		BezTriple *bezt;
		int i;

if (!BKE_curve_nurb_vert_active_get(cu, &act_nu, &act_vert)) {		for (i = nu->pntsu, bezt = nu->bezt; i--; bezt++) {
return false;		if (!bezt->hide) {
		float radius_ref = bezt->radius;
		if (ED_select_similar_compare_float_tree(tree, radius_ref, thresh, compare)) {
		changed = true;
		select_beztriple(bezt, SELECT, SELECT, VISIBLE);
}		}

if (act_nu->type == CU_BEZIER) {
radius_ref = ((BezTriple *)act_vert)->radius;
}		}
else {
radius_ref = ((BPoint *)act_vert)->radius;
}		}

/* make relative */
thresh *= radius_ref;

for (nu = editnurb->first; nu; nu = nu->next) {
if (nu->type == CU_BEZIER) {
curve_select_similar_radius__bezt(nu, radius_ref, compare, thresh);
}		}
else {		else {
curve_select_similar_radius__bp(nu, radius_ref, compare, thresh);		BPoint *bp;
		int i;

		for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {
		if (!bp->hide) {
		float radius_ref = bp->radius;
		if (ED_select_similar_compare_float_tree(tree, radius_ref, thresh, compare)) {
		changed = true;
		select_bpoint(bp, SELECT, SELECT, VISIBLE);
}		}
}		}
		}
return true;		}
		return changed;
}		}

static void curve_select_similar_weight__bezt(Nurb *nu, float weight_ref, int compare, float thresh)		static void curve_select_similar_weight__bezt(Nurb *nu, float weight_ref, int compare, float thresh)
{		{
BezTriple *bezt;		BezTriple *bezt;
int i;		int i;

for (i = nu->pntsu, bezt = nu->bezt; i--; bezt++) {		for (i = nu->pntsu, bezt = nu->bezt; i--; bezt++) {
if (!bezt->hide) {		if (!bezt->hide) {
if (curve_select_similar_cmp_fl(bezt->weight - weight_ref, thresh, compare)) {		if (curve_select_similar_cmp_fl(bezt->weight - weight_ref, thresh, compare)) {
select_beztriple(bezt, SELECT, SELECT, VISIBLE);		select_beztriple(bezt, SELECT, SELECT, VISIBLE);
}		}
}		}
}		}
}		}

static void curve_select_similar_weight__bp(Nurb *nu, float weight_ref, int compare, float thresh)		static void curve_select_similar_weight__bp(Nurb *nu, float weight_ref, int compare, float thresh)
{		{
BPoint *bp;		BPoint *bp;
int i;		int i;
		dfelintoUnsubmitted Not Done Inline Actions Comments should start with a capital letter and end with a full stop: `/* Get type of selected control points. /` dfelinto:* Comments should start with a capital letter and end with a full stop: `/* Get type of selected…

for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {		for (i = nu->pntsu * nu->pntsv, bp = nu->bp; i--; bp++) {
if (!bp->hide) {		if (!bp->hide) {
if (curve_select_similar_cmp_fl(bp->weight - weight_ref, thresh, compare)) {		if (curve_select_similar_cmp_fl(bp->weight - weight_ref, thresh, compare)) {
select_bpoint(bp, SELECT, SELECT, VISIBLE);		select_bpoint(bp, SELECT, SELECT, VISIBLE);
}		}
}		}
		dfelintoUnsubmitted Not Done Inline Actions Do a short break: if (!ED_curve...()) { continue; } dfelinto: Do a short break: ``` if (!ED_curve...()) { continue; } ```
}		}
}		}

static bool curve_select_similar_weight(ListBase editnurb, Curve cu, float compare, float thresh)		static bool curve_select_similar_weight(ListBase editnurb, Curve cu, float compare, float thresh)
{		{
Nurb nu, act_nu;		Nurb nu, act_nu;
void *act_vert;		void *act_vert;
float weight_ref;		float weight_ref;
Show All 15 Lines	for (nu = editnurb->first; nu; nu = nu->next) {
else {		else {
curve_select_similar_weight__bp(nu, weight_ref, compare, thresh);		curve_select_similar_weight__bp(nu, weight_ref, compare, thresh);
}		}
}		}

return true;		return true;
}		}

static bool curve_select_similar_type(ListBase editnurb, Curve cu)		static int curve_select_similar_exec(bContext C, wmOperator op)
{		{
Nurb nu, act_nu;		/* Get props */
int type_ref;		const int optype = RNA_enum_get(op->ptr, "type");
		float thresh = RNA_float_get(op->ptr, "threshold");
		const int compare = RNA_enum_get(op->ptr, "compare");

/* Get active nurb type */
act_nu = BKE_curve_nurb_active_get(cu);

if (!act_nu)		if (ELEM (optype, SIMCURHAND_WEIGHT, SIMCURHAND_DIRECTION))
return false;		{
		BKE_report(op->reports, RPT_ERROR, "type not supported at the moment.");
		return OPERATOR_CANCELLED;
		}

/* Get the active nurb type */		ViewLayer *view_layer = CTX_data_view_layer(C);
type_ref = act_nu->type;		View3D *v3d = CTX_wm_view3d(C);
		int tot_nurbs_selected_all = 0;
		uint objects_len = 0;
		Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
		bool changed_multi = false;

for (nu = editnurb->first; nu; nu = nu->next) {		for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
if (nu->type == type_ref) {		Object *obedit = objects[ob_index];
ED_curve_nurb_select_all(nu);		Curve *cu = obedit->data;
		tot_nurbs_selected_all += ED_curve_select_count(v3d, cu->editnurb);
}		}

		if (tot_nurbs_selected_all == 0) {
		BKE_report(op->reports, RPT_ERROR, "No control point selected");
		MEM_freeN(objects);
		return OPERATOR_CANCELLED;
}		}

return true;		KDTree *tree = NULL;
		short type_ref = 0;

		switch (optype) {
		case SIMCURHAND_RADIUS:
		case SIMCURHAND_WEIGHT:
		case SIMCURHAND_DIRECTION:
		tree = BLI_kdtree_new(tot_nurbs_selected_all);
		break;
}		}

		dfelintoUnsubmitted Not Done Inline Actions No need for the parenthesis around changed_multi. dfelinto: No need for the parenthesis around changed_multi.
static int curve_select_similar_exec(bContext C, wmOperator op)		/* get type of selected control points */
		for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
		Object *obedit = objects[ob_index];
		Curve *cu = obedit->data;
		EditNurb *editnurb = cu->editnurb;

		Nurb *nu;
		for (nu = editnurb->nurbs.first; nu; nu = nu->next) {
		if (ED_curve_nurb_select_check(v3d, nu)) {
		switch (optype) {
		case SIMCURHAND_TYPE:
{		{
Object *obedit = CTX_data_edit_object(C);		type_ref \|= nu->type;
		break;
		}
		case SIMCURHAND_RADIUS:
		curve_nurb_get_selected_radius_in_tree(nu, tree);
		break;
		case SIMCURHAND_WEIGHT:
		/* TODO */
		break;
		case SIMCURHAND_DIRECTION:
		/* TODO */
		break;
		}
		}
		}
		}

		if (tree != NULL) {
		BLI_kdtree_balance(tree);
		}

		/* select control points with desired type */
		for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
		Object *obedit = objects[ob_index];
Curve *cu = obedit->data;		Curve *cu = obedit->data;
ListBase *editnurb = object_editcurve_get(obedit);		EditNurb *editnurb = cu->editnurb;
bool changed = false;		bool changed = false;

/* Get props */		Nurb *nu;
const int type = RNA_enum_get(op->ptr, "type");
const float thresh = RNA_float_get(op->ptr, "threshold");
const int compare = RNA_enum_get(op->ptr, "compare");

switch (type) {		for (nu = editnurb->nurbs.first; nu; nu = nu->next) {
		switch (optype) {
case SIMCURHAND_TYPE:		case SIMCURHAND_TYPE:
changed = curve_select_similar_type(editnurb, cu);		{
		if (nu->type & type_ref) {
		ED_curve_nurb_select_all(nu);
		changed = true;
		}
break;		break;
		}
case SIMCURHAND_RADIUS:		case SIMCURHAND_RADIUS:
changed = curve_select_similar_radius(editnurb, cu, compare, thresh);		changed = curve_select_similar_radius_multi(nu, tree, thresh, compare);
break;		break;
case SIMCURHAND_WEIGHT:		case SIMCURHAND_WEIGHT:
changed = curve_select_similar_weight(editnurb, cu, compare, thresh);		/* TODO */
break;		break;
case SIMCURHAND_DIRECTION:		case SIMCURHAND_DIRECTION:
changed = curve_select_similar_direction(editnurb, cu, thresh);		/* TODO */
break;		break;

		}
}		}

if (changed) {		if (changed) {
		changed_multi = true;
DEG_id_tag_update(obedit->data, DEG_TAG_SELECT_UPDATE);		DEG_id_tag_update(obedit->data, DEG_TAG_SELECT_UPDATE);
WM_event_add_notifier(C, NC_GEOM \| ND_SELECT, obedit->data);		WM_event_add_notifier(C, NC_GEOM \| ND_SELECT, obedit->data);
return OPERATOR_FINISHED;
}		}
else {
return OPERATOR_CANCELLED;
}		}

		MEM_freeN(objects);
		if (tree != NULL) {
		BLI_kdtree_free(tree);
		}
		return (changed_multi) ? OPERATOR_FINISHED : OPERATOR_CANCELLED;

}		}

void CURVE_OT_select_similar(wmOperatorType *ot)		void CURVE_OT_select_similar(wmOperatorType *ot)
		dfelintoUnsubmitted Not Done Inline Actions Why to implement a _exec_multi? Why not just replace the _exec() function? dfelinto: Why to implement a _exec_multi? Why not just replace the _exec() function?
		zazizizouAuthorUnsubmitted Not Done Inline Actions will do with the final patch, just wanted to keep the original for reference zazizizou: will do with the final patch, just wanted to keep the original for reference
{		{
/* identifiers */		/* identifiers */
ot->name = "Select Similar";		ot->name = "Select Similar";
ot->idname = "CURVE_OT_select_similar";		ot->idname = "CURVE_OT_select_similar";
ot->description = "Select similar curve points by property type";		ot->description = "Select similar curve points by property type";

/* api callbacks */		/* api callbacks */
		dfelintoUnsubmitted Done Inline Actions Use ELEM instead: if (ELEM, type, SIMCURHAND_RADIUS, SIMCURHAND_WEIGHT, ...)) dfelinto: Use ELEM instead: if (ELEM, type, SIMCURHAND_RADIUS, SIMCURHAND_WEIGHT, ...))
ot->invoke = WM_menu_invoke;		ot->invoke = WM_menu_invoke;
ot->exec = curve_select_similar_exec;		ot->exec = curve_select_similar_exec;
ot->poll = ED_operator_editsurfcurve;		ot->poll = ED_operator_editsurfcurve;

/* flags */		/* flags */
ot->flag = OPTYPE_REGISTER \| OPTYPE_UNDO;		ot->flag = OPTYPE_REGISTER \| OPTYPE_UNDO;

/* properties */		/* properties */
Show All 13 Lines

static float curve_calc_dist_pair(const Nurb *nu, int a, int b)		static float curve_calc_dist_pair(const Nurb *nu, int a, int b)
{		{
const float a_fl, b_fl;		const float a_fl, b_fl;

if (nu->type == CU_BEZIER) {		if (nu->type == CU_BEZIER) {
a_fl = nu->bezt[a].vec[1];		a_fl = nu->bezt[a].vec[1];
b_fl = nu->bezt[b].vec[1];		b_fl = nu->bezt[b].vec[1];
}		}
		dfelintoUnsubmitted Done Inline Actions It is overkill to use gset here if there is only two options. Use bitflags instead. dfelinto: It is overkill to use gset here if there is only two options. Use bitflags instead.
else {		else {
a_fl = nu->bp[a].vec;		a_fl = nu->bp[a].vec;
b_fl = nu->bp[b].vec;		b_fl = nu->bp[b].vec;
}		}

return len_v3v3(a_fl, b_fl);		return len_v3v3(a_fl, b_fl);
}		}

▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	static void curve_select_shortest_path_surf(Nurb *nu, int vert_src, int vert_dst)
} *data;		} *data;

/* init connectivity data */		/* init connectivity data */
data = MEM_mallocN(sizeof(data) vert_num, __func__);		data = MEM_mallocN(sizeof(data) vert_num, __func__);
for (i = 0; i < vert_num; i++) {		for (i = 0; i < vert_num; i++) {
data[i].vert = i;		data[i].vert = i;
data[i].vert_prev = -1;		data[i].vert_prev = -1;
data[i].cost = FLT_MAX;		data[i].cost = FLT_MAX;
}		}
		dfelintoUnsubmitted Done Inline Actions No need to actually count the changed ones. Just use a bool, like `changed_multi`. dfelinto: No need to actually count the changed ones. Just use a bool, like `changed_multi`.

/* init heap */		/* init heap */
heap = BLI_heap_new();		heap = BLI_heap_new();

vert_curr = data[vert_src].vert;		vert_curr = data[vert_src].vert;
BLI_heap_insert(heap, 0.0f, &data[vert_src].vert);		BLI_heap_insert(heap, 0.0f, &data[vert_src].vert);
data[vert_src].cost = 0.0f;		data[vert_src].cost = 0.0f;
data[vert_src].vert_prev = vert_src; /* nop */		data[vert_src].vert_prev = vert_src; /* nop */
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines