Cycles Denoising: Cleanup: Rename tiles to tile_info

6 files changed, 50 insertions, 50 deletions

diff --git a/intern/cycles/device/device_cpu.cpp b/intern/cycles/device/device_cpu.cpp
index b824cddd87b..c54ac1e5933 100644
--- a/intern/cycles/device/device_cpu.cpp
+++ b/intern/cycles/device/device_cpu.cpp
@@ -179,8 +179,8 @@ public:
 	KernelFunctions<void(*)(KernelGlobals *, uchar4 *, float *, float, int, int, int, int)> convert_to_byte_kernel;
 	KernelFunctions<void(*)(KernelGlobals *, uint4 *, float4 *, int, int, int, int, int)>   shader_kernel;
 
-	KernelFunctions<void(*)(int, TilesInfo*, int, int, float*, float*, float*, float*, float*, int*, int, int)> filter_divide_shadow_kernel;
-	KernelFunctions<void(*)(int, TilesInfo*, int, int, int, int, float*, float*, int*, int, int)>               filter_get_feature_kernel;
+	KernelFunctions<void(*)(int, TileInfo*, int, int, float*, float*, float*, float*, float*, int*, int, int)> filter_divide_shadow_kernel;
+	KernelFunctions<void(*)(int, TileInfo*, int, int, int, int, float*, float*, int*, int, int)>               filter_get_feature_kernel;
 	KernelFunctions<void(*)(int, int, float*, float*, float*, float*, int*, int)>                               filter_detect_outliers_kernel;
 	KernelFunctions<void(*)(int, int, float*, float*, float*, float*, int*, int)>                               filter_combine_halves_kernel;
 
@@ -459,14 +459,14 @@ public:
 		}
 	};
 
-	bool denoising_set_tiles(device_ptr *buffers, DenoisingTask *task)
+	bool denoising_set_tile_info(device_ptr *buffers, DenoisingTask *task)
 	{
-		TilesInfo *tiles = (TilesInfo*) task->tiles_mem.host_pointer;
+		TileInfo *tile_info = (TileInfo*) task->tile_info_mem.host_pointer;
 		for(int i = 0; i < 9; i++) {
-			tiles->buffers[i] = buffers[i];
+			tile_info->buffers[i] = buffers[i];
 		}
 
-		task->tiles_mem.copy_to_device();
+		task->tile_info_mem.copy_to_device();
 
 		return true;
 	}
