[Bf-blender-cvs] [a52006c2fe8] soc-2019-cycles-procedural: Initial implementation of new vector math node.
OmarSquircleArt
noreply at git.blender.org
Thu May 30 13:34:22 CEST 2019
Commit: a52006c2fe879099b675c983d29b3373af016e8a
Author: OmarSquircleArt
Date: Thu May 30 13:26:32 2019 +0200
Branches: soc-2019-cycles-procedural
https://developer.blender.org/rBa52006c2fe879099b675c983d29b3373af016e8a
Initial implementation of new vector math node.
===================================================================
M intern/cycles/kernel/shaders/node_vector_math.osl
M intern/cycles/kernel/svm/svm_math.h
M intern/cycles/kernel/svm/svm_math_util.h
M intern/cycles/kernel/svm/svm_types.h
M intern/cycles/render/constant_fold.cpp
M intern/cycles/render/nodes.cpp
M intern/cycles/render/nodes.h
M intern/cycles/util/util_math_float3.h
M release/datafiles/locale
M release/scripts/addons
M release/scripts/addons_contrib
M source/blender/blenlib/BLI_math_vector.h
M source/blender/blenlib/intern/math_vector_inline.c
M source/blender/gpu/shaders/gpu_shader_material.glsl
M source/blender/makesdna/DNA_node_types.h
M source/blender/makesrna/intern/rna_nodetree.c
M source/blender/nodes/shader/nodes/node_shader_vectMath.c
===================================================================
diff --git a/intern/cycles/kernel/shaders/node_vector_math.osl b/intern/cycles/kernel/shaders/node_vector_math.osl
index 10bb0c7283c..4f04558c802 100644
--- a/intern/cycles/kernel/shaders/node_vector_math.osl
+++ b/intern/cycles/kernel/shaders/node_vector_math.osl
@@ -16,34 +16,90 @@
#include "stdosl.h"
+float safe_divide(float a, float b)
+{
+ return (b != 0.0) ? a / b : 0.0;
+}
+
+vector safe_divide(vector a, vector b)
+{
+ return vector((b[0] != 0.0) ? a[0] / b[0] : 0.0,
+ (b[1] != 0.0) ? a[1] / b[1] : 0.0,
+ (b[2] != 0.0) ? a[2] / b[2] : 0.0);
+}
+
+vector project(vector v, vector v_proj)
+{
+ float lenSquared = dot(v_proj, v_proj);
+ return (lenSquared != 0.0) ? (dot(v, v_proj) / lenSquared) * v_proj : vector(0.0);
+}
+
+vector snap(vector a, vector b)
+{
+ return vector(floor(safe_divide(a[0], b[0])) * b[0],
+ floor(safe_divide(a[1], b[1])) * b[1],
+ floor(safe_divide(a[2], b[2])) * b[2]);
+}
+
shader node_vector_math(string type = "add",
vector Vector1 = vector(0.0, 0.0, 0.0),
vector Vector2 = vector(0.0, 0.0, 0.0),
+ float Factor = 1.0,
output float Value = 0.0,
output vector Vector = vector(0.0, 0.0, 0.0))
{
if (type == "add") {
Vector = Vector1 + Vector2;
- Value = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2])) / 3.0;
}
else if (type == "subtract") {
Vector = Vector1 - Vector2;
- Value = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2])) / 3.0;
+ }
+ else if (type == "multiply") {
+ Vector = Vector1 * Vector2;
+ }
+ else if (type == "divide") {
+ Vector = safe_divide(Vector1, Vector2);
+ }
+ else if (type == "cross_product") {
+ Vector = cross(Vector1, Vector2);
+ }
+ else if (type == "project") {
+ Vector = project(Vector1, Vector2);
+ }
+ else if (type == "reflect") {
+ Vector = reflect(Vector1, Vector2);
}
else if (type == "average") {
- Value = length(Vector1 + Vector2);
Vector = normalize(Vector1 + Vector2);
}
else if (type == "dot_product") {
Value = dot(Vector1, Vector2);
}
- else if (type == "cross_product") {
- vector c = cross(Vector1, Vector2);
- Value = length(c);
- Vector = normalize(c);
+ else if (type == "distance") {
+ Value = distance(Vector1, Vector2);
}
- else if (type == "normalize") {
+ else if (type == "length") {
Value = length(Vector1);
+ }
+ else if (type == "scale") {
+ Vector = Vector1 * Factor;
+ }
+ else if (type == "normalize") {
Vector = normalize(Vector1);
}
+ else if (type == "snap") {
+ Vector = snap(Vector1, Vector2);
+ }
+ else if (type == "modulo") {
+ Vector = mod(Vector1, Vector2);
+ }
+ else if (type == "absolute") {
+ Vector = abs(Vector1);
+ }
+ else if (type == "minimum") {
+ Vector = min(Vector1, Vector2);
+ }
+ else if (type == "maximum") {
+ Vector = max(Vector1, Vector2);
+ }
}
diff --git a/intern/cycles/kernel/svm/svm_math.h b/intern/cycles/kernel/svm/svm_math.h
index 5920913825b..643b1f78a0d 100644
--- a/intern/cycles/kernel/svm/svm_math.h
+++ b/intern/cycles/kernel/svm/svm_math.h
@@ -44,20 +44,21 @@ ccl_device void svm_node_vector_math(KernelGlobals *kg,
uint v2_offset,
int *offset)
{
+ uint4 node1 = read_node(kg, offset);
+
NodeVectorMath type = (NodeVectorMath)itype;
float3 v1 = stack_load_float3(stack, v1_offset);
float3 v2 = stack_load_float3(stack, v2_offset);
+ float fac = stack_load_float(stack, node1.y);
float f;
float3 v;
- svm_vector_math(&f, &v, type, v1, v2);
-
- uint4 node1 = read_node(kg, offset);
+ svm_vector_math(&f, &v, type, v1, v2, fac);
- if (stack_valid(node1.y))
- stack_store_float(stack, node1.y, f);
if (stack_valid(node1.z))
- stack_store_float3(stack, node1.z, v);
+ stack_store_float(stack, node1.z, f);
+ if (stack_valid(node1.w))
+ stack_store_float3(stack, node1.w, v);
}
CCL_NAMESPACE_END
diff --git a/intern/cycles/kernel/svm/svm_math_util.h b/intern/cycles/kernel/svm/svm_math_util.h
index e3544515f1b..3d8c16a8495 100644
--- a/intern/cycles/kernel/svm/svm_math_util.h
+++ b/intern/cycles/kernel/svm/svm_math_util.h
@@ -16,38 +16,89 @@
CCL_NAMESPACE_BEGIN
-ccl_device float average_fac(float3 v)
-{
- return (fabsf(v.x) + fabsf(v.y) + fabsf(v.z)) / 3.0f;
-}
-
ccl_device void svm_vector_math(
- float *Fac, float3 *Vector, NodeVectorMath type, float3 Vector1, float3 Vector2)
+ float *Fac, float3 *Vector, NodeVectorMath type, float3 Vector1, float3 Vector2, float Factor)
{
- if (type == NODE_VECTOR_MATH_ADD) {
- *Vector = Vector1 + Vector2;
- *Fac = average_fac(*Vector);
- }
- else if (type == NODE_VECTOR_MATH_SUBTRACT) {
- *Vector = Vector1 - Vector2;
- *Fac = average_fac(*Vector);
- }
- else if (type == NODE_VECTOR_MATH_AVERAGE) {
- *Vector = safe_normalize_len(Vector1 + Vector2, Fac);
- }
- else if (type == NODE_VECTOR_MATH_DOT_PRODUCT) {
- *Fac = dot(Vector1, Vector2);
- *Vector = make_float3(0.0f, 0.0f, 0.0f);
- }
- else if (type == NODE_VECTOR_MATH_CROSS_PRODUCT) {
- *Vector = safe_normalize_len(cross(Vector1, Vector2), Fac);
- }
- else if (type == NODE_VECTOR_MATH_NORMALIZE) {
- *Vector = safe_normalize_len(Vector1, Fac);
- }
- else {
- *Fac = 0.0f;
- *Vector = make_float3(0.0f, 0.0f, 0.0f);
+ switch (type) {
+ case NODE_VECTOR_MATH_ADD:
+ *Vector = Vector1 + Vector2;
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_SUBTRACT:
+ *Vector = Vector1 - Vector2;
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_MULTIPLY:
+ *Vector = Vector1 * Vector2;
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_DIVIDE:
+ *Vector = safe_divide(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_CROSS_PRODUCT:
+ *Vector = cross(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_PROJECT:
+ *Vector = project(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_REFLECT:
+ *Vector = reflect(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_AVERAGE:
+ *Vector = safe_normalize(Vector1 + Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_DOT_PRODUCT:
+ *Vector = make_float3(0.0f, 0.0f, 0.0f);
+ *Fac = dot(Vector1, Vector2);
+ break;
+ case NODE_VECTOR_MATH_DISTANCE:
+ *Vector = make_float3(0.0f, 0.0f, 0.0f);
+ *Fac = len(Vector1 - Vector2);
+ break;
+ case NODE_VECTOR_MATH_LENGTH:
+ *Vector = make_float3(0.0f, 0.0f, 0.0f);
+ *Fac = len(Vector1);
+ break;
+ case NODE_VECTOR_MATH_SCALE:
+ *Vector = Vector1 * Factor;
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_NORMALIZE:
+ *Vector = safe_normalize(Vector1);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_SNAP:
+ *Vector = make_float3(floorf(safe_divide(Vector1.x, Vector2.x)) * Vector2.x,
+ floorf(safe_divide(Vector1.y, Vector2.y)) * Vector2.y,
+ floorf(safe_divide(Vector1.z, Vector2.z)) * Vector2.z);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_MOD:
+ *Vector = make_float3(safe_modulo(Vector1.x, Vector2.x),
+ safe_modulo(Vector1.y, Vector2.y),
+ safe_modulo(Vector1.z, Vector2.z));
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_ABS:
+ *Vector = fabs(Vector1);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_MIN:
+ *Vector = min(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ case NODE_VECTOR_MATH_MAX:
+ *Vector = max(Vector1, Vector2);
+ *Fac = 0.0f;
+ break;
+ default:
+ *Vector = make_float3(0.0f, 0.0f, 0.0f);
+ *Fac = 0.0f;
}
}
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index ea92fd7ce59..c49898d4691 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -276,7 +276,23 @@ typedef enum NodeVectorMath {
NODE_VECTOR_MATH_AVERAGE,
NODE_VECTOR_MATH_DOT_PRODUCT,
NODE_VECTOR_MATH_CROSS_PRODUCT,
- NODE_VECTOR_MATH_NORMALIZE
+ NODE_VECTOR_MATH_NORMALIZE,
+
+ NODE_VECTOR_MATH_MULTIPLY,
+ NODE_VECTOR_MATH_DIVIDE,
+
+ NODE_VECTOR_MATH_PROJECT,
+ NODE_VECTOR_MATH_REFLECT,
+
+ NODE_VECTOR_MATH_DISTANCE,
+ NODE_VECTOR_MATH_LENGTH,
+ NODE_VECTOR_MATH_SCALE,
+
+ NODE_VECTOR_MATH_SNAP,
+ NODE_VECTOR_MATH_MOD,
+ NODE_VECTOR_MATH_ABS,
+ NODE_VECTOR_MATH_MIN,
+ NODE_VECTOR_MATH_MAX,
} NodeVectorMath;
typedef enum NodeVectorTransformType {
diff --git a/intern/cycles/render/constant_fold.cpp b/intern/cycles/render/constant_fold.cpp
index e475ff60eef..482441a8433 100644
--- a/intern/cycles/render/constant_fold.cpp
+++ b/intern/cycles/render/constant_fold.cpp
@@ -363,6 +363,7 @@ void ConstantFolder::fold_vector_math(NodeVectorMath type) const
{
ShaderInput *vector1_in = node->input("Vector1");
ShaderInput *vector2_in = node->input("Vector2");
+ ShaderInput *factor_in = node->input("Factor");
switch (type) {
case NODE_VECTOR_MATH_ADD:
@@ -380,6 +381,27 @@ void ConstantFolder::fold_vector_math(NodeVectorMath type) const
try_bypass_or_make_constant(vector1_in);
}
break;
+ case NODE_VECTOR_MATH_MULTIPLY:
+ /* X * 0 == 0 * X == 0 */
+ if (is_zero(vector1_in) || is_zero(vector2_in)) {
+ make_zero();
+ } /* X * 1 == 1 * X == X */
+ else if (is_one(vector1_in)) {
+ try_bypass_or_make_constant(vector2_in);
+ }
+ else if (is_one(vector2_in)) {
+ try_bypass_or_make_constant(vector1_in);
+ }
+ break;
+ case NODE_VECTOR_MATH_DIVIDE:
+ /* X / 0 == 0 / X == 0 */
+ if (is_zero(vector1_in) || is_zero(vector2_in)) {
+ make_zero();
+ } /* X / 1 == X */
+ else if (is_one(vector2_in)) {
+ try_bypass_or_make_constant(vector1_in);
+ }
+ break;
case NODE_VECTOR_MATH_DOT_PRODUCT:
case NODE_V
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list