Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later.

Cycles uses code from some great open source projects, many thanks them:

* BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs":
http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/
* Open Shading Language for a large part of the shading system:
http://code.google.com/p/openshadinglanguage/
* Blender for procedural textures and a few other nodes.
* Approximate Catmull Clark subdivision from NVidia Mesh tools:
http://code.google.com/p/nvidia-mesh-tools/
* Sobol direction vectors from:
http://web.maths.unsw.edu.au/~fkuo/sobol/
* Film response functions from:
http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php

47 files changed, 3260 insertions, 0 deletions

diff --git a/intern/cycles/kernel/osl/nodes/CMakeLists.txt b/intern/cycles/kernel/osl/nodes/CMakeLists.txt
new file mode 100644
index 00000000000..435acc5f680
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/CMakeLists.txt
@@ -0,0 +1,69 @@
+
+# OSL node shaders
+
+SET(osl_sources
+	node_add_closure.osl
+	node_attribute.osl
+	node_background.osl
+	node_blend_texture.osl
+	node_bump.osl
+	node_clouds_texture.osl
+	node_convert_from_color.osl
+	node_convert_from_float.osl
+	node_convert_from_normal.osl
+	node_convert_from_point.osl
+	node_convert_from_vector.osl
+	node_diffuse_bsdf.osl
+	node_distorted_noise_texture.osl
+	node_emission.osl
+	node_environment_texture.osl
+	node_fresnel.osl
+	node_geometry.osl
+	node_glass_bsdf.osl
+	node_glossy_bsdf.osl
+	node_image_texture.osl
+	node_light_path.osl
+	node_magic_texture.osl
+	node_mapping.osl
+	node_marble_texture.osl
+	node_math.osl
+	node_mix.osl
+	node_mix_closure.osl
+	node_musgrave_texture.osl
+	node_noise_texture.osl
+	node_output_displacement.osl
+	node_output_surface.osl
+	node_output_volume.osl
+	node_sky_texture.osl
+	node_stucci_texture.osl
+	node_texture_coordinate.osl
+	node_translucent_bsdf.osl
+	node_transparent_bsdf.osl
+	node_value.osl
+	node_vector_math.osl
+	node_velvet_bsdf.osl
+	node_voronoi_texture.osl
+	node_ward_bsdf.osl
+	node_wood_texture.osl)
+
+SET(osl_headers
+	node_texture.h
+	stdosl.h)
+
+SET(oso_sources)
+
+FOREACH(_file ${osl_sources})
+	SET(osl_file ${CMAKE_CURRENT_SOURCE_DIR}/${_file})
+	STRING(REPLACE ".osl" ".oso" oso_file ${osl_file})
+	STRING(REPLACE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} oso_file ${oso_file})
+	ADD_CUSTOM_COMMAND(
+		OUTPUT ${oso_file} 
+		COMMAND ${OSL_COMPILER} -O2 ${osl_file}
+		DEPENDS ${osl_file} ${osl_headers})
+	LIST(APPEND oso_sources ${oso_file})
+ENDFOREACH()
+
+ADD_CUSTOM_TARGET(shader ALL DEPENDS ${oso_sources} ${osl_headers})
+
+INSTALL(FILES ${oso_sources} DESTINATION ${INSTALL_PATH}/cycles/shader)
+
diff --git a/intern/cycles/kernel/osl/nodes/node_add_closure.osl b/intern/cycles/kernel/osl/nodes/node_add_closure.osl
new file mode 100644
index 00000000000..ecf6bf5912e
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_add_closure.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_add_closure(
+	closure color Closure1 = background(),
+	closure color Closure2 = background(),
+	output closure color Closure = background())
+{
+	Closure = Closure1 + Closure2;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_attribute.osl b/intern/cycles/kernel/osl/nodes/node_attribute.osl
new file mode 100644
index 00000000000..d273d0c68d7
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_attribute.osl
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_attribute(
+	string bump_offset = "center",
+	string name = "",
+	output point Vector = point(0.0, 0.0, 0.0),
+	output color Color = color(0.0, 0.0, 0.0),
+	output float Fac = 0.0)
+{
+	getattribute(name, Color);
+	Vector = point(Color);
+	getattribute(name, Fac);
+
+	if(bump_offset == "dx") {
+		Color += Dx(Color);
+		Vector += Dx(Vector);
+		Fac += Dx(Fac);
+	}
+	else if(bump_offset == "dy") {
+		Color += Dy(Color);
+		Vector += Dy(Vector);
+		Fac += Dy(Fac);
+	}
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_background.osl b/intern/cycles/kernel/osl/nodes/node_background.osl
new file mode 100644
index 00000000000..69f8d85a82e
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_background.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_background(
+	color Color = color(0.8, 0.8, 0.8),
+	float Strength = 1.0,
+	output closure color Background = background())
+{
+	Background = Color*Strength*background();
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_blend_texture.osl b/intern/cycles/kernel/osl/nodes/node_blend_texture.osl
new file mode 100644
index 00000000000..de1bdaca90b
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_blend_texture.osl
@@ -0,0 +1,78 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Blend */
+
+float blend(point p, string progression, string axis)
+{
+	float x, y;
+
+	if(axis == "Vertical") {
+		x= p[1];
+		y= p[0];
+	}
+	else {
+		x= p[0];
+		y= p[1];
+	}
+
+	float result = 0.0;
+
+	if(progression == "Linear") {
+		result = (1.0 + x)/2.0;
+	}
+	else if(progression == "Quadratic") {
+		float r = max((1.0 + x)/2.0, 0.0);
+		result = r*r;
+	}
+	else if(progression == "Easing") {
+		float r = min(max((1.0 + x)/2.0, 0.0), 1.0);
+		float t = r*r;
+		
+		result = (3.0*t - 2.0*t*r);
+	}
+	else if(progression == "Diagonal") {
+		result = (2.0 + x + y)/4.0;
+	}
+	else if(progression == "Radial") {
+		result = atan2(y, x)/(2*M_PI) + 0.5;
+	}
+	else {
+		float r = max(1.0 - sqrt(x*x + y*y + p[2]*p[2]), 0.0);
+
+		if(progression == "Quadratic Sphere")
+			result = r*r;
+		else if(progression == "Spherical")
+			result = r;
+	}
+
+	return result;
+}
+
+shader node_blend_texture(
+	string Progression = "Linear",
+	string Axis = "Horizontal",
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	Fac = blend(Vector, Progression, Axis);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_bump.osl b/intern/cycles/kernel/osl/nodes/node_bump.osl
new file mode 100644
index 00000000000..a3849e70f98
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_bump.osl
@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+/* "Bump Mapping Unparametrized Surfaces on the GPU"
+ * Morten S. Mikkelsen, 2010 */
+
+surface node_bump(
+	float SampleCenter = 0.0,
+	float SampleX = 0.0,
+	float SampleY = 0.0,
+	output normal Normal = N)
+{
+	float dx = SampleX - SampleCenter;
+	float dy = SampleY - SampleCenter;
+
+	vector dPdx = Dx(P);
+	vector dPdy = Dy(P);
+
+	vector Rx = cross(dPdy, N);
+	vector Ry = cross(N, dPdx);
+
+	float det = dot(dPdx, Rx);
+	vector surfgrad = dx*Rx + dy*Ry;
+
+	surfgrad *= 0.1; /* todo: remove this factor */
+	
+	Normal = normalize(abs(det)*N - sign(det)*surfgrad);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl b/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl
new file mode 100644
index 00000000000..6d244d81e27
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_clouds_texture.osl
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Turbulence */
+
+shader node_clouds_texture(
+	string Basis = "Perlin",
+	int Hard = 0,
+	int Depth = 2,
+	float Size = 0.25,
+	point Vector = P,
+	output float Fac = 0.0,
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	float size = nonzero(Size, 1e-5);
+	point p = Vector/size;
+
+	Fac = noise_turbulence(p, Basis, Depth, Hard);
+
+	Color[0] = Fac;
+	Color[1] = noise_turbulence(point(p[1], p[0], p[2]), Basis, Depth, Hard);
+	Color[2] = noise_turbulence(point(p[1], p[2], p[0]), Basis, Depth, Hard);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl
new file mode 100644
index 00000000000..97356139c48
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_convert_from_color.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_convert_from_color(
+	color Color = color(0.0, 0.0, 0.0),
+	output float Val = 0.0,
+	output vector Vector = vector(0.0, 0.0, 0.0),
+	output point Point = point(0.0, 0.0, 0.0),
+	output normal Normal = normal(0.0, 0.0, 0.0))
+{
+	Val = Color[0]*0.2126 + Color[1]*0.7152 + Color[2]*0.0722;
+	Vector = vector(Color[0], Color[1], Color[2]);
+	Point = point(Color[0], Color[1], Color[2]);
+	Normal = normal(Color[0], Color[1], Color[2]);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl
new file mode 100644
index 00000000000..00e78f3bab4
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_convert_from_float.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_convert_from_float(
+	float Val = 0.0,
+	output color Color = color(0.0, 0.0, 0.0),
+	output vector Vector = vector(0.0, 0.0, 0.0),
+	output point Point = point(0.0, 0.0, 0.0),
+	output normal Normal = normal(0.0, 0.0, 0.0))
+{
+	Color = color(Val, Val, Val);
+	Vector = vector(Val, Val, Val);
+	Point = point(Val, Val, Val);
+	Normal = normal(Val, Val, Val);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl
new file mode 100644
index 00000000000..0bb9092591d
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_convert_from_normal.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_convert_from_normal(
+	normal Normal = normal(0.0, 0.0, 0.0),
+	output float Val = 0.0,
+	output vector Vector = vector(0.0, 0.0, 0.0),
+	output color Color = color(0.0, 0.0, 0.0),
+	output point Point = point(0.0, 0.0, 0.0))
+{
+	Val = (Normal[0] + Normal[1] + Normal[2])*(1.0/3.0);
+	Vector = vector(Normal[0], Normal[1], Normal[2]);
+	Color = color(Normal[0], Normal[1], Normal[2]);
+	Point = point(Normal[0], Normal[1], Normal[2]);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl
new file mode 100644
index 00000000000..e66d6a864d6
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_convert_from_point.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_convert_from_point(
+	point Point = point(0.0, 0.0, 0.0),
+	output float Val = 0.0,
+	output vector Vector = vector(0.0, 0.0, 0.0),
+	output color Color = color(0.0, 0.0, 0.0),
+	output normal Normal = normal(0.0, 0.0, 0.0))
+{
+	Val = (Point[0] + Point[1] + Point[2])*(1.0/3.0);
+	Vector = vector(Point[0], Point[1], Point[2]);
+	Color = color(Point[0], Point[1], Point[2]);
+	Normal = normal(Point[0], Point[1], Point[2]);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl b/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl
new file mode 100644
index 00000000000..37ba9582cad
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_convert_from_vector.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_convert_from_vector(
+	vector Vector = vector(0.0, 0.0, 0.0),
+	output float Val = 0.0,
+	output color Color = color(0.0, 0.0, 0.0),
+	output point Point = point(0.0, 0.0, 0.0),
+	output normal Normal = normal(0.0, 0.0, 0.0))
+{
+	Val = (Vector[0] + Vector[1] + Vector[2])*(1.0/3.0);
+	Color = color(Vector[0], Vector[1], Vector[2]);
+	Point = point(Vector[0], Vector[1], Vector[2]);
+	Normal = normal(Vector[0], Vector[1], Vector[2]);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl
new file mode 100644
index 00000000000..8cf161c17cc
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_diffuse_bsdf.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_diffuse_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	BSDF = Color*diffuse(Normal);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl b/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl
new file mode 100644
index 00000000000..bb338c4ef0f
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_distorted_noise_texture.osl
@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Distorted Noise (variable lacunarity noise) */
+
+float noise_distorted(point p, string basis, string distortion_basis, float distortion)
+{
+	point r;
+
+	r[0] = noise_basis(p + point(13.5), basis) * distortion;
+	r[1] = noise_basis(p, basis) * distortion;
+	r[2] = noise_basis(p - point(13.5), basis) * distortion;
+
+    return noise_basis(p + r, distortion_basis); /* distorted-domain noise */
+}
+
+shader node_distorted_noise_texture(
+	string Basis = "Perlin",
+	string DistortionBasis = "Perlin",
+	float Distortion = 1.0,
+	float Size = 0.25,
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	float size = nonzero(Size, 1e-5);
+	Fac = noise_distorted(Vector/size, Basis, DistortionBasis, Distortion);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_emission.osl b/intern/cycles/kernel/osl/nodes/node_emission.osl
new file mode 100644
index 00000000000..8bfd1af173a
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_emission.osl
@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_emission(
+	int TotalPower = 0,
+	color Color = color(0.8, 0.8, 0.8),
+	float Strength = 1.0,
+	output closure color Emission = emission())
+{
+	if(TotalPower)
+		Emission = ((Strength/surfacearea())*Color)*emission();
+	else
+		Emission = (Strength*Color)*emission();
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_environment_texture.osl b/intern/cycles/kernel/osl/nodes/node_environment_texture.osl
new file mode 100644
index 00000000000..569b22d53ec
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_environment_texture.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_environment_texture(
+	vector Vector = P,
+	string filename = "",
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	Color = (color)environment(filename, Vector);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_fresnel.h b/intern/cycles/kernel/osl/nodes/node_fresnel.h
new file mode 100644
index 00000000000..0c8a5276ede
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_fresnel.h
@@ -0,0 +1,21 @@
+
+float fresnel_dielectric(vector Incoming, normal Normal, float eta)
+{
+	/* compute fresnel reflectance without explicitly computing
+	   the refracted direction */
+	float c = fabs(dot(Incoming, Normal));
+	float g = eta * eta - 1 + c * c;
+	float result;
+
+	if(g > 0) {
+		g = sqrt(g);
+		float A =(g - c)/(g + c);
+		float B =(c *(g + c)- 1)/(c *(g - c)+ 1);
+		result = 0.5 * A * A *(1 + B * B);
+	}
+	else
+		result = 1.0;  /* TIR (no refracted component) */
+
+	return result;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_fresnel.osl b/intern/cycles/kernel/osl/nodes/node_fresnel.osl
new file mode 100644
index 00000000000..ddc86db130f
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_fresnel.osl
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_fresnel.h"
+
+shader node_fresnel(
+	float Fresnel = 0.3,
+	normal Normal = N,
+	output float Fac = 0.0)
+{
+	float f = max(1.0 - Fresnel, 0.00001);
+	Fac = fresnel_dielectric(I, Normal, backfacing()? f: 1.0/f);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_geometry.osl b/intern/cycles/kernel/osl/nodes/node_geometry.osl
new file mode 100644
index 00000000000..bf76e2e597a
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_geometry.osl
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_geometry(
+	normal NormalIn = N,
+	string bump_offset = "center",
+
+	output point Position = point(0.0, 0.0, 0.0),
+	output normal Normal = normal(0.0, 0.0, 0.0),
+	output normal Tangent = normal(0.0, 0.0, 0.0),
+	output normal TrueNormal = normal(0.0, 0.0, 0.0),
+	output vector Incoming = vector(0.0, 0.0, 0.0),
+	output point UV = point(0.0, 0.0, 0.0),
+	output float Backfacing = 0.0)
+{
+	Position = P;
+	Normal = NormalIn;
+	Tangent = normalize(dPdu);
+	TrueNormal = Ng;
+	Incoming = I;
+	UV = point(u, v, 0.0);
+	Backfacing = backfacing();
+
+	if(bump_offset == "dx") {
+		Position += Dx(Position);
+		UV += Dx(UV);
+	}
+	else if(bump_offset == "dy") {
+		Position += Dy(Position);
+		UV += Dy(UV);
+	}
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl
new file mode 100644
index 00000000000..af946048011
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_glass_bsdf.osl
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_fresnel.h"
+
+shader node_glass_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	string distribution = "Sharp",
+	float Roughness = 0.2,
+	float Fresnel = 0.3,
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	float f = clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5);
+	float eta = backfacing()? f: 1.0/f;
+	float Fr = fresnel_dielectric(I, Normal, eta);
+
+	if(distribution == "Sharp")
+		BSDF = Color*(Fr*reflection(Normal) + (1.0-Fr)*refraction(Normal, eta));
+	else if(distribution == "Beckmann")
+		BSDF = Color*(Fr*microfacet_beckmann(Normal, Roughness) + (1.0-Fr)*microfacet_beckmann_refraction(Normal, Roughness, eta));
+	else if(distribution == "GGX")
+		BSDF = Color*(Fr*microfacet_ggx(Normal, Roughness) + (1.0-Fr)*microfacet_ggx_refraction(Normal, Roughness, eta));
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl
new file mode 100644
index 00000000000..ca6bee74b38
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_glossy_bsdf.osl
@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_fresnel.h"
+
+shader node_glossy_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	string distribution = "Beckmann",
+	float Roughness = 0.2,
+	float Fresnel = 1.0,
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	float Fr = 1.0;
+
+	if(Fresnel < 1.0) {
+		float eta = 1.0/clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5);
+		Fr = fresnel_dielectric(I, Normal, eta);
+	}
+
+	if(distribution == "Sharp")
+		BSDF = (Fr*Color)*reflection(Normal);
+	else if(distribution == "Beckmann")
+		BSDF = (Fr*Color)*microfacet_beckmann(Normal, Roughness);
+	else if(distribution == "GGX")
+		BSDF = (Fr*Color)*microfacet_ggx(Normal, Roughness);
+
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_image_texture.osl b/intern/cycles/kernel/osl/nodes/node_image_texture.osl
new file mode 100644
index 00000000000..0dbcc122deb
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_image_texture.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_image_texture(
+	point Vector = P,
+	string filename = "",
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	Color = (color)texture(filename, Vector[0], 1.0-Vector[1], "wrap", "periodic");
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_light_path.osl b/intern/cycles/kernel/osl/nodes/node_light_path.osl
new file mode 100644
index 00000000000..081640428ab
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_light_path.osl
@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_light_path(
+	output float IsCameraRay = 0.0,
+	output float IsShadowRay = 0.0,
+	output float IsDiffuseRay = 0.0,
+	output float IsGlossyRay = 0.0,
+	output float IsReflectionRay = 0.0,
+	output float IsTransmissionRay = 0.0)
+{
+	IsCameraRay = raytype("camera");
+	IsShadowRay = raytype("shadow");
+	IsDiffuseRay = raytype("diffuse");
+	IsGlossyRay = raytype("glossy");
+	IsReflectionRay = raytype("reflection");
+	IsTransmissionRay = raytype("refraction");
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_magic_texture.osl b/intern/cycles/kernel/osl/nodes/node_magic_texture.osl
new file mode 100644
index 00000000000..0b6e980debc
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_magic_texture.osl
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Magic */
+
+color magic(point p, int n, float turbulence)
+{
+	float turb = turbulence/5.0;
+
+	float x = sin((p[0] + p[1] + p[2])*5.0);
+	float y = cos((-p[0] + p[1] - p[2])*5.0);
+	float z = -cos((-p[0] - p[1] + p[2])*5.0);
+
+	if(n > 0) {
+		x *= turb;
+		y *= turb;
+		z *= turb;
+		y = -cos(x-y+z);
+		y *= turb;
+
+		if(n > 1) {
+			x= cos(x-y-z);
+			x *= turb;
+
+			if(n > 2) {
+				z= sin(-x-y-z);
+				z *= turb;
+
+				if(n > 3) {
+					x= -cos(-x+y-z);
+					x *= turb;
+
+					if(n > 4) {
+						y= -sin(-x+y+z);
+						y *= turb;
+
+						if(n > 5) {
+							y= -cos(-x+y+z);
+							y *= turb;
+
+							if(n > 6) {
+								x= cos(x+y+z);
+								x *= turb;
+
+								if(n > 7) {
+									z= sin(x+y-z);
+									z *= turb;
+
+									if(n > 8) {
+										x= -cos(-x-y+z);
+										x *= turb;
+
+										if(n > 9) {
+											y= -sin(x-y+z);
+											y *= turb;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if(turb != 0.0) {
+		turb *= 2.0;
+		x /= turb;
+		y /= turb;
+		z /= turb;
+	}
+
+	return color(0.5 - x, 0.5 - y, 0.5 - z);
+}
+
+shader node_magic_texture(
+	int Depth = 2,
+	float Turbulence = 5.0,
+	point Vector = P,
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	Color = magic(Vector, Depth, Turbulence);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_mapping.osl b/intern/cycles/kernel/osl/nodes/node_mapping.osl
new file mode 100644
index 00000000000..f342837d3c9
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_mapping.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_mapping(
+	matrix Matrix = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+	point Vector = point(0.0, 0.0, 0.0),
+	output point Vector_ = point(0.0, 0.0, 0.0))
+{
+	Vector_ = transform(Matrix, Vector);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_marble_texture.osl b/intern/cycles/kernel/osl/nodes/node_marble_texture.osl
new file mode 100644
index 00000000000..9e18dee3235
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_marble_texture.osl
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Marble */
+
+float marble(point p, float size, string type, string wave, string basis, int hard, float turb, int depth)
+{
+	float x = p[0];
+	float y = p[1];
+	float z = p[2];
+
+    float n = 5.0 * (x + y + z);
+
+	float mi = n + turb * noise_turbulence(p/size, basis, depth, hard);
+
+	mi = noise_wave(wave, mi);
+
+	if(type == "Sharp")
+		mi = sqrt(mi);
+	else if(type == "Sharper")
+		mi = sqrt(sqrt(mi));
+
+    return mi;
+}
+
+shader node_marble_texture(
+	string Type = "Soft",
+	string Wave = "Sine",
+	string Basis = "Perlin",
+	int Hard = 0,
+	float Size = 0.25,
+	float Turbulence = 5.0,
+	int Depth = 2,
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	float size = nonzero(Size, 1e-5);
+	Fac = marble(Vector, size, Type, Wave, Basis, Hard, Turbulence, Depth);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_math.osl b/intern/cycles/kernel/osl/nodes/node_math.osl
new file mode 100644
index 00000000000..be9bb71d511
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_math.osl
@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+float safe_divide(float a, float b)
+{
+	float result;
+
+	if(b == 0.0)
+		result = 0.0;
+	else
+		result = a/b;
+	
+	return result;
+}
+
+float safe_log(float a, float b)
+{
+	if(a < 0.0 || b < 0.0)
+		return 0.0;
+	
+	return log(a)/log(b);
+}
+
+shader node_math(
+	string type = "Add",
+	float Value1 = 0.0,
+	float Value2 = 0.0,
+	output float Value = 0.0)
+{
+	/* OSL asin, acos, pow check for values that could give rise to nan */
+
+	if(type == "Add")
+		Value = Value1 + Value2;
+	if(type == "Subtract")
+		Value = Value1 - Value2;
+	if(type == "Multiply")
+		Value = Value1*Value2;
+	if(type == "Divide")
+		Value = safe_divide(Value1, Value2);
+	if(type == "Sine")
+		Value = sin(Value1);
+	if(type == "Cosine")
+		Value = cos(Value1);
+	if(type == "Tangent")
+		Value = tan(Value1);
+	if(type == "Arcsine")
+		Value = asin(Value1);
+	if(type == "Arccosine")
+		Value = acos(Value1);
+	if(type == "Arctangent")
+		Value = atan(Value1);
+	if(type == "Power")
+		Value = pow(Value1, Value2);
+	if(type == "Logarithm")
+		Value = safe_log(Value1, Value2);
+	if(type == "Minimum")
+		Value = min(Value1, Value2);
+	if(type == "Maximum")
+		Value = max(Value1, Value2);
+	if(type == "Round")
+		Value = floor(Value1 + 0.5);
+	if(type == "Less Than")
+		Value = Value1 < Value2;
+	if(type == "Greater Than")
+		Value = Value1 > Value2;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_mix.osl b/intern/cycles/kernel/osl/nodes/node_mix.osl
new file mode 100644
index 00000000000..582aa7b3c60
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_mix.osl
@@ -0,0 +1,388 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+color rgb_to_hsv(color rgb)
+{
+	float cmax, cmin, h, s, v, cdelta;
+	color c;
+
+	cmax = max(rgb[0], max(rgb[1], rgb[2]));
+	cmin = min(rgb[0], min(rgb[1], rgb[2]));
+	cdelta = cmax - cmin;
+
+	v = cmax;
+
+	if(cmax != 0.0) {
+		s = cdelta/cmax;
+	}
+	else {
+		s = 0.0;
+		h = 0.0;
+	}
+
+	if(s == 0.0) {
+		h = 0.0;
+	}
+	else {
+		c = (color(cmax, cmax, cmax) - rgb)/cdelta;
+
+		if(rgb[0] == cmax) h = c[2] - c[1];
+		else if(rgb[1] == cmax) h = 2.0 + c[0] -  c[2];
+		else h = 4.0 + c[1] - c[0];
+
+		h /= 6.0;
+
+		if(h < 0.0)
+			h += 1.0;
+	}
+
+	return color(h, s, v);
+}
+
+color hsv_to_rgb(color hsv)
+{
+	float i, f, p, q, t, h, s, v;
+	color rgb;
+
+	h = hsv[0];
+	s = hsv[1];
+	v = hsv[2];
+
+	if(s==0.0) {
+		rgb = color(v, v, v);
+	}
+	else {
+		if(h==1.0)
+			h = 0.0;
+		
+		h *= 6.0;
+		i = floor(h);
+		f = h - i;
+		rgb = color(f, f, f);
+		p = v*(1.0-s);
+		q = v*(1.0-(s*f));
+		t = v*(1.0-(s*(1.0-f)));
+		
+		if(i == 0.0) rgb = color(v, t, p);
+		else if(i == 1.0) rgb = color(q, v, p);
+		else if(i == 2.0) rgb = color(p, v, t);
+		else if(i == 3.0) rgb = color(p, q, v);
+		else if(i == 4.0) rgb = color(t, p, v);
+		else rgb = color(v, p, q);
+	}
+
+	return rgb;
+}
+
+color node_mix_blend(float t, color col1, color col2)
+{
+	return mix(col1, col2, t);
+}
+
+color node_mix_add(float t, color col1, color col2)
+{
+	return mix(col1, col1 + col2, t);
+}
+
+color node_mix_mul(float t, color col1, color col2)
+{
+	return mix(col1, col1 * col2, t);
+}
+
+color node_mix_screen(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	return color(1.0) - (color(tm) + t*(color(1.0) - col2))*(color(1.0) - col1);
+}
+
+color node_mix_overlay(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	color outcol = col1;
+
+	if(outcol[0] < 0.5)
+		outcol[0] *= tm + 2.0*t*col2[0];
+	else
+		outcol[0] = 1.0 - (tm + 2.0*t*(1.0 - col2[0]))*(1.0 - outcol[0]);
+
+	if(outcol[1] < 0.5)
+		outcol[1] *= tm + 2.0*t*col2[1];
+	else
+		outcol[1] = 1.0 - (tm + 2.0*t*(1.0 - col2[1]))*(1.0 - outcol[1]);
+
+	if(outcol[2] < 0.5)
+		outcol[2] *= tm + 2.0*t*col2[2];
+	else
+		outcol[2] = 1.0 - (tm + 2.0*t*(1.0 - col2[2]))*(1.0 - outcol[2]);
+	
+	return outcol;
+}
+
+color node_mix_sub(float t, color col1, color col2)
+{
+	return mix(col1, col1 - col2, t);
+}
+
+color node_mix_div(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	color outcol = col1;
+
+	if(col2[0] != 0.0) outcol[0] = tm*outcol[0] + t*outcol[0]/col2[0];
+	if(col2[1] != 0.0) outcol[1] = tm*outcol[1] + t*outcol[1]/col2[1];
+	if(col2[2] != 0.0) outcol[2] = tm*outcol[2] + t*outcol[2]/col2[2];
+
+	return outcol;
+}
+
+color node_mix_diff(float t, color col1, color col2)
+{
+	return mix(col1, abs(col1 - col2), t);
+}
+
+color node_mix_dark(float t, color col1, color col2)
+{
+	return min(col1, col2*t);
+}
+
+color node_mix_light(float t, color col1, color col2)
+{
+	return max(col1, col2*t);
+}
+
+color node_mix_dodge(float t, color col1, color col2)
+{
+	color outcol = col1;
+
+	if(outcol[0] != 0.0) {
+		float tmp = 1.0 - t*col2[0];
+		if(tmp <= 0.0)
+			outcol[0] = 1.0;
+		else if((tmp = outcol[0]/tmp) > 1.0)
+			outcol[0] = 1.0;
+		else
+			outcol[0] = tmp;
+	}
+	if(outcol[1] != 0.0) {
+		float tmp = 1.0 - t*col2[1];
+		if(tmp <= 0.0)
+			outcol[1] = 1.0;
+		else if((tmp = outcol[1]/tmp) > 1.0)
+			outcol[1] = 1.0;
+		else
+			outcol[1] = tmp;
+	}
+	if(outcol[2] != 0.0) {
+		float tmp = 1.0 - t*col2[2];
+		if(tmp <= 0.0)
+			outcol[2] = 1.0;
+		else if((tmp = outcol[2]/tmp) > 1.0)
+			outcol[2] = 1.0;
+		else
+			outcol[2] = tmp;
+	}
+
+	return outcol;
+}
+
+color node_mix_burn(float t, color col1, color col2)
+{
+	float tmp, tm = 1.0 - t;
+
+	color outcol = col1;
+
+	tmp = tm + t*col2[0];
+	if(tmp <= 0.0)
+		outcol[0] = 0.0;
+	else if((tmp = (1.0 - (1.0 - outcol[0])/tmp)) < 0.0)
+		outcol[0] = 0.0;
+	else if(tmp > 1.0)
+		outcol[0] = 1.0;
+	else
+		outcol[0] = tmp;
+
+	tmp = tm + t*col2[1];
+	if(tmp <= 0.0)
+		outcol[1] = 0.0;
+	else if((tmp = (1.0 - (1.0 - outcol[1])/tmp)) < 0.0)
+		outcol[1] = 0.0;
+	else if(tmp > 1.0)
+		outcol[1] = 1.0;
+	else
+		outcol[1] = tmp;
+
+	tmp = tm + t*col2[2];
+	if(tmp <= 0.0)
+		outcol[2] = 0.0;
+	else if((tmp = (1.0 - (1.0 - outcol[2])/tmp)) < 0.0)
+		outcol[2] = 0.0;
+	else if(tmp > 1.0)
+		outcol[2] = 1.0;
+	else
+		outcol[2] = tmp;
+	
+	return outcol;
+}
+
+color node_mix_hue(float t, color col1, color col2)
+{
+	color outcol = col1;
+	color hsv2 = rgb_to_hsv(col2);
+
+	if(hsv2[1] != 0.0) {
+		color hsv = rgb_to_hsv(outcol);
+		hsv[0] = hsv2[0];
+		color tmp = hsv_to_rgb(hsv); 
+
+		outcol = mix(outcol, tmp, t);
+	}
+
+	return outcol;
+}
+
+color node_mix_sat(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	color outcol = col1;
+
+	color hsv = rgb_to_hsv(outcol);
+
+	if(hsv[1] != 0.0) {
+		color hsv2 = rgb_to_hsv(col2);
+
+		hsv[1] = tm*hsv[1] + t*hsv2[1];
+		outcol = hsv_to_rgb(hsv);
+	}
+
+	return outcol;
+}
+
+color node_mix_val(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	color hsv = rgb_to_hsv(col1);
+	color hsv2 = rgb_to_hsv(col2);
+
+	hsv[2] = tm*hsv[2] + t*hsv2[2];
+
+	return hsv_to_rgb(hsv);
+}
+
+color node_mix_color(float t, color col1, color col2)
+{
+	color outcol = col1;
+	color hsv2 = rgb_to_hsv(col2);
+
+	if(hsv2[1] != 0.0) {
+		color hsv = rgb_to_hsv(outcol);
+		hsv[0] = hsv2[0];
+		hsv[1] = hsv2[1];
+		color tmp = hsv_to_rgb(hsv); 
+
+		outcol = mix(outcol, tmp, t);
+	}
+
+	return outcol;
+}
+
+color node_mix_soft(float t, color col1, color col2)
+{
+	float tm = 1.0 - t;
+
+	color one= color(1.0);
+	color scr= one - (one - col2)*(one - col1);
+
+	return tm*col1 + t*((one - col1)*col2*col1 + col1*scr);
+}
+
+color node_mix_linear(float t, color col1, color col2)
+{
+	color outcol = col1;
+
+	if(col2[0] > 0.5)
+		outcol[0]= col1[0] + t*(2.0*(col2[0] - 0.5));
+	else
+		outcol[0]= col1[0] + t*(2.0*(col2[0]) - 1.0);
+
+	if(col2[1] > 0.5)
+		outcol[1]= col1[1] + t*(2.0*(col2[1] - 0.5));
+	else
+		outcol[1]= col1[1] + t*(2.0*(col2[1]) - 1.0);
+
+	if(col2[2] > 0.5)
+		outcol[2]= col1[2] + t*(2.0*(col2[2] - 0.5));
+	else
+		outcol[2]= col1[2] + t*(2.0*(col2[2]) - 1.0);
+	
+	return outcol;
+}
+
+shader node_mix(
+	string type = "Mix",
+	float Fac = 0.5,
+	color Color1 = color(0.0, 0.0, 0.0),
+	color Color2 = color(0.0, 0.0, 0.0),
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	float t = clamp(Fac, 0.0, 1.0);
+
+	if(type == "Mix")
+		Color = node_mix_blend(t, Color1, Color2);
+	if(type == "Add")
+		Color = node_mix_add(t, Color1, Color2);
+	if(type == "Multiply")
+		Color = node_mix_mul(t, Color1, Color2);
+	if(type == "Screen")
+		Color = node_mix_screen(t, Color1, Color2);
+	if(type == "Overlay")
+		Color = node_mix_overlay(t, Color1, Color2);
+	if(type == "Subtract")
+		Color = node_mix_sub(t, Color1, Color2);
+	if(type == "Divide")
+		Color = node_mix_div(t, Color1, Color2);
+	if(type == "Difference")
+		Color = node_mix_diff(t, Color1, Color2);
+	if(type == "Darken")
+		Color = node_mix_dark(t, Color1, Color2);
+	if(type == "Lighten")
+		Color = node_mix_light(t, Color1, Color2);
+	if(type == "Dodge")
+		Color = node_mix_dodge(t, Color1, Color2);
+	if(type == "Burn")
+		Color = node_mix_burn(t, Color1, Color2);
+	if(type == "Hue")
+		Color = node_mix_hue(t, Color1, Color2);
+	if(type == "Saturation")
+		Color = node_mix_sat(t, Color1, Color2);
+	if(type == "Value")
+		Color = node_mix_val (t, Color1, Color2);
+	if(type == "Color")
+		Color = node_mix_color(t, Color1, Color2);
+	if(type == "Soft Light")
+		Color = node_mix_soft(t, Color1, Color2);
+	if(type == "Linear Light")
+		Color = node_mix_linear(t, Color1, Color2);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_mix_closure.osl b/intern/cycles/kernel/osl/nodes/node_mix_closure.osl
new file mode 100644
index 00000000000..1a377abd381
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_mix_closure.osl
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_mix_closure(
+	float Fac = 0.5,
+	closure color Closure1 = background(),
+	closure color Closure2 = background(),
+	output closure color Closure = background())
+{
+	float t = clamp(Fac, 0.0, 1.0);
+	Closure = (1.0 - t)*Closure1 + t*Closure2;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl b/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl
new file mode 100644
index 00000000000..fbd0ce5c3bd
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_musgrave_texture.osl
@@ -0,0 +1,218 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Musgrave fBm
+ *
+ * H: fractal increment parameter
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ *
+ * from "Texturing and Modelling: A procedural approach"
+ */
+
+float noise_musgrave_fBm(point p, string basis, float H, float lacunarity, float octaves)
+{
+	float rmd;
+	float value = 0.0;
+	float pwr = 1.0;
+	float pwHL = pow(lacunarity, -H);
+	int i;
+
+	for(i = 0; i < (int)octaves; i++) {
+		value += noise_basis(p, basis) * pwr;
+		pwr *= pwHL;
+		p *= lacunarity;
+	}
+
+	rmd = octaves - floor(octaves);
+	if(rmd != 0.0)
+		value += rmd * noise_basis(p, basis) * pwr;
+
+	return value;
+}
+
+/* Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+float noise_musgrave_multi_fractal(point p, string basis, float H, float lacunarity, float octaves)
+{
+	float rmd;
+	float value = 1.0;
+	float pwr = 1.0;
+	float pwHL = pow(lacunarity, -H);
+	int i;
+
+	for(i = 0; i < (int)octaves; i++) {
+		value *= (pwr * noise_basis(p, basis) + 1.0);
+		pwr *= pwHL;
+		p *= lacunarity;
+	}
+
+	rmd = octaves - floor(octaves);
+	if(rmd != 0.0)
+		value *= (rmd * pwr * noise_basis(p, basis) + 1.0); /* correct? */
+
+	return value;
+}
+
+/* Musgrave Heterogeneous Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+float noise_musgrave_hetero_terrain(point p, string basis, float H, float lacunarity, float octaves, float offset)
+{
+	float value, increment, rmd;
+	float pwHL = pow(lacunarity, -H);
+	float pwr = pwHL;
+	int i;
+
+	/* first unscaled octave of function; later octaves are scaled */
+	value = offset + noise_basis(p, basis);
+	p *= lacunarity;
+
+	for(i = 1; i < (int)octaves; i++) {
+		increment = (noise_basis(p, basis) + offset) * pwr * value;
+		value += increment;
+		pwr *= pwHL;
+		p *= lacunarity;
+	}
+
+	rmd = octaves - floor(octaves);
+	if(rmd != 0.0) {
+		increment = (noise_basis(p, basis) + offset) * pwr * value;
+		value += rmd * increment;
+	}
+
+	return value;
+}
+
+/* Hybrid Additive/Multiplicative Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+float noise_musgrave_hybrid_multi_fractal(point p, string basis, float H, float lacunarity, float octaves, float offset, float gain)
+{
+	float result, signal, weight, rmd;
+	float pwHL = pow(lacunarity, -H);
+	float pwr = pwHL;
+	int i;
+
+	result = noise_basis(p, basis) + offset;
+	weight = gain * result;
+	p *= lacunarity;
+
+	for(i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+		if(weight > 1.0)
+			weight = 1.0;
+
+		signal = (noise_basis(p, basis) + offset) * pwr;
+		pwr *= pwHL;
+		result += weight * signal;
+		weight *= gain * signal;
+		p *= lacunarity;
+	}
+
+	rmd = octaves - floor(octaves);
+	if(rmd != 0.0)
+		result += rmd * ((noise_basis(p, basis) + offset) * pwr);
+
+	return result;
+}
+
+/* Ridged Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+float noise_musgrave_ridged_multi_fractal(point p, string basis, float H, float lacunarity, float octaves, float offset, float gain)
+{
+	float result, signal, weight;
+	float pwHL = pow(lacunarity, -H);
+	float pwr = pwHL;
+	int i;
+
+	signal = offset - fabs(noise_basis(p, basis));
+	signal *= signal;
+	result = signal;
+	weight = 1.0;
+
+	for(i = 1; i < (int)octaves; i++) {
+		p *= lacunarity;
+		weight = clamp(signal * gain, 0.0, 1.0);
+		signal = offset - fabs(noise_basis(p, basis));
+		signal *= signal;
+		signal *= weight;
+		result += signal * pwr;
+		pwr *= pwHL;
+	}
+
+	return result;
+}
+
+/* Shader */
+
+shader node_musgrave_texture(
+	string Type = "fBM",
+	string Basis = "Perlin",
+	float Dimension = 2.0,
+	float Lacunarity = 1.0,
+	float Octaves = 2.0,
+	float Offset = 0.0,
+	float Intensity = 1.0,
+	float Gain = 1.0,
+	float Size = 0.25,
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	float dimension = max(Dimension, 0.0);
+	float octaves = max(Octaves, 0.0);
+	float lacunarity = max(Lacunarity, 1e-5);
+	float size = nonzero(Size, 1e-5);
+
+	point p = Vector/size;
+
+	if(Type == "Multifractal")
+		Fac = Intensity*noise_musgrave_multi_fractal(p, Basis, dimension, lacunarity, octaves);
+	else if(Type == "fBM")
+		Fac = Intensity*noise_musgrave_fBm(p, Basis, dimension, lacunarity, octaves);
+	else if(Type == "Hybrid Multifractal")
+		Fac = Intensity*noise_musgrave_hybrid_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain);
+	else if(Type == "Ridged Multifractal")
+		Fac = Intensity*noise_musgrave_ridged_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain);
+	else if(Type == "Hetero Terrain")
+		Fac = Intensity*noise_musgrave_hetero_terrain(p, Basis, dimension, lacunarity, octaves, Offset);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_noise_texture.osl b/intern/cycles/kernel/osl/nodes/node_noise_texture.osl
new file mode 100644
index 00000000000..193ed67d16e
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_noise_texture.osl
@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+shader node_noise_texture(
+	point Vector = P,
+	output color Color = color(0.0, 0.0, 0.0),
+	output float Fac = 0.0)
+{
+	point p = Vector*1e8;
+
+	float r = cellnoise(p);
+	float g = cellnoise(point(p[1], p[0], p[2]));
+	float b = cellnoise(point(p[1], p[2], p[0]));
+
+	Fac = r;
+	Color = color(r, g, b);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_output_displacement.osl b/intern/cycles/kernel/osl/nodes/node_output_displacement.osl
new file mode 100644
index 00000000000..a6b452c532a
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_output_displacement.osl
@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+displacement node_output_displacement(float Displacement = 0.0)
+{
+	P += N*Displacement*0.1; /* todo: get rid of this factor */
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_output_surface.osl b/intern/cycles/kernel/osl/nodes/node_output_surface.osl
new file mode 100644
index 00000000000..6efaf91121b
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_output_surface.osl
@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+surface node_output_surface(closure color Surface = background())
+{
+	Ci = Surface;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_output_volume.osl b/intern/cycles/kernel/osl/nodes/node_output_volume.osl
new file mode 100644
index 00000000000..18094242dc7
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_output_volume.osl
@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+volume node_output_volume(closure color Volume = background())
+{
+	Ci = Volume;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_sky_texture.osl b/intern/cycles/kernel/osl/nodes/node_sky_texture.osl
new file mode 100644
index 00000000000..fdb9b1d9708
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_sky_texture.osl
@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+struct KernelSunSky {
+	/* sun direction in spherical and cartesian */
+	float theta, phi;
+	vector dir;
+
+	/* perez function parameters */
+	float zenith_Y, zenith_x, zenith_y;
+	float perez_Y[5], perez_x[5], perez_y[5];
+};
+
+color xyY_to_xyz(float x, float y, float Y)
+{
+	float X, Z;
+
+	if(y != 0.0) X = (x / y) * Y;
+	else X = 0.0;
+
+	if(y != 0.0 && Y != 0.0) Z = ((1.0 - x - y) / y) * Y;
+	else Z = 0.0;
+
+	return color(X, Y, Z);
+}
+
+color xyz_to_rgb(float x, float y, float z)
+{
+	return color(3.240479 * x + -1.537150 * y + -0.498535 * z,
+				 -0.969256 * x + 1.875991 * y + 0.041556 * z,
+				 0.055648 * x + -0.204043 * y + 1.057311 * z);
+}
+
+float sky_angle_between(float thetav, float phiv, float theta, float phi)
+{
+	float cospsi = sin(thetav)*sin(theta)*cos(phi - phiv) + cos(thetav)*cos(theta);
+
+	if(cospsi > 1.0)
+		return 0.0;
+	if(cospsi < -1.0)
+		return M_PI;
+
+	return acos(cospsi);
+}
+
+vector sky_spherical_coordinates(vector dir)
+{
+	return vector(acos(dir[2]), atan2(dir[0], dir[1]), 0);
+}
+
+float sky_perez_function(float lam[5], float theta, float gamma)
+{
+	float ctheta = cos(theta);
+	float cgamma = cos(gamma);
+
+	return (1.0 + lam[0]*exp(lam[1] / ctheta)) * (1.0 + lam[2]*exp(lam[3]*gamma) + lam[4]*cgamma*cgamma);
+}
+
+color sky_xyz_radiance(KernelSunSky sunsky, vector dir)
+{
+	/* convert vector to spherical coordinates */
+	vector spherical = sky_spherical_coordinates(dir);
+	float theta = spherical[0];
+	float phi = spherical[1];
+
+	/* angle between sun direction and dir */
+	float gamma = sky_angle_between(theta, phi, sunsky.theta, sunsky.phi);
+
+	/* clamp theta to horizon */
+	theta = min(theta, M_PI_2 - 0.001);
+
+	/* compute xyY color space values */
+	float x = sunsky.zenith_x * sky_perez_function(sunsky.perez_x, theta, gamma);
+	float y = sunsky.zenith_y * sky_perez_function(sunsky.perez_y, theta, gamma);
+	float Y = sunsky.zenith_Y * sky_perez_function(sunsky.perez_Y, theta, gamma);
+
+	/* convert to RGB */
+	color xyz = xyY_to_xyz(x, y, Y);
+	return xyz_to_rgb(xyz[0], xyz[1], xyz[2]);
+}
+
+void precompute_sunsky(vector dir, float turbidity, output KernelSunSky sunsky)
+{
+	vector spherical = sky_spherical_coordinates(dir);
+	float theta = spherical[0];
+	float phi = spherical[1];
+
+	sunsky.theta = theta;
+	sunsky.phi = phi;
+	sunsky.dir = dir;
+
+	float theta2 = theta*theta;
+	float theta3 = theta*theta*theta;
+	float T = turbidity;
+	float T2 = T*T;
+
+	float chi = (4.0/ 9.0- T / 120.0) * (M_PI - 2.0* theta);
+	sunsky.zenith_Y = (4.0453*T - 4.9710) * tan(chi) - 0.2155*T + 2.4192;
+	sunsky.zenith_Y *= 0.06;
+
+	sunsky.zenith_x =
+	(0.00166* theta3 - 0.00375* theta2 + 0.00209* theta)*T2 +
+	(-0.02903* theta3 + 0.06377* theta2 - 0.03202* theta + 0.00394)*T +
+	(0.11693* theta3 - 0.21196* theta2 + 0.06052* theta + 0.25886);
+
+	sunsky.zenith_y =
+	(0.00275* theta3 - 0.00610* theta2 + 0.00317* theta)*T2 +
+	(-0.04214* theta3 + 0.08970* theta2 - 0.04153* theta + 0.00516)*T +
+	(0.15346* theta3 - 0.26756* theta2 + 0.06670* theta + 0.26688);
+
+	sunsky.perez_Y[0] = (0.1787*T - 1.4630);
+	sunsky.perez_Y[1] = (-0.3554*T + 0.4275);
+	sunsky.perez_Y[2] = (-0.0227*T + 5.3251);
+	sunsky.perez_Y[3] = (0.1206*T - 2.5771);
+	sunsky.perez_Y[4] = (-0.0670*T + 0.3703);
+
+	sunsky.perez_x[0] = (-0.0193*T - 0.2592);
+	sunsky.perez_x[1] = (-0.0665*T + 0.0008);
+	sunsky.perez_x[2] = (-0.0004*T + 0.2125);
+	sunsky.perez_x[3] = (-0.0641*T - 0.8989);
+	sunsky.perez_x[4] = (-0.0033*T + 0.0452);
+
+	sunsky.perez_y[0] = (-0.0167*T - 0.2608);
+	sunsky.perez_y[1] = (-0.0950*T + 0.0092);
+	sunsky.perez_y[2] = (-0.0079*T + 0.2102);
+	sunsky.perez_y[3] = (-0.0441*T - 1.6537);
+	sunsky.perez_y[4] = (-0.0109*T + 0.0529);
+
+	sunsky.zenith_Y /= sky_perez_function(sunsky.perez_Y, 0, theta);
+	sunsky.zenith_x /= sky_perez_function(sunsky.perez_x, 0, theta);
+	sunsky.zenith_y /= sky_perez_function(sunsky.perez_y, 0, theta);
+}
+
+shader node_sky_texture(
+	vector Vector = P,
+	vector sun_direction = vector(0, 0, 1),
+	float turbidity = 2.2,
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	KernelSunSky sunsky;
+
+	precompute_sunsky(sun_direction, turbidity, sunsky);
+	Color = sky_xyz_radiance(sunsky, Vector);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl b/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl
new file mode 100644
index 00000000000..f03e03d9a98
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_stucci_texture.osl
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Stucci */
+
+shader node_stucci_texture(
+	string Type = "Plastic",
+	string Basis = "Perlin",
+	int Hard = 0,
+	float Turbulence = 1.0,
+	float Size = 0.25,
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	float size = nonzero(Size, 1e-5);
+	point p = Vector/size;
+
+	float b2 = noise_basis_hard(p, Basis, Hard);
+	float ofs = Turbulence/200.0;
+
+	if(Type != "Plastic")
+		ofs *= b2*b2;
+	
+	Fac = noise_basis_hard(point(p[0], p[1], p[2]+ofs), Basis, Hard);
+
+	if(Type == "Wall Out")
+		Fac = 1.0 - Fac;
+	
+	Fac = max(Fac, 0.0);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_texture.h b/intern/cycles/kernel/osl/nodes/node_texture.h
new file mode 100644
index 00000000000..8adb0e8aeb5
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_texture.h
@@ -0,0 +1,251 @@
+/*
+ * 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.
+ */
+
+/* Voronoi Distances */
+
+float voronoi_distance(string distance_metric, vector d, float e)
+{
+	float result = 0.0;
+
+	if(distance_metric == "Distance Squared")
+		result = dot(d, d);
+	if(distance_metric == "Actual Distance")
+		result = length(d);
+	if(distance_metric == "Manhattan")
+		result = fabs(d[0]) + fabs(d[1]) + fabs(d[2]);
+	if(distance_metric == "Chebychev")
+		result = max(fabs(d[0]), max(fabs(d[1]), fabs(d[2])));
+	if(distance_metric == "Minkovsky 1/2")
+		result = sqrt(fabs(d[0])) + sqrt(fabs(d[1])) + sqrt(fabs(d[1]));
+	if(distance_metric == "Minkovsky 4")
+		result = sqrt(sqrt(dot(d*d, d*d)));
+	if(distance_metric == "Minkovsky")
+		result = pow(pow(fabs(d[0]), e) + pow(fabs(d[1]), e) + pow(fabs(d[2]), e), 1.0/e);
+	
+	return result;
+}
+
+/* Voronoi / Worley like */
+
+color cellnoise_color(point p)
+{
+	float r = cellnoise(p);
+	float g = cellnoise(point(p[1], p[0], p[2]));
+	float b = cellnoise(point(p[1], p[2], p[0]));
+
+	return color(r, g, b);
+}
+
+void voronoi(point p, string distance_metric, float e, float da[4], point pa[4])
+{
+	/* returns distances in da and point coords in pa */
+	int xx, yy, zz, xi, yi, zi;
+
+	xi = (int)floor(p[0]);
+	yi = (int)floor(p[1]);
+	zi = (int)floor(p[2]);
+
+	da[0] = 1e10;
+	da[1] = 1e10;
+	da[2] = 1e10;
+	da[3] = 1e10;
+
+	for(xx = xi-1; xx <= xi+1; xx++) {
+		for(yy = yi-1; yy <= yi+1; yy++) {
+			for(zz = zi-1; zz <= zi+1; zz++) {
+				point ip = point(xx, yy, zz);
+				point vp = (point)cellnoise_color(ip);
+				point pd = p - (vp + ip);
+				float d = voronoi_distance(distance_metric, pd, e);
+
+				vp += point(xx, yy, zz);
+
+				if(d < da[0]) {
+					da[3] = da[2];
+					da[2] = da[1];
+					da[1] = da[0];
+					da[0] = d;
+
+					pa[3] = pa[2];
+					pa[2] = pa[1];
+					pa[1] = pa[0];
+					pa[0] = vp;
+				}
+				else if(d < da[1]) {
+					da[3] = da[2];
+					da[2] = da[1];
+					da[1] = d;
+
+					pa[3] = pa[2];
+					pa[2] = pa[1];
+					pa[1] = vp;
+				}
+				else if(d < da[2]) {
+					da[3] = da[2];
+					da[2] = d;
+
+					pa[3] = pa[2];
+					pa[2] = vp;
+				}
+				else if(d < da[3]) {
+					da[3] = d;
+					pa[3] = vp;
+				}
+			}
+		}
+	}
+}
+
+float voronoi_Fn(point p, int n)
+{
+	float da[4];
+	point pa[4];
+
+	voronoi(p, "Distance Squared", 0, da, pa);
+
+	return da[n];
+}
+
+float voronoi_FnFn(point p, int n1, int n2)
+{
+	float da[4];
+	point pa[4];
+
+	voronoi(p, "Distance Squared", 0, da, pa);
+
+	return da[n2] - da[n1];
+}
+
+float voronoi_F1(point p) { return voronoi_Fn(p, 0); }
+float voronoi_F2(point p) { return voronoi_Fn(p, 1); }
+float voronoi_F3(point p) { return voronoi_Fn(p, 2); }
+float voronoi_F4(point p) { return voronoi_Fn(p, 3); }
+float voronoi_F1F2(point p) { return voronoi_FnFn(p, 0, 1); }
+
+float voronoi_Cr(point p)
+{
+	/* crackle type pattern, just a scale/clamp of F2-F1 */
+	float t = 10.0*voronoi_F1F2(p);
+	return (t > 1.0)? 1.0: t;
+}
+
+float voronoi_F1S(point p) { return 2.0*voronoi_F1(p) - 1.0; }
+float voronoi_F2S(point p) { return 2.0*voronoi_F2(p) - 1.0; }
+float voronoi_F3S(point p) { return 2.0*voronoi_F3(p) - 1.0; }
+float voronoi_F4S(point p) { return 2.0*voronoi_F4(p) - 1.0; }
+float voronoi_F1F2S(point p) { return 2.0*voronoi_F1F2(p) - 1.0; }
+float voronoi_CrS(point p) { return 2.0*voronoi_Cr(p) - 1.0; }
+
+/* Noise Bases */
+
+float noise_basis(point p, string basis)
+{
+	float result = 0.0;
+
+	if(basis == "Perlin")
+		result = noise(p);
+	if(basis == "Voronoi F1")
+		result = voronoi_F1S(p);
+	if(basis == "Voronoi F2")
+		result = voronoi_F2S(p);
+	if(basis == "Voronoi F3")
+		result = voronoi_F3S(p);
+	if(basis == "Voronoi F4")
+		result = voronoi_F4S(p);
+	if(basis == "Voronoi F2-F1")
+		result = voronoi_F1F2S(p);
+	if(basis == "Voronoi Crackle")
+		result = voronoi_CrS(p);
+	if(basis == "Cell Noise")
+		result = cellnoise(p);
+	
+	return result;
+}
+
+/* Soft/Hard Noise */
+
+float noise_basis_hard(point p, string basis, int hard)
+{
+	float t = noise_basis(p, basis);
+	return (hard)? fabs(2.0*t - 1.0): t;
+}
+
+/* Waves */
+
+float noise_wave(string wave, float a)
+{
+	float result = 0.0;
+
+	if(wave == "Sine") {
+    	result = 0.5 + 0.5*sin(a);
+	}
+	else if(wave == "Saw") {
+		float b = 2*M_PI;
+		int n = (int)(a / b);
+		a -= n*b;
+		if(a < 0) a += b;
+
+		result = a / b;
+	}
+	else if(wave == "Tri") {
+		float b = 2*M_PI;
+		float rmax = 1.0;
+
+		result = rmax - 2.0*fabs(floor((a*(1.0/b))+0.5) - (a*(1.0/b)));
+	}
+
+	return result;
+}
+
+/* Turbulence */
+
+float noise_turbulence(point p, string basis, int octaves, int hard)
+{
+	float fscale = 1.0;
+	float amp = 1.0;
+	float sum = 0.0;
+	int i;
+
+	for(i = 0; i <= octaves; i++) {
+		float t = noise_basis(fscale*p, basis);
+
+		if(hard)
+			t = fabs(2.0*t - 1.0);
+
+		sum += t*amp;
+		amp *= 0.5;
+		fscale *= 2.0;
+	}
+
+	sum *= ((float)(1 << octaves)/(float)((1 << (octaves+1)) - 1));
+
+	return sum;
+}
+
+/* Utility */
+
+float nonzero(float f, float eps)
+{
+	float r;
+
+	if(abs(f) < eps)
+		r = sign(f)*eps;
+	else
+		r = f;
+	
+	return r;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl b/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl
new file mode 100644
index 00000000000..2acf72aef54
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_texture_coordinate.osl
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_texture_coordinate(
+	normal Normal = N,
+	int is_background = 0,
+	string bump_offset = "center",
+
+	output point Generated = point(0.0, 0.0, 0.0),
+	output point UV = point(0.0, 0.0, 0.0),
+	output point Object = point(0.0, 0.0, 0.0),
+	output point Camera = point(0.0, 0.0, 0.0),
+	output point Window = point(0.0, 0.0, 0.0),
+	output point Reflection = point(0.0, 0.0, 0.0))
+{
+	if(is_background) {
+		Generated = P;
+		UV = point(0.0, 0.0, 0.0);
+		Object = P;
+		point Pcam = transform("camera", "world", point(0, 0, 0));
+		Camera = transform("camera", P + Pcam);
+		Window = transform("NDC", P + Pcam);
+		Reflection = I;
+	}
+	else {
+		getattribute("std::generated", Generated); 
+		getattribute("std::uv", UV);
+		Object = transform("object", P);
+		Camera = transform("camera", P);
+		Window = transform("NDC", P);
+		Reflection = reflect(I, Normal);
+	}
+
+	if(bump_offset == "dx") {
+		Generated += Dx(Generated);
+		UV += Dx(UV);
+		Object += Dx(Object);
+		Camera += Dx(Camera);
+		Window += Dx(Window);
+	}
+	else if(bump_offset == "dy") {
+		Generated += Dy(Generated);
+		UV += Dy(UV);
+		Object += Dy(Object);
+		Camera += Dy(Camera);
+		Window += Dy(Window);
+	}
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl
new file mode 100644
index 00000000000..9acd46756d2
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_translucent_bsdf.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_translucent_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	BSDF = Color*translucent(Normal);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl
new file mode 100644
index 00000000000..b347bfb116b
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_transparent_bsdf.osl
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_transparent_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	BSDF = Color*transparent();
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_value.osl b/intern/cycles/kernel/osl/nodes/node_value.osl
new file mode 100644
index 00000000000..bee6f39f2bc
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_value.osl
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_value(
+	float value_value = 0.0,
+	vector vector_value = vector(0.0, 0.0, 0.0),
+	color color_value = color(0.0, 0.0, 0.0),
+	output float Value = 0.0,
+	output vector Vector = vector(0.0, 0.0, 0.0),
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	Value = value_value;
+	Vector = vector_value;
+	Color = color_value;
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_vector_math.osl b/intern/cycles/kernel/osl/nodes/node_vector_math.osl
new file mode 100644
index 00000000000..c6231d4350d
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_vector_math.osl
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.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),
+	output float Fac = 0.0,
+	output vector Vector = vector(0.0, 0.0, 0.0))
+{
+	if(type == "Add") {
+		Vector = Vector1 + Vector2;
+		Fac = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2]))/3.0;
+	}
+	if(type == "Subtract") {
+		Vector = Vector1 + Vector2;
+		Fac = (abs(Vector[0]) + abs(Vector[1]) + abs(Vector[2]))/3.0;
+	}
+	if(type == "Average") {
+		Fac = length(Vector1 + Vector2);
+		Vector = normalize(Vector1 + Vector2);
+	}
+	if(type == "Dot Product") {
+		Fac = dot(Vector1, Vector2);
+	}
+	if(type == "Cross Product") {
+		vector c = cross(Vector1, Vector2);
+		Fac = length(c);
+		Vector = normalize(c);
+	}
+	if(type == "Normalize") {
+		Fac = length(Vector1);
+		Vector = normalize(Vector1);
+	}
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl
new file mode 100644
index 00000000000..2b6219f6325
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_velvet_bsdf.osl
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_fresnel.h"
+
+shader node_velvet_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	float Sigma = 0.0,
+	float Fresnel = 0.3,
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	float Fr = 1.0;
+
+	if(Fresnel < 1.0) {
+		float eta = 1.0/clamp(1.0 - Fresnel, 1e-5, 1.0 - 1e-5);
+		Fr = fresnel_dielectric(I, Normal, eta);
+	}
+
+	float sigma = clamp(Sigma, 0.0, 1.0);
+
+	BSDF = (Fr*Color)*ashikhmin_velvet(Normal, sigma);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl b/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl
new file mode 100644
index 00000000000..140ba6a6ba1
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_voronoi_texture.osl
@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Voronoi */
+
+shader node_voronoi_texture(
+	string DistanceMetric = "Actual Distance",
+	string Coloring = "Intensity",
+	float Weight1 = 1.0,
+	float Weight2 = 0.0,
+	float Weight3 = 0.0,
+	float Weight4 = 0.0,
+	float Exponent = 2.5,
+	float Intensity = 1.0,
+	float Size = 0.25,
+	point Vector = P,
+	output float Fac = 0.0,
+	output color Color = color(0.0, 0.0, 0.0))
+{
+	float exponent = max(Exponent, 1e-5);
+	float size = nonzero(Size, 1e-5);
+
+	float aw1 = fabs(Weight1);
+	float aw2 = fabs(Weight2);
+	float aw3 = fabs(Weight3);
+	float aw4 = fabs(Weight4);
+	float sc = (aw1 + aw2 + aw3 + aw4);
+
+	if(sc != 0.0)
+		sc = Intensity/sc;
+	
+	/* compute distance and point coordinate of 4 nearest neighbours */
+	float da[4];
+	point pa[4];
+
+	voronoi(Vector/size, DistanceMetric, exponent, da, pa);
+
+	/* Scalar output */
+	Fac = sc * fabs(Weight1*da[0] + Weight2*da[1] + Weight3*da[2] + Weight4*da[3]);
+
+	/* Colored output */
+	if(Coloring == "Intensity") {
+		Color = color(Fac, Fac, Fac);
+	}
+	else {
+		Color = aw1*cellnoise_color(pa[0]);
+		Color += aw2*cellnoise_color(pa[1]);
+		Color += aw3*cellnoise_color(pa[2]);
+		Color += aw4*cellnoise_color(pa[3]);
+
+		if(Coloring != "Position") {
+			float t1 = min((da[1] - da[0])*10.0, 1.0);
+
+			if(Coloring == "Position, Outline, and Intensity")
+				Color *= t1*Fac;
+			else if(Coloring == "Position and Outline")
+				Color *= t1*sc;
+		}
+		else {
+			Color *= sc;
+		}
+	}
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl b/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl
new file mode 100644
index 00000000000..68db07109ed
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_ward_bsdf.osl
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+
+shader node_ward_bsdf(
+	color Color = color(0.8, 0.8, 0.8),
+	float RoughnessU = 0.0,
+	float RoughnessV = 0.0,
+	normal Normal = N,
+	output closure color BSDF = diffuse(Normal))
+{
+	BSDF = Color*ward(Normal, normalize(dPdu), RoughnessU, RoughnessV);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_wood_texture.osl b/intern/cycles/kernel/osl/nodes/node_wood_texture.osl
new file mode 100644
index 00000000000..f1d2e278597
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/node_wood_texture.osl
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+#include "stdosl.h"
+#include "node_texture.h"
+
+/* Wood */
+
+float wood(point p, float size, string type, string wave, string basis, int hard, float turb)
+{
+	float x = p[0];
+	float y = p[1];
+	float z = p[2];
+
+	float result = 0.0;
+
+	if(type == "Bands") {
+		result = noise_wave(wave, (x + y + z)*10.0);
+	}
+	else if(type == "Rings") {
+		result = noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0);
+	}
+	else if (type == "Band Noise") {
+		float wi = turb*noise_basis_hard(p/size, basis, hard);
+		result = noise_wave(wave, (x + y + z)*10.0 + wi);
+	}
+	else if (type == "Ring Noise") {
+		float wi = turb*noise_basis_hard(p/size, basis, hard);
+		result = noise_wave(wave, sqrt(x*x + y*y + z*z)*20.0 + wi);
+	}
+
+	return result;
+}
+
+shader node_wood_texture(
+	string Type = "Bands",
+	string Wave = "Sine",
+	string Basis = "Perlin",
+	int Hard = 0,
+	float Size = 0.25,
+	float Turbulence = 5.0,
+	point Vector = P,
+	output float Fac = 0.0)
+{
+	float size = nonzero(Size, 1e-5);
+	Fac = wood(Vector, size, Type, Wave, Basis, Hard, Turbulence);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/stdosl.h b/intern/cycles/kernel/osl/nodes/stdosl.h
new file mode 100644
index 00000000000..6fe4f52df4a
--- /dev/null
+++ b/intern/cycles/kernel/osl/nodes/stdosl.h
@@ -0,0 +1,471 @@
+/////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.  All Rights Reserved.
+//
+// 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.
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef CCL_STDOSL_H
+#define CCL_STDOSL_H
+
+
+#ifndef M_PI
+#define M_PI       3.1415926535897932        /* pi */
+#define M_PI_2     1.5707963267948966        /* pi/2 */
+#define M_PI_4     0.7853981633974483        /* pi/4 */
+#define M_2_PI     0.6366197723675813        /* 2/pi */
+#define M_2_SQRTPI 1.1283791670955126        /* 2/sqrt(pi) */
+#define M_E        2.7182818284590452        /* e (Euler's number) */
+#define M_LN2      0.6931471805599453        /* ln(2) */
+#define M_LN10     2.3025850929940457        /* ln(10) */
+#define M_LOG2E    1.4426950408889634        /* log_2(e) */
+#define M_LOG10E   0.4342944819032518        /* log_10(e) */
+#define M_SQRT2    1.4142135623730950        /* sqrt(2) */
+#define M_SQRT1_2  0.7071067811865475        /* 1/sqrt(2) */
+#endif
+
+
+
+// Declaration of built-in functions and closures
+#define BUILTIN [[ int builtin = 1 ]]
+#define BUILTIN_DERIV [[ int builtin = 1, int deriv = 1 ]]
+
+#define PERCOMP1(name)                          \
+    normal name (normal x) BUILTIN;             \
+    vector name (vector x) BUILTIN;             \
+    point  name (point x) BUILTIN;              \
+    color  name (color x) BUILTIN;              \
+    float  name (float x) BUILTIN;
+
+#define PERCOMP2(name)                          \
+    normal name (normal x, normal y) BUILTIN;   \
+    vector name (vector x, vector y) BUILTIN;   \
+    point  name (point x, point y) BUILTIN;     \
+    color  name (color x, color y) BUILTIN;     \
+    float  name (float x, float y) BUILTIN;
+
+#define PERCOMP2F(name)                         \
+    normal name (normal x, float y) BUILTIN;    \
+    vector name (vector x, float y) BUILTIN;    \
+    point  name (point x, float y) BUILTIN;     \
+    color  name (color x, float y) BUILTIN;     \
+    float  name (float x, float y) BUILTIN;
+
+
+// Basic math
+normal degrees (normal x) { return x*(180.0/M_PI); }
+vector degrees (vector x) { return x*(180.0/M_PI); }
+point  degrees (point x)  { return x*(180.0/M_PI); }
+color  degrees (color x)  { return x*(180.0/M_PI); }
+float  degrees (float x)  { return x*(180.0/M_PI); }
+normal radians (normal x) { return x*(M_PI/180.0); }
+vector radians (vector x) { return x*(M_PI/180.0); }
+point  radians (point x)  { return x*(M_PI/180.0); }
+color  radians (color x)  { return x*(M_PI/180.0); }
+float  radians (float x)  { return x*(M_PI/180.0); }
+PERCOMP1 (cos)
+PERCOMP1 (sin)
+PERCOMP1 (tan)
+PERCOMP1 (acos)
+PERCOMP1 (asin)
+PERCOMP1 (atan)
+PERCOMP2 (atan2)
+PERCOMP1 (cosh)
+PERCOMP1 (sinh)
+PERCOMP1 (tanh)
+PERCOMP2F (pow)
+PERCOMP1 (exp)
+PERCOMP1 (exp2)
+PERCOMP1 (expm1)
+PERCOMP1 (log)
+point  log (point a,  float b) { return log(a)/log(b); }
+vector log (vector a, float b) { return log(a)/log(b); }
+color  log (color a,  float b) { return log(a)/log(b); }
+float  log (float a,  float b) { return log(a)/log(b); }
+PERCOMP1 (log2)
+PERCOMP1 (log10)
+PERCOMP1 (logb)
+PERCOMP1 (sqrt)
+PERCOMP1 (inversesqrt)
+float hypot (float a, float b) { return sqrt (a*a + b*b); }
+float hypot (float a, float b, float c) { return sqrt (a*a + b*b + c*c); }
+PERCOMP1 (abs)
+int abs (int x) BUILTIN;
+PERCOMP1 (fabs)
+int fabs (int x) BUILTIN;
+PERCOMP1 (sign)
+PERCOMP1 (floor)
+PERCOMP1 (ceil)
+PERCOMP1 (round)
+PERCOMP1 (trunc)
+PERCOMP2 (fmod)
+PERCOMP2F (fmod)
+PERCOMP2 (mod)
+PERCOMP2F (mod)
+int    mod (int x, int y) BUILTIN;
+PERCOMP2 (min)
+PERCOMP2 (max)
+normal clamp (normal x, normal minval, normal maxval) { return max(min(x,maxval),minval); }
+vector clamp (vector x, vector minval, vector maxval) { return max(min(x,maxval),minval); }
+point  clamp (point x, point minval, point maxval) { return max(min(x,maxval),minval); }
+color  clamp (color x, color minval, color maxval) { return max(min(x,maxval),minval); }
+float  clamp (float x, float minval, float maxval) { return max(min(x,maxval),minval); }
+//normal clamp (normal x, normal minval, normal maxval) BUILTIN;
+//vector clamp (vector x, vector minval, vector maxval) BUILTIN;
+//point  clamp (point x, point minval, point maxval) BUILTIN;
+//color  clamp (color x, color minval, color maxval) BUILTIN;
+//float  clamp (float x, float minval, float maxval) BUILTIN;
+normal mix (normal x, normal y, normal a) { return x*(1-a) + y*a; }
+normal mix (normal x, normal y, float  a) { return x*(1-a) + y*a; }
+vector mix (vector x, vector y, vector a) { return x*(1-a) + y*a; }
+vector mix (vector x, vector y, float  a) { return x*(1-a) + y*a; }
+point  mix (point  x, point  y, point  a) { return x*(1-a) + y*a; }
+point  mix (point  x, point  y, float  a) { return x*(1-a) + y*a; }
+color  mix (color  x, color  y, color  a) { return x*(1-a) + y*a; }
+color  mix (color  x, color  y, float  a) { return x*(1-a) + y*a; }
+float  mix (float  x, float  y, float  a) { return x*(1-a) + y*a; }
+int isnan (float x) BUILTIN;
+int isinf (float x) BUILTIN;
+int isfinite (float x) BUILTIN;
+float erf (float x) BUILTIN;
+float erfc (float x) BUILTIN;
+
+// Vector functions
+
+vector cross (vector a, vector b) BUILTIN;
+float dot (vector a, vector b) BUILTIN;
+float length (vector v) BUILTIN;
+float distance (point a, point b) BUILTIN;
+float distance (point a, point b, point q) BUILTIN;
+normal normalize (normal v) BUILTIN;
+vector normalize (vector v) BUILTIN;
+vector faceforward (vector N, vector I, vector Nref) BUILTIN;
+vector faceforward (vector N, vector I) BUILTIN;
+vector reflect (vector I, vector N) { return I - 2*dot(N,I)*N; }
+vector refract (vector I, vector N, float eta) {
+    float IdotN = dot (I, N);
+    float k = 1 - eta*eta * (1 - IdotN*IdotN);
+    return (k < 0) ? vector(0,0,0) : (eta*I - N * (eta*IdotN + sqrt(k)));
+}
+void fresnel (vector I, normal N, float eta,
+              output float Kr, output float Kt,
+              output vector R, output vector T)
+{
+    float sqr(float x) { return x*x; }
+    float c = dot(I, N);
+    if (c < 0)
+        c = -c;
+    R = reflect(I, N);
+    float g = 1.0 / sqr(eta) - 1.0 + c * c;
+    if (g >= 0.0) {
+        g = sqrt (g);
+        float beta = g - c;
+        float F = (c * (g+c) - 1.0) / (c * beta + 1.0);
+        F = 0.5 * (1.0 + sqr(F));
+        F *= sqr (beta / (g+c));
+        Kr = F;
+        Kt = (1.0 - Kr) * eta*eta;
+        // OPT: the following recomputes some of the above values, but it 
+        // gives us the same result as if the shader-writer called refract()
+        T = refract(I, N, eta);
+    } else {
+        // total internal reflection
+        Kr = 1.0;
+        Kt = 0.0;
+        T = vector (0,0,0);
+    }
+#undef sqr
+}
+
+void fresnel (vector I, normal N, float eta,
+              output float Kr, output float Kt)
+{
+    vector R, T;
+    fresnel(I, N, eta, Kr, Kt, R, T);
+}
+
+point rotate (point q, float angle, point a, point b) BUILTIN;
+
+normal transform (matrix Mto, normal p) BUILTIN;
+vector transform (matrix Mto, vector p) BUILTIN;
+point transform (matrix Mto, point p) BUILTIN;
+
+// Implementation of transform-with-named-space in terms of matrices:
+
+point transform (string tospace, point x)
+{
+    return transform (matrix ("common", tospace), x);
+}
+
+point transform (string fromspace, string tospace, point x)
+{
+    return transform (matrix (fromspace, tospace), x);
+}
+
+
+vector transform (string tospace, vector x)
+{
+    return transform (matrix ("common", tospace), x);
+}
+
+vector transform (string fromspace, string tospace, vector x)
+{
+    return transform (matrix (fromspace, tospace), x);
+}
+
+
+normal transform (string tospace, normal x)
+{
+    return transform (matrix ("common", tospace), x);
+}
+
+normal transform (string fromspace, string tospace, normal x)
+{
+    return transform (matrix (fromspace, tospace), x);
+}
+
+float transformu (string tounits, float x) BUILTIN;
+float transformu (string fromunits, string tounits, float x) BUILTIN;
+
+
+// Color functions
+
+float luminance (color c) {
+    return dot ((vector)c, vector(0.2126, 0.7152, 0.0722));
+}
+
+
+
+color transformc (string to, color x)
+{
+    color rgb_to_hsv (color rgb) {  // See Foley & van Dam
+        float r = rgb[0], g = rgb[1], b = rgb[2];
+        float mincomp = min (r, min (g, b));
+        float maxcomp = max (r, max (g, b));
+        float delta = maxcomp - mincomp;  // chroma
+        float h, s, v;
+        v = maxcomp;
+        if (maxcomp > 0)
+            s = delta / maxcomp;
+        else s = 0;
+        if (s <= 0)
+            h = 0;
+        else {
+            if      (r >= maxcomp) h = (g-b) / delta;
+            else if (g >= maxcomp) h = 2 + (b-r) / delta;
+            else                   h = 4 + (r-g) / delta;
+            h /= 6;
+            if (h < 0)
+                h += 1;
+        }
+        return color (h, s, v);
+    }
+
+    color rgb_to_hsl (color rgb) {  // See Foley & van Dam
+        // First convert rgb to hsv, then to hsl
+        float minval = min (rgb[0], min (rgb[1], rgb[2]));
+        color hsv = rgb_to_hsv (rgb);
+        float maxval = hsv[2];   // v == maxval
+        float h = hsv[0], s, l = (minval+maxval) / 2;
+        if (minval == maxval)
+            s = 0;  // special 'achromatic' case, hue is 0
+        else if (l <= 0.5)
+            s = (maxval - minval) / (maxval + minval);
+        else
+            s = (maxval - minval) / (2 - maxval - minval);
+        return color (h, s, l);
+    }
+
+    color r;
+    if (to == "rgb" || to == "RGB")
+        r = x;
+    else if (to == "hsv")
+        r = rgb_to_hsv (x);
+    else if (to == "hsl")
+        r = rgb_to_hsl (x);
+    else if (to == "YIQ")
+        r = color (dot (vector(0.299,  0.587,  0.114), (vector)x),
+                   dot (vector(0.596, -0.275, -0.321), (vector)x),
+                   dot (vector(0.212, -0.523,  0.311), (vector)x));
+    else if (to == "xyz")
+        r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x),
+                   dot (vector(0.212671, 0.715160, 0.072169), (vector)x),
+                   dot (vector(0.019334, 0.119193, 0.950227), (vector)x));
+    else {
+        error ("Unknown color space \"%s\"", to);
+        r = x;
+    }
+    return r;
+}
+
+
+color transformc (string from, string to, color x)
+{
+    color hsv_to_rgb (color c) { // Reference: Foley & van Dam
+        float h = c[0], s = c[1], v = c[2];
+        color r;
+        if (s < 0.0001) {
+            r = v;
+        } else {
+            h = 6 * (h - floor(h));  // expand to [0..6)
+            int hi = (int)h;
+            float f = h - hi;
+            float p = v * (1-s);
+            float q = v * (1-s*f);
+            float t = v * (1-s*(1-f));
+            if      (hi == 0) r = color (v, t, p);
+            else if (hi == 1) r = color (q, v, p);
+            else if (hi == 2) r = color (p, v, t);
+            else if (hi == 3) r = color (p, q, v);
+            else if (hi == 4) r = color (t, p, v);
+            else              r = color (v, p, q);
+        }
+        return r;
+    }
+
+    color hsl_to_rgb (color c) {
+        float h = c[0], s = c[1], l = c[2];
+        // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
+        float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
+        color r;
+        if (v <= 0) {
+            r = 0;
+        } else {
+            float min = 2 * l - v;
+            s = (v - min) / v;
+            r = hsv_to_rgb (color (h, s, v));
+        }
+        return r;
+    }
+
+    color r;
+    if (from == "rgb" || from == "RGB")
+        r = x;
+    else if (from == "hsv")
+        r = hsv_to_rgb (x);
+    else if (from == "hsl")
+        r = hsl_to_rgb (x);
+    else if (from == "YIQ")
+        r = color (dot (vector(1,  0.9557,  0.6199), (vector)x),
+                   dot (vector(1, -0.2716, -0.6469), (vector)x),
+                   dot (vector(1, -1.1082,  1.7051), (vector)x));
+    else if (from == "xyz")
+        r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x),
+                   dot (vector(-0.969256,  1.875991,  0.041556), (vector)x),
+                   dot (vector( 0.055648, -0.204043,  1.057311), (vector)x));
+    else {
+        error ("Unknown color space \"%s\"", to);
+        r = x;
+    }
+    return transformc (to, r);
+}
+
+ 
+
+// Matrix functions
+
+float determinant (matrix m) BUILTIN;
+matrix transpose (matrix m) BUILTIN;
+
+
+
+// Pattern generation
+
+float step (float edge, float x) BUILTIN;
+color step (color edge, color x) BUILTIN;
+point step (point edge, point x) BUILTIN;
+vector step (vector edge, vector x) BUILTIN;
+normal step (normal edge, normal x) BUILTIN;
+float smoothstep (float edge0, float edge1, float x) BUILTIN;
+
+
+// Derivatives and area operators
+
+
+// Displacement functions
+
+
+// String functions
+
+int strlen (string s) BUILTIN;
+int startswith (string s, string prefix) BUILTIN;
+int endswith (string s, string suffix) BUILTIN;
+string substr (string s, int start, int len) BUILTIN;
+string substr (string s, int start) { return substr (s, start, strlen(s)); }
+
+// Define concat in terms of shorter concat
+string concat (string a, string b, string c) {
+    return concat(concat(a,b), c);
+}
+string concat (string a, string b, string c, string d) {
+    return concat(concat(a,b,c), d);
+}
+string concat (string a, string b, string c, string d, string e) {
+    return concat(concat(a,b,c,d), e);
+}
+string concat (string a, string b, string c, string d, string e, string f) {
+    return concat(concat(a,b,c,d,e), f);
+}
+
+
+// Texture
+
+
+// Closures
+
+closure color diffuse(normal N) BUILTIN;
+closure color translucent(normal N) BUILTIN;
+closure color reflection(normal N, float eta) BUILTIN;
+closure color reflection(normal N) { return reflection (N, 0.0); }
+closure color refraction(normal N, float eta) BUILTIN;
+closure color dielectric(normal N, float eta) BUILTIN;
+closure color transparent() BUILTIN;
+closure color microfacet_ggx(normal N, float ag) BUILTIN;
+closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
+closure color microfacet_beckmann(normal N, float ab) BUILTIN;
+closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
+closure color ward(normal N, vector T,float ax, float ay) BUILTIN;
+closure color ashikhmin_velvet(normal N, float sigma) BUILTIN;
+closure color westin_backscatter(normal N, float roughness) BUILTIN;
+closure color westin_sheen(normal N, float edginess) BUILTIN;
+closure color bssrdf_cubic(color radius) BUILTIN;
+closure color emission(float inner_angle, float outer_angle) BUILTIN;
+closure color emission(float outer_angle) BUILTIN;
+closure color emission() BUILTIN;
+closure color debug(string tag) BUILTIN;
+closure color background() BUILTIN;
+closure color holdout() BUILTIN;
+closure color subsurface(float eta, float g, float mfp, float albedo) BUILTIN;
+
+// Renderer state
+int raytype (string typename) BUILTIN;
+
+#undef BUILTIN
+#undef BUILTIN_DERIV
+#undef PERCOMP1
+#undef PERCOMP2
+#undef PERCOMP2F
+
+#endif /* CCL_STDOSL_H */
+