[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [33011] branches/particles-2010/source/ blender/nodes/intern: input macros for kernels now take a result argument instead of returning a value or pointer .

Lukas Toenne lukas.toenne at googlemail.com
Thu Nov 11 15:01:55 CET 2010


Revision: 33011
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=33011
Author:   lukastoenne
Date:     2010-11-11 15:01:55 +0100 (Thu, 11 Nov 2010)

Log Message:
-----------
input macros for kernels now take a result argument instead of returning a value or pointer. This will allow more sophisticated conversions (e.g. float->vector), minor downside is that a few additional copies might be necessary.

Modified Paths:
--------------
    branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_if.c
    branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_math.c
    branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_pass.c
    branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_random.c
    branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_vectormath.c
    branches/particles-2010/source/blender/nodes/intern/SIM_util.h

Modified: branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_if.c
===================================================================
--- branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_if.c	2010-11-11 13:44:51 UTC (rev 33010)
+++ branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_if.c	2010-11-11 14:01:55 UTC (rev 33011)
@@ -114,42 +114,98 @@
 
 static void kernel_float(int global_id, void **args, SimNodeStack *node)
 {
-	*SIM_OUTPUT_FLOAT(0, global_id) = (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_FLOAT(1, global_id) : SIM_INPUT_FLOAT(2, global_id));
+	char cond;
+	float res;
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_FLOAT(1, global_id, &res);
+	else
+		SIM_INPUT_FLOAT(2, global_id, &res);
+	*SIM_OUTPUT_FLOAT(0, global_id) = res;
 }
 
 static void kernel_int(int global_id, void **args, SimNodeStack *node)
 {
-	*SIM_OUTPUT_INT(0, global_id) = (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_INT(1, global_id) : SIM_INPUT_INT(2, global_id));
+	char cond;
+	int res;
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_INT(1, global_id, &res);
+	else
+		SIM_INPUT_INT(2, global_id, &res);
+	*SIM_OUTPUT_INT(0, global_id) = res;
 }
 
 static void kernel_bool(int global_id, void **args, SimNodeStack *node)
 {
-	*SIM_OUTPUT_BOOL(0, global_id) = (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_BOOL(1, global_id) : SIM_INPUT_BOOL(2, global_id));
+	char cond;
+	char res;
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_BOOL(1, global_id, &res);
+	else
+		SIM_INPUT_BOOL(2, global_id, &res);
+	*SIM_OUTPUT_BOOL(0, global_id) = res;
 }
 
 static void kernel_vector(int global_id, void **args, SimNodeStack *node)
 {
-	copy_v3_v3(SIM_OUTPUT_VECTOR(0, global_id), (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_VECTOR(1, global_id) : SIM_INPUT_VECTOR(2, global_id)));
+	char cond;
+	float res[3];
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_VECTOR(1, global_id, res);
+	else
+		SIM_INPUT_VECTOR(2, global_id, res);
+	copy_v3_v3(SIM_OUTPUT_VECTOR(0, global_id), res);
 }
 
 static void kernel_rgba(int global_id, void **args, SimNodeStack *node)
 {
-	copy_v4_v4(SIM_OUTPUT_RGBA(0, global_id), (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_RGBA(1, global_id) : SIM_INPUT_RGBA(2, global_id)));
+	char cond;
+	float res[4];
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_RGBA(1, global_id, res);
+	else
+		SIM_INPUT_RGBA(2, global_id, res);
+	copy_v4_v4(SIM_OUTPUT_RGBA(0, global_id), res);
 }
 
 static void kernel_quat(int global_id, void **args, SimNodeStack *node)
 {
-	copy_v4_v4(SIM_OUTPUT_QUAT(0, global_id), (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_QUAT(1, global_id) : SIM_INPUT_QUAT(2, global_id)));
+	char cond;
+	float res[4];
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_QUAT(1, global_id, res);
+	else
+		SIM_INPUT_QUAT(2, global_id, res);
+	copy_qt_qt(SIM_OUTPUT_QUAT(0, global_id), res);
 }
 
 static void kernel_matrix(int global_id, void **args, SimNodeStack *node)
 {
-	memcpy(SIM_OUTPUT_MATRIX(0, global_id), (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_MATRIX(1, global_id) : SIM_INPUT_MATRIX(2, global_id)), 16*sizeof(float));
+	char cond;
+	float res[4][4];
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_MATRIX(1, global_id, res);
+	else
+		SIM_INPUT_MATRIX(2, global_id, res);
+	copy_m4_m4(SIM_OUTPUT_MATRIX(0, global_id), res);
 }
 
 static void kernel_string(int global_id, void **args, SimNodeStack *node)
 {
-	memcpy(SIM_OUTPUT_STRING(0, global_id), (SIM_INPUT_BOOL(0, global_id) ? SIM_INPUT_STRING(1, global_id) : SIM_INPUT_STRING(2, global_id)), SIM_STRINGLENGTH*sizeof(char));
+	char cond;
+	char res[SIM_STRINGLENGTH];
+	SIM_INPUT_BOOL(0, global_id, &cond);
+	if (cond)
+		SIM_INPUT_STRING(1, global_id, res);
+	else
+		SIM_INPUT_STRING(2, global_id, res);
+	strcpy(SIM_OUTPUT_STRING(0, global_id), res);
 }
 
 /* "if" node for data sets */

Modified: branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_math.c
===================================================================
--- branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_math.c	2010-11-11 13:44:51 UTC (rev 33010)
+++ branches/particles-2010/source/blender/nodes/intern/SIM_nodes/SIM_math.c	2010-11-11 14:01:55 UTC (rev 33011)
@@ -96,36 +96,30 @@
 			*OUTPUT0_VECTOR(get_global_id(0)) = INPUT0_VECTOR(get_global_id(0)) + INPUT1_VECTOR(get_global_id(0));
 			));
 		break;
