Differential D10300 Diff 33525 source/blender/editors/space_node/drawnode.c

Changeset View

Standalone View

source/blender/editors/space_node/drawnode.c

Show First 20 Lines • Show All 435 Lines • ▼ Show 20 Lines	if (node->flag & NODE_CUSTOM_COLOR) {
rgba_float_args_set(color, node->color[0], node->color[1], node->color[2], alpha);		rgba_float_args_set(color, node->color[0], node->color[1], node->color[2], alpha);
}		}
else {		else {
UI_GetThemeColor4fv(TH_NODE_FRAME, color);		UI_GetThemeColor4fv(TH_NODE_FRAME, color);
}		}

const rctf *rct = &node->totr;		const rctf *rct = &node->totr;
UI_draw_roundbox_corner_set(UI_CNR_ALL);		UI_draw_roundbox_corner_set(UI_CNR_ALL);
UI_draw_roundbox_aa(true, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);		UI_draw_roundbox_aa(rct, true, BASIS_RAD, color);

/* outline active and selected emphasis */		/* outline active and selected emphasis */
if (node->flag & SELECT) {		if (node->flag & SELECT) {
if (node->flag & NODE_ACTIVE) {		if (node->flag & NODE_ACTIVE) {
UI_GetThemeColorShadeAlpha4fv(TH_ACTIVE, 0, -40, color);		UI_GetThemeColorShadeAlpha4fv(TH_ACTIVE, 0, -40, color);
}		}
else {		else {
UI_GetThemeColorShadeAlpha4fv(TH_SELECT, 0, -40, color);		UI_GetThemeColorShadeAlpha4fv(TH_SELECT, 0, -40, color);
}		}

UI_draw_roundbox_aa(false, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);		UI_draw_roundbox_aa(rct, false, BASIS_RAD, color);
}		}

/* label */		/* label */
node_draw_frame_label(ntree, node, snode->aspect);		node_draw_frame_label(ntree, node, snode->runtime->aspect);

UI_block_end(C, node->block);		UI_block_end(C, node->block);
UI_block_draw(C, node->block);		UI_block_draw(C, node->block);
node->block = NULL;		node->block = NULL;
}		}