@@ -626,7 +626,7 @@ public:
 		for(int y = task->rect.y; y < task->rect.w; y++) {
 			for(int x = task->rect.x; x < task->rect.z; x++) {
 				filter_divide_shadow_kernel()(task->render_buffer.samples,
-				                              task->tiles,
+				                              task->tile_info,
 				                              x, y,
 				                              (float*) a_ptr,
 				                              (float*) b_ptr,
@@ -650,7 +650,7 @@ public:
 		for(int y = task->rect.y; y < task->rect.w; y++) {
 			for(int x = task->rect.x; x < task->rect.z; x++) {
 				filter_get_feature_kernel()(task->render_buffer.samples,
-				                            task->tiles,
+				                            task->tile_info,
 				                            mean_offset,
 				                            variance_offset,
 				                            x, y,
@@ -722,7 +722,7 @@ public:
 		denoising.functions.combine_halves = function_bind(&CPUDevice::denoising_combine_halves, this, _1, _2, _3, _4, _5, _6, &denoising);
 		denoising.functions.get_feature = function_bind(&CPUDevice::denoising_get_feature, this, _1, _2, _3, _4, &denoising);
 		denoising.functions.detect_outliers = function_bind(&CPUDevice::denoising_detect_outliers, this, _1, _2, _3, _4, &denoising);
-		denoising.functions.set_tiles = function_bind(&CPUDevice::denoising_set_tiles, this, _1, &denoising);
+		denoising.functions.set_tile_info = function_bind(&CPUDevice::denoising_set_tile_info, this, _1, &denoising);
 
 		denoising.filter_area = make_int4(tile.x, tile.y, tile.w, tile.h);
 		denoising.render_buffer.samples = tile.sample;
diff --git a/intern/cycles/device/device_cuda.cpp b/intern/cycles/device/device_cuda.cpp
index 1e7883f612b..c8e0ea4d896 100644
--- a/intern/cycles/device/device_cuda.cpp
+++ b/intern/cycles/device/device_cuda.cpp
@@ -1251,14 +1251,14 @@ public:
 		}
 	}
 
-	bool denoising_set_tiles(device_ptr *buffers, DenoisingTask *task)
+	bool denoising_set_tile_info(device_ptr *buffers, DenoisingTask *task)
 	{
-		TilesInfo *tiles = (TilesInfo*) task->tiles_mem.host_pointer;
+		TileInfo *tile_info = (TileInfo*) task->tile_info_mem.host_pointer;
 		for(int i = 0; i < 9; i++) {
-			tiles->buffers[i] = buffers[i];
+			tile_info->buffers[i] = buffers[i];
 		}
 
-		task->tiles_mem.copy_to_device();
+		task->tile_info_mem.copy_to_device();
 
 		return !have_error();
 	}
@@ -1534,7 +1534,7 @@ public:
 		                   task->rect.w-task->rect.y);
 
 		void *args[] = {&task->render_buffer.samples,
-		                &task->tiles_mem.device_pointer,
+		                &task->tile_info_mem.device_pointer,
 		                &a_ptr,
 		                &b_ptr,
 		                &sample_variance_ptr,
@@ -1568,7 +1568,7 @@ public:
 		                   task->rect.w-task->rect.y);
 
 		void *args[] = {&task->render_buffer.samples,
-		                &task->tiles_mem.device_pointer,
+		                &task->tile_info_mem.device_pointer,
 		                &mean_offset,
 		                &variance_offset,
 		                &mean_ptr,
@@ -1622,7 +1622,7 @@ public:
 		denoising.functions.combine_halves = function_bind(&CUDADevice::denoising_combine_halves, this, _1, _2, _3, _4, _5, _6, &denoising);
 		denoising.functions.get_feature = function_bind(&CUDADevice::denoising_get_feature, this, _1, _2, _3, _4, &denoising);
 		denoising.functions.detect_outliers = function_bind(&CUDADevice::denoising_detect_outliers, this, _1, _2, _3, _4, &denoising);
-		denoising.functions.set_tiles = function_bind(&CUDADevice::denoising_set_tiles, this, _1, &denoising);
+		denoising.functions.set_tile_info = function_bind(&CUDADevice::denoising_set_tile_info, this, _1, &denoising);
 
 		denoising.filter_area = make_int4(rtile.x, rtile.y, rtile.w, rtile.h);
 		denoising.render_buffer.samples = rtile.sample;
diff --git a/intern/cycles/device/device_denoising.cpp b/intern/cycles/device/device_denoising.cpp
index fe6b53fc374..318b14ab499 100644
--- a/intern/cycles/device/device_denoising.cpp
+++ b/intern/cycles/device/device_denoising.cpp
@@ -21,7 +21,7 @@
 CCL_NAMESPACE_BEGIN
 
 DenoisingTask::DenoisingTask(Device *device, const DeviceTask &task)
-: tiles_mem(device, "denoising tiles_mem", MEM_READ_WRITE),
+: tile_info_mem(device, "denoising tile info mem", MEM_READ_WRITE),
   storage(device),
   buffer(device),
   device(device)
@@ -55,33 +55,33 @@ DenoisingTask::~DenoisingTask()
 	storage.temporary_2.free();
 	storage.temporary_color.free();
 	buffer.mem.free();
-	tiles_mem.free();
+	tile_info_mem.free();
 }
 
 void DenoisingTask::set_render_buffer(RenderTile *rtiles)
 {
-	tiles = (TilesInfo*) tiles_mem.alloc(sizeof(TilesInfo)/sizeof(int));
+	tile_info = (TileInfo*) tile_info_mem.alloc(sizeof(TileInfo)/sizeof(int));
 
 	device_ptr buffers[9];
 	for(int i = 0; i < 9; i++) {
 		buffers[i] = rtiles[i].buffer;
-		tiles->offsets[i] = rtiles[i].offset;
-		tiles->strides[i] = rtiles[i].stride;
+		tile_info->offsets[i] = rtiles[i].offset;
+		tile_info->strides[i] = rtiles[i].stride;
 	}
-	tiles->x[0] = rtiles[3].x;
-	tiles->x[1] = rtiles[4].x;
-	tiles->x[2] = rtiles[5].x;
-	tiles->x[3] = rtiles[5].x + rtiles[5].w;
-	tiles->y[0] = rtiles[1].y;
-	tiles->y[1] = rtiles[4].y;
-	tiles->y[2] = rtiles[7].y;
-	tiles->y[3] = rtiles[7].y + rtiles[7].h;
+	tile_info->x[0] = rtiles[3].x;
+	tile_info->x[1] = rtiles[4].x;
+	tile_info->x[2] = rtiles[5].x;
+	tile_info->x[3] = rtiles[5].x + rtiles[5].w;
+	tile_info->y[0] = rtiles[1].y;
+	tile_info->y[1] = rtiles[4].y;
+	tile_info->y[2] = rtiles[7].y;
+	tile_info->y[3] = rtiles[7].y + rtiles[7].h;
 
 	target_buffer.offset = rtiles[9].offset;
 	target_buffer.stride = rtiles[9].stride;
 	target_buffer.ptr    = rtiles[9].buffer;
 
-	functions.set_tiles(buffers);
+	functions.set_tile_info(buffers);
 }
 
 void DenoisingTask::setup_denoising_buffer()
@@ -89,7 +89,7 @@ void DenoisingTask::setup_denoising_buffer()
 	/* Expand filter_area by radius pixels and clamp the result to the extent of the neighboring tiles */
 	rect = rect_from_shape(filter_area.x, filter_area.y, filter_area.z, filter_area.w);
 	rect = rect_expand(rect, radius);
-	rect = rect_clip(rect, make_int4(tiles->x[0], tiles->y[0], tiles->x[3], tiles->y[3]));
+	rect = rect_clip(rect, make_int4(tile_info->x[0], tile_info->y[0], tile_info->x[3], tile_info->y[3]));
 
 	buffer.passes = 14;
 	buffer.width = rect.z - rect.x;
diff --git a/intern/cycles/device/device_denoising.h b/intern/cycles/device/device_denoising.h
index 21af1b10fc5..1063d43d039 100644
--- a/intern/cycles/device/device_denoising.h
+++ b/intern/cycles/device/device_denoising.h
@@ -48,8 +48,8 @@ public:
 		device_ptr ptr;
 	} target_buffer;
 
-	TilesInfo *tiles;
-	device_vector<int> tiles_mem;
+	TileInfo *tile_info;
+	device_vector<int> tile_info_mem;
 
 	int4 rect;
 	int4 filter_area;
@@ -89,7 +89,7 @@ public:
 		              device_ptr depth_ptr,
 		              device_ptr output_ptr
 		              )> detect_outliers;
-		function<bool(device_ptr*)> set_tiles;
+		function<bool(device_ptr*)> set_tile_info;
 		function<void(RenderTile *rtiles)> map_neighbor_tiles;
 		function<void(RenderTile *rtiles)> unmap_neighbor_tiles;
 	} functions;