-	case SOCK_RGBA:
-		BLI_dynstr_append(source, STRINGIFY(
-			*OUTPUT0_RGBA(get_global_id(0)) = INPUT0_RGBA(get_global_id(0)) + INPUT1_RGBA(get_global_id(0));
-			));
-		break;
 	}
 	return sim_kernel_source_end(source);
 }
 static void kernel_add_float(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_FLOAT(0, global_id) = SIM_INPUT_FLOAT(0, global_id) + SIM_INPUT_FLOAT(1, global_id);
+	float a, b;
+	SIM_INPUT_FLOAT(0, global_id, &a);
+	SIM_INPUT_FLOAT(1, global_id, &b);
+	*SIM_OUTPUT_FLOAT(0, global_id) = a + b;
 }
 static void kernel_add_int(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_INT(0, global_id) = SIM_INPUT_INT(0, global_id) + SIM_INPUT_INT(1, global_id);
+	int a, b;
+	SIM_INPUT_INT(0, global_id, &a);
+	SIM_INPUT_INT(1, global_id, &b);
+	*SIM_OUTPUT_INT(0, global_id) = a + b;
 }
 static void kernel_add_vector(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	add_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(1, global_id));
+	float a[3], b[3];
+	SIM_INPUT_VECTOR(0, global_id, a);
+	SIM_INPUT_VECTOR(1, global_id, b);
+	add_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), a, b);
 }
-static void kernel_add_rgba(int global_id, void **UNUSED(args), SimNodeStack *node)
-{
-	float *res=SIM_OUTPUT_RGBA(0, global_id);
-	const float *a=SIM_INPUT_RGBA(0, global_id);
-	const float *b=SIM_INPUT_RGBA(1, global_id);
-	res[0] = a[0] + b[0];
-	res[1] = a[1] + b[1];
-	res[2] = a[2] + b[2];
-	res[3] = a[3] + b[3];
-}
 
 static void enqueue_add(SimExecData *execdata, SimNodeStack *node, SimDataContext *self)
 {
@@ -138,7 +132,6 @@
 	case SOCK_FLOAT:	kernelfunc= kernel_add_float;	break;
 	case SOCK_INT:		kernelfunc= kernel_add_int;		break;
 	case SOCK_VECTOR:	kernelfunc= kernel_add_vector;	break;
-	case SOCK_RGBA:		kernelfunc= kernel_add_rgba;	break;
 	default:			kernelfunc= NULL;
 	}
 	
@@ -193,36 +186,30 @@
 			*OUTPUT0_VECTOR(get_global_id(0)) = INPUT0_VECTOR(get_global_id(0)) - INPUT1_VECTOR(get_global_id(0));
 			));
 		break;
-	case SOCK_RGBA:
-		BLI_dynstr_append(source, STRINGIFY(
-			*OUTPUT0_RGBA(get_global_id(0)) = INPUT0_RGBA(get_global_id(0)) - INPUT1_RGBA(get_global_id(0));
-			));
-		break;
 	}
 	return sim_kernel_source_end(source);
 }
 static void kernel_subtract_float(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_FLOAT(0, global_id) = SIM_INPUT_FLOAT(0, global_id) - SIM_INPUT_FLOAT(1, global_id);
+	float a, b;
+	SIM_INPUT_FLOAT(0, global_id, &a);
+	SIM_INPUT_FLOAT(1, global_id, &b);
+	*SIM_OUTPUT_FLOAT(0, global_id) = a - b;
 }
 static void kernel_subtract_int(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_INT(0, global_id) = SIM_INPUT_INT(0, global_id) - SIM_INPUT_INT(1, global_id);
+	int a, b;
+	SIM_INPUT_INT(0, global_id, &a);
+	SIM_INPUT_INT(1, global_id, &b);
+	*SIM_OUTPUT_INT(0, global_id) = a - b;
 }
 static void kernel_subtract_vector(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	sub_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(1, global_id));