static int node_resize_area_frame(bNode *node, int x, int y)		static int node_resize_area_frame(bNode *node, int x, int y)
{		{
▲ Show 20 Lines • Show All 2,693 Lines • ▼ Show 20 Lines

static void node_geometry_buts_random_attribute(uiLayout *layout,		static void node_geometry_buts_random_attribute(uiLayout *layout,
bContext *UNUSED(C),		bContext *UNUSED(C),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
uiItemR(layout, ptr, "data_type", DEFAULT_FLAGS, "", ICON_NONE);		uiItemR(layout, ptr, "data_type", DEFAULT_FLAGS, "", ICON_NONE);
}		}

		static bool node_attribute_math_operation_use_input_b(const NodeMathOperation operation)
		{
		switch (operation) {
		case NODE_MATH_ADD:
		case NODE_MATH_SUBTRACT:
		case NODE_MATH_MULTIPLY:
		case NODE_MATH_DIVIDE:
		case NODE_MATH_POWER:
		case NODE_MATH_LOGARITHM:
		case NODE_MATH_MINIMUM:
		case NODE_MATH_MAXIMUM:
		case NODE_MATH_LESS_THAN:
		case NODE_MATH_GREATER_THAN:
		case NODE_MATH_MODULO:
		case NODE_MATH_ARCTAN2:
		case NODE_MATH_SNAP:
		case NODE_MATH_WRAP:
		case NODE_MATH_COMPARE:
		case NODE_MATH_MULTIPLY_ADD:
		case NODE_MATH_PINGPONG:
		case NODE_MATH_SMOOTH_MIN:
		case NODE_MATH_SMOOTH_MAX:
		return true;
		case NODE_MATH_SINE:
		case NODE_MATH_COSINE:
		case NODE_MATH_TANGENT:
		case NODE_MATH_ARCSINE:
		case NODE_MATH_ARCCOSINE:
		case NODE_MATH_ARCTANGENT:
		case NODE_MATH_ROUND:
		case NODE_MATH_ABSOLUTE:
		case NODE_MATH_FLOOR:
		case NODE_MATH_CEIL:
		case NODE_MATH_FRACTION:
		case NODE_MATH_SQRT:
		case NODE_MATH_INV_SQRT:
		case NODE_MATH_SIGN:
		case NODE_MATH_EXPONENT:
		case NODE_MATH_RADIANS:
		case NODE_MATH_DEGREES:
		case NODE_MATH_SINH:
		case NODE_MATH_COSH:
		case NODE_MATH_TANH:
		case NODE_MATH_TRUNC:
		return false;
		}
		BLI_assert(false);
		return false;
		}

static void node_geometry_buts_attribute_math(uiLayout *layout,		static void node_geometry_buts_attribute_math(uiLayout *layout,
bContext *UNUSED(C),		bContext *UNUSED(C),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
		bNode node = (bNode )ptr->data;
		NodeAttributeMath node_storage = (NodeAttributeMath )node->storage;
		NodeMathOperation operation = (NodeMathOperation)node_storage->operation;

uiItemR(layout, ptr, "operation", DEFAULT_FLAGS, "", ICON_NONE);		uiItemR(layout, ptr, "operation", DEFAULT_FLAGS, "", ICON_NONE);
uiItemR(layout, ptr, "input_type_a", DEFAULT_FLAGS, IFACE_("Type A"), ICON_NONE);		uiItemR(layout, ptr, "input_type_a", DEFAULT_FLAGS, IFACE_("Type A"), ICON_NONE);

		/* These "use input b / c" checks are copied from the node's code.
		* They could be de-duplicated if the drawing code was moved to the node's file. */
		if (node_attribute_math_operation_use_input_b(operation)) {
uiItemR(layout, ptr, "input_type_b", DEFAULT_FLAGS, IFACE_("Type B"), ICON_NONE);		uiItemR(layout, ptr, "input_type_b", DEFAULT_FLAGS, IFACE_("Type B"), ICON_NONE);
}		}
		if (ELEM(operation,
		NODE_MATH_MULTIPLY_ADD,
		NODE_MATH_SMOOTH_MIN,
		NODE_MATH_SMOOTH_MAX,
		NODE_MATH_WRAP,
		NODE_MATH_COMPARE)) {
		uiItemR(layout, ptr, "input_type_c", DEFAULT_FLAGS, IFACE_("Type C"), ICON_NONE);
		}
		}

static void node_geometry_buts_attribute_vector_math(uiLayout *layout,		static void node_geometry_buts_attribute_vector_math(uiLayout *layout,
bContext *UNUSED(C),		bContext *UNUSED(C),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
bNode node = (bNode )ptr->data;		bNode node = (bNode )ptr->data;
NodeAttributeVectorMath node_storage = (NodeAttributeVectorMath )node->storage;		NodeAttributeVectorMath node_storage = (NodeAttributeVectorMath )node->storage;

▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines	static void node_geometry_buts_point_scale(uiLayout layout, bContext UNUSED(C), PointerRNA *ptr)
uiItemR(layout, ptr, "input_type", DEFAULT_FLAGS, IFACE_("Type"), ICON_NONE);		uiItemR(layout, ptr, "input_type", DEFAULT_FLAGS, IFACE_("Type"), ICON_NONE);
}		}

static void node_geometry_buts_object_info(uiLayout layout, bContext UNUSED(C), PointerRNA *ptr)		static void node_geometry_buts_object_info(uiLayout layout, bContext UNUSED(C), PointerRNA *ptr)
{		{
uiItemR(layout, ptr, "transform_space", UI_ITEM_R_EXPAND, NULL, ICON_NONE);		uiItemR(layout, ptr, "transform_space", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
}		}

		static void node_geometry_buts_attribute_sample_texture(uiLayout *layout,
		bContext *C,
		PointerRNA *ptr)
		{
		uiTemplateID(layout, C, ptr, "texture", "texture.new", NULL, NULL, 0, ICON_NONE, NULL);
		}

		static void node_geometry_buts_points_to_volume(uiLayout *layout,
		bContext *UNUSED(C),
		PointerRNA *ptr)
		{
		uiLayoutSetPropSep(layout, true);
		uiLayoutSetPropDecorate(layout, false);
		uiItemR(layout, ptr, "resolution_mode", DEFAULT_FLAGS, IFACE_("Resolution"), ICON_NONE);
		uiItemR(layout, ptr, "input_type_radius", DEFAULT_FLAGS, IFACE_("Radius"), ICON_NONE);
		}

		static void node_geometry_buts_collection_info(uiLayout *layout,
		bContext *UNUSED(C),
		PointerRNA *ptr)
		{
		uiItemR(layout, ptr, "transform_space", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
		}

static void node_geometry_set_butfunc(bNodeType *ntype)		static void node_geometry_set_butfunc(bNodeType *ntype)
{		{
switch (ntype->type) {		switch (ntype->type) {
case GEO_NODE_BOOLEAN:		case GEO_NODE_BOOLEAN:
ntype->draw_buttons = node_geometry_buts_boolean_math;		ntype->draw_buttons = node_geometry_buts_boolean_math;
break;		break;
case GEO_NODE_SUBDIVISION_SURFACE:		case GEO_NODE_SUBDIVISION_SURFACE:
ntype->draw_buttons = node_geometry_buts_subdivision_surface;		ntype->draw_buttons = node_geometry_buts_subdivision_surface;
Show All 38 Lines	case GEO_NODE_POINT_TRANSLATE:
ntype->draw_buttons = node_geometry_buts_point_translate;		ntype->draw_buttons = node_geometry_buts_point_translate;
break;		break;
case GEO_NODE_POINT_SCALE:		case GEO_NODE_POINT_SCALE:
ntype->draw_buttons = node_geometry_buts_point_scale;		ntype->draw_buttons = node_geometry_buts_point_scale;
break;		break;
case GEO_NODE_OBJECT_INFO:		case GEO_NODE_OBJECT_INFO:
ntype->draw_buttons = node_geometry_buts_object_info;		ntype->draw_buttons = node_geometry_buts_object_info;
break;		break;
		case GEO_NODE_ATTRIBUTE_SAMPLE_TEXTURE:
		ntype->draw_buttons = node_geometry_buts_attribute_sample_texture;
		break;
		case GEO_NODE_POINTS_TO_VOLUME:
		ntype->draw_buttons = node_geometry_buts_points_to_volume;
		break;
		case GEO_NODE_COLLECTION_INFO:
		ntype->draw_buttons = node_geometry_buts_collection_info;
		break;
}		}
}		}

/* **************** BUTTON CALLBACKS FOR FUNCTION NODES *************** */		/* **************** BUTTON CALLBACKS FOR FUNCTION NODES *************** */

static void node_function_buts_boolean_math(uiLayout layout, bContext UNUSED(C), PointerRNA *ptr)		static void node_function_buts_boolean_math(uiLayout layout, bContext UNUSED(C), PointerRNA *ptr)
{		{
uiItemR(layout, ptr, "operation", DEFAULT_FLAGS, "", ICON_NONE);		uiItemR(layout, ptr, "operation", DEFAULT_FLAGS, "", ICON_NONE);
▲ Show 20 Lines • Show All 468 Lines • ▼ Show 20 Lines	void draw_nodespace_back_pix(const bContext *C,
}		}

BKE_image_release_ibuf(ima, ibuf, lock);		BKE_image_release_ibuf(ima, ibuf, lock);
GPU_matrix_pop_projection();		GPU_matrix_pop_projection();
GPU_matrix_pop();		GPU_matrix_pop();
}		}

/* return quadratic beziers points for a given nodelink and clip if v2d is not NULL. */		/* return quadratic beziers points for a given nodelink and clip if v2d is not NULL. */
static bool node_link_bezier_handles(View2D *v2d,		static bool node_link_bezier_handles(const View2D *v2d,
SpaceNode *snode,		const SpaceNode *snode,
bNodeLink *link,		const bNodeLink *link,
float vec[4][2])		float vec[4][2])
{		{
float cursor[2] = {0.0f, 0.0f};		float cursor[2] = {0.0f, 0.0f};

/* this function can be called with snode null (via cut_links_intersect) */		/* this function can be called with snode null (via cut_links_intersect) */
/* XXX map snode->cursor back to view space */		/* XXX map snode->runtime->cursor back to view space */
if (snode) {		if (snode) {
cursor[0] = snode->cursor[0] * UI_DPI_FAC;		cursor[0] = snode->runtime->cursor[0] * UI_DPI_FAC;
cursor[1] = snode->cursor[1] * UI_DPI_FAC;		cursor[1] = snode->runtime->cursor[1] * UI_DPI_FAC;
}		}

/* in v0 and v3 we put begin/end points */		/* in v0 and v3 we put begin/end points */
int toreroute, fromreroute;		int toreroute, fromreroute;
if (link->fromsock) {		if (link->fromsock) {
vec[0][0] = link->fromsock->locx;		vec[0][0] = link->fromsock->locx;
vec[0][1] = link->fromsock->locy;		vec[0][1] = link->fromsock->locy;
fromreroute = (link->fromnode && link->fromnode->type == NODE_REROUTE);		fromreroute = (link->fromnode && link->fromnode->type == NODE_REROUTE);
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines	static bool node_link_bezier_handles(const View2D *v2d,
if (v2d && max_ffff(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) < v2d->cur.xmin) {		if (v2d && max_ffff(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) < v2d->cur.xmin) {
return false; /* clipped */		return false; /* clipped */
}		}

return true;		return true;
}		}

/* if v2d not NULL, it clips and returns 0 if not visible */		/* if v2d not NULL, it clips and returns 0 if not visible */
bool node_link_bezier_points(		bool node_link_bezier_points(const View2D *v2d,
View2D v2d, SpaceNode snode, bNodeLink *link, float coord_array[][2], int resol)		const SpaceNode *snode,
		const bNodeLink *link,
		float coord_array[][2],
		const int resol)
{		{
float vec[4][2];		float vec[4][2];

if (node_link_bezier_handles(v2d, snode, link, vec)) {		if (node_link_bezier_handles(v2d, snode, link, vec)) {
/* always do all three, to prevent data hanging around */		/* always do all three, to prevent data hanging around */
BKE_curve_forward_diff_bezier(		BKE_curve_forward_diff_bezier(
vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0] + 0, resol, sizeof(float[2]));		vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0] + 0, resol, sizeof(float[2]));
BKE_curve_forward_diff_bezier(		BKE_curve_forward_diff_bezier(
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines	switch (th_col) {
case TH_EDGE_SELECT:		case TH_EDGE_SELECT:
return 4;		return 4;
case TH_REDALERT:		case TH_REDALERT:
return 5;		return 5;
}		}
return 0;		return 0;
}		}

static void nodelink_batch_draw(SpaceNode *snode)		static void nodelink_batch_draw(const SpaceNode *snode)
{		{
if (g_batch_link.count == 0) {		if (g_batch_link.count == 0) {
return;		return;
}		}

GPU_blend(GPU_BLEND_ALPHA);		GPU_blend(GPU_BLEND_ALPHA);

float colors[6][4] = {{0.0f}};		float colors[6][4] = {{0.0f}};
UI_GetThemeColor4fv(TH_WIRE_INNER, colors[nodelink_get_color_id(TH_WIRE_INNER)]);		UI_GetThemeColor4fv(TH_WIRE_INNER, colors[nodelink_get_color_id(TH_WIRE_INNER)]);
UI_GetThemeColor4fv(TH_WIRE, colors[nodelink_get_color_id(TH_WIRE)]);		UI_GetThemeColor4fv(TH_WIRE, colors[nodelink_get_color_id(TH_WIRE)]);
UI_GetThemeColor4fv(TH_ACTIVE, colors[nodelink_get_color_id(TH_ACTIVE)]);		UI_GetThemeColor4fv(TH_ACTIVE, colors[nodelink_get_color_id(TH_ACTIVE)]);
UI_GetThemeColor4fv(TH_EDGE_SELECT, colors[nodelink_get_color_id(TH_EDGE_SELECT)]);		UI_GetThemeColor4fv(TH_EDGE_SELECT, colors[nodelink_get_color_id(TH_EDGE_SELECT)]);
UI_GetThemeColor4fv(TH_REDALERT, colors[nodelink_get_color_id(TH_REDALERT)]);		UI_GetThemeColor4fv(TH_REDALERT, colors[nodelink_get_color_id(TH_REDALERT)]);

GPU_vertbuf_data_len_set(g_batch_link.inst_vbo, g_batch_link.count);		GPU_vertbuf_data_len_set(g_batch_link.inst_vbo, g_batch_link.count);
GPU_vertbuf_use(g_batch_link.inst_vbo); /* force update. */		GPU_vertbuf_use(g_batch_link.inst_vbo); /* force update. */

GPU_batch_program_set_builtin(g_batch_link.batch, GPU_SHADER_2D_NODELINK_INST);		GPU_batch_program_set_builtin(g_batch_link.batch, GPU_SHADER_2D_NODELINK_INST);
GPU_batch_uniform_4fv_array(g_batch_link.batch, "colors", 6, colors);		GPU_batch_uniform_4fv_array(g_batch_link.batch, "colors", 6, colors);
GPU_batch_uniform_1f(g_batch_link.batch, "expandSize", snode->aspect * LINK_WIDTH);		GPU_batch_uniform_1f(g_batch_link.batch, "expandSize", snode->runtime->aspect * LINK_WIDTH);
GPU_batch_uniform_1f(g_batch_link.batch, "arrowSize", ARROW_SIZE);		GPU_batch_uniform_1f(g_batch_link.batch, "arrowSize", ARROW_SIZE);
GPU_batch_draw(g_batch_link.batch);		GPU_batch_draw(g_batch_link.batch);

nodelink_batch_reset();		nodelink_batch_reset();

GPU_blend(GPU_BLEND_NONE);		GPU_blend(GPU_BLEND_NONE);
}		}

void nodelink_batch_start(SpaceNode *UNUSED(snode))		void nodelink_batch_start(SpaceNode *UNUSED(snode))
{		{
g_batch_link.enabled = true;		g_batch_link.enabled = true;
}		}

void nodelink_batch_end(SpaceNode *snode)		void nodelink_batch_end(SpaceNode *snode)
{		{
nodelink_batch_draw(snode);		nodelink_batch_draw(snode);
g_batch_link.enabled = false;		g_batch_link.enabled = false;
}		}

static void nodelink_batch_add_link(SpaceNode *snode,		static void nodelink_batch_add_link(const SpaceNode *snode,
const float p0[2],		const float p0[2],
const float p1[2],		const float p1[2],
const float p2[2],		const float p2[2],
const float p3[2],		const float p3[2],
int th_col1,		int th_col1,
int th_col2,		int th_col2,
int th_col3,		int th_col3,
bool drawarrow)		bool drawarrow)
Show All 15 Lines	static void nodelink_batch_add_link(const SpaceNode *snode,
colid[3] = drawarrow;		colid[3] = drawarrow;

if (g_batch_link.count == NODELINK_GROUP_SIZE) {		if (g_batch_link.count == NODELINK_GROUP_SIZE) {
nodelink_batch_draw(snode);		nodelink_batch_draw(snode);
}		}
}		}

/* don't do shadows if th_col3 is -1. */		/* don't do shadows if th_col3 is -1. */
void node_draw_link_bezier(		void node_draw_link_bezier(const View2D *v2d,
View2D v2d, SpaceNode snode, bNodeLink *link, int th_col1, int th_col2, int th_col3)		const SpaceNode *snode,
		const bNodeLink *link,
		int th_col1,
		int th_col2,
		int th_col3)
{		{
float vec[4][2];		float vec[4][2];

if (node_link_bezier_handles(v2d, snode, link, vec)) {		if (node_link_bezier_handles(v2d, snode, link, vec)) {
int drawarrow = ((link->tonode && (link->tonode->type == NODE_REROUTE)) &&		int drawarrow = ((link->tonode && (link->tonode->type == NODE_REROUTE)) &&
(link->fromnode && (link->fromnode->type == NODE_REROUTE)));		(link->fromnode && (link->fromnode->type == NODE_REROUTE)));

if (g_batch_link.batch == NULL) {		if (g_batch_link.batch == NULL) {
Show All 13 Lines	else {
}		}
UI_GetThemeColor4fv(th_col1, colors[1]);		UI_GetThemeColor4fv(th_col1, colors[1]);
UI_GetThemeColor4fv(th_col2, colors[2]);		UI_GetThemeColor4fv(th_col2, colors[2]);

GPUBatch *batch = g_batch_link.batch_single;		GPUBatch *batch = g_batch_link.batch_single;
GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_NODELINK);		GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_NODELINK);
GPU_batch_uniform_2fv_array(batch, "bezierPts", 4, vec);		GPU_batch_uniform_2fv_array(batch, "bezierPts", 4, vec);
GPU_batch_uniform_4fv_array(batch, "colors", 3, colors);		GPU_batch_uniform_4fv_array(batch, "colors", 3, colors);
GPU_batch_uniform_1f(batch, "expandSize", snode->aspect * LINK_WIDTH);		GPU_batch_uniform_1f(batch, "expandSize", snode->runtime->aspect * LINK_WIDTH);
GPU_batch_uniform_1f(batch, "arrowSize", ARROW_SIZE);		GPU_batch_uniform_1f(batch, "arrowSize", ARROW_SIZE);
GPU_batch_uniform_1i(batch, "doArrow", drawarrow);		GPU_batch_uniform_1i(batch, "doArrow", drawarrow);
GPU_batch_draw(batch);		GPU_batch_draw(batch);
}		}
}		}
}		}

/* note; this is used for fake links in groups too */		/* note; this is used for fake links in groups too */
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines