Cycles: add some volume nodes, they don't actually do anything, this is just

to give other developers who may want to work on this to get a starting point.

9 files changed, 230 insertions, 35 deletions

diff --git a/intern/cycles/app/cycles_xml.cpp b/intern/cycles/app/cycles_xml.cpp
index c7580642c43..5f9e1d7a5ff 100644
--- a/intern/cycles/app/cycles_xml.cpp
+++ b/intern/cycles/app/cycles_xml.cpp
@@ -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();
 		}
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 1f412093773..3993efbce39 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -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;
diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index 8083da971ed..e09eaa8284c 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -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 {
diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index 65d92a91df9..bd5c07753ad 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -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;
diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h
index 68f91408f1f..90636380e43 100644
--- a/intern/cycles/kernel/svm/svm_closure.h
+++ b/intern/cycles/kernel/svm/svm_closure.h
@@ -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__
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 483f3c76f3c..baec3d7ac6e 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -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)
diff --git a/intern/cycles/kernel/svm/volume.h b/intern/cycles/kernel/svm/volume.h
index dc377b5c595..86cb2dcc24e 100644
--- a/intern/cycles/kernel/svm/volume.h
+++ b/intern/cycles/kernel/svm/volume.h
@@ -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
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 038a6c45b97..4fd562b540c 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -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()
diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h
index f11f34778e3..0a7ac158431 100644
--- a/intern/cycles/render/nodes.h
+++ b/intern/cycles/render/nodes.h
@@ -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)