__init__.py

# <pep8 compliant>
#  Light Temperature - Professional light temperature control for Blender
#  Copyright (C) 2024 softyoda
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 3
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

# CHANGELOG
# v 2.8 February 2024 - Light Temperature
#   ☒ Added temperature sync via Ctrl+L menu
#   ☒ Improved state management and error handling
#   ☒ Added power toggle with energy preservation
#   ☒ Initial release with temperature control and presets

bl_info = {
    "name": "Light Temperature Color",
    "author": "softyoda",
    "version": (1, 0),
    "blender": (4, 3, 2),
    "location": "Properties > Light > Light Temperature, Object > Link/Transfer Data",
    "description": "Professional light temperature control with physical accuracy",
    "warning": "Requires Cycles render engine",
    "doc_url": "",  # Add your documentation URL if available
    "category": "Lighting",
}

import bpy
from bpy.props import FloatProperty, BoolProperty
from bpy.types import Panel, Operator, PropertyGroup
from bpy.app.handlers import persistent

# --------------------------- 
# Operators
# ---------------------------

class LIGHT_OT_preset_temperature(Operator):
    """Apply predefined temperature preset to the selected light"""
    bl_idname = "light.apply_preset"
    bl_label = "Apply Temperature Preset"
    bl_options = {'REGISTER', 'UNDO'}
    
    temperature: FloatProperty(
        name="Temperature",
        description="Light temperature in Kelvin",
        min=800,
        max=12000,
        default=6500
    )
    
    def execute(self, context):
        light = context.active_object.data
        if not light.temperature_setup:
            setup_temperature_nodes(light)
        light.temperature = self.temperature
        return {'FINISHED'}

class LIGHT_OT_setup_temperature(Operator):
    """Initialize the temperature control system for this light"""
    bl_idname = "light.setup_temperature"
    bl_label = "Enable Temperature Control"
    bl_options = {'REGISTER', 'UNDO'}
    
    def execute(self, context):
        light = context.active_object.data
        setup_temperature_nodes(light)
        return {'FINISHED'}

class LIGHT_OT_copy_temperature(Operator):
    """Copy temperature settings from active light to selected lights"""
    bl_idname = "light.copy_temperature"
    bl_label = "Copy Temperature Settings"
    bl_options = {'REGISTER', 'UNDO'}
    
    def execute(self, context):
        active = context.active_object
        if not active or active.type != 'LIGHT':
            self.report({'ERROR'}, "Active object must be a light")
            return {'CANCELLED'}
            
        active_light = active.data
        if not active_light.temperature_setup:
            self.report({'ERROR'}, "Active light must have temperature control enabled")
            return {'CANCELLED'}
        
        # Copy settings to all selected lights
        for obj in context.selected_objects:
            if obj != active and obj.type == 'LIGHT':
                light = obj.data
                if not light.temperature_setup:
                    setup_temperature_nodes(light)
                light.temperature = active_light.temperature
                light.light_enabled = active_light.light_enabled
                if light.light_enabled:
                    light.energy = active_light.energy
                
        return {'FINISHED'}

# --------------------------- 
# Core Functionality
# ---------------------------

def setup_temperature_nodes(light):
    """Create and configure the node setup for temperature control"""
    try:
        light.use_nodes = True
        tree = light.node_tree
        tree.nodes.clear()
        
        # Create basic node setup
        output = tree.nodes.new('ShaderNodeOutputLight')
        emission = tree.nodes.new('ShaderNodeEmission')
        blackbody = tree.nodes.new('ShaderNodeBlackbody')
        
        # Position nodes for clean layout
        output.location = (400, 0)
        emission.location = (200, 0)
        blackbody.location = (0, 0)
        
        # Connect nodes
        tree.links.new(blackbody.outputs['Color'], emission.inputs['Color'])
        tree.links.new(emission.outputs['Emission'], output.inputs['Surface'])
        
        # Initialize values
        blackbody.inputs['Temperature'].default_value = light.temperature
        light.color = (1, 1, 1)
        light.temperature_setup = True
        light.prev_energy = light.energy
        light.light_enabled = light.energy > 0
    
    except Exception as e:
        print(f"Node setup failed: {str(e)}")
        light.temperature_setup = False

def update_light_temperature(self, context):
    """Update the blackbody node when temperature value changes"""
    if self.temperature_setup:
        if self.color[:3] != (1, 1, 1):
            self.temperature_setup = False
            return
            
        if tree := self.node_tree:
            if blackbody := next((n for n in tree.nodes if n.type == 'BLACKBODY'), None):
                blackbody.inputs['Temperature'].default_value = self.temperature

