Fix cycles OSL missing support for texture mapping paramaters found in texture

properties tab.

17 files changed, 159 insertions, 35 deletions

diff --git a/intern/cycles/kernel/shaders/node_brick_texture.osl b/intern/cycles/kernel/shaders/node_brick_texture.osl
index 478d9457001..b1f2a35789f 100644
--- a/intern/cycles/kernel/shaders/node_brick_texture.osl
+++ b/intern/cycles/kernel/shaders/node_brick_texture.osl
@@ -58,6 +58,8 @@ float brick(point p, float mortar_size, float bias,
 }
 
 shader node_brick_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	float Offset = 0.5,
 	int OffsetFrequency = 2,
 	float Squash = 1.0,
@@ -74,10 +76,15 @@ shader node_brick_texture(
 	output float Fac = 0.0,
 	output color Color = color(0.2, 0.2, 0.2))
 {
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
 	float tint = 0.0;
 	color Col = Color1;
 	
-	Fac = brick(Vector * Scale, MortarSize, Bias, BrickWidth, RowHeight,
+	Fac = brick(p * Scale, MortarSize, Bias, BrickWidth, RowHeight,
 		Offset, OffsetFrequency, Squash, SquashFrequency, tint);
 		
 	if (Fac != 1.0) {
diff --git a/intern/cycles/kernel/shaders/node_checker_texture.osl b/intern/cycles/kernel/shaders/node_checker_texture.osl
index 577caf308ff..eed56f4453a 100644
--- a/intern/cycles/kernel/shaders/node_checker_texture.osl
+++ b/intern/cycles/kernel/shaders/node_checker_texture.osl
@@ -40,6 +40,8 @@ float checker(point p)
 }
 
 shader node_checker_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	float Scale = 5.0,
 	point Vector = P,
 	color Color1 = color(0.8, 0.8, 0.8),
@@ -47,7 +49,12 @@ shader node_checker_texture(
 	output float Fac = 0.0,
 	output color Color = color(0.0, 0.0, 0.0))
 {
-	Fac = checker(Vector * Scale);
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
+	Fac = checker(p * Scale);
 	if (Fac == 1.0) {
 		Color = Color1;
 	}
diff --git a/intern/cycles/kernel/shaders/node_environment_texture.osl b/intern/cycles/kernel/shaders/node_environment_texture.osl
index a177f0ad1ad..90c7ce475ae 100644
--- a/intern/cycles/kernel/shaders/node_environment_texture.osl
+++ b/intern/cycles/kernel/shaders/node_environment_texture.osl
@@ -40,6 +40,8 @@ vector environment_texture_direction_to_mirrorball(vector dir) {
 }
 
 shader node_environment_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	vector Vector = P,
 	string filename = "",
 	string projection = "Equirectangular",
@@ -47,16 +49,20 @@ shader node_environment_texture(
 	output color Color = color(0.0, 0.0, 0.0),
 	output float Alpha = 1.0)
 {
-	vector Vec = normalize(Vector);
+	vector p = Vector;
 
-	if (projection == "Equirectangular") {
-		Vec = environment_texture_direction_to_equirectangular(Vec);
-	}
-	else {
-		Vec = environment_texture_direction_to_mirrorball(Vec);
-	}
+	if (use_mapping)
+		p = transform(mapping, p);
+	
+	p = normalize(p);
 
-	Color = (color)texture(filename, Vec[0], 1.0 - Vec[1], "wrap", "periodic", "alpha", Alpha);
+	if (projection == "Equirectangular")
+		p = environment_texture_direction_to_equirectangular(p);
+	else
+		p = environment_texture_direction_to_mirrorball(p);
+
+	/* todo: use environment for better texture filtering of equirectangular */
+	Color = (color)texture(filename, p[0], 1.0 - p[1], "wrap", "periodic", "alpha", Alpha);
 
 	if (color_space == "sRGB")
 		Color = color_srgb_to_scene_linear(Color);
diff --git a/intern/cycles/kernel/shaders/node_gradient_texture.osl b/intern/cycles/kernel/shaders/node_gradient_texture.osl
index ae7cfa51f59..8d862dbad67 100644
--- a/intern/cycles/kernel/shaders/node_gradient_texture.osl
+++ b/intern/cycles/kernel/shaders/node_gradient_texture.osl
@@ -63,12 +63,19 @@ float gradient(point p, string type)
 }
 
 shader node_gradient_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	string Type = "Linear",
 	point Vector = P,
 	output float Fac = 0.0,
 	output color Color = color(0.0, 0.0, 0.0))
 {
-	Fac = gradient(Vector, Type);
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
+	Fac = gradient(p, Type);
 	Color = color(Fac, Fac, Fac);
 }
 
diff --git a/intern/cycles/kernel/shaders/node_image_texture.osl b/intern/cycles/kernel/shaders/node_image_texture.osl
index 6393605e6b5..53c4aeaeb5f 100644
--- a/intern/cycles/kernel/shaders/node_image_texture.osl
+++ b/intern/cycles/kernel/shaders/node_image_texture.osl
@@ -30,6 +30,8 @@ color image_texture_lookup(string filename, string color_space, float u, float v
 }
 
 shader node_image_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	point Vector = P,
 	string filename = "",
 	string color_space = "sRGB",
@@ -38,8 +40,13 @@ shader node_image_texture(
 	output color Color = color(0.0, 0.0, 0.0),
 	output float Alpha = 1.0)
 {
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
 	if (projection == "Flat") {
-		Color = image_texture_lookup(filename, color_space, Vector[0], Vector[1], Alpha);
+		Color = image_texture_lookup(filename, color_space, p[0], p[1], Alpha);
 	}
 	else if (projection == "Box") {
 		/* object space normal */
@@ -104,15 +111,15 @@ shader node_image_texture(
 		float tmp_alpha;
 
 		if (weight[0] > 0.0) {
-			Color += weight[0]*image_texture_lookup(filename, color_space, Vector[1], Vector[2], tmp_alpha);
+			Color += weight[0]*image_texture_lookup(filename, color_space, p[1], p[2], tmp_alpha);
 			Alpha += weight[0]*tmp_alpha;
 		}
 		if (weight[1] > 0.0) {
-			Color += weight[1]*image_texture_lookup(filename, color_space, Vector[0], Vector[2], tmp_alpha);
+			Color += weight[1]*image_texture_lookup(filename, color_space, p[0], p[2], tmp_alpha);
 			Alpha += weight[1]*tmp_alpha;
 		}
 		if (weight[2] > 0.0) {
-			Color += weight[2]*image_texture_lookup(filename, color_space, Vector[1], Vector[0], tmp_alpha);
+			Color += weight[2]*image_texture_lookup(filename, color_space, p[1], p[0], tmp_alpha);
 			Alpha += weight[2]*tmp_alpha;
 		}
 	}
diff --git a/intern/cycles/kernel/shaders/node_magic_texture.osl b/intern/cycles/kernel/shaders/node_magic_texture.osl
index e464b83bc9e..b81a30499b2 100644
--- a/intern/cycles/kernel/shaders/node_magic_texture.osl
+++ b/intern/cycles/kernel/shaders/node_magic_texture.osl
@@ -93,12 +93,19 @@ color magic(point p, int n, float distortion)
 }
 
 shader node_magic_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	int Depth = 2,
 	float Distortion = 5.0,
 	float Scale = 5.0,
 	point Vector = P,
 	output color Color = color(0.0, 0.0, 0.0))
 {
-	Color = magic(Vector * Scale, Depth, Distortion);
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
+	Color = magic(p * Scale, Depth, Distortion);
 }
 
diff --git a/intern/cycles/kernel/shaders/node_musgrave_texture.osl b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
index 71461b8fd79..afdbca27a3f 100644
--- a/intern/cycles/kernel/shaders/node_musgrave_texture.osl
+++ b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
@@ -187,6 +187,8 @@ float noise_musgrave_ridged_multi_fractal(point p, string basis, float H,
 /* Shader */
 
 shader node_musgrave_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	string Type = "fBM",
 	float Dimension = 2.0,
 	float Lacunarity = 1.0,
@@ -204,7 +206,12 @@ shader node_musgrave_texture(
 	string Basis = "Perlin";
 	float intensity = 1.0;
 
-	point p = Vector * Scale;
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
+	p = p * Scale;
 
 	if (Type == "Multifractal")
 		Fac = intensity * noise_musgrave_multi_fractal(p, Basis, dimension, lacunarity, octaves);
diff --git a/intern/cycles/kernel/shaders/node_noise_texture.osl b/intern/cycles/kernel/shaders/node_noise_texture.osl
index 227b2bf8cea..0a379491781 100644
--- a/intern/cycles/kernel/shaders/node_noise_texture.osl
+++ b/intern/cycles/kernel/shaders/node_noise_texture.osl
@@ -43,6 +43,8 @@ float noise(point p, string basis, float distortion, float detail, float fac, co
 }
 
 shader node_noise_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	float Distortion = 0.0,
 	float Scale = 5.0,
 	float Detail = 2.0,
@@ -50,7 +52,12 @@ shader node_noise_texture(
 	output float Fac = 0.0,
 	output color Color = color(0.2, 0.2, 0.2))
 {
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
 	string Basis = "Perlin";
-	Fac = noise(Vector * Scale, Basis, Distortion, Detail, Fac, Color);
+	Fac = noise(p * Scale, Basis, Distortion, Detail, Fac, Color);
 }
 
diff --git a/intern/cycles/kernel/shaders/node_sky_texture.osl b/intern/cycles/kernel/shaders/node_sky_texture.osl
index 98986ba1d65..24a63c78458 100644
--- a/intern/cycles/kernel/shaders/node_sky_texture.osl
+++ b/intern/cycles/kernel/shaders/node_sky_texture.osl
@@ -149,14 +149,21 @@ void precompute_sunsky(vector dir, float turbidity, output KernelSunSky sunsky)
 }
 
 shader node_sky_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	vector Vector = P,
 	vector sun_direction = vector(0, 0, 1),
 	float turbidity = 2.2,
 	output color Color = color(0.0, 0.0, 0.0))
 {
+	vector p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
 	KernelSunSky sunsky;
 
 	precompute_sunsky(sun_direction, turbidity, sunsky);
-	Color = sky_xyz_radiance(sunsky, Vector);
+	Color = sky_xyz_radiance(sunsky, p);
 }
 
diff --git a/intern/cycles/kernel/shaders/node_voronoi_texture.osl b/intern/cycles/kernel/shaders/node_voronoi_texture.osl
index a44df00a267..43f8ecc666a 100644
--- a/intern/cycles/kernel/shaders/node_voronoi_texture.osl
+++ b/intern/cycles/kernel/shaders/node_voronoi_texture.osl
@@ -22,17 +22,24 @@
 /* Voronoi */
 
 shader node_voronoi_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	string Coloring = "Intensity",
 	float Scale = 5.0,
 	point Vector = P,
 	output float Fac = 0.0,
 	output color Color = color(0.0, 0.0, 0.0))
 {
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
 	/* compute distance and point coordinate of 4 nearest neighbours */
 	float da[4];
 	point pa[4];
 
-	voronoi(Vector * Scale, "Distance Squared", 1.0, da, pa);
+	voronoi(p * Scale, "Distance Squared", 1.0, da, pa);
 
 	/* Colored output */
 	if (Coloring == "Intensity") {
diff --git a/intern/cycles/kernel/shaders/node_wave_texture.osl b/intern/cycles/kernel/shaders/node_wave_texture.osl
index 79b8a8885d1..6648cd06278 100644
--- a/intern/cycles/kernel/shaders/node_wave_texture.osl
+++ b/intern/cycles/kernel/shaders/node_wave_texture.osl
@@ -46,6 +46,8 @@ float wave(point p, float scale, string type, float detail, float distortion, fl
 }
 
 shader node_wave_texture(
+	int use_mapping = 0,
+	matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 	string Type = "Bands",
 	float Scale = 5.0,
 	float Distortion = 0.0,
@@ -55,7 +57,12 @@ shader node_wave_texture(
 	output float Fac = 0.0,
 	output color Color = color (0.0, 0.0, 0.0))
 {
-	Fac = wave(Vector, Scale, Type, Detail, Distortion, DetailScale);
+	point p = Vector;
+
+	if (use_mapping)
+		p = transform(mapping, p);
+
+	Fac = wave(p, Scale, Type, Detail, Distortion, DetailScale);
 	Color = color(Fac, Fac, Fac);
 }
 
diff --git a/intern/cycles/render/image.cpp b/intern/cycles/render/image.cpp
index f136f08dc2c..93c9e761f28 100644
--- a/intern/cycles/render/image.cpp
+++ b/intern/cycles/render/image.cpp
@@ -67,7 +67,7 @@ void ImageManager::set_extended_image_limits(void)
 	tex_image_byte_start = TEX_EXTENDED_IMAGE_BYTE_START;
 }
 
-static bool is_float_image(const string& filename)
+bool ImageManager::is_float_image(const string& filename)
 {
 	ImageInput *in = ImageInput::create(filename);
 	bool is_float = false;
diff --git a/intern/cycles/render/image.h b/intern/cycles/render/image.h
index 485bfc5cbf5..584448647d6 100644
--- a/intern/cycles/render/image.h
+++ b/intern/cycles/render/image.h
@@ -53,6 +53,7 @@ public:
 
 	int add_image(const string& filename, bool& is_float);
 	void remove_image(const string& filename);
+	bool is_float_image(const string& filename);
 
 	void device_update(Device *device, DeviceScene *dscene, Progress& progress);
 	void device_free(Device *device, DeviceScene *dscene);
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index fa90a9a09ff..b297e6ea38c 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -100,6 +100,16 @@ void TextureMapping::compile(SVMCompiler& compiler, int offset_in, int offset_ou
 	}
 }
 
+void TextureMapping::compile(OSLCompiler &compiler)
+{
+	if(!skip()) {
+		Transform tfm = transform_transpose(compute_transform());
+
+		compiler.parameter("mapping", tfm);
+		compiler.parameter("use_mapping", 1);
+	}
+}
+
 /* Image Texture */
 
 static ShaderEnum color_space_init()
@@ -130,7 +140,7 @@ ImageTextureNode::ImageTextureNode()
 {
 	image_manager = NULL;
 	slot = -1;
-	is_float = false;
+	is_float = -1;
 	filename = "";
 	color_space = ustring("Color");
 	projection = ustring("Flat");;
@@ -152,7 +162,7 @@ ShaderNode *ImageTextureNode::clone() const
 	ImageTextureNode *node = new ImageTextureNode(*this);
 	node->image_manager = NULL;
 	node->slot = -1;
-	node->is_float = false;
+	node->is_float = -1;
 	return node;
 }
 
@@ -163,8 +173,11 @@ void ImageTextureNode::compile(SVMCompiler& compiler)
 	ShaderOutput *alpha_out = output("Alpha");
 
 	image_manager = compiler.image_manager;
-	if(slot == -1)
-		slot = image_manager->add_image(filename, is_float);
+	if(is_float == -1) {
+		bool is_float_bool;
+		slot = image_manager->add_image(filename, is_float_bool);
+		is_float = (int)is_float_bool;
+	}
 
 	if(!color_out->links.empty())
 		compiler.stack_assign(color_out);
@@ -220,6 +233,11 @@ void ImageTextureNode::compile(SVMCompiler& compiler)
 
 void ImageTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
+	if(is_float == -1)
+		is_float = (int)image_manager->is_float_image(filename);
+
 	compiler.parameter("filename", filename.c_str());
 	if(is_float || color_space != "Color")
 		compiler.parameter("color_space", "Linear");
@@ -250,7 +268,7 @@ EnvironmentTextureNode::EnvironmentTextureNode()
 {
 	image_manager = NULL;
 	slot = -1;
-	is_float = false;
+	is_float = -1;
 	filename = "";
 	color_space = ustring("Color");
 	projection = ustring("Equirectangular");
@@ -271,7 +289,7 @@ ShaderNode *EnvironmentTextureNode::clone() const
 	EnvironmentTextureNode *node = new EnvironmentTextureNode(*this);
 	node->image_manager = NULL;
 	node->slot = -1;
-	node->is_float = false;
+	node->is_float = -1;
 	return node;
 }
 
@@ -282,8 +300,11 @@ void EnvironmentTextureNode::compile(SVMCompiler& compiler)
 	ShaderOutput *alpha_out = output("Alpha");
 
 	image_manager = compiler.image_manager;
-	if(slot == -1)
-		slot = image_manager->add_image(filename, is_float);
+	if(slot == -1) {
+		bool is_float_bool;
+		slot = image_manager->add_image(filename, is_float_bool);
+		is_float = (int)is_float_bool;
+	}
 
 	if(!color_out->links.empty())
 		compiler.stack_assign(color_out);
@@ -328,6 +349,11 @@ void EnvironmentTextureNode::compile(SVMCompiler& compiler)
 
 void EnvironmentTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
+	if(is_float == -1)
+		is_float = (int)image_manager->is_float_image(filename);
+
 	compiler.parameter("filename", filename.c_str());
 	compiler.parameter("projection", projection);
 	if(is_float || color_space != "Color")
@@ -439,6 +465,8 @@ void SkyTextureNode::compile(SVMCompiler& compiler)
 
 void SkyTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter_vector("sun_direction", sun_direction);
 	compiler.parameter("turbidity", turbidity);
 	compiler.add(this, "node_sky_texture");
@@ -502,6 +530,8 @@ void GradientTextureNode::compile(SVMCompiler& compiler)
 
 void GradientTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Type", type);
 	compiler.add(this, "node_gradient_texture");
 }
@@ -560,6 +590,8 @@ void NoiseTextureNode::compile(SVMCompiler& compiler)
 
 void NoiseTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.add(this, "node_noise_texture");
 }
 
@@ -620,6 +652,8 @@ void VoronoiTextureNode::compile(SVMCompiler& compiler)
 
 void VoronoiTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Coloring", coloring);
 	compiler.add(this, "node_voronoi_texture");
 }
