UI/Python: rename Lamps to Lights, to follow more standard terminology.

Internally it's still mostly named lamps, though some modules like Cycles
were already calling them lights.

8 files changed, 122 insertions, 122 deletions

diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index df6949f2095..85947b4bd28 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -887,17 +887,17 @@ class CyclesMaterialSettings(bpy.types.PropertyGroup):
         del bpy.types.Material.cycles
 
 
-class CyclesLampSettings(bpy.types.PropertyGroup):
+class CyclesLightSettings(bpy.types.PropertyGroup):
     @classmethod
     def register(cls):
-        bpy.types.Lamp.cycles = PointerProperty(
-                name="Cycles Lamp Settings",
-                description="Cycles lamp settings",
+        bpy.types.Light.cycles = PointerProperty(
+                name="Cycles Light Settings",
+                description="Cycles light settings",
                 type=cls,
                 )
         cls.cast_shadow = BoolProperty(
                 name="Cast Shadow",
-                description="Lamp casts shadows",
+                description="Light casts shadows",
                 default=True,
                 )
         cls.samples = IntProperty(
@@ -914,20 +914,20 @@ class CyclesLampSettings(bpy.types.PropertyGroup):
                 )
         cls.use_multiple_importance_sampling = BoolProperty(
                 name="Multiple Importance Sample",
-                description="Use multiple importance sampling for the lamp, "
-                            "reduces noise for area lamps and sharp glossy materials",
+                description="Use multiple importance sampling for the light, "
+                            "reduces noise for area lights and sharp glossy materials",
                 default=True,
                 )
         cls.is_portal = BoolProperty(
                 name="Is Portal",
-                description="Use this area lamp to guide sampling of the background, "
-                            "note that this will make the lamp invisible",
+                description="Use this area light to guide sampling of the background, "
+                            "note that this will make the light invisible",
                 default=False,
                 )
 
     @classmethod
     def unregister(cls):
-        del bpy.types.Lamp.cycles
+        del bpy.types.Light.cycles
 
 
 class CyclesWorldSettings(bpy.types.PropertyGroup):
@@ -1460,7 +1460,7 @@ def register():
     bpy.utils.register_class(CyclesRenderSettings)
     bpy.utils.register_class(CyclesCameraSettings)
     bpy.utils.register_class(CyclesMaterialSettings)
-    bpy.utils.register_class(CyclesLampSettings)
+    bpy.utils.register_class(CyclesLightSettings)
     bpy.utils.register_class(CyclesWorldSettings)
     bpy.utils.register_class(CyclesVisibilitySettings)
     bpy.utils.register_class(CyclesMeshSettings)
@@ -1475,7 +1475,7 @@ def unregister():
     bpy.utils.unregister_class(CyclesRenderSettings)
     bpy.utils.unregister_class(CyclesCameraSettings)
     bpy.utils.unregister_class(CyclesMaterialSettings)
-    bpy.utils.unregister_class(CyclesLampSettings)
+    bpy.utils.unregister_class(CyclesLightSettings)
     bpy.utils.unregister_class(CyclesWorldSettings)
     bpy.utils.unregister_class(CyclesMeshSettings)
     bpy.utils.unregister_class(CyclesObjectSettings)
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index 7a4ed4fbdaf..6688874de49 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -1008,7 +1008,7 @@ class CYCLES_OBJECT_PT_cycles_settings(CyclesButtonsPanel, Panel):
     def poll(cls, context):
         ob = context.object
         return (CyclesButtonsPanel.poll(context) and
-                ob and ((ob.type in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META', 'LAMP'}) or
+                ob and ((ob.type in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META', 'LIGHT'}) or
                         (ob.dupli_type == 'COLLECTION' and ob.dupli_group)))
 
     def draw(self, context):
@@ -1029,7 +1029,7 @@ class CYCLES_OBJECT_PT_cycles_settings(CyclesButtonsPanel, Panel):
         flow.prop(visibility, "transmission")
         flow.prop(visibility, "scatter")
 
-        if ob.type != 'LAMP':
+        if ob.type != 'LIGHT':
             flow.prop(visibility, "shadow")
 
         row = layout.row()
@@ -1049,7 +1049,7 @@ class CYCLES_OBJECT_PT_cycles_settings(CyclesButtonsPanel, Panel):
 
 
 class CYCLES_OT_use_shading_nodes(Operator):
-    """Enable nodes on a material, world or lamp"""
+    """Enable nodes on a material, world or light"""
     bl_idname = "cycles.use_shading_nodes"
     bl_label = "Use Nodes"
 
@@ -1063,8 +1063,8 @@ class CYCLES_OT_use_shading_nodes(Operator):
             context.material.use_nodes = True
         elif context.world:
             context.world.use_nodes = True
-        elif context.lamp:
-            context.lamp.use_nodes = True
+        elif context.light:
+            context.light.use_nodes = True
 
         return {'FINISHED'}
 
@@ -1089,7 +1089,7 @@ def panel_node_draw(layout, id_data, output_type, input_name):
     return True
 
 
-class CYCLES_LAMP_PT_preview(CyclesButtonsPanel, Panel):
+class CYCLES_LIGHT_PT_preview(CyclesButtonsPanel, Panel):
     bl_label = "Preview"
     bl_context = "data"
     bl_options = {'DEFAULT_CLOSED'}
@@ -1097,52 +1097,52 @@ class CYCLES_LAMP_PT_preview(CyclesButtonsPanel, Panel):
     @classmethod
     def poll(cls, context):
         return (
-            context.lamp and
+            context.light and
             not (
-                context.lamp.type == 'AREA' and
-                context.lamp.cycles.is_portal
+                context.light.type == 'AREA' and
+                context.light.cycles.is_portal
             ) and
             CyclesButtonsPanel.poll(context)
         )
 
     def draw(self, context):
-        self.layout.template_preview(context.lamp)
+        self.layout.template_preview(context.light)
 
 
-class CYCLES_LAMP_PT_lamp(CyclesButtonsPanel, Panel):
-    bl_label = "Lamp"
+class CYCLES_LIGHT_PT_light(CyclesButtonsPanel, Panel):
+    bl_label = "Light"
     bl_context = "data"
 
     @classmethod
     def poll(cls, context):
-        return context.lamp and CyclesButtonsPanel.poll(context)
+        return context.light and CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
 
-        lamp = context.lamp
-        clamp = lamp.cycles
+        light = context.light
+        clamp = light.cycles
         # cscene = context.scene.cycles
 
-        layout.prop(lamp, "type", expand=True)
+        layout.prop(light, "type", expand=True)
 
         layout.use_property_split = True
 
         col = layout.column()
 
-        if lamp.type in {'POINT', 'SUN', 'SPOT'}:
-            col.prop(lamp, "shadow_soft_size", text="Size")
-        elif lamp.type == 'AREA':
-            col.prop(lamp, "shape", text="Shape")
+        if light.type in {'POINT', 'SUN', 'SPOT'}:
+            col.prop(light, "shadow_soft_size", text="Size")
+        elif light.type == 'AREA':
+            col.prop(light, "shape", text="Shape")
             sub = col.column(align=True)
 
-            if lamp.shape in {'SQUARE', 'DISK'}:
-                sub.prop(lamp, "size")
-            elif lamp.shape in {'RECTANGLE', 'ELLIPSE'}:
-                sub.prop(lamp, "size", text="Size X")
-                sub.prop(lamp, "size_y", text="Y")
+            if light.shape in {'SQUARE', 'DISK'}:
+                sub.prop(light, "size")
+            elif light.shape in {'RECTANGLE', 'ELLIPSE'}:
+                sub.prop(light, "size", text="Size X")
+                sub.prop(light, "size_y", text="Y")
 
-        if not (lamp.type == 'AREA' and clamp.is_portal):
+        if not (light.type == 'AREA' and clamp.is_portal):
             sub = col.column()
             if use_branched_path(context):
                 subsub = sub.row(align=True)
@@ -1151,53 +1151,53 @@ class CYCLES_LAMP_PT_lamp(CyclesButtonsPanel, Panel):
             sub.prop(clamp, "max_bounces")
 
         sub = col.column(align=True)
-        sub.active = not (lamp.type == 'AREA' and clamp.is_portal)
+        sub.active = not (light.type == 'AREA' and clamp.is_portal)
         sub.prop(clamp, "cast_shadow")
         sub.prop(clamp, "use_multiple_importance_sampling", text="Multiple Importance")
 
-        if lamp.type == 'AREA':
+        if light.type == 'AREA':
             col.prop(clamp, "is_portal", text="Portal")
 
-        if lamp.type == 'HEMI':
-            layout.label(text="Not supported, interpreted as sun lamp")
+        if light.type == 'HEMI':
+            layout.label(text="Not supported, interpreted as sun light")
 
 
-class CYCLES_LAMP_PT_nodes(CyclesButtonsPanel, Panel):
+class CYCLES_LIGHT_PT_nodes(CyclesButtonsPanel, Panel):
     bl_label = "Nodes"
     bl_context = "data"
 
     @classmethod
     def poll(cls, context):
-        return context.lamp and not (context.lamp.type == 'AREA' and
-                                     context.lamp.cycles.is_portal) and \
+        return context.light and not (context.light.type == 'AREA' and
+                                     context.light.cycles.is_portal) and \
             CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
 
-        lamp = context.lamp
-        if not panel_node_draw(layout, lamp, 'OUTPUT_LAMP', 'Surface'):
-            layout.prop(lamp, "color")
+        light = context.light
+        if not panel_node_draw(layout, light, 'OUTPUT_LIGHT', 'Surface'):
+            layout.prop(light, "color")
 
 
-class CYCLES_LAMP_PT_spot(CyclesButtonsPanel, Panel):
+class CYCLES_LIGHT_PT_spot(CyclesButtonsPanel, Panel):
     bl_label = "Spot Shape"
     bl_context = "data"
 
     @classmethod
     def poll(cls, context):
-        lamp = context.lamp
-        return (lamp and lamp.type == 'SPOT') and CyclesButtonsPanel.poll(context)
+        light = context.light
+        return (light and light.type == 'SPOT') and CyclesButtonsPanel.poll(context)
 
     def draw(self, context):
         layout = self.layout
-        lamp = context.lamp
+        light = context.light
         layout.use_property_split = True
 
         col = layout.column()
-        col.prop(lamp, "spot_size", text="Size")
-        col.prop(lamp, "spot_blend", text="Blend", slider=True)
-        col.prop(lamp, "show_cone")
+        col.prop(light, "spot_size", text="Size")
+        col.prop(light, "spot_blend", text="Blend", slider=True)
+        col.prop(light, "show_cone")
 
 
 class CYCLES_WORLD_PT_preview(CyclesButtonsPanel, Panel):
@@ -1789,7 +1789,7 @@ def get_panels():
         'DATA_PT_area',
         'DATA_PT_camera_dof',
         'DATA_PT_falloff_curve',
-        'DATA_PT_lamp',
+        'DATA_PT_light',
         'DATA_PT_preview',
         'DATA_PT_spot',
         'MATERIAL_PT_context_material',
@@ -1843,10 +1843,10 @@ classes = (
     CYCLES_OBJECT_PT_motion_blur,
     CYCLES_OBJECT_PT_cycles_settings,
     CYCLES_OT_use_shading_nodes,
-    CYCLES_LAMP_PT_preview,
-    CYCLES_LAMP_PT_lamp,
-    CYCLES_LAMP_PT_nodes,
-    CYCLES_LAMP_PT_spot,
+    CYCLES_LIGHT_PT_preview,
+    CYCLES_LIGHT_PT_light,
+    CYCLES_LIGHT_PT_nodes,
+    CYCLES_LIGHT_PT_spot,
     CYCLES_WORLD_PT_preview,
     CYCLES_WORLD_PT_surface,
     CYCLES_WORLD_PT_volume,
diff --git a/intern/cycles/blender/addon/version_update.py b/intern/cycles/blender/addon/version_update.py
index 3334ccd65fd..b6ace0e6b57 100644
--- a/intern/cycles/blender/addon/version_update.py
+++ b/intern/cycles/blender/addon/version_update.py
@@ -55,10 +55,10 @@ def check_is_new_shading_world(world):
     return check_is_new_shading_ntree(world.node_tree)
 
 
-def check_is_new_shading_lamp(lamp):
-    if not lamp.node_tree:
+def check_is_new_shading_light(light):
+    if not light.node_tree:
         return False
-    return check_is_new_shading_ntree(lamp.node_tree)
+    return check_is_new_shading_ntree(light.node_tree)
 
 
 def foreach_notree_node(nodetree, callback, traversed):
@@ -83,9 +83,9 @@ def foreach_cycles_node(callback):
                 foreach_notree_node(world.node_tree,
                                     callback,
                                     traversed)
-    for lamp in bpy.data.lamps:
-        if check_is_new_shading_world(lamp):
-                foreach_notree_node(lamp.node_tree,
+    for light in bpy.data.lights:
+        if check_is_new_shading_world(light):
+                foreach_notree_node(light.node_tree,
                                     callback,
                                     traversed)
 
@@ -393,12 +393,12 @@ def do_versions(self):
             if not cscene.is_property_set("tile_order"):
                 cscene.tile_order = 'CENTER'
 
-        for lamp in bpy.data.lamps:
-            clamp = lamp.cycles
+        for light in bpy.data.lights:
+            clight = light.cycles
 
             # MIS
-            if not clamp.is_property_set("use_multiple_importance_sampling"):
-                clamp.use_multiple_importance_sampling = False
+            if not clight.is_property_set("use_multiple_importance_sampling"):
+                clight.use_multiple_importance_sampling = False
 
         for mat in bpy.data.materials:
             cmat = mat.cycles
diff --git a/intern/cycles/blender/blender_camera.cpp b/intern/cycles/blender/blender_camera.cpp
index 228f0645f94..fc86094949f 100644
--- a/intern/cycles/blender/blender_camera.cpp
+++ b/intern/cycles/blender/blender_camera.cpp
@@ -232,7 +232,7 @@ static void blender_camera_from_object(BlenderCamera *bcam,
 		bcam->motion_steps = object_motion_steps(b_ob, b_ob);
 	}
 	else {
-		/* from lamp not implemented yet */
+		/* from light not implemented yet */
 	}
 }
 
diff --git a/intern/cycles/blender/blender_object.cpp b/intern/cycles/blender/blender_object.cpp
index 70d6092622a..ed01d728931 100644
--- a/intern/cycles/blender/blender_object.cpp
+++ b/intern/cycles/blender/blender_object.cpp
@@ -89,7 +89,7 @@ bool BlenderSync::object_is_light(BL::Object& b_ob)
 {
 	BL::ID b_ob_data = b_ob.data();
 
-	return (b_ob_data && b_ob_data.is_a(&RNA_Lamp));
+	return (b_ob_data && b_ob_data.is_a(&RNA_Light));
 }
 
 static uint object_ray_visibility(BL::Object& b_ob)
@@ -127,56 +127,56 @@ void BlenderSync::sync_light(BL::Object& b_parent,
 		return;
 	}
 
-	BL::Lamp b_lamp(b_ob.data());
+	BL::Light b_light(b_ob.data());
 
 	/* type */
-	switch(b_lamp.type()) {
-		case BL::Lamp::type_POINT: {
-			BL::PointLamp b_point_lamp(b_lamp);
-			light->size = b_point_lamp.shadow_soft_size();
+	switch(b_light.type()) {
+		case BL::Light::type_POINT: {
+			BL::PointLight b_point_light(b_light);
+			light->size = b_point_light.shadow_soft_size();
 			light->type = LIGHT_POINT;
 			break;
 		}
-		case BL::Lamp::type_SPOT: {
-			BL::SpotLamp b_spot_lamp(b_lamp);
-			light->size = b_spot_lamp.shadow_soft_size();
+		case BL::Light::type_SPOT: {
+			BL::SpotLight b_spot_light(b_light);
+			light->size = b_spot_light.shadow_soft_size();
 			light->type = LIGHT_SPOT;
-			light->spot_angle = b_spot_lamp.spot_size();
-			light->spot_smooth = b_spot_lamp.spot_blend();
+			light->spot_angle = b_spot_light.spot_size();
+			light->spot_smooth = b_spot_light.spot_blend();
 			break;
 		}
-		case BL::Lamp::type_HEMI: {
+		case BL::Light::type_HEMI: {
 			light->type = LIGHT_DISTANT;
 			light->size = 0.0f;
 			break;
 		}
-		case BL::Lamp::type_SUN: {
-			BL::SunLamp b_sun_lamp(b_lamp);
-			light->size = b_sun_lamp.shadow_soft_size();
+		case BL::Light::type_SUN: {
+			BL::SunLight b_sun_light(b_light);
+			light->size = b_sun_light.shadow_soft_size();
 			light->type = LIGHT_DISTANT;
 			break;
 		}
-		case BL::Lamp::type_AREA: {
-			BL::AreaLamp b_area_lamp(b_lamp);
+		case BL::Light::type_AREA: {
+			BL::AreaLight b_area_light(b_light);
 			light->size = 1.0f;
 			light->axisu = transform_get_column(&tfm, 0);
 			light->axisv = transform_get_column(&tfm, 1);
-			light->sizeu = b_area_lamp.size();
-			switch(b_area_lamp.shape()) {
-				case BL::AreaLamp::shape_SQUARE:
+			light->sizeu = b_area_light.size();
+			switch(b_area_light.shape()) {
+				case BL::AreaLight::shape_SQUARE:
 					light->sizev = light->sizeu;
 					light->round = false;
 					break;
-				case BL::AreaLamp::shape_RECTANGLE:
-					light->sizev = b_area_lamp.size_y();
+				case BL::AreaLight::shape_RECTANGLE:
+					light->sizev = b_area_light.size_y();
 					light->round = false;
 					break;
-				case BL::AreaLamp::shape_DISK:
+				case BL::AreaLight::shape_DISK:
 					light->sizev = light->sizeu;
 					light->round = true;
 					break;
-				case BL::AreaLamp::shape_ELLIPSE:
-					light->sizev = b_area_lamp.size_y();
+				case BL::AreaLight::shape_ELLIPSE:
+					light->sizev = b_area_light.size_y();
 					light->round = true;
 					break;
 			}
@@ -192,22 +192,22 @@ void BlenderSync::sync_light(BL::Object& b_parent,
 
 	/* shader */
 	vector<Shader*> used_shaders;
-	find_shader(b_lamp, used_shaders, scene->default_light);
+	find_shader(b_light, used_shaders, scene->default_light);
 	light->shader = used_shaders[0];
 
 	/* shadow */
 	PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
-	PointerRNA clamp = RNA_pointer_get(&b_lamp.ptr, "cycles");
-	light->cast_shadow = get_boolean(clamp, "cast_shadow");
-	light->use_mis = get_boolean(clamp, "use_multiple_importance_sampling");
+	PointerRNA clight = RNA_pointer_get(&b_light.ptr, "cycles");
+	light->cast_shadow = get_boolean(clight, "cast_shadow");
+	light->use_mis = get_boolean(clight, "use_multiple_importance_sampling");
 
-	int samples = get_int(clamp, "samples");
+	int samples = get_int(clight, "samples");
 	if(get_boolean(cscene, "use_square_samples"))
 		light->samples = samples * samples;
 	else
 		light->samples = samples;
 
-	light->max_bounces = get_int(clamp, "max_bounces");
+	light->max_bounces = get_int(clight, "max_bounces");
 
 	if(b_ob != b_ob_instance) {
 		light->random_id = random_id;
@@ -217,7 +217,7 @@ void BlenderSync::sync_light(BL::Object& b_parent,
 	}
 
 	if(light->type == LIGHT_AREA)
-		light->is_portal = get_boolean(clamp, "is_portal");
+		light->is_portal = get_boolean(clight, "is_portal");
 	else
 		light->is_portal = false;
 
@@ -315,7 +315,7 @@ Object *BlenderSync::sync_object(BL::Depsgraph& b_depsgraph,
 
 	/* light is handled separately */
 	if(object_is_light(b_ob)) {
-		/* don't use lamps for excluded layers used as mask layer */
+		/* don't use lights for excluded layers used as mask layer */
 		if(!motion && !((layer_flag & view_layer.holdout_layer) &&
 		                (layer_flag & view_layer.exclude_layer)))
 		{
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index e2463200001..e254ee6f68d 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -1393,45 +1393,45 @@ void BlenderSync::sync_world(BL::Depsgraph& b_depsgraph, bool update_all)
 		background->tag_update(scene);
 }
 
-/* Sync Lamps */
+/* Sync Lights */
 
-void BlenderSync::sync_lamps(BL::Depsgraph& b_depsgraph, bool update_all)
+void BlenderSync::sync_lights(BL::Depsgraph& b_depsgraph, bool update_all)
 {
 	shader_map.set_default(scene->default_light);
 
 	BL::Depsgraph::ids_iterator b_id;
 	for(b_depsgraph.ids.begin(b_id); b_id != b_depsgraph.ids.end(); ++b_id) {
-		if (!b_id->is_a(&RNA_Lamp)) {
+		if (!b_id->is_a(&RNA_Light)) {
 			continue;
 		}
 
-		BL::Lamp b_lamp(*b_id);
+		BL::Light b_light(*b_id);
 		Shader *shader;
 
 		/* test if we need to sync */
-		if(shader_map.sync(&shader, b_lamp) || update_all) {
+		if(shader_map.sync(&shader, b_light) || update_all) {
 			ShaderGraph *graph = new ShaderGraph();
 
 			/* create nodes */
-			if(b_lamp.use_nodes() && b_lamp.node_tree()) {
-				shader->name = b_lamp.name().c_str();
+			if(b_light.use_nodes() && b_light.node_tree()) {
+				shader->name = b_light.name().c_str();
 
-				BL::ShaderNodeTree b_ntree(b_lamp.node_tree());
+				BL::ShaderNodeTree b_ntree(b_light.node_tree());
 
 				add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
 			}
 			else {
 				float strength = 1.0f;
 
-				if(b_lamp.type() == BL::Lamp::type_POINT ||
-				   b_lamp.type() == BL::Lamp::type_SPOT ||
-				   b_lamp.type() == BL::Lamp::type_AREA)
+				if(b_light.type() == BL::Light::type_POINT ||
+				   b_light.type() == BL::Light::type_SPOT ||
+				   b_light.type() == BL::Light::type_AREA)
 				{
 					strength = 100.0f;
 				}
 
 				EmissionNode *emission = new EmissionNode();
-				emission->color = get_float3(b_lamp.color());
+				emission->color = get_float3(b_light.color());
 				emission->strength = strength;
 				graph->add(emission);
 
@@ -1459,7 +1459,7 @@ void BlenderSync::sync_shaders(BL::Depsgraph& b_depsgraph)
 	shader_map.pre_sync();
 
 	sync_world(b_depsgraph, auto_refresh_update);
-	sync_lamps(b_depsgraph, auto_refresh_update);
+	sync_lights(b_depsgraph, auto_refresh_update);
 	sync_materials(b_depsgraph, auto_refresh_update);
 
 	/* false = don't delete unused shaders, not supported */
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index f9e04bdef7c..cbca623ece7 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -113,10 +113,10 @@ void BlenderSync::sync_recalc(BL::Depsgraph& b_depsgraph)
 			BL::Material b_mat(b_id);
 			shader_map.set_recalc(b_mat);
 		}
-		/* Lamp */
-		else if (b_id.is_a(&RNA_Lamp)) {
-			BL::Lamp b_lamp(b_id);
-			shader_map.set_recalc(b_lamp);
+		/* Light */
+		else if (b_id.is_a(&RNA_Light)) {
+			BL::Light b_light(b_id);
+			shader_map.set_recalc(b_light);
 		}
 		/* Object */
 		else if (b_id.is_a(&RNA_Object)) {
diff --git a/intern/cycles/blender/blender_sync.h b/intern/cycles/blender/blender_sync.h
index 1dce7ec99ef..cd1a37d3f13 100644
--- a/intern/cycles/blender/blender_sync.h
+++ b/intern/cycles/blender/blender_sync.h
@@ -100,7 +100,7 @@ public:
 
 private:
 	/* sync */
-	void sync_lamps(BL::Depsgraph& b_depsgraph, bool update_all);
+	void sync_lights(BL::Depsgraph& b_depsgraph, bool update_all);
 	void sync_materials(BL::Depsgraph& b_depsgraph, bool update_all);
 	void sync_objects(BL::Depsgraph& b_depsgraph, float motion_time = 0.0f);
 	void sync_motion(BL::RenderSettings& b_render,