Code refactor: store device/interp/extension/type in each device_memory.

14 files changed, 113 insertions, 69 deletions

diff --git a/intern/cycles/render/bake.cpp b/intern/cycles/render/bake.cpp
index 2bedf3668f7..66615bf336c 100644
--- a/intern/cycles/render/bake.cpp
+++ b/intern/cycles/render/bake.cpp
@@ -150,7 +150,7 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 		size_t shader_size = (size_t)fminf(num_pixels - shader_offset, m_shader_limit);
 
 		/* setup input for device task */
-		device_vector<uint4> d_input;
+		device_vector<uint4> d_input(device, "bake_input", MEM_READ_ONLY);
 		uint4 *d_input_data = d_input.resize(shader_size * 2);
 		size_t d_input_size = 0;
 
@@ -165,15 +165,15 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 		}
 
 		/* run device task */
-		device_vector<float4> d_output;
+		device_vector<float4> d_output(device, "bake_output", MEM_READ_WRITE);
 		d_output.resize(shader_size);
 
 		/* needs to be up to data for attribute access */
 		device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-		device->mem_alloc("bake_input", d_input, MEM_READ_ONLY);
+		device->mem_alloc(d_input);
 		device->mem_copy_to(d_input);
-		device->mem_alloc("bake_output", d_output, MEM_READ_WRITE);
+		device->mem_alloc(d_output);
 		device->mem_zero(d_output);
 
 		DeviceTask task(DeviceTask::SHADER);
diff --git a/intern/cycles/render/buffers.cpp b/intern/cycles/render/buffers.cpp
index b7477ffadd0..2342dd52d86 100644
--- a/intern/cycles/render/buffers.cpp
+++ b/intern/cycles/render/buffers.cpp
@@ -114,9 +114,10 @@ RenderTile::RenderTile()
 
 /* Render Buffers */
 
-RenderBuffers::RenderBuffers(Device *device_)
+RenderBuffers::RenderBuffers(Device *device)
+: buffer(device, "RenderBuffers", MEM_READ_WRITE),
+  device(device)
 {
-	device = device_;
 }
 
 RenderBuffers::~RenderBuffers()
@@ -138,10 +139,10 @@ void RenderBuffers::reset(Device *device, BufferParams& params_)
 
 	/* free existing buffers */
 	device_free();
-	
+
 	/* allocate buffer */
 	buffer.resize(params.width*params.height*params.get_passes_size());
-	device->mem_alloc("render_buffer", buffer, MEM_READ_WRITE);
+	device->mem_alloc(buffer);
 	device->mem_zero(buffer);
 }
 
