== Shader nodes ==
authorMatt Ebb <matt@mke3.net>
Thu, 31 May 2007 06:55:02 +0000 (06:55 +0000)
committerMatt Ebb <matt@mke3.net>
Thu, 31 May 2007 06:55:02 +0000 (06:55 +0000)
* Geometry node: Front/back output
This is used as a mask for determining whether you're looking at the front side or back side of a mesh, useful for blending materials, my practical need was giving different materials to the pages of a magazine: http://mke3.net/blender/etc/frontback-h264.mov

Give 1.0 if it's the front side, and 0.0 if it's the back side.

* Extended material node
This is the same as the material node, but gives more available inputs and outputs, (basically just connecting up more of ShadeInput and ShadeResult to the node). I didn't want to add it to the normal simple Material node since you don't always need all that stuff, and it would make the node huge, but when you do need it, it's nice to have it.

== Comp nodes ==

* Invert node
Inverting is something that happens all the time in a node setup, and this makes it easier. It's been possible to invert previously by adding a mix node and subtracting the input from 1.0, but it's not the best way of doing it. This node:
 - makes it a lot faster to set up, rather than all the clicking required with the mix node
 - is a lot more usable amidst a complex comp setup, when you're looking at a node tree, it's very helpful to be able to see at a glance what's going on. Using subtract for inverting is easily mixed up with other nodes in which you are actually subtracting, not inverting, and looks very similar to all the other mix nodes that usually litter a comp tree.
 - has options to invert the RGB channels, the Alpha channel, or both. This saves adding lots of extra nodes (separate RGBA, subtract, set alpha) when you want to do something simple like invert an alpha channel. I'd like to add this option to other nodes too.

There's also a shader node version too.

* Also a few fixes that I committed ages ago, but seems to have been overwritten in Bob's node refactor:
 - adding new compbufs to the set alpha and alphaover nodes when you have only one noodle connected to the lower input
 - making the fac value on RGB curves still work when there's nothing connected to it

17 files changed:
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/intern/node.c
source/blender/nodes/CMP_node.h
source/blender/nodes/SHD_node.h
source/blender/nodes/intern/CMP_nodes/CMP_alphaOver.c
source/blender/nodes/intern/CMP_nodes/CMP_curves.c
source/blender/nodes/intern/CMP_nodes/CMP_invert.c [new file with mode: 0644]
source/blender/nodes/intern/CMP_nodes/CMP_mixrgb.c
source/blender/nodes/intern/CMP_nodes/CMP_setalpha.c
source/blender/nodes/intern/SHD_nodes/SHD_geom.c
source/blender/nodes/intern/SHD_nodes/SHD_invert.c [new file with mode: 0644]
source/blender/nodes/intern/SHD_nodes/SHD_material.c
source/blender/nodes/intern/SHD_util.c
source/blender/nodes/intern/SHD_util.h
source/blender/render/extern/include/RE_shader_ext.h
source/blender/render/intern/source/shadeinput.c
source/blender/src/drawnode.c

index bace38651eae00cb443173e6c96768db983c1962..44266a1c854ecf401121d650b52debb1b461d903 100644 (file)
@@ -204,6 +204,8 @@ struct ShadeResult;
 #define SH_NODE_MATH           115
 #define SH_NODE_VECT_MATH      116
 #define SH_NODE_SQUEEZE                117
+#define SH_NODE_MATERIAL_EXT   118
+#define SH_NODE_INVERT         119
 
 
 /* custom defines options for Material node */
