[Bf-blender-cvs] [635ab9d1dde] master: Shading: Extend Vector Math Node with Sin, Cos, Tan and Wrap functions

Charlie Jolly noreply at git.blender.org
Fri Feb 14 23:14:51 CET 2020


Commit: 635ab9d1dded4d4975bd4486718fde19e8e901ca
Author: Charlie Jolly
Date:   Fri Feb 14 21:46:10 2020 +0000
Branches: master
https://developer.blender.org/rB635ab9d1dded4d4975bd4486718fde19e8e901ca

Shading: Extend Vector Math Node with Sin, Cos, Tan and Wrap functions

This adds some extra functions recently added to the float Maths Node.
Not all functions have been ported over in this patch.

Also:
+ Tidy up menu
+ Change node color to match other vector nodes, this helps distinguish vector and float nodes in the tree
+ Move shared OSL functions to new header node_math.h

Reviewed By: brecht

Differential Revision: https://developer.blender.org/D6713

===================================================================

M	intern/cycles/kernel/shaders/CMakeLists.txt
A	intern/cycles/kernel/shaders/node_math.h
M	intern/cycles/kernel/shaders/node_math.osl
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/nodes.cpp
M	intern/cycles/render/nodes.h
M	release/scripts/addons
M	source/blender/gpu/shaders/material/gpu_shader_material_math.glsl
M	source/blender/gpu/shaders/material/gpu_shader_material_math_util.glsl
M	source/blender/gpu/shaders/material/gpu_shader_material_vector_math.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_vector_math.c

===================================================================

diff --git a/intern/cycles/kernel/shaders/CMakeLists.txt b/intern/cycles/kernel/shaders/CMakeLists.txt
index 8605f23b8fa..1c9445107ad 100644
--- a/intern/cycles/kernel/shaders/CMakeLists.txt
+++ b/intern/cycles/kernel/shaders/CMakeLists.txt
@@ -112,6 +112,7 @@ set(SRC_OSL_HEADERS
   node_color.h
   node_fresnel.h
   node_hash.h
+  node_math.h
   node_noise.h
   node_ramp_util.h
   stdcycles.h
diff --git a/intern/cycles/kernel/shaders/node_math.h b/intern/cycles/kernel/shaders/node_math.h
new file mode 100644
index 00000000000..9baf1014418
--- /dev/null
+++ b/intern/cycles/kernel/shaders/node_math.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011-2020 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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);
+}
+
+float safe_modulo(float a, float b)
+{
+  return (b != 0.0) ? fmod(a, b) : 0.0;
+}
+
+float fract(float a)
+{
+  return a - floor(a);
+}
+
+/* See: https://www.iquilezles.org/www/articles/smin/smin.htm. */
+float smoothmin(float a, float b, float c)
+{
+  if (c != 0.0) {
+    float h = max(c - abs(a - b), 0.0) / c;
+    return min(a, b) - h * h * h * c * (1.0 / 6.0);
+  }
+  else {
+    return min(a, b);
+  }
+}
+
+float pingpong(float a, float b)
+{
+  return (b != 0.0) ? abs(fract((a - b) / (b * 2.0)) * b * 2.0 - b) : 0.0;
+}
+
+float safe_sqrt(float a)
+{
+  return (a > 0.0) ? sqrt(a) : 0.0;
+}
+
+float safe_log(float a, float b)
+{
+  return (a > 0.0 && b > 0.0) ? log(a) / log(b) : 0.0;
+}
+
+float safe_divide(float a, float b)
+{
+  return (b != 0.0) ? a / b : 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 floor(safe_divide(a, b)) * b;
+}
+
+/* Adapted from godotengine math_funcs.h. */
+float wrap(float value, float max, float min)
+{
+  float range = max - min;
+  return (range != 0.0) ? value - (range * floor((value - min) / range)) : min;
+}
+
+point wrap(point value, point max, point min)
+{
+  return point(wrap(value[0], max[0], min[0]),
+               wrap(value[1], max[1], min[1]),
+               wrap(value[2], max[2], min[2]));
+}
diff --git a/intern/cycles/kernel/shaders/node_math.osl b/intern/cycles/kernel/shaders/node_math.osl
index 54a2e38dcd6..6c3dd1547a6 100644
--- a/intern/cycles/kernel/shaders/node_math.osl
+++ b/intern/cycles/kernel/shaders/node_math.osl
@@ -15,55 +15,7 @@
  */
 
 #include "stdcycles.h"
