Cycles: add some volume nodes, they don't actually do anything, this is just
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Tue, 27 Sep 2011 20:03:16 +0000 (20:03 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Tue, 27 Sep 2011 20:03:16 +0000 (20:03 +0000)
to give other developers who may want to work on this to get a starting point.

16 files changed:
intern/cycles/app/cycles_xml.cpp
intern/cycles/blender/blender_shader.cpp
intern/cycles/kernel/kernel_types.h
intern/cycles/kernel/svm/svm.h
intern/cycles/kernel/svm/svm_closure.h
intern/cycles/kernel/svm/svm_types.h
intern/cycles/kernel/svm/volume.h
intern/cycles/render/nodes.cpp
intern/cycles/render/nodes.h
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/intern/node.c
source/blender/makesrna/intern/rna_nodetree_types.h
source/blender/nodes/CMakeLists.txt
source/blender/nodes/NOD_shader.h
source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c [new file with mode: 0644]
source/blender/nodes/shader/nodes/node_shader_volume_transparent.c [new file with mode: 0644]

index c7580642c435a4d1e9eb1bf20ab08139c33f04de..5f9e1d7a5ffbb87c6012cc5e500b640abdc0ef8c 100644 (file)
@@ -435,6 +435,12 @@ static void xml_read_shader_graph(const XMLReadState& state, Shader *shader, pug
                else if(string_iequals(node.name(), "background")) {
                        snode = new BackgroundNode();
                }
+               else if(string_iequals(node.name(), "transparent_volume")) {
+                       snode = new TransparentVolumeNode();
+               }
+               else if(string_iequals(node.name(), "isotropic_volume")) {
+                       snode = new IsotropicVolumeNode();
+               }
                else if(string_iequals(node.name(), "geometry")) {
                        snode = new GeometryNode();
                }
index 1f4120937731fdec971ced12a49a478cd85c95ca..3993efbce39f306077b868fd0beaa058a8ae88b6 100644 (file)
@@ -275,6 +275,14 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
                        node = new EmissionNode();
                        break;
                }
+               case BL::ShaderNode::type_VOLUME_ISOTROPIC: {
+                       node = new IsotropicVolumeNode();
+                       break;
+               }
+               case BL::ShaderNode::type_VOLUME_TRANSPARENT: {
+                       node = new TransparentVolumeNode();
+                       break;
+               }
                case BL::ShaderNode::type_GEOMETRY: {
                        node = new GeometryNode();
                        break;
index 8083da971ed34c2080f798e597d5e44c825f8691..e09eaa8284c9ae9d702706cea26e3c9f0df65667 100644 (file)
@@ -218,7 +218,8 @@ enum ShaderDataFlag {
        SD_BSDF = 4,                    /* have bsdf closure? */
        SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
        SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
-       SD_HOLDOUT = 32                 /* have holdout closure? */
+       SD_HOLDOUT = 32,                /* have holdout closure? */
+       SD_VOLUME = 64                  /* have volume closure? */
 };
 
 typedef struct ShaderData {
index 65d92a91df91ae61d6a41730a1579eeffab8409c..bd5c07753adfb10ca918f01d3dc873b7460f8f0b 100644 (file)
@@ -184,6 +184,9 @@ __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderT
                        case NODE_CLOSURE_HOLDOUT:
                                svm_node_closure_holdout(sd, stack, node);
                                break;
+                       case NODE_CLOSURE_VOLUME:
+                               svm_node_closure_volume(kg, sd, stack, node, path_flag);
+                               break;
                        case NODE_CLOSURE_SET_WEIGHT:
                                svm_node_closure_set_weight(sd, node.y, node.z, node.w);
                                break;
index 68f91408f1f1392d9cd930a6c0bf9d0eb23770ba..90636380e43906c72f68495820ccaf7bf4370180 100644 (file)
@@ -192,6 +192,47 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
        }
 }
 
+__device void svm_node_closure_volume(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int path_flag)
+{
+       uint type, param1_offset, param2_offset;
+
+#ifdef __MULTI_CLOSURE__
+       uint mix_weight_offset;
+       decode_node_uchar4(node.y, &type, &param1_offset, &param2_offset, &mix_weight_offset);
+       float mix_weight = (stack_valid(mix_weight_offset)? stack_load_float(stack, mix_weight_offset): 1.0f);
+
+       if(mix_weight == 0.0f)
+               return;
+#else
+       decode_node_uchar4(node.y, &type, &param1_offset, &param2_offset, NULL);
+       float mix_weight = 1.0f;
+#endif
+
+       float param1 = (stack_valid(param1_offset))? stack_load_float(stack, param1_offset): __int_as_float(node.z);
+       //float param2 = (stack_valid(param2_offset))? stack_load_float(stack, param2_offset): __int_as_float(node.w);
+
+       switch(type) {
+               case CLOSURE_VOLUME_TRANSPARENT_ID: {
+                       ShaderClosure *sc = svm_node_closure_get(sd);
+                       svm_node_closure_set_mix_weight(sc, mix_weight);
+
+                       float density = param1;
+                       volume_transparent_setup(sd, sc, density);
+                       break;
+               }
+               case CLOSURE_VOLUME_ISOTROPIC_ID: {
+                       ShaderClosure *sc = svm_node_closure_get(sd);
+                       svm_node_closure_set_mix_weight(sc, mix_weight);
+
+                       float density = param1;
+                       volume_isotropic_setup(sd, sc, density);
+                       break;
+               }
+               default:
+                       break;
+       }
+}
+
 __device void svm_node_closure_emission(ShaderData *sd, float *stack, uint4 node)
 {
 #ifdef __MULTI_CLOSURE__
index 483f3c76f3cf28827a2340f1642f8b36743780cc..baec3d7ac6ef5cc669659bc6f2eb392bc0f7ed2e 100644 (file)
@@ -83,7 +83,8 @@ typedef enum NodeType {
        NODE_ATTR_BUMP_DY = 4500,
        NODE_TEX_ENVIRONMENT = 4600,
        NODE_CLOSURE_HOLDOUT = 4700,
-       NODE_BLEND_WEIGHT = 4800
+       NODE_BLEND_WEIGHT = 4800,
+       NODE_CLOSURE_VOLUME = 4900
 } NodeType;
 
 typedef enum NodeAttributeType {
@@ -286,14 +287,17 @@ typedef enum ClosureType {
        CLOSURE_BACKGROUND_ID,
        CLOSURE_HOLDOUT_ID,
        CLOSURE_SUBSURFACE_ID,
+
        CLOSURE_VOLUME_ID,
+       CLOSURE_VOLUME_TRANSPARENT_ID,
+       CLOSURE_VOLUME_ISOTROPIC_ID,
 
        NBUILTIN_CLOSURES
 } ClosureType;
 
 /* watch this, being lazy with memory usage */
 #define CLOSURE_IS_BSDF(type) (type <= CLOSURE_BSDF_WESTIN_SHEEN_ID)
-#define CLOSURE_IS_VOLUME(type) (type == CLOSURE_VOLUME_ID)
+#define CLOSURE_IS_VOLUME(type) (type >= CLOSURE_VOLUME_ID && type <= CLOSURE_VOLUME_ISOTROPIC_ID)
 #define CLOSURE_IS_EMISSION(type) (type == CLOSURE_EMISSION_ID)
 #define CLOSURE_IS_HOLDOUT(type) (type == CLOSURE_HOLDOUT_ID)
 #define CLOSURE_IS_BACKGROUND(type) (type == CLOSURE_BACKGROUND_ID)
index dc377b5c59507ca617846a2f01825cb816e0c0bb..86cb2dcc24e32fe5a87b0fcfe773872cfc1af0af 100644 (file)
@@ -1,42 +1,73 @@
-/* 
- * Adapted from Open Shading Language with this license: 
- * 
- * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al. 
- * All Rights Reserved. 
- * 
- * Modifications Copyright 2011, Blender Foundation. 
- *  
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are 
- * met: 
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer. 
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in the 
- *   documentation and/or other materials provided with the distribution. 
- * * Neither the name of Sony Pictures Imageworks nor the names of its 
- *   contributors may be used to endorse or promote products derived from 
- *   this software without specific prior written permission. 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
-*/
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
 
 CCL_NAMESPACE_BEGIN
 
+/* note: the interfaces here are just as an example, need to figure
+   out the right functions and parameters to use */
+
+/* ISOTROPIC VOLUME CLOSURE */
+
+__device void volume_isotropic_setup(ShaderData *sd, ShaderClosure *sc, float density)
+{
+       sc->type = CLOSURE_VOLUME_ISOTROPIC_ID;
+       sd->flag |= SD_VOLUME;
+       sc->data0 = density;
+}
+
+__device float3 volume_isotropic_eval_phase(const ShaderData *sd, const ShaderClosure *sc, const float3 omega_in, const float3 omega_out)
+{
+       return make_float3(1.0f, 1.0f, 1.0f);
+}
+
+/* TRANSPARENT VOLUME CLOSURE */
+
+__device void volume_transparent_setup(ShaderData *sd, ShaderClosure *sc, float density)
+{
+       sc->type = CLOSURE_VOLUME_TRANSPARENT_ID;
+       sd->flag |= SD_VOLUME;
+       sc->data0 = density;
+}
+
+__device float3 volume_transparent_eval_phase(const ShaderData *sd, const ShaderClosure *sc, const float3 omega_in, const float3 omega_out)
+{
+       return make_float3(1.0f, 1.0f, 1.0f);
+}
+
 /* VOLUME CLOSURE */
 
 __device float3 volume_eval_phase(const ShaderData *sd, const ShaderClosure *sc, const float3 omega_in, const float3 omega_out)
 {
-       return make_float3(1.0f, 1.0f, 1.0f);
+       float3 eval;
+
+       switch(sc->type) {
+               case CLOSURE_VOLUME_ISOTROPIC_ID:
+                       eval = volume_isotropic_eval_phase(sd, sc, omega_in, omega_out);
+                       break;
+               case CLOSURE_VOLUME_TRANSPARENT_ID:
+                       eval = volume_transparent_eval_phase(sd, sc, omega_in, omega_out);
+                       break;
+               default:
+                       eval = make_float3(0.0f, 0.0f, 0.0f);
+                       break;
+       }
+
+       return eval;
 }
 
 CCL_NAMESPACE_END
index 038a6c45b97b7b54c744ea8f7e27446ea90f48df..4fd562b540c8ff2bcb4b237e8ca92a26c3d057ce 100644 (file)
@@ -1312,6 +1312,88 @@ void HoldoutNode::compile(OSLCompiler& compiler)
        compiler.add(this, "node_holdout");
 }
 
+/* Volume Closure */
+
+VolumeNode::VolumeNode()
+: ShaderNode("volume")
+{
+       closure = ccl::CLOSURE_VOLUME_ISOTROPIC_ID;
+
+       add_input("Color", SHADER_SOCKET_COLOR, make_float3(0.8f, 0.8f, 0.8f));
+       add_input("Density", SHADER_SOCKET_FLOAT, 1.0f);
+
+       add_output("Volume", SHADER_SOCKET_CLOSURE);
+}
+
+void VolumeNode::compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2)
+{
+       ShaderInput *color_in = input("Color");
+
+       if(color_in->link) {
+               compiler.stack_assign(color_in);
+               compiler.add_node(NODE_CLOSURE_WEIGHT, color_in->stack_offset);
+       }
+       else
+               compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color_in->value);
+       
+       if(param1)
+               compiler.stack_assign(param1);
+       if(param2)
+               compiler.stack_assign(param2);
+
+       compiler.add_node(NODE_CLOSURE_VOLUME,
+               compiler.encode_uchar4(closure,
+                       (param1)? param1->stack_offset: SVM_STACK_INVALID,
+                       (param2)? param2->stack_offset: SVM_STACK_INVALID,
+                       compiler.closure_mix_weight_offset()),
+               __float_as_int((param1)? param1->value.x: 0.0f),
+               __float_as_int((param2)? param2->value.x: 0.0f));
+}
+
+void VolumeNode::compile(SVMCompiler& compiler)
+{
+       compile(compiler, NULL, NULL);
+}
+
+void VolumeNode::compile(OSLCompiler& compiler)
+{
+       assert(0);
+}
+
+/* Transparent Volume Closure */
+
+TransparentVolumeNode::TransparentVolumeNode()
+{
+       closure = CLOSURE_VOLUME_TRANSPARENT_ID;
+}
+
+void TransparentVolumeNode::compile(SVMCompiler& compiler)
+{
+       VolumeNode::compile(compiler, input("Density"), NULL);
+}
+
+void TransparentVolumeNode::compile(OSLCompiler& compiler)
+{
+       compiler.add(this, "node_isotropic_volume");
+}
+
+/* Isotropic Volume Closure */
+
+IsotropicVolumeNode::IsotropicVolumeNode()
+{
+       closure = CLOSURE_VOLUME_ISOTROPIC_ID;
+}
+
+void IsotropicVolumeNode::compile(SVMCompiler& compiler)
+{
+       VolumeNode::compile(compiler, input("Density"), NULL);
+}
+
+void IsotropicVolumeNode::compile(OSLCompiler& compiler)
+{
+       compiler.add(this, "node_isotropic_volume");
+}
+
 /* Geometry */
 
 GeometryNode::GeometryNode()