diff --git a/intern/cycles/device/opencl/opencl.h b/intern/cycles/device/opencl/opencl.h
index 7526f1e15a1..c550d738bd5 100644
--- a/intern/cycles/device/opencl/opencl.h
+++ b/intern/cycles/device/opencl/opencl.h
@@ -436,8 +436,8 @@ protected:
 	                               device_ptr depth_ptr,
 	                               device_ptr output_ptr,
 	                               DenoisingTask *task);
-	bool denoising_set_tiles(device_ptr *buffers,
-	                         DenoisingTask *task);
+	bool denoising_set_tile_info(device_ptr *buffers,
+	                             DenoisingTask *task);
 
 	device_ptr mem_alloc_sub_ptr(device_memory& mem, int offset, int size);
 	void mem_free_sub_ptr(device_ptr ptr);
diff --git a/intern/cycles/device/opencl/opencl_base.cpp b/intern/cycles/device/opencl/opencl_base.cpp
index 4e49e0ef166..50d371e4c55 100644
--- a/intern/cycles/device/opencl/opencl_base.cpp
+++ b/intern/cycles/device/opencl/opencl_base.cpp
@@ -246,7 +246,7 @@ bool OpenCLDeviceBase::load_kernels(const DeviceRequestedFeatures& requested_fea
 	denoising_program.add_kernel(ustring("filter_nlm_normalize"));
 	denoising_program.add_kernel(ustring("filter_nlm_construct_gramian"));
 	denoising_program.add_kernel(ustring("filter_finalize"));
-	denoising_program.add_kernel(ustring("filter_set_tiles"));
+	denoising_program.add_kernel(ustring("filter_set_tile_info"));
 
 	vector<OpenCLProgram*> programs;
 	programs.push_back(&base_program);
@@ -977,13 +977,13 @@ bool OpenCLDeviceBase::denoising_divide_shadow(device_ptr a_ptr,
 	cl_mem sv_variance_mem = CL_MEM_PTR(sv_variance_ptr);
 	cl_mem buffer_variance_mem = CL_MEM_PTR(buffer_variance_ptr);
 
-	cl_mem tiles_mem = CL_MEM_PTR(task->tiles_mem.device_pointer);
+	cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);
 
 	cl_kernel ckFilterDivideShadow = denoising_program(ustring("filter_divide_shadow"));
 
 	kernel_set_args(ckFilterDivideShadow, 0,
 	                task->render_buffer.samples,
-	                tiles_mem,
+	                tile_info_mem,
 	                a_mem,
 	                b_mem,
 	                sample_variance_mem,
@@ -1008,13 +1008,13 @@ bool OpenCLDeviceBase::denoising_get_feature(int mean_offset,
 	cl_mem mean_mem = CL_MEM_PTR(mean_ptr);
 	cl_mem variance_mem = CL_MEM_PTR(variance_ptr);
 
-	cl_mem tiles_mem = CL_MEM_PTR(task->tiles_mem.device_pointer);
+	cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);
 
 	cl_kernel ckFilterGetFeature = denoising_program(ustring("filter_get_feature"));
 
 	kernel_set_args(ckFilterGetFeature, 0,
 	                task->render_buffer.samples,
-	                tiles_mem,
+	                tile_info_mem,
 	                mean_offset,
 	                variance_offset,
 	                mean_mem,
@@ -1056,29 +1056,29 @@ bool OpenCLDeviceBase::denoising_detect_outliers(device_ptr image_ptr,
 	return true;
 }
 
-bool OpenCLDeviceBase::denoising_set_tiles(device_ptr *buffers,
-                                           DenoisingTask *task)
+bool OpenCLDeviceBase::denoising_set_tile_info(device_ptr *buffers,
+                                               DenoisingTask *task)
 {
-	task->tiles_mem.copy_to_device();
+	task->tile_info_mem.copy_to_device();
 
-	cl_mem tiles_mem = CL_MEM_PTR(task->tiles_mem.device_pointer);
+	cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);
 
-	cl_kernel ckFilterSetTiles = denoising_program(ustring("filter_set_tiles"));
+	cl_kernel ckFilterSetTileInfo = denoising_program(ustring("filter_set_tile_info"));
 
-	kernel_set_args(ckFilterSetTiles, 0, tiles_mem);
+	kernel_set_args(ckFilterSetTileInfo, 0, tile_info_mem);
 	for(int i = 0; i < 9; i++) {
 		cl_mem buffer_mem = CL_MEM_PTR(buffers[i]);
-		kernel_set_args(ckFilterSetTiles, i+1, buffer_mem);
+		kernel_set_args(ckFilterSetTileInfo, i+1, buffer_mem);
 	}
 
-	enqueue_kernel(ckFilterSetTiles, 1, 1);
+	enqueue_kernel(ckFilterSetTileInfo, 1, 1);
 
 	return true;
 }
 
 void OpenCLDeviceBase::denoise(RenderTile &rtile, DenoisingTask& denoising)
 {
-	denoising.functions.set_tiles = function_bind(&OpenCLDeviceBase::denoising_set_tiles, this, _1, &denoising);
+	denoising.functions.set_tile_info = function_bind(&OpenCLDeviceBase::denoising_set_tile_info, this, _1, &denoising);
 	denoising.functions.construct_transform = function_bind(&OpenCLDeviceBase::denoising_construct_transform, this, &denoising);
 	denoising.functions.reconstruct = function_bind(&OpenCLDeviceBase::denoising_reconstruct, this, _1, _2, _3, &denoising);
 	denoising.functions.divide_shadow = function_bind(&OpenCLDeviceBase::denoising_divide_shadow, this, _1, _2, _3, _4, _5, &denoising);