-
-float safe_divide(float a, float b)
-{
-  return (b != 0.0) ? a / b : 0.0;
-}
-
-float safe_modulo(float a, float b)
-{
-  return (b != 0.0) ? fmod(a, b) : 0.0;
-}
-
-float fract(float a)
-{
-  return a - floor(a);
-}
-
-/* Adapted from godotengine math_funcs.h. */
-float wrap(float value, float max, float min)
-{
-  float range = max - min;
-  return (range != 0.0) ? value - (range * floor((value - min) / range)) : min;
-}
-
-/* See: https://www.iquilezles.org/www/articles/smin/smin.htm. */
-float smoothmin(float a, float b, float c)
-{
-  if (c != 0.0) {
-    float h = max(c - abs(a - b), 0.0) / c;
-    return min(a, b) - h * h * h * c * (1.0 / 6.0);
-  }
-  else {
-    return min(a, b);
-  }
-}
-
-float pingpong(float a, float b)
-{
-  return (b != 0.0) ? abs(fract((a - b) / (b * 2.0)) * b * 2.0 - b) : 0.0;
-}
-
-float safe_sqrt(float a)
-{
-  return (a > 0.0) ? sqrt(a) : 0.0;
-}
-
-float safe_log(float a, float b)
-{
-  return (a > 0.0 && b > 0.0) ? log(a) / log(b) : 0.0;
-}
+#include "node_math.h"
 
 /* OSL asin, acos, and pow functions are safe by default. */
 shader node_math(string type = "add",
diff --git a/intern/cycles/kernel/shaders/node_vector_math.osl b/intern/cycles/kernel/shaders/node_vector_math.osl
index 87bfb663d2c..7f3ea781f38 100644
--- a/intern/cycles/kernel/shaders/node_vector_math.osl
+++ b/intern/cycles/kernel/shaders/node_vector_math.osl
@@ -15,33 +15,12 @@
  */
 
 #include "stdcycles.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 floor(safe_divide(a, b)) * b;
-}
+#include "node_math.h"
 
 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),
+                        vector Vector3 = vector(0.0, 0.0, 0.0),
                         float Scale = 1.0,
                         output float Value = 0.0,
                         output vector Vector = vector(0.0, 0.0, 0.0))