def update_light_state(self, context):
    """Handle power state changes and energy management"""
    if self.light_enabled and self.energy == 0:
        self.energy = self.prev_energy
    elif not self.light_enabled and self.energy > 0:
        self.prev_energy = self.energy
        self.energy = 0.0

@persistent
def check_light_changes(scene):
    """Monitor light changes to maintain proper state synchronization"""
    for obj in scene.objects:
        if obj.type == 'LIGHT':
            light = obj.data
            if light.temperature_setup:
                # Detect manual color changes
                if light.color[:3] != (1, 1, 1):
                    light.temperature_setup = False
                
                # Sync power state with energy
                if light.energy > 0 and not light.light_enabled:
                    light.light_enabled = True
                elif light.energy == 0 and light.light_enabled:
                    light.light_enabled = False

# --------------------------- 
# UI
# ---------------------------

class LIGHT_PT_temperature(Panel):
    """Light Temperature Control Panel"""
    bl_label = "Light Temperature"
    bl_idname = "LIGHT_PT_temperature"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "data"
    bl_order = 1
    
    @classmethod
    def poll(cls, context):
        return (context.scene.render.engine == 'CYCLES' 
                and context.active_object 
                and context.active_object.type == 'LIGHT')
    
    def draw(self, context):
        layout = self.layout
        light = context.active_object.data
        
        if not light.temperature_setup:
            layout.operator("light.setup_temperature",
                         icon='LIGHT',
                         text="Enable Temperature Control")
            return
        
        main_col = layout.column(align=True)
            
        # Temperature control
        main_col.prop(light, "temperature", slider=True)
            
        # Common temperature presets
        presets = main_col.grid_flow(row_major=True, columns=4, align=True)
        for label, temp in [("Candle", 1500), ("Tungsten", 3200),
                          ("Daylight", 6500), ("Overcast", 7500)]:
            props = presets.operator("light.apply_preset", text=label)
            props.temperature = temp
        
        # Power control
        power_row = main_col.row(align=True)
        power_row.prop(light, "light_enabled",
                     text="Power: On" if light.light_enabled else "Power: Off",
                     toggle=True,
                     icon='CHECKBOX_HLT' if light.light_enabled else 'CHECKBOX_DEHLT')

def light_temperature_menu(self, context):
    """Add temperature copying to the Link menu"""
    self.layout.operator(LIGHT_OT_copy_temperature.bl_idname, 
                        text="Light Temperature Settings")

# --------------------------- 
# Registration
# ---------------------------

def register():
    # Register classes
    bpy.utils.register_class(LIGHT_OT_preset_temperature)
    bpy.utils.register_class(LIGHT_OT_setup_temperature)
    bpy.utils.register_class(LIGHT_OT_copy_temperature)
    bpy.utils.register_class(LIGHT_PT_temperature)
    
    # Register properties
    bpy.types.Light.temperature = FloatProperty(
        name="Temperature",
        description="Color temperature in Kelvin",
        min=800,
        max=12000,
        default=6500,
        update=update_light_temperature,
        options={'ANIMATABLE'}
    )
        
    bpy.types.Light.temperature_setup = BoolProperty(
        name="Temperature Setup",
        description="Whether temperature control is enabled for this light",
        default=False
    )
        
    bpy.types.Light.light_enabled = BoolProperty(
        name="Light Enabled",
        description="Toggle light power while preserving energy value",
        default=True,
        update=update_light_state
    )
        
    bpy.types.Light.prev_energy = FloatProperty(
        name="Previous Energy",
        description="Stores previous energy value when light is disabled",
        default=10.0
    )

    # Register update handler
    if check_light_changes not in bpy.app.handlers.depsgraph_update_post:
        bpy.app.handlers.depsgraph_update_post.append(check_light_changes)
    
    # Add menu item
    bpy.types.VIEW3D_MT_make_links.append(light_temperature_menu)

def unregister():
    # Unregister classes
    bpy.utils.unregister_class(LIGHT_OT_preset_temperature)
    bpy.utils.unregister_class(LIGHT_OT_setup_temperature)
    bpy.utils.unregister_class(LIGHT_OT_copy_temperature)
    bpy.utils.unregister_class(LIGHT_PT_temperature)
    
    # Remove menu item
    bpy.types.VIEW3D_MT_make_links.remove(light_temperature_menu)
    
    # Remove update handler
    if check_light_changes in bpy.app.handlers.depsgraph_update_post:
        bpy.app.handlers.depsgraph_update_post.remove(check_light_changes)
        
    # Remove properties
    del bpy.types.Light.temperature
    del bpy.types.Light.temperature_setup
    del bpy.types.Light.light_enabled
    del bpy.types.Light.prev_energy

if __name__ == "__main__":
    register()