@@ -293,9 +295,16 @@ void                       set_node_shader_lamp_loop(void (*lamp_loop_func)(struct ShadeInput *, str
 #define CMP_NODE_COMBHSVA      246
 #define CMP_NODE_MATH          247
 #define CMP_NODE_LUMA_MATTE    248
-
 #define CMP_NODE_BRIGHTCONTRAST 249
 #define CMP_NODE_GAMMA         250
+#define CMP_NODE_INVERT                251
+
+/* channel toggles */
+#define CMP_CHAN_RGB           1
+#define CMP_CHAN_A                     2
+#define CMP_CHAN_R                     4
+#define CMP_CHAN_G                     8
+#define CMP_CHAN_B                     16
 
 /* filter types */
 #define CMP_FILT_SOFT          0
index 842e07cebe7dec43c936f9f51763a0dc36cfd4b3..e7b7b36aaa41ca1801b0c1e88da655e45faa487e 100644 (file)
@@ -2322,6 +2322,9 @@ static void registerCompositNodes(ListBase *ntypelist)
        nodeRegisterType(ntypelist, &cmp_node_curve_rgb);
        nodeRegisterType(ntypelist, &cmp_node_mix_rgb);
        nodeRegisterType(ntypelist, &cmp_node_hue_sat);
+       nodeRegisterType(ntypelist, &cmp_node_brightcontrast);
+       nodeRegisterType(ntypelist, &cmp_node_gamma);
+       nodeRegisterType(ntypelist, &cmp_node_invert);
        nodeRegisterType(ntypelist, &cmp_node_alphaover);
        nodeRegisterType(ntypelist, &cmp_node_zcombine);
        
@@ -2361,9 +2364,6 @@ static void registerCompositNodes(ListBase *ntypelist)
        nodeRegisterType(ntypelist, &cmp_node_flip);
        nodeRegisterType(ntypelist, &cmp_node_displace);
        nodeRegisterType(ntypelist, &cmp_node_mapuv);
-
-       nodeRegisterType(ntypelist, &cmp_node_brightcontrast);
-       nodeRegisterType(ntypelist, &cmp_node_gamma);
 }
 
 static void registerShaderNodes(ListBase *ntypelist) 
@@ -2383,9 +2383,11 @@ static void registerShaderNodes(ListBase *ntypelist)
        nodeRegisterType(ntypelist, &sh_node_squeeze);
        nodeRegisterType(ntypelist, &sh_node_camera);
        nodeRegisterType(ntypelist, &sh_node_material);
+       nodeRegisterType(ntypelist, &sh_node_material_ext);
        nodeRegisterType(ntypelist, &sh_node_value);
        nodeRegisterType(ntypelist, &sh_node_rgb);
        nodeRegisterType(ntypelist, &sh_node_texture);
+       nodeRegisterType(ntypelist, &sh_node_invert);
 }
 
 void init_nodesystem(void) 
index ea15d4dbe73687bb8ada6d445bdf4186098cb6d4..3410238c0a2335975d90ea27356114f989645643 100644 (file)
@@ -53,6 +53,9 @@ extern bNodeType cmp_node_output_file;
 extern bNodeType cmp_node_curve_rgb;
 extern bNodeType cmp_node_mix_rgb;
 extern bNodeType cmp_node_hue_sat;
+extern bNodeType cmp_node_brightcontrast;
+extern bNodeType cmp_node_gamma;
+extern bNodeType cmp_node_invert;
 extern bNodeType cmp_node_alphaover;
 extern bNodeType cmp_node_zcombine;
 
@@ -93,9 +96,6 @@ extern bNodeType cmp_node_flip;
 extern bNodeType cmp_node_displace;
 extern bNodeType cmp_node_mapuv;
 
-extern bNodeType cmp_node_brightcontrast;
-extern bNodeType cmp_node_gamma;
-
 #endif
 
 
index b443a39624bf38ad19670f4eb945ec9e7da9d160..688494d6de5e3519b00f761ad619478c2cb61f99 100644 (file)
@@ -56,6 +56,8 @@ extern bNodeType sh_node_curve_rgb;
 extern bNodeType sh_node_math;
 extern bNodeType sh_node_vect_math;
 extern bNodeType sh_node_squeeze;
+extern bNodeType sh_node_material_ext;
+extern bNodeType sh_node_invert;
 
 #endif
 
