Merged changes in the trunk up to revision 54594.

36 files changed, 342 insertions, 218 deletions

diff --git a/intern/bsp/intern/CSG_BooleanOps.cpp b/intern/bsp/intern/CSG_BooleanOps.cpp
index 4f71e7992a1..f74dfc3c253 100644
--- a/intern/bsp/intern/CSG_BooleanOps.cpp
+++ b/intern/bsp/intern/CSG_BooleanOps.cpp
@@ -88,16 +88,16 @@ CSG_PerformBooleanOperation(
 
 	BoolOpType boolType;
 	
-	switch( op_type ) {
-	case e_csg_union:
-		boolType = BOP_UNION;
-		break;
-	case e_csg_difference:
-		boolType = BOP_DIFFERENCE;
-		break;
-	default:
-		boolType = BOP_INTERSECTION;
-		break;
+	switch (op_type) {
+		case e_csg_union:
+			boolType = BOP_UNION;
+			break;
+		case e_csg_difference:
+			boolType = BOP_DIFFERENCE;
+			break;
+		default:
+			boolType = BOP_INTERSECTION;
+			break;
 	}
 
 	BoolOpState boolOpResult;
diff --git a/intern/cycles/SConscript b/intern/cycles/SConscript
index 8a8ef9cce39..7b4d2db6861 100644
--- a/intern/cycles/SConscript
+++ b/intern/cycles/SConscript
@@ -43,6 +43,8 @@ incs = []
 defs = []
 cxxflags = Split(env['CXXFLAGS'])
 
+defs.append('GLEW_STATIC')
+
 defs.append('CCL_NAMESPACE_BEGIN=namespace ccl {')
 defs.append('CCL_NAMESPACE_END=}')
 
diff --git a/intern/cycles/blender/blender_session.cpp b/intern/cycles/blender/blender_session.cpp
index 951f7022a10..dda7eb053c4 100644
--- a/intern/cycles/blender/blender_session.cpp
+++ b/intern/cycles/blender/blender_session.cpp
@@ -128,7 +128,8 @@ void BlenderSession::reset_session(BL::BlendData b_data_, BL::Scene b_scene_)
 	height = b_engine.resolution_y();
 
 	if(scene->params.modified(scene_params) ||
-	   session->params.modified(session_params))
+	   session->params.modified(session_params) ||
+	   !scene_params.persistent_data)
 	{
 		/* if scene or session parameters changed, it's easier to simply re-create
 		 * them rather than trying to distinguish which settings need to be updated
@@ -410,8 +411,10 @@ void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::Re
 			int components = b_pass.channels();
 
 			/* copy pixels */
-			if(buffers->get_pass_rect(pass_type, exposure, rtile.sample, components, &pixels[0]))
-				b_pass.rect(&pixels[0]);
+			if(!buffers->get_pass_rect(pass_type, exposure, rtile.sample, components, &pixels[0]))
+				memset(&pixels[0], 0, pixels.size()*sizeof(float));
+
+			b_pass.rect(&pixels[0]);
 		}
 	}
 
@@ -517,6 +520,9 @@ bool BlenderSession::draw(int w, int h)
 			session->reset(buffer_params, session_params.samples);
 		}
 	}
+	else {
+		tag_update();
+	}
 
 	/* update status and progress for 3d view draw */
 	update_status_progress();
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index 7ad663b7e26..f6ff78ab2ac 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -307,7 +307,10 @@ SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background)
 	params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
 	params.use_bvh_cache = (background)? RNA_boolean_get(&cscene, "use_cache"): false;
 
-	params.persistent_images = (background)? r.use_persistent_data(): false;
+	if(background && params.shadingsystem != SceneParams::OSL)
+		params.persistent_data = r.use_persistent_data();
+	else
+		params.persistent_data = false;
 
 	return params;
 }
diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h
index 0947b5a2e9d..976ed875211 100644
--- a/intern/cycles/blender/blender_util.h
+++ b/intern/cycles/blender/blender_util.h
@@ -41,7 +41,7 @@ CCL_NAMESPACE_BEGIN
 
 static inline BL::Mesh object_to_mesh(BL::BlendData data, BL::Object object, BL::Scene scene, bool apply_modifiers, bool render)
 {
-	return data.meshes.new_from_object(scene, object, apply_modifiers, (render)? 2: 1);
+	return data.meshes.new_from_object(scene, object, apply_modifiers, (render)? 2: 1, true);
 }
 
 static inline void colorramp_to_array(BL::ColorRamp ramp, float4 *data, int size)
diff --git a/intern/cycles/bvh/bvh.cpp b/intern/cycles/bvh/bvh.cpp
index 011406344ea..f11b3c4c0bc 100644
--- a/intern/cycles/bvh/bvh.cpp
+++ b/intern/cycles/bvh/bvh.cpp
@@ -30,6 +30,7 @@
 #include "util_foreach.h"
 #include "util_map.h"
 #include "util_progress.h"
+#include "util_system.h"
 #include "util_types.h"
 
 CCL_NAMESPACE_BEGIN
@@ -71,6 +72,7 @@ BVH *BVH::create(const BVHParams& params, const vector<Object*>& objects)
 
 bool BVH::cache_read(CacheData& key)
 {
+	key.add(system_cpu_bits());
 	key.add(&params, sizeof(params));
 
 	foreach(Object *ob, objects) {
@@ -340,6 +342,10 @@ void BVH::pack_primitives()
 			Object *ob = objects[tob];
 			pack.prim_visibility[i] = ob->visibility;
 		}
+		else {
+			memset(&pack.tri_woop[i * nsize], 0, sizeof(float4)*3);
+			pack.prim_visibility[i] = 0;
+		}
 	}
 }
 
@@ -476,7 +482,7 @@ void BVH::pack_instances(size_t nodes_size)
 		}
 
 		/* merge nodes */