index f11f34778e30fd5f94c88a6d7349e281816992d5..0a7ac158431f87fec645bc22a15bac6b1292bbe1 100644 (file)
@@ -262,6 +262,25 @@ public:
        SHADER_NODE_CLASS(HoldoutNode)
 };
 
+class VolumeNode : public ShaderNode {
+public:
+       SHADER_NODE_CLASS(VolumeNode)
+
+       void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
+
+       ClosureType closure;
+};
+
+class TransparentVolumeNode : public VolumeNode {
+public:
+       SHADER_NODE_CLASS(TransparentVolumeNode)
+};
+
+class IsotropicVolumeNode : public VolumeNode {
+public:
+       SHADER_NODE_CLASS(IsotropicVolumeNode)
+};
+
 class GeometryNode : public ShaderNode {
 public:
        SHADER_NODE_CLASS(GeometryNode)
index d269b2932d61ff43b290d29450b0c66669226674..92968f23396927a13b3bbd8e7d985cc6824232bd 100644 (file)
@@ -488,6 +488,8 @@ struct ShadeResult;
 #define SH_NODE_OUTPUT_TEXTURE                 158
 #define SH_NODE_HOLDOUT                                        159
 #define SH_NODE_BLEND_WEIGHT                   160
+#define SH_NODE_VOLUME_TRANSPARENT             161
+#define SH_NODE_VOLUME_ISOTROPIC               162
 
 /* custom defines options for Material node */
 #define SH_NODE_MAT_DIFF   1
index 14e753d54514039d5edd22e428dbba51bf450953..3c4c3d32452ce2d91d765410a55ca0a0af693fe3 100644 (file)
@@ -1886,9 +1886,11 @@ static void registerShaderNodes(ListBase *ntypelist)
        register_node_type_sh_bsdf_transparent(ntypelist);
        register_node_type_sh_bsdf_velvet(ntypelist);
        register_node_type_sh_emission(ntypelist);
+       register_node_type_sh_volume_transparent(ntypelist);
+       register_node_type_sh_volume_isotropic(ntypelist);
+       register_node_type_sh_holdout(ntypelist);
        register_node_type_sh_mix_shader(ntypelist);
        register_node_type_sh_add_shader(ntypelist);
-       register_node_type_sh_holdout(ntypelist);
 
        register_node_type_sh_output_lamp(ntypelist);
        register_node_type_sh_output_material(ntypelist);
index 03873a514e1826f421222ede2bf2c133459c6558..f837a2f6898dbc23f466748de8606487f52e43ad 100644 (file)
@@ -74,6 +74,8 @@ DefNode( ShaderNode,     SH_NODE_BSDF_GLASS, def_glossy, "BSDF_GLASS", BsdfGlass
 DefNode( ShaderNode,     SH_NODE_BSDF_TRANSLUCENT, 0, "BSDF_TRANSLUCENT", BsdfTranslucent, "Translucent Bsdf", "")
 DefNode( ShaderNode,     SH_NODE_BSDF_TRANSPARENT, 0, "BSDF_TRANSPARENT", BsdfTransparent, "Transparent Bsdf", "")
 DefNode( ShaderNode,     SH_NODE_BSDF_VELVET, 0, "BSDF_VELVET", BsdfVelvet, "Velvet Bsdf", "")
+DefNode( ShaderNode,     SH_NODE_VOLUME_TRANSPARENT, 0, "VOLUME_TRANSPARENT", VolumeTransparent, "Transparent Volume", "")
+DefNode( ShaderNode,     SH_NODE_VOLUME_ISOTROPIC, 0, "VOLUME_ISOTROPIC", VolumeIsotropic, "Isotropic Volume", "")
 DefNode( ShaderNode,     SH_NODE_EMISSION, 0, "EMISSION", Emission, "Emission", "")
 DefNode( ShaderNode,     SH_NODE_GEOMETRY, 0, "GEOMETRY", Geometry, "Geometry", "")
 DefNode( ShaderNode,     SH_NODE_LIGHT_PATH, 0, "LIGHT_PATH", Light_path, "Light_path", "")
index 9c5c5213fd29b58e3cf2763f71fa502df931212e..8ee67fc4f9a44a0b570274c12ac1f4ad2e6fab8d 100644 (file)
@@ -138,6 +138,8 @@ set(SRC
        shader/nodes/node_shader_blend_weight.c
        shader/nodes/node_shader_geometry.c
        shader/nodes/node_shader_holdout.c
+       shader/nodes/node_shader_volume_transparent.c
+       shader/nodes/node_shader_volume_isotropic.c
        shader/nodes/node_shader_light_path.c
        shader/nodes/node_shader_mix_shader.c
        shader/nodes/node_shader_add_shader.c
index 1c7d77df18daf3bbd3d15387a9f52f54fec33cd3..d504b6d757bbc3f4bd634dadb4660474fd0f53f9 100644 (file)
@@ -75,6 +75,8 @@ void register_node_type_sh_bsdf_transparent(ListBase *lb);
 void register_node_type_sh_bsdf_velvet(ListBase *lb);
 void register_node_type_sh_emission(ListBase *lb);
 void register_node_type_sh_holdout(ListBase *lb);
+void register_node_type_sh_volume_transparent(ListBase *lb);
+void register_node_type_sh_volume_isotropic(ListBase *lb);
 void register_node_type_sh_mix_shader(ListBase *lb);
 void register_node_type_sh_add_shader(ListBase *lb);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c b/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c
new file mode 100644 (file)
index 0000000..e5579c1
--- /dev/null
@@ -0,0 +1,69 @@
+/**
+ * $Id: node_shader_output.c 32517 2010-10-16 14:32:17Z campbellbarton $
+ *
+ * ***** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 "../node_shader_util.h"
+
+/* **************** OUTPUT ******************** */
+
+static bNodeSocketTemplate sh_node_volume_isotropic_in[]= {
+       {       SOCK_RGBA, 1, "Color",          0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_FLOAT, 1, "Density",       1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+       {       -1, 0, ""       }
+};
+
+static bNodeSocketTemplate sh_node_volume_isotropic_out[]= {
+       {       SOCK_SHADER, 0, "Volume"},
+       {       -1, 0, ""       }
+};
+
+static void node_shader_exec_volume_isotropic(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
+{
+}
+
+static int node_shader_gpu_volume_isotropic(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
+{
+       return 0;
+}
+
+/* node type definition */
+void register_node_type_sh_volume_isotropic(ListBase *lb)
+{
+       static bNodeType ntype;
+
+       node_type_base(&ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0);
+       node_type_socket_templates(&ntype, sh_node_volume_isotropic_in, sh_node_volume_isotropic_out);
+       node_type_size(&ntype, 150, 60, 200);
+       node_type_init(&ntype, NULL);
+       node_type_storage(&ntype, "", NULL, NULL);
+       node_type_exec(&ntype, node_shader_exec_volume_isotropic);
+       node_type_gpu(&ntype, node_shader_gpu_volume_isotropic);
+
+       nodeRegisterType(lb, &ntype);
+};
+
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c b/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c
new file mode 100644 (file)
index 0000000..b2e9e22
--- /dev/null
@@ -0,0 +1,69 @@
+/**
+ * $Id: node_shader_output.c 32517 2010-10-16 14:32:17Z campbellbarton $
+ *
+ * ***** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 "../node_shader_util.h"
+
+/* **************** OUTPUT ******************** */
+
+static bNodeSocketTemplate sh_node_volume_transparent_in[]= {
+       {       SOCK_RGBA, 1, "Color",          0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+       {       SOCK_FLOAT, 1, "Density",       1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+       {       -1, 0, ""       }
+};
+
+static bNodeSocketTemplate sh_node_volume_transparent_out[]= {
+       {       SOCK_SHADER, 0, "Volume"},
+       {       -1, 0, ""       }
+};
+
+static void node_shader_exec_volume_transparent(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
+{
+}
+
+static int node_shader_gpu_volume_transparent(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
+{
+       return 0;
+}
+
+/* node type definition */
+void register_node_type_sh_volume_transparent(ListBase *lb)
+{
+       static bNodeType ntype;
+
+       node_type_base(&ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0);
+       node_type_socket_templates(&ntype, sh_node_volume_transparent_in, sh_node_volume_transparent_out);
+       node_type_size(&ntype, 150, 60, 200);
+       node_type_init(&ntype, NULL);
+       node_type_storage(&ntype, "", NULL, NULL);
+       node_type_exec(&ntype, node_shader_exec_volume_transparent);
+       node_type_gpu(&ntype, node_shader_gpu_volume_transparent);
+
+       nodeRegisterType(lb, &ntype);
+};
+