@@ -396,13 +397,15 @@ bool RenderBuffers::get_pass_rect(PassType type, float exposure, int sample, int
 
 /* Display Buffer */
 
-DisplayBuffer::DisplayBuffer(Device *device_, bool linear)
+DisplayBuffer::DisplayBuffer(Device *device, bool linear)
+: draw_width(0),
+  draw_height(0),
+  transparent(true), /* todo: determine from background */
+  half_float(linear),
+  rgba_byte(device, "display buffer byte", MEM_WRITE_ONLY),
+  rgba_half(device, "display buffer half", MEM_WRITE_ONLY),
+  device(device)
 {
-	device = device_;
-	draw_width = 0;
-	draw_height = 0;
-	transparent = true; /* todo: determine from background */
-	half_float = linear;
 }
 
 DisplayBuffer::~DisplayBuffer()
diff --git a/intern/cycles/render/image.cpp b/intern/cycles/render/image.cpp
index c9fbd237010..e7f5ff002b7 100644
--- a/intern/cycles/render/image.cpp
+++ b/intern/cycles/render/image.cpp
@@ -729,7 +729,7 @@ void ImageManager::device_load_image(Device *device,
 
 	/* Create new texture. */
 	if(type == IMAGE_DATA_TYPE_FLOAT4) {
-		device_vector<float4> *tex_img = new device_vector<float4>();
+		device_vector<float4> *tex_img = new device_vector<float4>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::FLOAT, float>(img,
 		                                            type,
@@ -748,7 +748,7 @@ void ImageManager::device_load_image(Device *device,
 		img->mem = tex_img;
 	}
 	else if(type == IMAGE_DATA_TYPE_FLOAT) {
-		device_vector<float> *tex_img = new device_vector<float>();
+		device_vector<float> *tex_img = new device_vector<float>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::FLOAT, float>(img,
 		                                            type,
@@ -764,7 +764,7 @@ void ImageManager::device_load_image(Device *device,
 		img->mem = tex_img;
 	}
 	else if(type == IMAGE_DATA_TYPE_BYTE4) {
-		device_vector<uchar4> *tex_img = new device_vector<uchar4>();
+		device_vector<uchar4> *tex_img = new device_vector<uchar4>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::UINT8, uchar>(img,
 		                                            type,
@@ -783,7 +783,7 @@ void ImageManager::device_load_image(Device *device,
 		img->mem = tex_img;
 	}
 	else if(type == IMAGE_DATA_TYPE_BYTE) {
-		device_vector<uchar> *tex_img = new device_vector<uchar>();
+		device_vector<uchar> *tex_img = new device_vector<uchar>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::UINT8, uchar>(img,
 		                                            type,
@@ -798,7 +798,7 @@ void ImageManager::device_load_image(Device *device,
 		img->mem = tex_img;
 	}
 	else if(type == IMAGE_DATA_TYPE_HALF4) {
-		device_vector<half4> *tex_img = new device_vector<half4>();
+		device_vector<half4> *tex_img = new device_vector<half4>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::HALF, half>(img,
 		                                          type,
@@ -816,7 +816,7 @@ void ImageManager::device_load_image(Device *device,
 		img->mem = tex_img;
 	}
 	else if(type == IMAGE_DATA_TYPE_HALF) {
-		device_vector<half> *tex_img = new device_vector<half>();
+		device_vector<half> *tex_img = new device_vector<half>(device, name.c_str());
 
 		if(!file_load_image<TypeDesc::HALF, half>(img,
 		                                          type,
@@ -833,11 +833,11 @@ void ImageManager::device_load_image(Device *device,
 
 	/* Copy to device. */
 	if(img->mem) {
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
 		thread_scoped_lock device_lock(device_mutex);
-		device->tex_alloc(name.c_str(),
-						  *img->mem,
-						  img->interpolation,
-						  img->extension);
+		device->tex_alloc(*img->mem);
 	}
 
 
diff --git a/intern/cycles/render/integrator.cpp b/intern/cycles/render/integrator.cpp
index b268478e6d3..b128f18db08 100644
--- a/intern/cycles/render/integrator.cpp
+++ b/intern/cycles/render/integrator.cpp
@@ -195,7 +195,7 @@ void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene
 
 	sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);
 
-	device->tex_alloc("__sobol_directions", dscene->sobol_directions);
+	device->tex_alloc(dscene->sobol_directions);
 
 	/* Clamping. */
 	bool use_sample_clamp = (sample_clamp_direct != 0.0f ||
diff --git a/intern/cycles/render/light.cpp b/intern/cycles/render/light.cpp
index bb73ebd7e41..9664e1310d5 100644
--- a/intern/cycles/render/light.cpp
+++ b/intern/cycles/render/light.cpp
@@ -36,8 +36,8 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 	int width = res;
 	int height = res;
 
-	device_vector<uint4> d_input;
-	device_vector<float4> d_output;
+	device_vector<uint4> d_input(device, "background_input", MEM_READ_ONLY);
+	device_vector<float4> d_output(device, "background_output", MEM_WRITE_ONLY);
 
 	uint4 *d_input_data = d_input.resize(width*height);
 
@@ -57,9 +57,9 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 
 	device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-	device->mem_alloc("shade_background_pixels_input", d_input, MEM_READ_ONLY);
+	device->mem_alloc(d_input);
 	device->mem_copy_to(d_input);
-	device->mem_alloc("shade_background_pixels_output", d_output, MEM_WRITE_ONLY);
+	device->mem_alloc(d_output);
 	device->mem_zero(d_output);
 
 	DeviceTask main_task(DeviceTask::SHADER);
@@ -451,7 +451,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 			kfilm->pass_shadow_scale *= (float)(num_lights - num_background_lights)/(float)num_lights;
 
 		/* CDF */
-		device->tex_alloc("__light_distribution", dscene->light_distribution);
+		device->tex_alloc(dscene->light_distribution);
 
 		/* Portals */
 		if(num_portals > 0) {
@@ -611,8 +611,8 @@ void LightManager::device_update_background(Device *device,
 	VLOG(2) << "Background MIS build time " << time_dt() - time_start << "\n";
 
 	/* update device */
-	device->tex_alloc("__light_background_marginal_cdf", dscene->light_background_marginal_cdf);
-	device->tex_alloc("__light_background_conditional_cdf", dscene->light_background_conditional_cdf);
+	device->tex_alloc(dscene->light_background_marginal_cdf);
+	device->tex_alloc(dscene->light_background_conditional_cdf);
 }
 
 void LightManager::device_update_points(Device *device,
@@ -813,7 +813,7 @@ void LightManager::device_update_points(Device *device,
 	VLOG(1) << "Number of lights without contribution: "
 	        << num_scene_lights - light_index;
 
-	device->tex_alloc("__light_data", dscene->light_data);
+	device->tex_alloc(dscene->light_data);
 }
 
 void LightManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
diff --git a/intern/cycles/render/mesh.cpp b/intern/cycles/render/mesh.cpp
index 69c21fc3cb3..685272b80c1 100644
--- a/intern/cycles/render/mesh.cpp
+++ b/intern/cycles/render/mesh.cpp
@@ -1359,7 +1359,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce
 
 	/* copy to device */
 	dscene->data.bvh.attributes_map_stride = attr_map_stride;
-	device->tex_alloc("__attributes_map", dscene->attributes_map);
+	device->tex_alloc(dscene->attributes_map);
 }
 
 static void update_attribute_element_size(Mesh *mesh,
@@ -1617,13 +1617,13 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
 	progress.set_status("Updating Mesh", "Copying Attributes to device");
 
 	if(dscene->attributes_float.size()) {
-		device->tex_alloc("__attributes_float", dscene->attributes_float);
+		device->tex_alloc(dscene->attributes_float);
 	}
 	if(dscene->attributes_float3.size()) {
-		device->tex_alloc("__attributes_float3", dscene->attributes_float3);
+		device->tex_alloc(dscene->attributes_float3);
 	}
 	if(dscene->attributes_uchar4.size()) {
-		device->tex_alloc("__attributes_uchar4", dscene->attributes_uchar4);
+		device->tex_alloc(dscene->attributes_uchar4);
 	}
 }
 
@@ -1754,11 +1754,11 @@ void MeshManager::device_update_mesh(Device *device,
 		/* vertex coordinates */
 		progress.set_status("Updating Mesh", "Copying Mesh to device");
 
-		device->tex_alloc("__tri_shader", dscene->tri_shader);
-		device->tex_alloc("__tri_vnormal", dscene->tri_vnormal);
-		device->tex_alloc("__tri_vindex", dscene->tri_vindex);
-		device->tex_alloc("__tri_patch", dscene->tri_patch);
-		device->tex_alloc("__tri_patch_uv", dscene->tri_patch_uv);
+		device->tex_alloc(dscene->tri_shader);
+		device->tex_alloc(dscene->tri_vnormal);
+		device->tex_alloc(dscene->tri_vindex);
+		device->tex_alloc(dscene->tri_patch);
+		device->tex_alloc(dscene->tri_patch_uv);
 	}
 
 	if(curve_size != 0) {
@@ -1772,8 +1772,8 @@ void MeshManager::device_update_mesh(Device *device,
 			if(progress.get_cancel()) return;
 		}
 
-		device->tex_alloc("__curve_keys", dscene->curve_keys);
-		device->tex_alloc("__curves", dscene->curves);
+		device->tex_alloc(dscene->curve_keys);
+		device->tex_alloc(dscene->curves);
 	}
 
 	if(patch_size != 0) {
@@ -1791,7 +1791,7 @@ void MeshManager::device_update_mesh(Device *device,
 			if(progress.get_cancel()) return;
 		}
 
-		device->tex_alloc("__patches", dscene->patches);
+		device->tex_alloc(dscene->patches);
 	}
 
 	if(for_displacement) {
@@ -1805,7 +1805,7 @@ void MeshManager::device_update_mesh(Device *device,
 				prim_tri_verts[offset + 2] = float3_to_float4(mesh->verts[t.v[2]]);
 			}
 		}
-		device->tex_alloc("__prim_tri_verts", dscene->prim_tri_verts);
+		device->tex_alloc(dscene->prim_tri_verts);
 	}
 }
 
@@ -1841,43 +1841,43 @@ void MeshManager::device_update_bvh(Device *device, DeviceScene *dscene, Scene *
 
 	if(pack.nodes.size()) {
 		dscene->bvh_nodes.steal_data(pack.nodes);
-		device->tex_alloc("__bvh_nodes", dscene->bvh_nodes);
+		device->tex_alloc(dscene->bvh_nodes);
 	}
 	if(pack.leaf_nodes.size()) {
 		dscene->bvh_leaf_nodes.steal_data(pack.leaf_nodes);
-		device->tex_alloc("__bvh_leaf_nodes", dscene->bvh_leaf_nodes);
+		device->tex_alloc(dscene->bvh_leaf_nodes);
 	}
 	if(pack.object_node.size()) {
 		dscene->object_node.steal_data(pack.object_node);
-		device->tex_alloc("__object_node", dscene->object_node);
+		device->tex_alloc(dscene->object_node);
 	}
 	if(pack.prim_tri_index.size()) {
 		dscene->prim_tri_index.steal_data(pack.prim_tri_index);
-		device->tex_alloc("__prim_tri_index", dscene->prim_tri_index);
+		device->tex_alloc(dscene->prim_tri_index);
 	}
 	if(pack.prim_tri_verts.size()) {
 		dscene->prim_tri_verts.steal_data(pack.prim_tri_verts);
-		device->tex_alloc("__prim_tri_verts", dscene->prim_tri_verts);
+		device->tex_alloc(dscene->prim_tri_verts);
 	}
 	if(pack.prim_type.size()) {
 		dscene->prim_type.steal_data(pack.prim_type);
-		device->tex_alloc("__prim_type", dscene->prim_type);
+		device->tex_alloc(dscene->prim_type);
 	}
 	if(pack.prim_visibility.size()) {
 		dscene->prim_visibility.steal_data(pack.prim_visibility);
-		device->tex_alloc("__prim_visibility", dscene->prim_visibility);
+		device->tex_alloc(dscene->prim_visibility);
 	}
 	if(pack.prim_index.size()) {
 		dscene->prim_index.steal_data(pack.prim_index);
-		device->tex_alloc("__prim_index", dscene->prim_index);
+		device->tex_alloc(dscene->prim_index);
 	}
 	if(pack.prim_object.size()) {
 		dscene->prim_object.steal_data(pack.prim_object);
-		device->tex_alloc("__prim_object", dscene->prim_object);
+		device->tex_alloc(dscene->prim_object);
 	}
 	if(pack.prim_time.size()) {
 		dscene->prim_time.steal_data(pack.prim_time);
-		device->tex_alloc("__prim_time", dscene->prim_time);
+		device->tex_alloc(dscene->prim_time);
 	}
 
 	dscene->data.bvh.root = pack.root_index;
diff --git a/intern/cycles/render/mesh_displace.cpp b/intern/cycles/render/mesh_displace.cpp
index 350a56bf185..c06cf86ea9c 100644
--- a/intern/cycles/render/mesh_displace.cpp
+++ b/intern/cycles/render/mesh_displace.cpp
@@ -64,7 +64,7 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 	/* setup input for device task */
 	const size_t num_verts = mesh->verts.size();
 	vector<bool> done(num_verts, false);
-	device_vector<uint4> d_input;
+	device_vector<uint4> d_input(device, "displace_input", MEM_READ_ONLY);
 	uint4 *d_input_data = d_input.resize(num_verts);
 	size_t d_input_size = 0;
 
@@ -115,15 +115,15 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 		return false;
 	
 	/* run device task */
-	device_vector<float4> d_output;
+	device_vector<float4> d_output(device, "displace_output", MEM_WRITE_ONLY);
 	d_output.resize(d_input_size);
 
 	/* needs to be up to data for attribute access */
 	device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-	device->mem_alloc("displace_input", d_input, MEM_READ_ONLY);
+	device->mem_alloc(d_input);
 	device->mem_copy_to(d_input);
-	device->mem_alloc("displace_output", d_output, MEM_WRITE_ONLY);
+	device->mem_alloc(d_output);
 	device->mem_zero(d_output);
 
 	DeviceTask task(DeviceTask::SHADER);
diff --git a/intern/cycles/render/object.cpp b/intern/cycles/render/object.cpp
index 12690090066..daa872239ce 100644
--- a/intern/cycles/render/object.cpp
+++ b/intern/cycles/render/object.cpp
@@ -534,9 +534,9 @@ void ObjectManager::device_update_transforms(Device *device,
 		}
 	}
 
-	device->tex_alloc("__objects", dscene->objects);
+	device->tex_alloc(dscene->objects);
 	if(state.need_motion == Scene::MOTION_PASS) {
-		device->tex_alloc("__objects_vector", dscene->objects_vector);
+		device->tex_alloc(dscene->objects_vector);
 	}
 
 	dscene->data.bvh.have_motion = state.have_motion;
@@ -638,7 +638,7 @@ void ObjectManager::device_update_flags(Device *device,
 	}
 
 	/* allocate object flag */
-	device->tex_alloc("__object_flag", dscene->object_flag);
+	device->tex_alloc(dscene->object_flag);
 }
 
 void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene *dscene, Scene *scene)
@@ -672,7 +672,7 @@ void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene
 
 	if(update) {
 		device->tex_free(dscene->objects);
-		device->tex_alloc("__objects", dscene->objects);
+		device->tex_alloc(dscene->objects);
 	}
 }
 
diff --git a/intern/cycles/render/particles.cpp b/intern/cycles/render/particles.cpp
index a51822a08be..a84ca51f274 100644
--- a/intern/cycles/render/particles.cpp
+++ b/intern/cycles/render/particles.cpp
@@ -91,7 +91,7 @@ void ParticleSystemManager::device_update_particles(Device *device, DeviceScene
 		}
 	}
 	
-	device->tex_alloc("__particles", dscene->particles);
+	device->tex_alloc(dscene->particles);
 }
 
 void ParticleSystemManager::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 00c32312d9f..e362a35471d 100644
--- a/intern/cycles/render/scene.cpp
+++ b/intern/cycles/render/scene.cpp
@@ -40,8 +40,47 @@
 
 CCL_NAMESPACE_BEGIN
 
+DeviceScene::DeviceScene(Device *device)
+: bvh_nodes(device, "__bvh_nodes"),
+  bvh_leaf_nodes(device, "__bvh_leaf_nodes"),
+  object_node(device, "__object_node"),
+  prim_tri_index(device, "__prim_tri_index"),
+  prim_tri_verts(device, "__prim_tri_verts"),
+  prim_type(device, "__prim_type"),
+  prim_visibility(device, "__prim_visibility"),
+  prim_index(device, "__prim_index"),
+  prim_object(device, "__prim_object"),
+  prim_time(device, "__prim_time"),
+  tri_shader(device, "__tri_shader"),
+  tri_vnormal(device, "__tri_vnormal"),
+  tri_vindex(device, "__tri_vindex"),
+  tri_patch(device, "__tri_patch"),
+  tri_patch_uv(device, "__tri_patch_uv"),
+  curves(device, "__curves"),
+  curve_keys(device, "__curve_keys"),
+  patches(device, "__patches"),
+  objects(device, "__objects"),
+  objects_vector(device, "__objects_vector"),
+  attributes_map(device, "__attributes_map"),
+  attributes_float(device, "__attributes_float"),
+  attributes_float3(device, "__attributes_float3"),
+  attributes_uchar4(device, "__attributes_uchar4"),
+  light_distribution(device, "__light_distribution"),
+  light_data(device, "__light_data"),
+  light_background_marginal_cdf(device, "__light_background_marginal_cdf"),
+  light_background_conditional_cdf(device, "__light_background_conditional_cdf"),
+  particles(device, "__particles"),
+  svm_nodes(device, "__svm_nodes"),
+  shader_flag(device, "__shader_flag"),
+  object_flag(device, "__object_flag"),
+  lookup_table(device, "__lookup_table"),
+  sobol_directions(device, "__sobol_directions")
+{
+	memset(&data, 0, sizeof(data));
+}
+
 Scene::Scene(const SceneParams& params_, Device *device)
-: device(device), params(params_)
+: device(device), dscene(device), params(params_)
 {
 	memset(&dscene.data, 0, sizeof(dscene.data));
 
diff --git a/intern/cycles/render/scene.h b/intern/cycles/render/scene.h
index 23b9eb06a7b..204c38e5963 100644
--- a/intern/cycles/render/scene.h
+++ b/intern/cycles/render/scene.h
@@ -114,6 +114,8 @@ public:
 	device_vector<uint> sobol_directions;
 
 	KernelData data;
+
+	DeviceScene(Device *device);
 };
 
 /* Scene Parameters */
diff --git a/intern/cycles/render/shader.cpp b/intern/cycles/render/shader.cpp
index 3992ada2e85..a77df55e520 100644
--- a/intern/cycles/render/shader.cpp
+++ b/intern/cycles/render/shader.cpp
@@ -479,7 +479,7 @@ void ShaderManager::device_update_common(Device *device,
 		has_transparent_shadow |= (flag & SD_HAS_TRANSPARENT_SHADOW) != 0;
 	}
 
-	device->tex_alloc("__shader_flag", dscene->shader_flag);
+	device->tex_alloc(dscene->shader_flag);
 
 	/* lookup tables */
 	KernelTables *ktables = &dscene->data.tables;
diff --git a/intern/cycles/render/svm.cpp b/intern/cycles/render/svm.cpp
index 278a8a87b20..cf0dc97ef3f 100644
--- a/intern/cycles/render/svm.cpp
+++ b/intern/cycles/render/svm.cpp
@@ -130,7 +130,7 @@ void SVMShaderManager::device_update(Device *device, DeviceScene *dscene, Scene
 	}
 
 	dscene->svm_nodes.steal_data(svm_nodes);
-	device->tex_alloc("__svm_nodes", dscene->svm_nodes);
+	device->tex_alloc(dscene->svm_nodes);
 
 	for(i = 0; i < scene->shaders.size(); i++) {
 		Shader *shader = scene->shaders[i];
diff --git a/intern/cycles/render/tables.cpp b/intern/cycles/render/tables.cpp
index c08c83cfe11..9d04778abc6 100644
--- a/intern/cycles/render/tables.cpp
+++ b/intern/cycles/render/tables.cpp
@@ -45,7 +45,7 @@ void LookupTables::device_update(Device *device, DeviceScene *dscene)
 	device->tex_free(dscene->lookup_table);
 
 	if(lookup_tables.size() > 0)
-		device->tex_alloc("__lookup_table", dscene->lookup_table);
+		device->tex_alloc(dscene->lookup_table);
 
 	need_update = false;
 }