@@ -707,6 +741,8 @@ void MusgraveTextureNode::compile(SVMCompiler& compiler)
 
 void MusgraveTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Type", type);
 
 	compiler.add(this, "node_musgrave_texture");
@@ -785,6 +821,8 @@ void WaveTextureNode::compile(SVMCompiler& compiler)
 
 void WaveTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Type", type);
 
 	compiler.add(this, "node_wave_texture");
@@ -842,6 +880,8 @@ void MagicTextureNode::compile(SVMCompiler& compiler)
 
 void MagicTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Depth", depth);
 	compiler.add(this, "node_magic_texture");
 }
@@ -898,6 +938,8 @@ void CheckerTextureNode::compile(SVMCompiler& compiler)
 
 void CheckerTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.add(this, "node_checker_texture");
 }
 
@@ -986,6 +1028,8 @@ void BrickTextureNode::compile(SVMCompiler& compiler)
 
 void BrickTextureNode::compile(OSLCompiler& compiler)
 {
+	tex_mapping.compile(compiler);
+
 	compiler.parameter("Offset", offset);
 	compiler.parameter("OffsetFrequency", offset_frequency);
 	compiler.parameter("Squash", squash);
diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h
index 27b07769e28..d8f88cde259 100644
--- a/intern/cycles/render/nodes.h
+++ b/intern/cycles/render/nodes.h
@@ -36,6 +36,7 @@ public:
 	Transform compute_transform();
 	bool skip();
 	void compile(SVMCompiler& compiler, int offset_in, int offset_out);
+	void compile(OSLCompiler &compiler);
 
 	float3 translation;
 	float3 rotation;
@@ -67,7 +68,7 @@ public:
 
 	ImageManager *image_manager;
 	int slot;
-	bool is_float;
+	int is_float;
 	string filename;
 	ustring color_space;
 	ustring projection;
@@ -85,7 +86,7 @@ public:
 
 	ImageManager *image_manager;
 	int slot;
-	bool is_float;
+	int is_float;
 	string filename;
 	ustring color_space;
 	ustring projection;
diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp
index 5fbc7932849..d2600541efc 100644
--- a/intern/cycles/render/osl.cpp
+++ b/intern/cycles/render/osl.cpp
@@ -81,7 +81,7 @@ void OSLShaderManager::device_update(Device *device, DeviceScene *dscene, Scene
 		if(shader->sample_as_light && shader->has_surface_emission)
 			scene->light_manager->need_update = true;
 
-		OSLCompiler compiler((void*)this, (void*)ss);
+		OSLCompiler compiler((void*)this, (void*)ss, scene->image_manager);
 		compiler.background = (shader == scene->shaders[scene->default_background]);
 		compiler.compile(og, shader);
 	}
@@ -286,10 +286,11 @@ const char *OSLShaderManager::shader_load_bytecode(const string& hash, const str
 
 /* Graph Compiler */
 
-OSLCompiler::OSLCompiler(void *manager_, void *shadingsys_)
+OSLCompiler::OSLCompiler(void *manager_, void *shadingsys_, ImageManager *image_manager_)
 {
 	manager = manager_;
 	shadingsys = shadingsys_;
+	image_manager = image_manager_;
 	current_type = SHADER_TYPE_SURFACE;
 	current_shader = NULL;
 	background = false;
diff --git a/intern/cycles/render/osl.h b/intern/cycles/render/osl.h
index b4b3f59e02a..17934765155 100644
--- a/intern/cycles/render/osl.h
+++ b/intern/cycles/render/osl.h
@@ -83,7 +83,7 @@ protected:
 
 class OSLCompiler {
 public:
-	OSLCompiler(void *manager, void *shadingsys);
+	OSLCompiler(void *manager, void *shadingsys, ImageManager *image_manager);
 	void compile(OSLGlobals *og, Shader *shader);
 
 	void add(ShaderNode *node, const char *name, bool isfilepath = false);
@@ -110,6 +110,7 @@ public:
 	ShaderType output_type() { return current_type; }
 
 	bool background;
+	ImageManager *image_manager;
 
 private:
 	string id(ShaderNode *node);