@@ -94,6 +73,9 @@ shader node_vector_math(string type = "add",
   else if (type == "modulo") {
     Vector = fmod(Vector1, Vector2);
   }
+  else if (type == "wrap") {
+    Vector = wrap(Vector1, Vector2, Vector3);
+  }
   else if (type == "fraction") {
     Vector = Vector1 - floor(Vector1);
   }
@@ -106,6 +88,15 @@ shader node_vector_math(string type = "add",
   else if (type == "maximum") {
     Vector = max(Vector1, Vector2);
   }
+  else if (type == "sine") {
+    Vector = sin(Vector1);
+  }
+  else if (type == "cosine") {
+    Vector = cos(Vector1);
+  }
+  else if (type == "tangent") {
+    Vector = tan(Vector1);
+  }
   else {
     warning("%s", "Unknown vector math operator!");
   }
diff --git a/intern/cycles/kernel/svm/svm_math.h b/intern/cycles/kernel/svm/svm_math.h
index 82cae7bbacf..01e01c399ea 100644
--- a/intern/cycles/kernel/svm/svm_math.h
+++ b/intern/cycles/kernel/svm/svm_math.h
@@ -51,11 +51,19 @@ ccl_device void svm_node_vector_math(KernelGlobals *kg,
 
   float3 a = stack_load_float3(stack, a_stack_offset);
   float3 b = stack_load_float3(stack, b_stack_offset);
+  float3 c;
   float scale = stack_load_float(stack, scale_stack_offset);
 
   float value;
   float3 vector;
-  svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, scale);
+
+  /* 3 Vector Operators */
+  if (type == NODE_VECTOR_MATH_WRAP) {
+    uint4 extra_node = read_node(kg, offset);
+    c = stack_load_float3(stack, extra_node.x);
+  }
+
+  svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, scale);
 
   if (stack_valid(value_stack_offset))
     stack_store_float(stack, value_stack_offset, value);
diff --git a/intern/cycles/kernel/svm/svm_math_util.h b/intern/cycles/kernel/svm/svm_math_util.h
index 7b9eaaeb710..8b431b54eea 100644
--- a/intern/cycles/kernel/svm/svm_math_util.h
+++ b/intern/cycles/kernel/svm/svm_math_util.h
@@ -17,7 +17,7 @@
 CCL_NAMESPACE_BEGIN
 
 ccl_device void svm_vector_math(
-    float *value, float3 *vector, NodeVectorMathType type, float3 a, float3 b, float scale)
+    float *value, float3 *vector, NodeVectorMathType type, float3 a, float3 b, float3 c, float scale)
 {
   switch (type) {
     case NODE_VECTOR_MATH_ADD:
@@ -68,6 +68,10 @@ ccl_device void svm_vector_math(
     case NODE_VECTOR_MATH_MODULO:
       *vector = make_float3(safe_modulo(a.x, b.x), safe_modulo(a.y, b.y), safe_modulo(a.z, b.z));
       break;
+    case NODE_VECTOR_MATH_WRAP:
+      *vector = make_float3(
+          wrapf(a.x, b.x, c.x), wrapf(a.y, b.y, c.y), wrapf(a.z, b.z, c.z));
+      break;
     case NODE_VECTOR_MATH_FRACTION:
       *vector = a - floor(a);
       break;
@@ -80,6 +84,15 @@ ccl_device void svm_vector_math(
     case NODE_VECTOR_MATH_MAXIMUM:
       *vector = max(a, b);
       break;
+    case NODE_VECTOR_MATH_SINE:
+      *vector = make_float3(sinf(a.x), sinf(a.y), sinf(a.z));
+      break;
+    case NODE_VECTOR_MATH_COSINE:
+      *vector = make_float3(cosf(a.x), cosf(a.y), cosf(a.z));
+      break;
+    case NODE_VECTOR_MATH_TANGENT:
+      *vector = make_float3(tanf(a.x), tanf(a.y), tanf(a.z));
+      break;
     default:
       *vector = make_float3(0.0f, 0.0f, 0.0f);
       *value = 0.0f;
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 8dbb147e76a..828b43eb8e4 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -326,6 +326,10 @@ typedef enum NodeVectorMathType {
   NODE_VECTOR_MATH_ABSOLUTE,
   NODE_VECTOR_MATH_MINIMUM,
   NODE_VECTOR_MATH_MAXIMUM,
+  NODE_VECTOR_MATH_WRAP,
+  NODE_VECTOR_MATH_SINE,
+  NODE_VECTOR_MATH_COSINE,
+  NODE_VECTOR_MATH_TANGENT,
 } NodeVectorMathType;
 
 typedef enum NodeClampType {
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 75e21e00dcf..3f5c2aacc98 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -6022,14 +6022,20 @@ NODE_DEFINE(VectorMathNode)
   type_enum.insert("floor", NODE_VECTOR_MATH_FLOOR);
   type_enum.insert("ceil", NODE_VECTOR_MATH_CEIL);
   type_enum.insert("modulo", NODE_VECTOR_MATH_MODULO);
+  type_enum.insert("wrap", NODE_VECTOR_MATH_WRAP);
   type_enum.insert("fraction", NODE_VECTOR_MATH_FRACTION);
   type_enum.insert("absolute", NODE_VECTOR_MATH_ABSOLUTE);
   type_enum.insert("minimum", NODE_VECTOR_MATH_MINIMUM);
   type_enum.insert("maximum", NODE_VECTOR_MATH_MAXIMUM);
+
+  type_enum.insert("sine", NODE_VECTOR_MATH_SINE);
+  type_enum.insert("cosine", NODE_VECTOR_MATH_COSINE);
+  type_enum.insert("tangent", NODE_VECTOR_MATH_TANG

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list