-		if( bvh->pack.nodes.size()) {
+		if(bvh->pack.nodes.size()) {
 			size_t nsize_bbox = (use_qbvh)? nsize-2: nsize-1;
 			int4 *bvh_nodes = &bvh->pack.nodes[0];
 			size_t bvh_nodes_size = bvh->pack.nodes.size(); 
diff --git a/intern/cycles/device/device_cpu.cpp b/intern/cycles/device/device_cpu.cpp
index 1915245bb55..c2ba91faf69 100644
--- a/intern/cycles/device/device_cpu.cpp
+++ b/intern/cycles/device/device_cpu.cpp
@@ -171,7 +171,7 @@ public:
 			int end_sample = tile.start_sample + tile.num_samples;
 
 #ifdef WITH_OPTIMIZED_KERNEL
-			if(system_cpu_support_sse2()) {
+			if(system_cpu_support_sse3()) {
 				for(int sample = start_sample; sample < end_sample; sample++) {
 					if (task.get_cancel() || task_pool.cancelled()) {
 						if(task.need_finish_queue == false)
@@ -180,7 +180,7 @@ public:
 
 					for(int y = tile.y; y < tile.y + tile.h; y++) {
 						for(int x = tile.x; x < tile.x + tile.w; x++) {
-							kernel_cpu_sse2_path_trace(&kg, render_buffer, rng_state,
+							kernel_cpu_sse3_path_trace(&kg, render_buffer, rng_state,
 								sample, x, y, tile.offset, tile.stride);
 						}
 					}
@@ -190,7 +190,7 @@ public:
 					task.update_progress(tile);
 				}
 			}
-			else if(system_cpu_support_sse3()) {
+			else if(system_cpu_support_sse2()) {
 				for(int sample = start_sample; sample < end_sample; sample++) {
 					if (task.get_cancel() || task_pool.cancelled()) {
 						if(task.need_finish_queue == false)
@@ -199,7 +199,7 @@ public:
 
 					for(int y = tile.y; y < tile.y + tile.h; y++) {
 						for(int x = tile.x; x < tile.x + tile.w; x++) {
-							kernel_cpu_sse3_path_trace(&kg, render_buffer, rng_state,
+							kernel_cpu_sse2_path_trace(&kg, render_buffer, rng_state,
 								sample, x, y, tile.offset, tile.stride);
 						}
 					}
@@ -247,16 +247,16 @@ public:
 	void thread_tonemap(DeviceTask& task)
 	{
 #ifdef WITH_OPTIMIZED_KERNEL
-		if(system_cpu_support_sse2()) {
+		if(system_cpu_support_sse3()) {
 			for(int y = task.y; y < task.y + task.h; y++)
 				for(int x = task.x; x < task.x + task.w; x++)
-					kernel_cpu_sse2_tonemap(&kernel_globals, (uchar4*)task.rgba, (float*)task.buffer,
+					kernel_cpu_sse3_tonemap(&kernel_globals, (uchar4*)task.rgba, (float*)task.buffer,
 						task.sample, task.resolution, x, y, task.offset, task.stride);
 		}
-		else if(system_cpu_support_sse3()) {
+		else if(system_cpu_support_sse2()) {
 			for(int y = task.y; y < task.y + task.h; y++)
 				for(int x = task.x; x < task.x + task.w; x++)
-					kernel_cpu_sse3_tonemap(&kernel_globals, (uchar4*)task.rgba, (float*)task.buffer,
+					kernel_cpu_sse2_tonemap(&kernel_globals, (uchar4*)task.rgba, (float*)task.buffer,
 						task.sample, task.resolution, x, y, task.offset, task.stride);
 		}
 		else
@@ -278,17 +278,17 @@ public:
 #endif
 
 #ifdef WITH_OPTIMIZED_KERNEL
-		if(system_cpu_support_sse2()) {
+		if(system_cpu_support_sse3()) {
 			for(int x = task.shader_x; x < task.shader_x + task.shader_w; x++) {
-				kernel_cpu_sse2_shader(&kg, (uint4*)task.shader_input, (float4*)task.shader_output, task.shader_eval_type, x);
+				kernel_cpu_sse3_shader(&kg, (uint4*)task.shader_input, (float4*)task.shader_output, task.shader_eval_type, x);
 
 				if(task_pool.cancelled())
 					break;
 			}
 		}
-		else if(system_cpu_support_sse3()) {
+		else if(system_cpu_support_sse2()) {
 			for(int x = task.shader_x; x < task.shader_x + task.shader_w; x++) {
-				kernel_cpu_sse3_shader(&kg, (uint4*)task.shader_input, (float4*)task.shader_output, task.shader_eval_type, x);
+				kernel_cpu_sse2_shader(&kg, (uint4*)task.shader_input, (float4*)task.shader_output, task.shader_eval_type, x);
 
 				if(task_pool.cancelled())
 					break;
diff --git a/intern/cycles/device/device_cuda.cpp b/intern/cycles/device/device_cuda.cpp
index 0c590645808..77082006169 100644
--- a/intern/cycles/device/device_cuda.cpp
+++ b/intern/cycles/device/device_cuda.cpp
@@ -109,11 +109,11 @@ public:
 		}
 	}
 
-#ifdef NDEBUG
+/*#ifdef NDEBUG
 #define cuda_abort()
 #else
 #define cuda_abort() abort()
-#endif
+#endif*/
 
 #define cuda_assert(stmt) \
 	{ \
@@ -128,19 +128,21 @@ public:
 		} \
 	}
 
-	bool cuda_error(CUresult result)
+	bool cuda_error_(CUresult result, const string& stmt)
 	{
 		if(result == CUDA_SUCCESS)
 			return false;
 
-		string message = string_printf("CUDA error: %s", cuda_error_string(result));
+		string message = string_printf("CUDA error at %s: %s", stmt.c_str(), cuda_error_string(result));
 		if(error_msg == "")
 			error_msg = message;
 		fprintf(stderr, "%s\n", message.c_str());
 		return true;
 	}
 
-	void cuda_error(const string& message)
+#define cuda_error(stmt) cuda_error_(stmt, #stmt)
+
+	void cuda_error_message(const string& message)
 	{
 		if(error_msg == "")
 			error_msg = message;
@@ -187,7 +189,7 @@ public:
 			}
 		}
 
-		if(cuda_error(result))
+		if(cuda_error_(result, "cuCtxCreate"))
 			return;
 
 		cuda_pop_context();
@@ -208,7 +210,7 @@ public:
 			cuDeviceComputeCapability(&major, &minor, cuDevId);
 
 			if(major <= 1 && minor <= 2) {
-				cuda_error(string_printf("CUDA device supported only with compute capability 1.3 or up, found %d.%d.", major, minor));
+				cuda_error_message(string_printf("CUDA device supported only with compute capability 1.3 or up, found %d.%d.", major, minor));
 				return false;
 			}
 		}
@@ -241,9 +243,9 @@ public:
 #ifdef _WIN32
 		if(cuHavePrecompiledKernels()) {
 			if(major <= 1 && minor <= 2)
-				cuda_error(string_printf("CUDA device requires compute capability 1.3 or up, found %d.%d. Your GPU is not supported.", major, minor));
+				cuda_error_message(string_printf("CUDA device requires compute capability 1.3 or up, found %d.%d. Your GPU is not supported.", major, minor));
 			else
-				cuda_error(string_printf("CUDA binary kernel for this graphics card compute capability (%d.%d) not found.", major, minor));
+				cuda_error_message(string_printf("CUDA binary kernel for this graphics card compute capability (%d.%d) not found.", major, minor));
 			return "";
 		}
 #endif
@@ -252,7 +254,7 @@ public:
 		string nvcc = cuCompilerPath();
 
 		if(nvcc == "") {
-			cuda_error("CUDA nvcc compiler not found. Install CUDA toolkit in default location.");
+			cuda_error_message("CUDA nvcc compiler not found. Install CUDA toolkit in default location.");
 			return "";
 		}
 
@@ -272,13 +274,13 @@ public:
 			nvcc.c_str(), major, minor, machine, kernel.c_str(), cubin.c_str(), maxreg, include.c_str());
 
 		if(system(command.c_str()) == -1) {
-			cuda_error("Failed to execute compilation command, see console for details.");
+			cuda_error_message("Failed to execute compilation command, see console for details.");
 			return "";
 		}
 
 		/* verify if compilation succeeded */
 		if(!path_exists(cubin)) {
-			cuda_error("CUDA kernel compilation failed, see console for details.");
+			cuda_error_message("CUDA kernel compilation failed, see console for details.");
 			return "";
 		}
 
@@ -306,8 +308,8 @@ public:
 		cuda_push_context();
 
 		CUresult result = cuModuleLoad(&cuModule, cubin.c_str());
-		if(cuda_error(result))
-			cuda_error(string_printf("Failed loading CUDA kernel %s.", cubin.c_str()));
+		if(cuda_error_(result, "cuModuleLoad"))
+			cuda_error_message(string_printf("Failed loading CUDA kernel %s.", cubin.c_str()));
 
 		cuda_pop_context();
 
@@ -737,7 +739,7 @@ public:
 			
 			CUresult result = cuGraphicsGLRegisterBuffer(&pmem.cuPBOresource, pmem.cuPBO, CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE);
 
-			if(!cuda_error(result)) {
+			if(result == CUDA_SUCCESS) {
 				cuda_pop_context();
 
 				mem.device_pointer = pmem.cuTexId;
diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h
index 4048bbd9dfc..9787af535bb 100644
--- a/intern/cycles/kernel/kernel_emission.h
+++ b/intern/cycles/kernel/kernel_emission.h
@@ -20,7 +20,7 @@ CCL_NAMESPACE_BEGIN
 
 /* Direction Emission */
 
-__device float3 direct_emissive_eval(KernelGlobals *kg, float rando,
+__device_noinline float3 direct_emissive_eval(KernelGlobals *kg, float rando,
 	LightSample *ls, float u, float v, float3 I, float t, float time)
 {
 	/* setup shading at emitter */
@@ -74,7 +74,7 @@ __device float3 direct_emissive_eval(KernelGlobals *kg, float rando,
 	return eval;
 }
 
-__device bool direct_emission(KernelGlobals *kg, ShaderData *sd, int lindex,
+__device_noinline bool direct_emission(KernelGlobals *kg, ShaderData *sd, int lindex,
 	float randt, float rando, float randu, float randv, Ray *ray, BsdfEval *eval,
 	bool *is_lamp)
 {
@@ -141,14 +141,14 @@ __device bool direct_emission(KernelGlobals *kg, ShaderData *sd, int lindex,
 	}
 
 	/* return if it's a lamp for shadow pass */
-	*is_lamp = (ls.prim == ~0);
+	*is_lamp = (ls.prim == ~0 && ls.type != LIGHT_BACKGROUND);
 
 	return true;
 }
 
 /* Indirect Primitive Emission */
 
-__device float3 indirect_primitive_emission(KernelGlobals *kg, ShaderData *sd, float t, int path_flag, float bsdf_pdf)
+__device_noinline float3 indirect_primitive_emission(KernelGlobals *kg, ShaderData *sd, float t, int path_flag, float bsdf_pdf)
 {
 	/* evaluate emissive closure */
 	float3 L = shader_emissive_eval(kg, sd);
@@ -171,7 +171,7 @@ __device float3 indirect_primitive_emission(KernelGlobals *kg, ShaderData *sd, f
 
 /* Indirect Lamp Emission */
 
-__device bool indirect_lamp_emission(KernelGlobals *kg, Ray *ray, int path_flag, float bsdf_pdf, float randt, float3 *emission)
+__device_noinline bool indirect_lamp_emission(KernelGlobals *kg, Ray *ray, int path_flag, float bsdf_pdf, float randt, float3 *emission)
 {
 	LightSample ls;
 	int lamp = lamp_light_eval_sample(kg, randt);
@@ -200,7 +200,7 @@ __device bool indirect_lamp_emission(KernelGlobals *kg, Ray *ray, int path_flag,
 
 /* Indirect Background */
 
-__device float3 indirect_background(KernelGlobals *kg, Ray *ray, int path_flag, float bsdf_pdf)
+__device_noinline float3 indirect_background(KernelGlobals *kg, Ray *ray, int path_flag, float bsdf_pdf)
 {
 #ifdef __BACKGROUND__
 	/* evaluate background closure */
diff --git a/intern/cycles/kernel/kernel_light.h b/intern/cycles/kernel/kernel_light.h
index 10a32226f17..f6fbd3599ad 100644
--- a/intern/cycles/kernel/kernel_light.h
+++ b/intern/cycles/kernel/kernel_light.h
@@ -454,7 +454,7 @@ __device void triangle_light_sample(KernelGlobals *kg, int prim, int object,
 	ls->lamp = ~0;
 	ls->shader |= SHADER_USE_MIS;
 	ls->t = 0.0f;
-	ls->type = LIGHT_AREA;
+	ls->type = LIGHT_TRIANGLE;
 	ls->eval_fac = 1.0f;
 
 	object_transform_light_sample(kg, ls, object, time);
diff --git a/intern/cycles/kernel/kernel_passes.h b/intern/cycles/kernel/kernel_passes.h
index 727639386ed..57dbdc2ffc1 100644
--- a/intern/cycles/kernel/kernel_passes.h
+++ b/intern/cycles/kernel/kernel_passes.h
@@ -125,14 +125,7 @@ __device_inline void kernel_write_light_passes(KernelGlobals *kg, __global float
 		kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_color, sample, L->color_transmission);
 	if(flag & PASS_SHADOW) {
 		float4 shadow = L->shadow;
-
-		/* bit of an ugly hack to compensate for emitting triangles influencing
-		 * amount of samples we get for this pass */
-		if(kernel_data.integrator.progressive && kernel_data.integrator.pdf_triangles != 0.0f)
-			shadow.w = 0.5f;
-		else
-			shadow.w = 1.0f;
-
+		shadow.w = kernel_data.film.pass_shadow_scale;
 		kernel_write_pass_float4(buffer + kernel_data.film.pass_shadow, sample, shadow);
 	}
 #endif
diff --git a/intern/cycles/kernel/kernel_shader.h b/intern/cycles/kernel/kernel_shader.h
index b7d87427bd3..df86b352697 100644
--- a/intern/cycles/kernel/kernel_shader.h
+++ b/intern/cycles/kernel/kernel_shader.h
@@ -53,7 +53,7 @@ __device_noinline void shader_setup_object_transforms(KernelGlobals *kg, ShaderD
 }
 #endif
 
-__device void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
+__device_noinline void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
 	const Intersection *isect, const Ray *ray)
 {
 #ifdef __INSTANCING__
@@ -160,7 +160,7 @@ __device void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
 
 /* ShaderData setup from position sampled on mesh */
 
-__device void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
+__device_noinline void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
 	const float3 P, const float3 Ng, const float3 I,
 	int shader, int object, int prim, float u, float v, float t, float time, int segment = ~0)
 {
@@ -283,7 +283,7 @@ __device void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
 
 /* ShaderData setup for displacement */
 
-__device void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
+__device_noinline void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
 	int object, int prim, float u, float v)
 {
 	/* Note: no OSLShader::init call here, this is done in shader_setup_from_sample! */
diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index 52bdddc72fb..ddbda9240fb 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -299,6 +299,7 @@ typedef enum LightType {
 	LIGHT_AREA,
 	LIGHT_AO,
 	LIGHT_SPOT,
+	LIGHT_TRIANGLE,
 	LIGHT_STRAND
 } LightType;
 
@@ -609,9 +610,9 @@ typedef struct KernelFilm {
 	int pass_ao;
 
 	int pass_shadow;
+	float pass_shadow_scale;
 	int pass_pad1;
 	int pass_pad2;
-	int pass_pad3;
 } KernelFilm;
 
 typedef struct KernelBackground {
diff --git a/intern/cycles/render/buffers.cpp b/intern/cycles/render/buffers.cpp
index 3b61ccd176d..572cfae45cd 100644
--- a/intern/cycles/render/buffers.cpp
+++ b/intern/cycles/render/buffers.cpp
@@ -83,6 +83,7 @@ RenderTile::RenderTile()
 	w = 0;
 	h = 0;
 
+	sample = 0;
 	start_sample = 0;
 	num_samples = 0;
 	resolution = 0;
diff --git a/intern/cycles/render/image.cpp b/intern/cycles/render/image.cpp
index 6bfaf48c0c9..8e844bc788e 100644
--- a/intern/cycles/render/image.cpp
+++ b/intern/cycles/render/image.cpp
@@ -85,9 +85,10 @@ bool ImageManager::set_animation_frame_update(int frame)
 	return false;
 }
 
-bool ImageManager::is_float_image(const string& filename, void *builtin_data)
+bool ImageManager::is_float_image(const string& filename, void *builtin_data, bool& is_linear)
 {
 	bool is_float = false;
+	is_linear = false;
 
 	if(builtin_data) {
 		if(builtin_image_info_cb) {
@@ -95,6 +96,9 @@ bool ImageManager::is_float_image(const string& filename, void *builtin_data)
 			builtin_image_info_cb(filename, builtin_data, is_float, width, height, channels);
 		}
 
+		if(is_float)
+			is_linear = true;
+
 		return is_float;
 	}
 
@@ -106,13 +110,29 @@ bool ImageManager::is_float_image(const string& filename, void *builtin_data)
 		if(in->open(filename, spec)) {
 			/* check the main format, and channel formats;
 			 * if any take up more than one byte, we'll need a float texture slot */
-			if(spec.format.basesize() > 1)
+			if(spec.format.basesize() > 1) {
 				is_float = true;
+				is_linear = true;
+			}
 
 			for(size_t channel = 0; channel < spec.channelformats.size(); channel++) {
-				if(spec.channelformats[channel].basesize() > 1)
+				if(spec.channelformats[channel].basesize() > 1) {
 					is_float = true;
+					is_linear = true;
+				}
+			}
+
+			/* basic color space detection, not great but better than nothing
+			 * before we do OpenColorIO integration */
+			if(is_float) {
+				string colorspace = spec.get_string_attribute("oiio:ColorSpace");
+
+				is_linear = !(colorspace == "sRGB" ||
+				              colorspace == "GammaCorrected" ||
+							  strcmp(in->format_name(), "png") == 0);
 			}
+			else
+				is_linear = false;
 
 			in->close();
 		}
@@ -123,13 +143,13 @@ bool ImageManager::is_float_image(const string& filename, void *builtin_data)
 	return is_float;
 }
 
-int ImageManager::add_image(const string& filename, void *builtin_data, bool animated, bool& is_float)
+int ImageManager::add_image(const string& filename, void *builtin_data, bool animated, bool& is_float, bool& is_linear)
 {
 	Image *img;
 	size_t slot;
 
 	/* load image info and find out if we need a float texture */
-	is_float = (pack_images)? false: is_float_image(filename, builtin_data);
+	is_float = (pack_images)? false: is_float_image(filename, builtin_data, is_linear);
 
 	if(is_float) {
 		/* find existing image */
diff --git a/intern/cycles/render/image.h b/intern/cycles/render/image.h
index 464b87ff530..b20ff23fbbb 100644
--- a/intern/cycles/render/image.h
+++ b/intern/cycles/render/image.h
@@ -51,9 +51,9 @@ public:
 	ImageManager();
 	~ImageManager();
 
-	int add_image(const string& filename, void *builtin_data, bool animated, bool& is_float);
+	int add_image(const string& filename, void *builtin_data, bool animated, bool& is_float, bool& is_linear);
 	void remove_image(const string& filename, void *builtin_data);
-	bool is_float_image(const string& filename, void *builtin_data);
+	bool is_float_image(const string& filename, void *builtin_data, bool& is_linear);
 
 	void device_update(Device *device, DeviceScene *dscene, Progress& progress);
 	void device_free(Device *device, DeviceScene *dscene);
diff --git a/intern/cycles/render/light.cpp b/intern/cycles/render/light.cpp
index e7fb9514371..ccc6c5142bd 100644
--- a/intern/cycles/render/light.cpp
+++ b/intern/cycles/render/light.cpp
@@ -143,6 +143,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 
 	/* count */
 	size_t num_lights = scene->lights.size();
+	size_t num_background_lights = 0;
 	size_t num_triangles = 0;
 	size_t num_curve_segments = 0;
 
@@ -306,6 +307,8 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 
 		if(light->size > 0.0f && light->use_mis)
 			use_lamp_mis = true;
+		if(light->type == LIGHT_BACKGROUND)
+			num_background_lights++;
 	}
 
 	/* normalize cumulative distribution functions */
@@ -324,6 +327,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 
 	/* update device */
 	KernelIntegrator *kintegrator = &dscene->data.integrator;
+	KernelFilm *kfilm = &dscene->data.film;
 	kintegrator->use_direct_light = (totarea > 0.0f);
 
 	if(kintegrator->use_direct_light) {
@@ -354,6 +358,16 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 
 		kintegrator->use_lamp_mis = use_lamp_mis;
 
+		/* bit of an ugly hack to compensate for emitting triangles influencing
+		 * amount of samples we get for this pass */
+		if(scene->integrator->progressive && kintegrator->pdf_triangles != 0.0f)
+			kfilm->pass_shadow_scale = 0.5f;
+		else
+			kfilm->pass_shadow_scale = 1.0f;
+
+		if(num_background_lights < num_lights)
+			kfilm->pass_shadow_scale *= (float)(num_lights - num_background_lights)/(float)num_lights;
+
 		/* CDF */
 		device->tex_alloc("__light_distribution", dscene->light_distribution);
 	}
@@ -366,6 +380,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 		kintegrator->pdf_lights = 0.0f;
 		kintegrator->inv_pdf_lights = 0.0f;
 		kintegrator->use_lamp_mis = false;
+		kfilm->pass_shadow_scale = 1.0f;
 	}
 }
 
diff --git a/intern/cycles/render/mesh.cpp b/intern/cycles/render/mesh.cpp
index 57776e4cfa6..8d12ace4252 100644
--- a/intern/cycles/render/mesh.cpp
+++ b/intern/cycles/render/mesh.cpp
@@ -966,6 +966,16 @@ void MeshManager::device_free(Device *device, DeviceScene *dscene)
 	dscene->attributes_map.clear();
 	dscene->attributes_float.clear();
 	dscene->attributes_float3.clear();
+
+#ifdef WITH_OSL
+	OSLGlobals *og = (OSLGlobals*)device->osl_memory();
+
+	if(og) {
+		og->object_name_map.clear();
+		og->attribute_map.clear();
+		og->object_names.clear();
+	}
+#endif
 }
 
 void MeshManager::tag_update(Scene *scene)
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index a0a933ef682..8ac12242e15 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -141,6 +141,7 @@ ImageTextureNode::ImageTextureNode()
 	image_manager = NULL;
 	slot = -1;
 	is_float = -1;
+	is_linear = false;
 	filename = "";
 	builtin_data = NULL;
 	color_space = ustring("Color");
@@ -165,6 +166,7 @@ ShaderNode *ImageTextureNode::clone() const
 	node->image_manager = NULL;
 	node->slot = -1;
 	node->is_float = -1;
+	node->is_linear = false;
 	return node;
 }
 
@@ -177,7 +179,7 @@ void ImageTextureNode::compile(SVMCompiler& compiler)
 	image_manager = compiler.image_manager;
 	if(is_float == -1) {
 		bool is_float_bool;
-		slot = image_manager->add_image(filename, builtin_data, animated, is_float_bool);
+		slot = image_manager->add_image(filename, builtin_data, animated, is_float_bool, is_linear);
 		is_float = (int)is_float_bool;
 	}
 
@@ -189,7 +191,7 @@ void ImageTextureNode::compile(SVMCompiler& compiler)
 	if(slot != -1) {
 		compiler.stack_assign(vector_in);
 
-		int srgb = (is_float || color_space != "Color")? 0: 1;
+		int srgb = (is_linear || color_space != "Color")? 0: 1;
 		int vector_offset = vector_in->stack_offset;
 
 		if(!tex_mapping.skip()) {
@@ -238,10 +240,10 @@ void ImageTextureNode::compile(OSLCompiler& compiler)
 	tex_mapping.compile(compiler);
 
 	if(is_float == -1)
-		is_float = (int)image_manager->is_float_image(filename, NULL);
+		is_float = (int)image_manager->is_float_image(filename, NULL, is_linear);
 
 	compiler.parameter("filename", filename.c_str());
-	if(is_float || color_space != "Color")
+	if(is_linear || color_space != "Color")
 		compiler.parameter("color_space", "Linear");
 	else
 		compiler.parameter("color_space", "sRGB");
@@ -271,6 +273,7 @@ EnvironmentTextureNode::EnvironmentTextureNode()
 	image_manager = NULL;
 	slot = -1;
 	is_float = -1;
+	is_linear = false;
 	filename = "";
 	builtin_data = NULL;
 	color_space = ustring("Color");
@@ -294,6 +297,7 @@ ShaderNode *EnvironmentTextureNode::clone() const
 	node->image_manager = NULL;
 	node->slot = -1;
 	node->is_float = -1;
+	node->is_linear = false;
 	return node;
 }
 
@@ -306,7 +310,7 @@ void EnvironmentTextureNode::compile(SVMCompiler& compiler)
 	image_manager = compiler.image_manager;
 	if(slot == -1) {
 		bool is_float_bool;
-		slot = image_manager->add_image(filename, builtin_data, animated, is_float_bool);
+		slot = image_manager->add_image(filename, builtin_data, animated, is_float_bool, is_linear);
 		is_float = (int)is_float_bool;
 	}
 
@@ -318,7 +322,7 @@ void EnvironmentTextureNode::compile(SVMCompiler& compiler)
 	if(slot != -1) {
 		compiler.stack_assign(vector_in);
 
-		int srgb = (is_float || color_space != "Color")? 0: 1;
+		int srgb = (is_linear || color_space != "Color")? 0: 1;
 		int vector_offset = vector_in->stack_offset;
 
 		if(!tex_mapping.skip()) {
@@ -356,11 +360,11 @@ void EnvironmentTextureNode::compile(OSLCompiler& compiler)
 	tex_mapping.compile(compiler);
 
 	if(is_float == -1)
-		is_float = (int)image_manager->is_float_image(filename, NULL);
+		is_float = (int)image_manager->is_float_image(filename, NULL, is_linear);
 
 	compiler.parameter("filename", filename.c_str());
 	compiler.parameter("projection", projection);
-	if(is_float || color_space != "Color")
+	if(is_linear || color_space != "Color")
 		compiler.parameter("color_space", "Linear");
 	else
 		compiler.parameter("color_space", "sRGB");
diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h
index 66be919d098..3609497e5ce 100644
--- a/intern/cycles/render/nodes.h
+++ b/intern/cycles/render/nodes.h
@@ -69,6 +69,7 @@ public:
 	ImageManager *image_manager;
 	int slot;
 	int is_float;
+	bool is_linear;
 	string filename;
 	void *builtin_data;
 	ustring color_space;
@@ -89,6 +90,7 @@ public:
 	ImageManager *image_manager;
 	int slot;
 	int is_float;
+	bool is_linear;
 	string filename;
 	void *builtin_data;
 	ustring color_space;
diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp
index 28de56f3a72..56158278e29 100644
--- a/intern/cycles/render/osl.cpp
+++ b/intern/cycles/render/osl.cpp
@@ -47,15 +47,25 @@ OSLShaderManager::OSLShaderManager()
 {
 	services = new OSLRenderServices();
 
-	shading_system_init();
 	texture_system_init();
+	shading_system_init();
 }
 
 OSLShaderManager::~OSLShaderManager()
 {
 	OSL::ShadingSystem::destroy(ss);
 	OSL::TextureSystem::destroy(ts);
+
+	delete services;
+}
+
+void OSLShaderManager::reset(Scene *scene)
+{
+	OSL::ShadingSystem::destroy(ss);
 	delete services;
+
+	services = new OSLRenderServices();
+	shading_system_init();
 }
 
 void OSLShaderManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
@@ -88,6 +98,7 @@ void OSLShaderManager::device_update(Device *device, DeviceScene *dscene, Scene
 	og->ss = ss;
 	og->ts = ts;
 	og->services = services;
+
 	int background_id = scene->shader_manager->get_shader_id(scene->default_background);
 	og->background_state = og->surface_state[background_id & SHADER_MASK];
 	og->use = true;
diff --git a/intern/cycles/render/osl.h b/intern/cycles/render/osl.h
index 3c599caa893..4b4ed6cba00 100644
--- a/intern/cycles/render/osl.h
+++ b/intern/cycles/render/osl.h
@@ -36,7 +36,7 @@ class Device;
 class DeviceScene;
 class ImageManager;
 class OSLRenderServices;
-class OSLGlobals;
+struct OSLGlobals;
 class Scene;
 class ShaderGraph;
 class ShaderNode;
@@ -64,6 +64,8 @@ public:
 	OSLShaderManager();
 	~OSLShaderManager();
 
+	void reset(Scene *scene);
+
 	bool use_osl() { return true; }
 
 	void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
diff --git a/intern/cycles/render/scene.cpp b/intern/cycles/render/scene.cpp
index 093bfecf88e..7b82a91cae8 100644
--- a/intern/cycles/render/scene.cpp
+++ b/intern/cycles/render/scene.cpp
@@ -85,6 +85,12 @@ void Scene::free_memory(bool final)
 	foreach(ParticleSystem *p, particle_systems)
 		delete p;
 
+	shaders.clear();
+	meshes.clear();
+	objects.clear();
+	lights.clear();
+	particle_systems.clear();
+
 	if(device) {
 		camera->device_free(device, &dscene);
 		filter->device_free(device, &dscene);
@@ -100,7 +106,7 @@ void Scene::free_memory(bool final)
 		particle_system_manager->device_free(device, &dscene);
 		curve_system_manager->device_free(device, &dscene);
 
-		if(!params.persistent_images || final)
+		if(!params.persistent_data || final)
 			image_manager->device_free(device, &dscene);
 	}
 
@@ -118,13 +124,6 @@ void Scene::free_memory(bool final)
 		delete curve_system_manager;
 		delete image_manager;
 	}
-	else {
-		shaders.clear();
-		meshes.clear();
-		objects.clear();
-		lights.clear();
-		particle_systems.clear();
-	}
 }
 
 void Scene::device_update(Device *device_, Progress& progress)
@@ -257,6 +256,7 @@ bool Scene::need_reset()
 
 void Scene::reset()
 {
+	shader_manager->reset(this);
 	shader_manager->add_default(this);
 
 	/* ensure all objects are updated */
diff --git a/intern/cycles/render/scene.h b/intern/cycles/render/scene.h
index f6e1daea80d..fc6b538af03 100644
--- a/intern/cycles/render/scene.h
+++ b/intern/cycles/render/scene.h
@@ -125,7 +125,7 @@ public:
 	bool use_bvh_cache;
 	bool use_bvh_spatial_split;
 	bool use_qbvh;
-	bool persistent_images;
+	bool persistent_data;
 
 	SceneParams()
 	{
@@ -146,7 +146,7 @@ public:
 		&& use_bvh_cache == params.use_bvh_cache
 		&& use_bvh_spatial_split == params.use_bvh_spatial_split
 		&& use_qbvh == params.use_qbvh
-		&& persistent_images == params.persistent_images); }
+		&& persistent_data == params.persistent_data); }
 };
 
 /* Scene */
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 94cb69102d2..6ed14452c6b 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -132,6 +132,8 @@ bool Session::ready_to_reset()
 
 void Session::reset_gpu(BufferParams& buffer_params, int samples)
 {
+	thread_scoped_lock pause_lock(pause_mutex);
+
 	/* block for buffer acces and reset immediately. we can't do this
 	 * in the thread, because we need to allocate an OpenGL buffer, and
 	 * that only works in the main thread */
@@ -208,7 +210,12 @@ void Session::run_gpu()
 			 * wait for pause condition notify to wake up again */
 			thread_scoped_lock pause_lock(pause_mutex);
 
-			if(pause || no_tiles) {
+			if(!pause && !tile_manager.done()) {
+				/* reset could have happened after no_tiles was set, before this lock.
+				 * in this case we shall not wait for pause condition
+				 */
+			}
+			else if(pause || no_tiles) {
 				update_status_time(pause, no_tiles);
 
 				while(1) {
@@ -295,6 +302,7 @@ void Session::run_gpu()
 void Session::reset_cpu(BufferParams& buffer_params, int samples)
 {
 	thread_scoped_lock reset_lock(delayed_reset.mutex);
+	thread_scoped_lock pause_lock(pause_mutex);
 
 	display_outdated = true;
 	reset_time = time_dt();
@@ -484,7 +492,16 @@ void Session::run_cpu()
 			 * wait for pause condition notify to wake up again */
 			thread_scoped_lock pause_lock(pause_mutex);
 
-			if(pause || no_tiles) {
+			if(!pause && delayed_reset.do_reset) {
+				/* reset once to start */
+				thread_scoped_lock reset_lock(delayed_reset.mutex);
+				thread_scoped_lock buffers_lock(buffers_mutex);
+				thread_scoped_lock display_lock(display_mutex);
+
+				reset_(delayed_reset.params, delayed_reset.samples);
+				delayed_reset.do_reset = false;
+			}
+			else if(pause || no_tiles) {
 				update_status_time(pause, no_tiles);
 
 				while(1) {
diff --git a/intern/cycles/render/shader.h b/intern/cycles/render/shader.h
index d4421002ceb..b38e098e3cb 100644
--- a/intern/cycles/render/shader.h
+++ b/intern/cycles/render/shader.h
@@ -110,6 +110,8 @@ public:
 	static ShaderManager *create(Scene *scene, int shadingsystem);
 	virtual ~ShaderManager();
 
+	virtual void reset(Scene *scene) = 0;
+
 	virtual bool use_osl() { return false; }
 
 	/* device update */
diff --git a/intern/cycles/render/svm.cpp b/intern/cycles/render/svm.cpp
index f7cb8f62247..5cb11a4ec1a 100644
--- a/intern/cycles/render/svm.cpp
+++ b/intern/cycles/render/svm.cpp
@@ -40,6 +40,10 @@ SVMShaderManager::~SVMShaderManager()
 {
 }
 
+void SVMShaderManager::reset(Scene *scene)
+{
+}
+
 void SVMShaderManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
 {
 	if(!need_update)
diff --git a/intern/cycles/render/svm.h b/intern/cycles/render/svm.h
index 0b15c5aaa1e..c1ce619e12a 100644
--- a/intern/cycles/render/svm.h
+++ b/intern/cycles/render/svm.h
@@ -45,6 +45,8 @@ public:
 	SVMShaderManager();
 	~SVMShaderManager();
 
+	void reset(Scene *scene);
+
 	void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
 	void device_free(Device *device, DeviceScene *dscene);
 };
diff --git a/intern/cycles/util/util_boundbox.h b/intern/cycles/util/util_boundbox.h
index 0c857f906ee..7564c1f3c5c 100644
--- a/intern/cycles/util/util_boundbox.h
+++ b/intern/cycles/util/util_boundbox.h
@@ -61,15 +61,17 @@ public:
 
 	__forceinline void grow(const float3& pt)  
 	{
-		min = ccl::min(min, pt);
-		max = ccl::max(max, pt);
+		/* the order of arguments to min is such that if pt is nan, it will not
+		 * influence the resulting bounding box */
+		min = ccl::min(pt, min);
+		max = ccl::max(pt, max);
 	}
 
 	__forceinline void grow(const float3& pt, float border)  
 	{
 		float3 shift = {border, border, border, 0.0f};
-		min = ccl::min(min, pt - shift);
-		max = ccl::max(max, pt + shift);
+		min = ccl::min(pt - shift, min);
+		max = ccl::max(pt + shift, max);
 	}
 
 	__forceinline void grow(const BoundBox& bbox)
diff --git a/intern/cycles/util/util_cache.h b/intern/cycles/util/util_cache.h
index e8f111a5397..deff05fff16 100644
--- a/intern/cycles/util/util_cache.h
+++ b/intern/cycles/util/util_cache.h
@@ -72,7 +72,7 @@ public:
 		buffers.push_back(buffer);
 	}
 
-	void add(void *data, size_t size)
+	void add(const void *data, size_t size)
 	{
 		if(size) {
 			CacheBuffer buffer(data, size);
@@ -80,19 +80,19 @@ public:
 		}
 	}
 
-	void add(int& data)
+	void add(const int& data)
 	{
 		CacheBuffer buffer(&data, sizeof(int));
 		buffers.push_back(buffer);
 	}
 
-	void add(float& data)
+	void add(const float& data)
 	{
 		CacheBuffer buffer(&data, sizeof(float));
 		buffers.push_back(buffer);
 	}
 
-	void add(size_t& data)
+	void add(const size_t& data)
 	{
 		CacheBuffer buffer(&data, sizeof(size_t));
 		buffers.push_back(buffer);
diff --git a/intern/ghost/intern/GHOST_SystemCocoa.mm b/intern/ghost/intern/GHOST_SystemCocoa.mm
index e4245aaf095..6cf4ada6311 100644
--- a/intern/ghost/intern/GHOST_SystemCocoa.mm
+++ b/intern/ghost/intern/GHOST_SystemCocoa.mm
@@ -1028,8 +1028,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType,
 	if (!validWindow(window)) {
 		return GHOST_kFailure;
 	}
-		switch(eventType) 
-		{
+		switch (eventType) {
 			case GHOST_kEventWindowClose:
 				pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window) );
 				break;
@@ -1086,8 +1085,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleDraggingEvent(GHOST_TEventType eventType
 	if (!validWindow(window)) {
 		return GHOST_kFailure;
 	}
-	switch(eventType) 
-	{
+	switch (eventType) {
 		case GHOST_kEventDraggingEntered:
 		case GHOST_kEventDraggingUpdated:
 		case GHOST_kEventDraggingExited:
diff --git a/intern/ghost/intern/GHOST_SystemX11.cpp b/intern/ghost/intern/GHOST_SystemX11.cpp
index 7ba8889fd1e..48fb8375303 100644
--- a/intern/ghost/intern/GHOST_SystemX11.cpp
+++ b/intern/ghost/intern/GHOST_SystemX11.cpp
@@ -109,32 +109,37 @@ GHOST_SystemX11(
 	m_xim = NULL;
 #endif
 
-	m_delete_window_atom 
-	    = XInternAtom(m_display, "WM_DELETE_WINDOW", True);
-
-	m_wm_protocols = XInternAtom(m_display, "WM_PROTOCOLS", False);
-	m_wm_take_focus = XInternAtom(m_display, "WM_TAKE_FOCUS", False);
-	m_wm_state = XInternAtom(m_display, "WM_STATE", False);
-	m_wm_change_state = XInternAtom(m_display, "WM_CHANGE_STATE", False);
-	m_net_state = XInternAtom(m_display, "_NET_WM_STATE", False);
-	m_net_max_horz = XInternAtom(m_display,
-	                             "_NET_WM_STATE_MAXIMIZED_HORZ", False);
-	m_net_max_vert = XInternAtom(m_display,
-	                             "_NET_WM_STATE_MAXIMIZED_VERT", False);
-	m_net_fullscreen = XInternAtom(m_display,
-	                               "_NET_WM_STATE_FULLSCREEN", False);
-	m_motif = XInternAtom(m_display, "_MOTIF_WM_HINTS", False);
-	m_targets = XInternAtom(m_display, "TARGETS", False);
-	m_string = XInternAtom(m_display, "STRING", False);
-	m_compound_text = XInternAtom(m_display, "COMPOUND_TEXT", False);
-	m_text = XInternAtom(m_display, "TEXT", False);
-	m_clipboard = XInternAtom(m_display, "CLIPBOARD", False);
-	m_primary = XInternAtom(m_display, "PRIMARY", False);
-	m_xclip_out = XInternAtom(m_display, "XCLIP_OUT", False);
-	m_incr = XInternAtom(m_display, "INCR", False);
-	m_utf8_string = XInternAtom(m_display, "UTF8_STRING", False);
-	m_last_warp = 0;
+#define GHOST_INTERN_ATOM_IF_EXISTS(atom) { m_atom.atom = XInternAtom(m_display, #atom , True);  } (void)0
+#define GHOST_INTERN_ATOM(atom)           { m_atom.atom = XInternAtom(m_display, #atom , False); } (void)0
+
+	GHOST_INTERN_ATOM_IF_EXISTS(WM_DELETE_WINDOW);
+	GHOST_INTERN_ATOM(WM_PROTOCOLS);
+	GHOST_INTERN_ATOM(WM_TAKE_FOCUS);
+	GHOST_INTERN_ATOM(WM_STATE);
+	GHOST_INTERN_ATOM(WM_CHANGE_STATE);
+	GHOST_INTERN_ATOM(_NET_WM_STATE);
+	GHOST_INTERN_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ);
+	GHOST_INTERN_ATOM(_NET_WM_STATE_MAXIMIZED_VERT);
+
+	GHOST_INTERN_ATOM(_NET_WM_STATE_FULLSCREEN);
+	GHOST_INTERN_ATOM(_MOTIF_WM_HINTS);
+	GHOST_INTERN_ATOM(TARGETS);
+	GHOST_INTERN_ATOM(STRING);
+	GHOST_INTERN_ATOM(COMPOUND_TEXT);
+	GHOST_INTERN_ATOM(TEXT);
+	GHOST_INTERN_ATOM(CLIPBOARD);
+	GHOST_INTERN_ATOM(PRIMARY);
+	GHOST_INTERN_ATOM(XCLIP_OUT);
+	GHOST_INTERN_ATOM(INCR);
+	GHOST_INTERN_ATOM(UTF8_STRING);
+#ifdef WITH_X11_XINPUT
+	m_atom.TABLET = XInternAtom(m_display, XI_TABLET, False);
+#endif
 
+#undef GHOST_INTERN_ATOM_IF_EXISTS
+#undef GHOST_INTERN_ATOM
+
+	m_last_warp = 0;
 
 	/* compute the initial time */
 	timeval tv;
@@ -959,7 +964,7 @@ GHOST_SystemX11::processEvent(XEvent *xe)
 		{
 			XClientMessageEvent & xcme = xe->xclient;
 
-			if (((Atom)xcme.data.l[0]) == m_delete_window_atom) {
+			if (((Atom)xcme.data.l[0]) == m_atom.WM_DELETE_WINDOW) {
 				g_event = new 
 				          GHOST_Event(
 				    getMilliSeconds(),
@@ -967,7 +972,7 @@ GHOST_SystemX11::processEvent(XEvent *xe)
 				    window
 				    );
 			}
-			else if (((Atom)xcme.data.l[0]) == m_wm_take_focus) {
+			else if (((Atom)xcme.data.l[0]) == m_atom.WM_TAKE_FOCUS) {
 				XWindowAttributes attr;
 				Window fwin;
 				int revert_to;
@@ -1520,7 +1525,7 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 			}
 
 			/* Send a selection request */
-			XConvertSelection(m_display, sel, target, m_xclip_out, win, CurrentTime);
+			XConvertSelection(m_display, sel, target, m_atom.XCLIP_OUT, win, CurrentTime);
 			*context = XCLIB_XCOUT_SENTCONVSEL;
 			return;
 
@@ -1528,28 +1533,28 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 			if (evt.type != SelectionNotify)
 				return;
 
-			if (target == m_utf8_string && evt.xselection.property == None) {
+			if (target == m_atom.UTF8_STRING && evt.xselection.property == None) {
 				*context = XCLIB_XCOUT_FALLBACK_UTF8;
 				return;
 			}
-			else if (target == m_compound_text && evt.xselection.property == None) {
+			else if (target == m_atom.COMPOUND_TEXT && evt.xselection.property == None) {
 				*context = XCLIB_XCOUT_FALLBACK_COMP;
 				return;
 			}
-			else if (target == m_text && evt.xselection.property == None) {
+			else if (target == m_atom.TEXT && evt.xselection.property == None) {
 				*context = XCLIB_XCOUT_FALLBACK_TEXT;
 				return;
 			}
 
 			/* find the size and format of the data in property */
-			XGetWindowProperty(m_display, win, m_xclip_out, 0, 0, False,
+			XGetWindowProperty(m_display, win, m_atom.XCLIP_OUT, 0, 0, False,
 			                   AnyPropertyType, &pty_type, &pty_format,
 			                   &pty_items, &pty_size, &buffer);
 			XFree(buffer);
 
-			if (pty_type == m_incr) {
+			if (pty_type == m_atom.INCR) {
 				/* start INCR mechanism by deleting property */
-				XDeleteProperty(m_display, win, m_xclip_out);
+				XDeleteProperty(m_display, win, m_atom.XCLIP_OUT);
 				XFlush(m_display);
 				*context = XCLIB_XCOUT_INCR;
 				return;
@@ -1564,12 +1569,12 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 			}
 
 			// not using INCR mechanism, just read the property
-			XGetWindowProperty(m_display, win, m_xclip_out, 0, (long) pty_size,
+			XGetWindowProperty(m_display, win, m_atom.XCLIP_OUT, 0, (long) pty_size,
 			                   False, AnyPropertyType, &pty_type,
 			                   &pty_format, &pty_items, &pty_size, &buffer);
 
 			/* finished with property, delete it */
-			XDeleteProperty(m_display, win, m_xclip_out);
+			XDeleteProperty(m_display, win, m_atom.XCLIP_OUT);
 
 			/* copy the buffer to the pointer for returned data */
 			ltxt = (unsigned char *) malloc(pty_items);
@@ -1602,7 +1607,7 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 				return;
 
 			/* check size and format of the property */
-			XGetWindowProperty(m_display, win, m_xclip_out, 0, 0, False,
+			XGetWindowProperty(m_display, win, m_atom.XCLIP_OUT, 0, 0, False,
 			                   AnyPropertyType, &pty_type, &pty_format,
 			                   &pty_items, &pty_size, &buffer);
 
@@ -1611,14 +1616,14 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 				 * to tell the other X client that we have read
 				 * it and to send the next property */
 				XFree(buffer);
-				XDeleteProperty(m_display, win, m_xclip_out);
+				XDeleteProperty(m_display, win, m_atom.XCLIP_OUT);
 				return;
 			}
 
 			if (pty_size == 0) {
 				/* no more data, exit from loop */
 				XFree(buffer);
-				XDeleteProperty(m_display, win, m_xclip_out);
+				XDeleteProperty(m_display, win, m_atom.XCLIP_OUT);
 				*context = XCLIB_XCOUT_NONE;
 
 				/* this means that an INCR transfer is now
@@ -1630,7 +1635,7 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 
 			/* if we have come this far, the property contains
 			 * text, we know the size. */
-			XGetWindowProperty(m_display, win, m_xclip_out, 0, (long) pty_size,
+			XGetWindowProperty(m_display, win, m_atom.XCLIP_OUT, 0, (long) pty_size,
 			                   False, AnyPropertyType, &pty_type, &pty_format,
 			                   &pty_items, &pty_size, &buffer);
 
@@ -1651,7 +1656,7 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 			XFree(buffer);
 
 			/* delete property to get the next item */
-			XDeleteProperty(m_display, win, m_xclip_out);
+			XDeleteProperty(m_display, win, m_atom.XCLIP_OUT);
 			XFlush(m_display);
 			return;
 	}
@@ -1661,7 +1666,7 @@ void GHOST_SystemX11::getClipboard_xcout(XEvent evt,
 GHOST_TUns8 *GHOST_SystemX11::getClipboard(bool selection) const
 {
 	Atom sseln;
-	Atom target = m_utf8_string;
+	Atom target = m_atom.UTF8_STRING;
 	Window owner;
 
 	/* from xclip.c doOut() v0.11 */
@@ -1671,9 +1676,9 @@ GHOST_TUns8 *GHOST_SystemX11::getClipboard(bool selection) const
 	unsigned int context = XCLIB_XCOUT_NONE;
 
 	if (selection == True)
-		sseln = m_primary;
+		sseln = m_atom.PRIMARY;
 	else
-		sseln = m_clipboard;
+		sseln = m_atom.CLIPBOARD;
 
 	vector<GHOST_IWindow *> & win_vec = m_windowManager->getWindows();
 	vector<GHOST_IWindow *>::iterator win_it = win_vec.begin();
@@ -1683,7 +1688,7 @@ GHOST_TUns8 *GHOST_SystemX11::getClipboard(bool selection) const
 	/* check if we are the owner. */
 	owner = XGetSelectionOwner(m_display, sseln);
 	if (owner == win) {
-		if (sseln == m_clipboard) {
+		if (sseln == m_atom.CLIPBOARD) {
 			sel_buf = (unsigned char *)malloc(strlen(txt_cut_buffer) + 1);
 			strcpy((char *)sel_buf, txt_cut_buffer);
 			return sel_buf;
@@ -1708,19 +1713,19 @@ GHOST_TUns8 *GHOST_SystemX11::getClipboard(bool selection) const
 		/* fallback is needed. set XA_STRING to target and restart the loop. */
 		if (context == XCLIB_XCOUT_FALLBACK) {
 			context = XCLIB_XCOUT_NONE;
-			target = m_string;
+			target = m_atom.STRING;
 			continue;
 		}
 		else if (context == XCLIB_XCOUT_FALLBACK_UTF8) {
 			/* utf8 fail, move to compouned text. */
 			context = XCLIB_XCOUT_NONE;
-			target = m_compound_text;
+			target = m_atom.COMPOUND_TEXT;
 			continue;
 		}
 		else if (context == XCLIB_XCOUT_FALLBACK_COMP) {
 			/* compouned text faile, move to text. */
 			context = XCLIB_XCOUT_NONE;
-			target = m_text;
+			target = m_atom.TEXT;
 			continue;
 		}
 
@@ -1737,7 +1742,7 @@ GHOST_TUns8 *GHOST_SystemX11::getClipboard(bool selection) const
 		memcpy((char *)tmp_data, (char *)sel_buf, sel_len);
 		tmp_data[sel_len] = '\0';
 		
-		if (sseln == m_string)
+		if (sseln == m_atom.STRING)
 			XFree(sel_buf);
 		else
 			free(sel_buf);
@@ -1758,8 +1763,8 @@ void GHOST_SystemX11::putClipboard(GHOST_TInt8 *buffer, bool selection) const
 
 	if (buffer) {
 		if (selection == False) {
-			XSetSelectionOwner(m_display, m_clipboard, m_window, CurrentTime);
-			owner = XGetSelectionOwner(m_display, m_clipboard);
+			XSetSelectionOwner(m_display, m_atom.CLIPBOARD, m_window, CurrentTime);
+			owner = XGetSelectionOwner(m_display, m_atom.CLIPBOARD);
 			if (txt_cut_buffer)
 				free((void *)txt_cut_buffer);
 
@@ -1767,8 +1772,8 @@ void GHOST_SystemX11::putClipboard(GHOST_TInt8 *buffer, bool selection) const
 			strcpy(txt_cut_buffer, buffer);
 		}
 		else {
-			XSetSelectionOwner(m_display, m_primary, m_window, CurrentTime);
-			owner = XGetSelectionOwner(m_display, m_primary);
+			XSetSelectionOwner(m_display, m_atom.PRIMARY, m_window, CurrentTime);
+			owner = XGetSelectionOwner(m_display, m_atom.PRIMARY);
 			if (txt_select_buffer)
 				free((void *)txt_select_buffer);
 
@@ -1939,7 +1944,9 @@ void GHOST_SystemX11::initXInputDevices()
 //				printf("Tablet type:'%s', name:'%s', index:%d\n", device_type, device_info[i].name, i);
 
 
-				if (m_xtablet.StylusDevice == NULL && is_stylus(device_info[i].name, device_type)) {
+				if ((m_xtablet.StylusDevice == NULL) &&
+				    (is_stylus(device_info[i].name, device_type) || (device_info[i].type == m_atom.TABLET)))
+				{
 //					printf("\tfound stylus\n");
 					m_xtablet.StylusID = device_info[i].id;
 					m_xtablet.StylusDevice = XOpenDevice(m_display, m_xtablet.StylusID);
@@ -1952,11 +1959,18 @@ void GHOST_SystemX11::initXInputDevices()
 //								printf("\t\tfound ValuatorClass\n");
 								XValuatorInfo *xvi = (XValuatorInfo *)ici;
 								m_xtablet.PressureLevels = xvi->axes[2].max_value;
-							
-								/* this is assuming that the tablet has the same tilt resolution in both
-								 * positive and negative directions. It would be rather weird if it didn't.. */
-								m_xtablet.XtiltLevels = xvi->axes[3].max_value;
-								m_xtablet.YtiltLevels = xvi->axes[4].max_value;
+
+								if (xvi->num_axes > 3) {
+									/* this is assuming that the tablet has the same tilt resolution in both
+									 * positive and negative directions. It would be rather weird if it didn't.. */
+									m_xtablet.XtiltLevels = xvi->axes[3].max_value;
+									m_xtablet.YtiltLevels = xvi->axes[4].max_value;
+								}
+								else {
+									m_xtablet.XtiltLevels = 0;
+									m_xtablet.YtiltLevels = 0;
+								}
+
 								break;
 							}
 						
@@ -1967,7 +1981,9 @@ void GHOST_SystemX11::initXInputDevices()
 						m_xtablet.StylusID = 0;
 					}
 				}
-				else if (m_xtablet.EraserDevice == NULL && is_eraser(device_info[i].name, device_type)) {
+				else if ((m_xtablet.EraserDevice == NULL) &&
+				         (is_eraser(device_info[i].name, device_type)))
+				{
 //					printf("\tfound eraser\n");
 					m_xtablet.EraserID = device_info[i].id;
 					m_xtablet.EraserDevice = XOpenDevice(m_display, m_xtablet.EraserID);
diff --git a/intern/ghost/intern/GHOST_SystemX11.h b/intern/ghost/intern/GHOST_SystemX11.h
index 5fd494637f9..a11aea240be 100644
--- a/intern/ghost/intern/GHOST_SystemX11.h
+++ b/intern/ghost/intern/GHOST_SystemX11.h
@@ -274,34 +274,6 @@ public:
 		return 0;
 	}
 
-	/**
-	 * Atom used for ICCCM, WM-spec and Motif.
-	 * We only need get this atom at the start, it's relative
-	 * to the display not the window and are public for every
-	 * window that need it.
-	 */
-	Atom m_wm_state;
-	Atom m_wm_change_state;
-	Atom m_net_state;
-	Atom m_net_max_horz;
-	Atom m_net_max_vert;
-	Atom m_net_fullscreen;
-	Atom m_motif;
-	Atom m_wm_take_focus;
-	Atom m_wm_protocols;
-	Atom m_delete_window_atom;
-
-	/* Atoms for Selection, copy & paste. */
-	Atom m_targets;
-	Atom m_string;
-	Atom m_compound_text;
-	Atom m_text;
-	Atom m_clipboard;
-	Atom m_primary;
-	Atom m_xclip_out;
-	Atom m_incr;
-	Atom m_utf8_string;
-
 #ifdef WITH_X11_XINPUT
 	typedef struct GHOST_TabletX11 {
 		XDevice *StylusDevice;
@@ -323,6 +295,39 @@ public:
 	}
 #endif // WITH_X11_XINPUT
 
+	struct {
+		/**
+		 * Atom used for ICCCM, WM-spec and Motif.
+		 * We only need get this atom at the start, it's relative
+		 * to the display not the window and are public for every
+		 * window that need it.
+		 */
+		Atom WM_STATE;
+		Atom WM_CHANGE_STATE;
+		Atom _NET_WM_STATE;
+		Atom _NET_WM_STATE_MAXIMIZED_HORZ;
+		Atom _NET_WM_STATE_MAXIMIZED_VERT;
+		Atom _NET_WM_STATE_FULLSCREEN;
+		Atom _MOTIF_WM_HINTS;
+		Atom WM_TAKE_FOCUS;
+		Atom WM_PROTOCOLS;
+		Atom WM_DELETE_WINDOW;
+
+		/* Atoms for Selection, copy & paste. */
+		Atom TARGETS;
+		Atom STRING;
+		Atom COMPOUND_TEXT;
+		Atom TEXT;
+		Atom CLIPBOARD;
+		Atom PRIMARY;
+		Atom XCLIP_OUT;
+		Atom INCR;
+		Atom UTF8_STRING;
+#ifdef WITH_X11_XINPUT
+		Atom TABLET;
+#endif
+	} m_atom;
+
 private:
 
 	Display *m_display;
diff --git a/intern/ghost/intern/GHOST_WindowX11.cpp b/intern/ghost/intern/GHOST_WindowX11.cpp
index 7ef3a739b7e..50520b7eda5 100644
--- a/intern/ghost/intern/GHOST_WindowX11.cpp
+++ b/intern/ghost/intern/GHOST_WindowX11.cpp
@@ -395,16 +395,16 @@ GHOST_WindowX11(
 	XFree(xclasshint);
 
 	/* The basic for a good ICCCM "work" */
-	if (m_system->m_wm_protocols) {
+	if (m_system->m_atom.WM_PROTOCOLS) {
 		natom = 0;
 
-		if (m_system->m_delete_window_atom) {
-			atoms[natom] = m_system->m_delete_window_atom;
+		if (m_system->m_atom.WM_DELETE_WINDOW) {
+			atoms[natom] = m_system->m_atom.WM_DELETE_WINDOW;
 			natom++;
 		}
 
-		if (m_system->m_wm_take_focus) {
-			atoms[natom] = m_system->m_wm_take_focus;
+		if (m_system->m_atom.WM_TAKE_FOCUS) {
+			atoms[natom] = m_system->m_atom.WM_TAKE_FOCUS;
 			natom++;
 		}
 
@@ -744,7 +744,7 @@ void GHOST_WindowX11::icccmSetState(int state)
 	xev.xclient.display = m_display;
 	xev.xclient.window = m_window;
 	xev.xclient.format = 32;
-	xev.xclient.message_type = m_system->m_wm_change_state;
+	xev.xclient.message_type = m_system->m_atom.WM_CHANGE_STATE;
 	xev.xclient.data.l[0] = state;
 	XSendEvent(m_display, RootWindow(m_display, DefaultScreen(m_display)),
 	           False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
@@ -758,8 +758,8 @@ int GHOST_WindowX11::icccmGetState(void) const
 	int format_ret, st;
 
 	prop_ret = NULL;
-	st = XGetWindowProperty(m_display, m_window, m_system->m_wm_state, 0,
-	                        0x7fffffff, False, m_system->m_wm_state, &type_ret,
+	st = XGetWindowProperty(m_display, m_window, m_system->m_atom.WM_STATE, 0,
+	                        0x7fffffff, False, m_system->m_atom.WM_STATE, &type_ret,
 	                        &format_ret, &num_ret, &bytes_after, &prop_ret);
 
 	if ((st == Success) && (prop_ret) && (num_ret == 2))
@@ -780,7 +780,7 @@ void GHOST_WindowX11::netwmMaximized(bool set)
 	xev.xclient.serial = 0;
 	xev.xclient.send_event = True;
 	xev.xclient.window = m_window;
-	xev.xclient.message_type = m_system->m_net_state;
+	xev.xclient.message_type = m_system->m_atom._NET_WM_STATE;
 	xev.xclient.format = 32;
 
 	if (set == True)
@@ -788,8 +788,8 @@ void GHOST_WindowX11::netwmMaximized(bool set)
 	else
 		xev.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
 
-	xev.xclient.data.l[1] = m_system->m_net_max_horz;
-	xev.xclient.data.l[2] = m_system->m_net_max_vert;
+	xev.xclient.data.l[1] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_HORZ;
+	xev.xclient.data.l[2] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_VERT;
 	xev.xclient.data.l[3] = 0;
 	xev.xclient.data.l[4] = 0;
 	XSendEvent(m_display, RootWindow(m_display, DefaultScreen(m_display)),
@@ -806,15 +806,15 @@ bool GHOST_WindowX11::netwmIsMaximized(void) const
 
 	prop_ret = NULL;
 	st = False;
-	ret = XGetWindowProperty(m_display, m_window, m_system->m_net_state, 0,
+	ret = XGetWindowProperty(m_display, m_window, m_system->m_atom._NET_WM_STATE, 0,
 	                         0x7fffffff, False, XA_ATOM, &type_ret, &format_ret,
 	                         &num_ret, &bytes_after, &prop_ret);
 	if ((ret == Success) && (prop_ret) && (format_ret == 32)) {
 		count = 0;
 		for (i = 0; i < num_ret; i++) {
-			if (((unsigned long *) prop_ret)[i] == m_system->m_net_max_horz)
+			if (((unsigned long *) prop_ret)[i] == m_system->m_atom._NET_WM_STATE_MAXIMIZED_HORZ)
 				count++;
-			if (((unsigned long *) prop_ret)[i] == m_system->m_net_max_vert)
+			if (((unsigned long *) prop_ret)[i] == m_system->m_atom._NET_WM_STATE_MAXIMIZED_VERT)
 				count++;
 			if (count == 2) {
 				st = True;
@@ -836,7 +836,7 @@ void GHOST_WindowX11::netwmFullScreen(bool set)
 	xev.xclient.serial = 0;
 	xev.xclient.send_event = True;
 	xev.xclient.window = m_window;
-	xev.xclient.message_type = m_system->m_net_state;
+	xev.xclient.message_type = m_system->m_atom._NET_WM_STATE;
 	xev.xclient.format = 32;
 
 	if (set == True)
@@ -844,7 +844,7 @@ void GHOST_WindowX11::netwmFullScreen(bool set)
 	else
 		xev.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
 
-	xev.xclient.data.l[1] = m_system->m_net_fullscreen;
+	xev.xclient.data.l[1] = m_system->m_atom._NET_WM_STATE_FULLSCREEN;
 	xev.xclient.data.l[2] = 0;
 	xev.xclient.data.l[3] = 0;
 	xev.xclient.data.l[4] = 0;
@@ -862,12 +862,12 @@ bool GHOST_WindowX11::netwmIsFullScreen(void) const
 
 	prop_ret = NULL;
 	st = False;
-	ret = XGetWindowProperty(m_display, m_window, m_system->m_net_state, 0,
+	ret = XGetWindowProperty(m_display, m_window, m_system->m_atom._NET_WM_STATE, 0,
 	                         0x7fffffff, False, XA_ATOM, &type_ret, &format_ret,
 	                         &num_ret, &bytes_after, &prop_ret);
 	if ((ret == Success) && (prop_ret) && (format_ret == 32)) {
 		for (i = 0; i < num_ret; i++) {
-			if (((unsigned long *) prop_ret)[i] == m_system->m_net_fullscreen) {
+			if (((unsigned long *) prop_ret)[i] == m_system->m_atom._NET_WM_STATE_FULLSCREEN) {
 				st = True;
 				break;
 			}
@@ -889,8 +889,8 @@ void GHOST_WindowX11::motifFullScreen(bool set)
 	else
 		hints.decorations = 1;
 
-	XChangeProperty(m_display, m_window, m_system->m_motif,
-	                m_system->m_motif, 32, PropModeReplace,
+	XChangeProperty(m_display, m_window, m_system->m_atom._MOTIF_WM_HINTS,
+	                m_system->m_atom._MOTIF_WM_HINTS, 32, PropModeReplace,
 	                (unsigned char *) &hints, 4);
 }
 
@@ -905,8 +905,8 @@ bool GHOST_WindowX11::motifIsFullScreen(void) const
 
 	prop_ret = NULL;
 	state = False;
-	st = XGetWindowProperty(m_display, m_window, m_system->m_motif, 0,
-	                        0x7fffffff, False, m_system->m_motif,
+	st = XGetWindowProperty(m_display, m_window, m_system->m_atom._MOTIF_WM_HINTS, 0,
+	                        0x7fffffff, False, m_system->m_atom._MOTIF_WM_HINTS,
 	                        &type_ret, &format_ret, &num_ret,
 	                        &bytes_after, &prop_ret);
 	if ((st == Success) && (prop_ret)) {
diff --git a/intern/smoke/intern/FFT_NOISE.h b/intern/smoke/intern/FFT_NOISE.h
index 8b7e4f2728b..0d8be7db602 100644
--- a/intern/smoke/intern/FFT_NOISE.h
+++ b/intern/smoke/intern/FFT_NOISE.h
@@ -94,9 +94,9 @@ static void generatTile_FFT(float* const noiseTileData, std::string filename)
 			for (int x = 0; x < xRes; x++)
 			{
 				int index = x + y * xRes + z * xRes * yRes;
-				float diff[] = {abs(x - xRes/2), 
-				abs(y - yRes/2), 
-				abs(z - zRes/2)};
+				float diff[] = {(float)abs(x - xRes / 2),
+				                (float)abs(y - yRes / 2),
+				                (float)abs(z - zRes / 2)};
 				float radius = sqrtf(diff[0] * diff[0] + 
 				diff[1] * diff[1] + 
 				diff[2] * diff[2]) / (xRes / 2);
diff --git a/intern/smoke/intern/FLUID_3D.cpp b/intern/smoke/intern/FLUID_3D.cpp
index a1d39286a90..5f0b2439200 100644
--- a/intern/smoke/intern/FLUID_3D.cpp
+++ b/intern/smoke/intern/FLUID_3D.cpp
@@ -1654,7 +1654,7 @@ void FLUID_3D::processBurn(float *fuel, float *smoke, float *react, float *flame
 		fuel[index] -= burning_rate * dt;
 		if (fuel[index] < 0.0f) fuel[index] = 0.0f;
 		/* process reaction coordinate */
-		if (orig_fuel) {
+		if (orig_fuel > FLT_EPSILON) {
 			react[index] *= fuel[index]/orig_fuel;
 			react_coord = react[index];
 		}
@@ -1681,7 +1681,7 @@ void FLUID_3D::processBurn(float *fuel, float *smoke, float *react, float *flame
 			heat[index] = (1.0f-flame[index])*ignition_point + flame[index]*temp_max;
 
 		/* mix new color */
-		if (r && smoke_emit) {
+		if (r && smoke_emit > FLT_EPSILON) {
 			float smoke_factor = smoke[index]/(orig_smoke+smoke_emit);
 			r[index] = (r[index] + _flame_smoke_color[0] * smoke_emit) * smoke_factor;
 			g[index] = (g[index] + _flame_smoke_color[1] * smoke_emit) * smoke_factor;