+	float a[3], b[3];
+	SIM_INPUT_VECTOR(0, global_id, a);
+	SIM_INPUT_VECTOR(1, global_id, b);
+	sub_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), a, b);
 }
-static void kernel_subtract_rgba(int global_id, void **UNUSED(args), SimNodeStack *node)
-{
-	float *res=SIM_OUTPUT_RGBA(0, global_id);
-	const float *a=SIM_INPUT_RGBA(0, global_id);
-	const float *b=SIM_INPUT_RGBA(1, global_id);
-	res[0] = a[0] - b[0];
-	res[1] = a[1] - b[1];
-	res[2] = a[2] - b[2];
-	res[3] = a[3] - b[3];
-}
 
 static void enqueue_subtract(SimExecData *execdata, SimNodeStack *node, SimDataContext *self)
 {
@@ -235,7 +222,6 @@
 	case SOCK_FLOAT:	kernelfunc= kernel_subtract_float;	break;
 	case SOCK_INT:		kernelfunc= kernel_subtract_int;		break;
 	case SOCK_VECTOR:	kernelfunc= kernel_subtract_vector;	break;
-	case SOCK_RGBA:		kernelfunc= kernel_subtract_rgba;	break;
 	default:			kernelfunc= NULL;
 	}
 	
@@ -290,36 +276,30 @@
 			*OUTPUT0_VECTOR(get_global_id(0)) = INPUT0_VECTOR(get_global_id(0)) * INPUT1_VECTOR(get_global_id(0));
 			));
 		break;
-	case SOCK_RGBA:
-		BLI_dynstr_append(source, STRINGIFY(
-			*OUTPUT0_RGBA(get_global_id(0)) = INPUT0_RGBA(get_global_id(0)) * INPUT1_RGBA(get_global_id(0));
-			));
-		break;
 	}
 	return sim_kernel_source_end(source);
 }
 static void kernel_multiply_float(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_FLOAT(0, global_id) = SIM_INPUT_FLOAT(0, global_id) * SIM_INPUT_FLOAT(1, global_id);
+	float a, b;
+	SIM_INPUT_FLOAT(0, global_id, &a);
+	SIM_INPUT_FLOAT(1, global_id, &b);
+	*SIM_OUTPUT_FLOAT(0, global_id) = a * b;
 }
 static void kernel_multiply_int(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	*SIM_OUTPUT_INT(0, global_id) = SIM_INPUT_INT(0, global_id) * SIM_INPUT_INT(1, global_id);
+	int a, b;
+	SIM_INPUT_INT(0, global_id, &a);
+	SIM_INPUT_INT(1, global_id, &b);
+	*SIM_OUTPUT_INT(0, global_id) = a * b;
 }
 static void kernel_multiply_vector(int global_id, void **UNUSED(args), SimNodeStack *node)
 {
-	mul_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(0, global_id), SIM_INPUT_VECTOR(1, global_id));
+	float a[3], b[3];
+	SIM_INPUT_VECTOR(0, global_id, a);
+	SIM_INPUT_VECTOR(1, global_id, b);
+	mul_v3_v3v3(SIM_OUTPUT_VECTOR(0, global_id), a, b);
 }
-static void kernel_multiply_rgba(int global_id, void **UNUSED(args), SimNodeStack *node)
-{
-	float *res=SIM_OUTPUT_RGBA(0, global_id);
-	const float *a=SIM_INPUT_RGBA(0, global_id);
-	const float *b=SIM_INPUT_RGBA(1, global_id);
-	res[0] = a[0] * b[0];
-	res[1] = a[1] * b[1];
-	res[2] = a[2] * b[2];
-	res[3] = a[3] * b[3];
-}
 
 static void enqueue_multiply(SimExecData *execdata, SimNodeStack *node, SimDataContext *self)
 {
@@ -332,7 +312,6 @@
 	case SOCK_FLOAT:	kernelfunc= kernel_multiply_float;	break;
 	case SOCK_INT:		kernelfunc= kernel_multiply_int;		break;
 	case SOCK_VECTOR:	kernelfunc= kernel_multiply_vector;	break;
-	case SOCK_RGBA:		kernelfunc= kernel_multiply_rgba;	break;

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list