index aedaa036d67325bcf6e0fd5453e6699ba195ee23..f108098750c640b833ff0f347120f801ab7acd4d 100644 (file)
@@ -90,12 +90,12 @@ static void node_composit_exec_alphaover(void *data, bNode *node, bNodeStack **i
                return;
        
        /* input no image? then only color operation */
-       if(in[1]->data==NULL) {
+       if(in[1]->data==NULL && in[2]->data==NULL) {
                do_alphaover_premul(node, out[0]->vec, in[1]->vec, in[2]->vec, in[0]->vec);
        }
        else {
                /* make output size of input image */
-               CompBuf *cbuf= in[1]->data;
+               CompBuf *cbuf= in[1]->data?in[1]->data:in[2]->data;
                CompBuf *stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_RGBA, 1); /* allocs */
                
                if(node->custom1)
index 754d016fb2524fae596ae5d5ea5726670933b3b3..17d9821a5ef3984a2232ee4f11ac9cf5be3e62e0 100644 (file)
@@ -172,10 +172,10 @@ static void node_composit_exec_curve_rgb(void *data, bNode *node, bNodeStack **i
                CompBuf *cbuf= in[1]->data;
                CompBuf *stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_RGBA, 1); /* allocs */
                
-               if(in[0]->data)
-                       composit2_pixel_processor(node, stackbuf, in[1]->data, in[1]->vec, in[0]->data, in[0]->vec, do_curves_fac, CB_RGBA, CB_VAL);
-               else
+               if(in[0]->vec[0] == 1.0)
                        composit1_pixel_processor(node, stackbuf, in[1]->data, in[1]->vec, do_curves, CB_RGBA);
+               else
+                       composit2_pixel_processor(node, stackbuf, in[1]->data, in[1]->vec, in[0]->data, in[0]->vec, do_curves_fac, CB_RGBA, CB_VAL);
                
                out[0]->data= stackbuf;
        }
diff --git a/source/blender/nodes/intern/CMP_nodes/CMP_invert.c b/source/blender/nodes/intern/CMP_nodes/CMP_invert.c
new file mode 100644 (file)
index 0000000..4bc0263
--- /dev/null
@@ -0,0 +1,131 @@
+/**
+ * $Id: CMP_mixrgb.c,v 1.4 2007/04/04 13:58:10 jesterking Exp $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2006 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#include "../CMP_util.h"
+
+/* **************** INVERT ******************** */
+static bNodeSocketType cmp_node_invert_in[]= { 
+       { SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}, 
+       { SOCK_RGBA, 1, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, 
+       { -1, 0, "" } 
+};
+
+static bNodeSocketType cmp_node_invert_out[]= { 
+       { SOCK_RGBA, 0, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, 
+       { -1, 0, "" } 
+};
+
+static void do_invert(bNode *node, float *out, float *in)
+{
+       if(node->custom1 & CMP_CHAN_RGB) {
+               out[0] = 1.0f - in[0];
+               out[1] = 1.0f - in[1];
+               out[2] = 1.0f - in[2];
+       } else
+               VECCOPY(out, in);
+               
+       if(node->custom1 & CMP_CHAN_A)
+               out[3] = 1.0f - in[3];
+       else
+               out[3] = in[3];
+}
+
+static void do_invert_fac(bNode *node, float *out, float *in, float *fac)
+{
+       float col[4], facm;
+
+       do_invert(node, col, in);
+
+       /* blend inverted result against original input with fac */
+       facm = 1.0 - fac[0];
+
+       if(node->custom1 & CMP_CHAN_RGB) {
+               col[0] = fac[0]*col[0] + (facm*in[0]);
+               col[1] = fac[0]*col[1] + (facm*in[1]);
+               col[2] = fac[0]*col[2] + (facm*in[2]);
+       }
+       if(node->custom1 & CMP_CHAN_A)
+               col[3] = fac[0]*col[3] + (facm*in[3]);
+       
+       QUATCOPY(out, col);
+}
+
+static void node_composit_exec_invert(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
+{
+       /* stack order in: fac, Image, Image */
+       /* stack order out: Image */
+       float *fac= in[0]->vec;
+       
+       if(out[0]->hasoutput==0) return;
+       
+       /* input no image? then only color operation */
+       if(in[1]->data==NULL && in[0]->data==NULL) {
+               do_invert_fac(node, out[0]->vec, in[1]->vec, fac);
+       }
+       else {
+               /* make output size of first available input image, or then size of fac */
+               CompBuf *cbuf= in[1]->data?in[1]->data:in[0]->data;
+               CompBuf *stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_RGBA, 1); /* allocs */
+               
+               /* if neither RGB or A toggled on, pass through */
+               if (node->custom1 == 0) {
+                       out[0]->data = pass_on_compbuf(cbuf);
+                       return;
+               }
+
+               if (fac[0] < 1.0f || in[0]->data!=NULL)
+                       composit2_pixel_processor(node, stackbuf, in[1]->data, in[1]->vec, in[0]->data, fac, do_invert_fac, CB_RGBA, CB_VAL);
+               else
+                       composit1_pixel_processor(node, stackbuf, in[1]->data, in[1]->vec, do_invert, CB_RGBA);
+               out[0]->data= stackbuf;
+       }
+}
+
+static void node_composit_init_invert(bNode *node)
+{
+   node->custom1 |= CMP_CHAN_RGB;
+}
+
+/* custom1 = mix type */
+bNodeType cmp_node_invert= {
+       /* *next,*prev */       NULL, NULL,
+       /* type code   */       CMP_NODE_INVERT,
+       /* name        */       "Invert",
+       /* width+range */       120, 120, 140,
+       /* class+opts  */       NODE_CLASS_OP_COLOR, NODE_OPTIONS,
+       /* input sock  */       cmp_node_invert_in,
+       /* output sock */       cmp_node_invert_out,
+       /* storage     */       "", 
+       /* execfunc    */       node_composit_exec_invert,
+       /* butfunc     */       NULL,
+       /* initfunc    */       node_composit_init_invert,
+       /* freestoragefunc    */        NULL,
+       /* copystoragefunc    */        NULL,
+       /* id          */       NULL
+       
+};
index 790b24a105a03c4c9444371f4b64031185783cf1..6a4916b3fac1550553c0f6895e5e5a501c53c92a 100644 (file)
@@ -81,7 +81,7 @@ bNodeType cmp_node_mix_rgb= {
        /* *next,*prev */       NULL, NULL,
        /* type code   */       CMP_NODE_MIX_RGB,
        /* name        */       "Mix",
-       /* width+range */       80, 60, 120,
+       /* width+range */       110, 60, 120,
        /* class+opts  */       NODE_CLASS_OP_COLOR, NODE_OPTIONS,
        /* input sock  */       cmp_node_mix_rgb_in,
        /* output sock */       cmp_node_mix_rgb_out,
index d56baecb587516d473fff7e1d83088d52b795732..a7e0e28989ba645b4bfa4072fec54b7e9c1e5da8 100644 (file)
@@ -46,7 +46,7 @@ static void node_composit_exec_setalpha(void *data, bNode *node, bNodeStack **in
        /* stack order in: col, alpha */
        
        /* input no image? then only color operation */
-       if(in[0]->data==NULL) {
+       if(in[0]->data==NULL && in[1]->data==NULL) {
                out[0]->vec[0] = in[0]->vec[0];
                out[0]->vec[1] = in[0]->vec[1];
                out[0]->vec[2] = in[0]->vec[2];
@@ -54,7 +54,7 @@ static void node_composit_exec_setalpha(void *data, bNode *node, bNodeStack **in
        }
        else {
                /* make output size of input image */
-               CompBuf *cbuf= in[0]->data;
+               CompBuf *cbuf= in[0]->data?in[0]->data:in[1]->data;
                CompBuf *stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_RGBA, 1); /* allocs */
                
                if(in[1]->data==NULL && in[1]->vec[0]==1.0f) {
index 3875dead2b0c4eefd3679418198dec17def542a4..b15aa6802f37a9d3881d7362fcb17473ffa427d0 100644 (file)
@@ -41,6 +41,7 @@ static bNodeSocketType sh_node_geom_out[]= {
        {       SOCK_VECTOR, 0, "UV",   0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
        {       SOCK_VECTOR, 0, "Normal",       0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
        {       SOCK_RGBA,   0, "Vertex Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE,   0, "Front/Back", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
        {       -1, 0, ""       }
 };
 
@@ -52,6 +53,7 @@ static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **in, bNod
                NodeGeometry *ngeo= (NodeGeometry*)node->storage;
                ShadeInputUV *suv= &shi->uv[0];
                static float defaultvcol[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+               static float front= 0.0;
                int i;
 
                if(ngeo->uvname[0]) {
@@ -105,6 +107,15 @@ static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **in, bNod
                        out[GEOM_OUT_NORMAL]->data= shi->dxno;
                        out[GEOM_OUT_NORMAL]->datatype= NS_OSA_VECTORS;
                }
+               
+               /* front/back
+               * check the original un-flipped normals to determine front or back side */
+               if (shi->orignor[2] < FLT_EPSILON) {
+                       front= 1.0f;
+               } else {
+                       front = 0.0f;
+               }
+               out[GEOM_OUT_FRONTBACK]->vec[0]= front;
        }
 }
 
diff --git a/source/blender/nodes/intern/SHD_nodes/SHD_invert.c b/source/blender/nodes/intern/SHD_nodes/SHD_invert.c
new file mode 100644 (file)
index 0000000..4d1ce28
--- /dev/null
@@ -0,0 +1,83 @@
+/**
+ * $Id: SHD_math.c,v 1.4 2007/04/04 13:58:12 jesterking Exp $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2005 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "../SHD_util.h"
+
+
+
+/* **************** INVERT ******************** */ 
+static bNodeSocketType sh_node_invert_in[]= { 
+       { SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}, 
+       { SOCK_RGBA, 1, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, 
+       { -1, 0, "" } 
+};
+
+static bNodeSocketType sh_node_invert_out[]= { 
+       { SOCK_RGBA, 0, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, 
+       { -1, 0, "" } 
+};
+
+static void node_shader_exec_invert(void *data, bNode *node, bNodeStack **in, 
+bNodeStack **out) 
+{
+       float col[3], facm;
+
+       col[0] = 1.0f - in[1]->vec[0];
+       col[1] = 1.0f - in[1]->vec[1];
+       col[2] = 1.0f - in[1]->vec[2];
+       
+       /* if fac, blend result against original input */
+       if (in[0]->vec[0] < 1.0f) {
+               facm = 1.0 - in[0]->vec[0];
+
+               col[0] = in[0]->vec[0]*col[0] + (facm*in[1]->vec[0]);
+               col[1] = in[0]->vec[0]*col[1] + (facm*in[1]->vec[1]);
+               col[2] = in[0]->vec[0]*col[2] + (facm*in[1]->vec[2]);
+       }
+       
+       VECCOPY(out[0]->vec, col);
+}
+
+bNodeType sh_node_invert= {
+       /* *next,*prev */       NULL, NULL,
+       /* type code   */       SH_NODE_INVERT, 
+       /* name        */       "Invert", 
+       /* width+range */       90, 80, 100, 
+       /* class+opts  */       NODE_CLASS_OP_COLOR, NODE_OPTIONS, 
+       /* input sock  */       sh_node_invert_in, 
+       /* output sock */       sh_node_invert_out, 
+       /* storage     */       "", 
+       /* execfunc    */       node_shader_exec_invert,
+       /* butfunc     */       NULL,
+       /* initfunc    */       NULL,
+       /* freestoragefunc    */        NULL,
+       /* copystoragefunc    */        NULL,
+       /* id          */       NULL
+};
+
index 1dc18f974965009a4b054fb22d69d69a38f02ea4..bdceb134c0d15acb4360378180343ba08965583d 100644 (file)
@@ -39,11 +39,6 @@ static bNodeSocketType sh_node_material_in[]= {
        {       -1, 0, ""       }
 };
 
-/* output socket defines */
-#define MAT_OUT_COLOR  0
-#define MAT_OUT_ALPHA  1
-#define MAT_OUT_NORMAL 2
-
 static bNodeSocketType sh_node_material_out[]= {
        {       SOCK_RGBA, 0, "Color",          0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
        {       SOCK_VALUE, 0, "Alpha",         1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -51,6 +46,34 @@ static bNodeSocketType sh_node_material_out[]= {
        {       -1, 0, ""       }
 };
 
+/* **************** EXTENDED MATERIAL ******************** */
+
+static bNodeSocketType sh_node_material_ext_in[]= {
+       {       SOCK_RGBA, 1, "Color",          0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_RGBA, 1, "Spec",           0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Refl",          0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VECTOR, 1, "Normal",       0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
+       {       SOCK_RGBA, 1, "Mirror",         0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_RGBA, 1, "AmbCol",         0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Ambient",       0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Emit",          0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "SpecTra",       0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Ray Mirror",    0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Alpha",         0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 1, "Translucency",  0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       -1, 0, ""       }
+};
+
+static bNodeSocketType sh_node_material_ext_out[]= {
+       {       SOCK_RGBA, 0, "Color",          0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_VALUE, 0, "Alpha",         1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+       {       SOCK_VECTOR, 0, "Normal",       0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
+       {       SOCK_RGBA, 0, "Diffuse",                0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_RGBA, 0, "Spec",           0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_RGBA, 0, "AO",             0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+       {       -1, 0, ""       }
+};
+
 static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
 {
        if(data && node->id) {
@@ -91,6 +114,25 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in,
                        shi->vn[2]= -shi->vn[2];
                }
                
+               if (node->type == SH_NODE_MATERIAL_EXT) {
+                       if(in[MAT_IN_MIR]->hasinput)
+                               nodestack_get_vec(&shi->mirr, SOCK_VECTOR, in[MAT_IN_MIR]);
+                       if(in[MAT_IN_AMBCOL]->hasinput)
+                               nodestack_get_vec(&shi->ambr, SOCK_VECTOR, in[MAT_IN_AMBCOL]);
+                       if(in[MAT_IN_AMB]->hasinput)
+                               nodestack_get_vec(&shi->amb, SOCK_VALUE, in[MAT_IN_AMB]);
+                       if(in[MAT_IN_EMIT]->hasinput)
+                               nodestack_get_vec(&shi->emit, SOCK_VALUE, in[MAT_IN_EMIT]);
+                       if(in[MAT_IN_SPECTRA]->hasinput)
+                               nodestack_get_vec(&shi->spectra, SOCK_VALUE, in[MAT_IN_SPECTRA]);
+                       if(in[MAT_IN_RAY_MIRROR]->hasinput)
+                               nodestack_get_vec(&shi->ray_mirror, SOCK_VALUE, in[MAT_IN_RAY_MIRROR]);
+                       if(in[MAT_IN_ALPHA]->hasinput)
+                               nodestack_get_vec(&shi->alpha, SOCK_VALUE, in[MAT_IN_ALPHA]);
+                       if(in[MAT_IN_TRANSLUCENCY]->hasinput)
+                               nodestack_get_vec(&shi->translucency, SOCK_VALUE, in[MAT_IN_TRANSLUCENCY]);                     
+               }
+               
                node_shader_lamp_loop(shi, &shrnode);   /* clears shrnode */
                
                /* write to outputs */
@@ -122,6 +164,15 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in,
                
                VECCOPY(out[MAT_OUT_NORMAL]->vec, shi->vn);
                
+               /* Extended material options */
+               if (node->type == SH_NODE_MATERIAL_EXT) {
+                       /* Shadow, Reflect, Refract, Radiosity, Speed seem to cause problems inside
+                        * a node tree :( */
+                       VECCOPY(out[MAT_OUT_DIFFUSE]->vec, shrnode.diff);
+                       VECCOPY(out[MAT_OUT_SPEC]->vec, shrnode.spec);
+                       VECCOPY(out[MAT_OUT_AO]->vec, shrnode.ao);
+               }
+               
                /* copy passes, now just active node */
                if(node->flag & NODE_ACTIVE_ID)
                        *(shcd->shr)= shrnode;
@@ -153,3 +204,21 @@ bNodeType sh_node_material= {
        
 };
 
+bNodeType sh_node_material_ext= {
+       /* *next,*prev */       NULL, NULL,
+       /* type code   */       SH_NODE_MATERIAL_EXT,
+       /* name        */       "Extended Material",
+       /* width+range */       120, 80, 240,
+       /* class+opts  */       NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW,
+       /* input sock  */       sh_node_material_ext_in,
+       /* output sock */       sh_node_material_ext_out,
+       /* storage     */       "",
+       /* execfunc    */       node_shader_exec_material,
+       /* butfunc     */       NULL,
+       /* initfunc    */       node_shader_init_material,
+       /* freestoragefunc    */        NULL,
+       /* copystoragefunc    */        NULL,
+       /* id          */       NULL
+       
+};
+
index 8401c302386793cdadeb68821636b516aefd875e..c9f58fbce492c6bfeb96f455c1a130b278df0ecb 100644 (file)
@@ -145,7 +145,7 @@ void nodeShaderSynchronizeID(bNode *node, int copyto)
 {
        if(node->id==NULL) return;
        
-       if(node->type==SH_NODE_MATERIAL) {
+       if(ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) {
                bNodeSocket *sock;
                Material *ma= (Material *)node->id;
                int a;
@@ -161,6 +161,20 @@ void nodeShaderSynchronizeID(bNode *node, int copyto)
                                                        VECCOPY(&ma->specr, sock->ns.vec); break;
                                                case MAT_IN_REFL:
                                                        ma->ref= sock->ns.vec[0]; break;
+                                               case MAT_IN_MIR:
+                                                       VECCOPY(&ma->mirr, sock->ns.vec); break;
+                                               case MAT_IN_AMB:
+                                                       VECCOPY(&ma->ambr, sock->ns.vec); break;
+                                               case MAT_IN_EMIT:
+                                                       ma->emit= sock->ns.vec[0]; break;
+                                               case MAT_IN_SPECTRA:
+                                                       ma->spectra= sock->ns.vec[0]; break;
+                                               case MAT_IN_RAY_MIRROR:
+                                                       ma->ray_mirror= sock->ns.vec[0]; break;
+                                               case MAT_IN_ALPHA:
+                                                       ma->alpha= sock->ns.vec[0]; break;
+                                               case MAT_IN_TRANSLUCENCY:
+                                                       ma->translucency= sock->ns.vec[0]; break;
                                        }
                                }
                                else {
@@ -171,6 +185,20 @@ void nodeShaderSynchronizeID(bNode *node, int copyto)
                                                        VECCOPY(sock->ns.vec, &ma->specr); break;
                                                case MAT_IN_REFL:
                                                        sock->ns.vec[0]= ma->ref; break;
+                                               case MAT_IN_MIR:
+                                                       VECCOPY(sock->ns.vec, &ma->mirr); break;
+                                               case MAT_IN_AMB:
+                                                       VECCOPY(sock->ns.vec, &ma->ambr); break;
+                                               case MAT_IN_EMIT:
+                                                       sock->ns.vec[0]= ma->emit; break;
+                                               case MAT_IN_SPECTRA:
+                                                       sock->ns.vec[0]= ma->spectra; break;
+                                               case MAT_IN_RAY_MIRROR:
+                                                       sock->ns.vec[0]= ma->ray_mirror; break;
+                                               case MAT_IN_ALPHA:
+                                                       sock->ns.vec[0]= ma->alpha; break;
+                                               case MAT_IN_TRANSLUCENCY:
+                                                       sock->ns.vec[0]= ma->translucency; break;
                                        }
                                }
                        }
index 6b9a26de350b74e299d09e1017f106b2edfcf8ab..f75802b7c15759e10ca4fbcd39c0ac68e8e420d9 100644 (file)
@@ -108,12 +108,30 @@ typedef struct ShaderCallData {
 #define GEOM_OUT_UV            4
 #define GEOM_OUT_NORMAL        5
 #define GEOM_OUT_VCOL  6
+#define GEOM_OUT_FRONTBACK     7
+
 
 /* input socket defines */
 #define MAT_IN_COLOR   0
 #define MAT_IN_SPEC            1
 #define MAT_IN_REFL            2
 #define MAT_IN_NORMAL  3
+#define MAT_IN_MIR             4
+#define MAT_IN_AMBCOL  5
+#define MAT_IN_AMB             6
+#define MAT_IN_EMIT    7
+#define MAT_IN_SPECTRA 8
+#define MAT_IN_RAY_MIRROR      9
+#define MAT_IN_ALPHA   10
+#define MAT_IN_TRANSLUCENCY    11
+
+/* output socket defines */
+#define MAT_OUT_COLOR          0
+#define MAT_OUT_ALPHA          1
+#define MAT_OUT_NORMAL 2
+#define MAT_OUT_DIFFUSE        3
+#define MAT_OUT_SPEC           4
+#define MAT_OUT_AO             5
 
 
 extern void node_ID_title_cb(void *node_v, void *unused_v);
index c1b20da53b7752c8444daffb20798e873dd16bfa..364535736ae03face3adb66bcbae9076c32c8158 100644 (file)
@@ -151,6 +151,10 @@ typedef struct ShadeInput
        int samplenr;                   /* sample counter, to detect if we should do shadow again */
        int depth;                              /* 1 or larger on raytrace shading */
        
+       /* stored copy of original face normal (facenor) 
+        * before flipping. Used in Front/back output on geometry node */
+       float orignor[3];
+
        /* from initialize, part or renderlayer */
        short do_preview;               /* for nodes, in previewrender */
        short thread, sample;   /* sample: ShadeSample array index */
@@ -158,6 +162,7 @@ typedef struct ShadeInput
        int layflag, passflag, combinedflag;
        struct Group *light_override;
        struct Material *mat_override;
+       
 } ShadeInput;
 
 
index 51157cb83f44a216794f840be964739822dba4d2..ca661469b36a99121b78ff6d294fcf2654484039 100644 (file)
@@ -259,6 +259,11 @@ void shade_input_set_triangle_i(ShadeInput *shi, VlakRen *vlr, short i1, short i
        /* facenormal copy, can get flipped */
        VECCOPY(shi->facenor, vlr->n);
        
+       /* copy of original pre-flipped normal, for geometry->front/back node output */
+       VECCOPY(shi->orignor, vlr->n);
+       if (vlr->noflag & R_FLIPPED_NO) {
+               VECMUL(shi->orignor, -1.0f);
+       }
 }
 
 /* note, facenr declared volatile due to over-eager -O2 optimizations
index e1cab659171d4ae7cd2af21579d604e6314a55cc..883fd05909ff54b06c19568095a1f3f3b95d2170 100644 (file)
@@ -622,6 +622,7 @@ static void node_shader_set_butfunc(bNodeType *ntype)
                /* case NODE_GROUP:      note, typeinfo for group is generated... see "XXX ugly hack" */
 
                case SH_NODE_MATERIAL:
+               case SH_NODE_MATERIAL_EXT:
                        ntype->butfunc= node_shader_buts_material;
                        break;
                case SH_NODE_TEXTURE:
@@ -1508,6 +1509,21 @@ static int node_composit_buts_scale(uiBlock *block, bNodeTree *ntree, bNode *nod
        return 20;
 }
 
+static int node_composit_buts_invert(uiBlock *block, bNodeTree *ntree, bNode *node, rctf *butr) 
+{
+       if(block) {
+               uiBlockBeginAlign(block);
+               uiDefButBitS(block, TOG, CMP_CHAN_RGB, B_NODE_EXEC+node->nr, "RGB",
+                                        butr->xmin, butr->ymin, (butr->xmax-butr->xmin)/2, 20, 
+                                        &node->custom1, 0, 0, 0, 0, "");
+               uiDefButBitS(block, TOG, CMP_CHAN_A, B_NODE_EXEC+node->nr, "A",
+                                        butr->xmin+(butr->xmax-butr->xmin)/2, butr->ymin, (butr->xmax-butr->xmin)/2, 20, 
+                                        &node->custom1, 0, 0, 0, 0, "");
+               uiBlockEndAlign(block);
+       }
+       return 20;      
+}
+
 /* only once called */
 static void node_composit_set_butfunc(bNodeType *ntype)
 {
@@ -1609,6 +1625,9 @@ static void node_composit_set_butfunc(bNodeType *ntype)
                case CMP_NODE_MATH:
                        ntype->butfunc= node_buts_math;
                        break;
+               case CMP_NODE_INVERT:
+                       ntype->butfunc= node_composit_buts_invert;
+                       break;
                default:
                        ntype->butfunc= NULL;
        }