fixture.py

#    Copyright Hugo Aboud, vanous
#
#    This file is part of BlenderDMX.
#
#    BlenderDMX 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.
#
#    BlenderDMX 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, see <https://www.gnu.org/licenses/>.


import traceback
import bpy
import math
import mathutils
import random
import os
import uuid as py_uuid

from .material import getEmitterMaterial, get_gobo_material, set_light_nodes, get_ies_node, getGeometryNodes
from .model import DMX_Model
from .logging import DMX_Log

import pygdtf
import pymvr

from .gdtf import DMX_GDTF
from .data import DMX_Data
from .util import cmy_to_rgb, add_rgb, colors_to_rgb, rgb2xyY, kelvin_table
from .osc_utils import DMX_OSC_Handlers
from bpy.props import (IntProperty,
                       BoolProperty,
                       FloatVectorProperty,
                       IntVectorProperty,
                       PointerProperty,
                       StringProperty,
                       CollectionProperty)

from bpy.types import (PropertyGroup,
                       Collection,
                       Object,
                       Image,
                       Material,
                       GeometryNodeTree,
                       Text)
from .node_arranger import DMX_OT_ArrangeSelected

# Shader Nodes default labels
# Blender API naming convention is inconsistent for internationalization
# Every label used is listed here, so it's easier to fix it on new API updates
STRENGTH = "Strength"
COLOR = "Color"


class DMX_Manufacturer(PropertyGroup):
    name: StringProperty (
        name = "Name",
        description = "Name of the manufacturer",
        default = "Manufacturer 0")


manufacturers: CollectionProperty(
    name = "Manufacturers",
    description = "Fixture GDTF Manufacturers",
    type = DMX_Manufacturer
)


class DMX_Fixture_Object(PropertyGroup):
    object: PointerProperty(
        name = "Fixture > Object",
        type = Object)

class DMX_Fixture_Image(PropertyGroup):
    image: PointerProperty(
        name = "Fixture > Image",
        type = Image)
    count: IntProperty(
            default = 0
            )

class DMX_Emitter_Material(PropertyGroup):
    material: PointerProperty(
        name = "Emitter > Material",
        type = Material)

class DMX_Geometry_Node(PropertyGroup):
    node: PointerProperty(
        name = "Geometry Node",
        type = GeometryNodeTree)

class DMX_IES_Data(PropertyGroup):
    ies: PointerProperty(
        name = "Spot > IES",
        type = Text)


class DMX_Fixture_Channel(PropertyGroup):
    id: StringProperty(
        name = "Fixture > Channel > ID",
        default = '')
    default: IntProperty(
        name = "Fixture > Channel > Default",
        default = 0)
    geometry: StringProperty(
        name = "Fixture > Geometry",
        default = '')

class DMX_Fixture(PropertyGroup):

    # Blender RNA #

    collection: PointerProperty(
        name = "Fixture > Collection",
        type = Collection)

    objects: CollectionProperty(
        name = "Fixture > Objects",
        type = DMX_Fixture_Object
    )

    lights: CollectionProperty(
        name = "Fixture > Lights",
        type = DMX_Fixture_Object
    )

    images: CollectionProperty(
        name = "Fixture > Images",
        type = DMX_Fixture_Image
    )

    emitter_materials: CollectionProperty(
        name = "Fixture > Materials",
        type = DMX_Emitter_Material)

    geometry_nodes: CollectionProperty(
        name = "Fixture > Geometry Nodes",
        type = DMX_Geometry_Node)

    gobo_materials: CollectionProperty(
        name = "Fixture > Gobo Materials",
        type = DMX_Emitter_Material)

    ies_data: CollectionProperty(
        name = "Fixture > IES Files",
        type = DMX_IES_Data)

    # DMX properties

    profile: StringProperty(
        name = "Fixture > Profile",
        default = "")

    mode : StringProperty(
        name = "Fixture > Mode",
        description="Fixture DMX Mode",
        default = '')

    channels: CollectionProperty(
        name = "Fixture > Channels",
        type = DMX_Fixture_Channel
    )
    virtual_channels: CollectionProperty(
        name = "Fixture > Virtual Channels",
        type = DMX_Fixture_Channel
    )

    gdtf_long_name: StringProperty(
        name = "Fixture > Name",
        default = "")

    gdtf_manufacturer: StringProperty(
        name = "Fixture > Manufacturer",
        default = "")

    def ensure_universe_exists(self, context):
        dmx = bpy.context.scene.dmx
        dmx.ensureUniverseExists(self.universe)

    universe : IntProperty(
        name = "Fixture > Universe",
        description="Fixture DMX Universe",
        default = 0,
        min = 0,
        max = 511,
        update = ensure_universe_exists
        )

    address : IntProperty(
        name = "Fixture > Address",
        description="Fixture DMX Address",
        default = 1,
        min = 1,
        max = 512)

    uuid: StringProperty(
        name = "UUID",
        description = "Unique ID, used for MVR",
        default = str(py_uuid.uuid4())
            )

    fixture_id: StringProperty(
        name = "FixtureID",
        description = "The Fixture ID is an identifier for the instance of this fixture that can be used to activate / select them for programming.",
        default = ""
            )

    unit_number: IntProperty(
        name = "UnitNumber",
        description = "The identification of a fixture on its position. Use this as an alternative numbering scheme if the planning and programming numbering is different.",
        default = 0
            )

    fixture_id_numeric: IntProperty(
        name = "FixtureIDNumeric",
        description = "The Fixture ID is an identifier for the instance of this fixture that can be used to activate / select them for programming.",
        default = 0
            )

    custom_id: IntProperty(
        name = "CustomId",
        description = "The Fixture ID is an identifier for the instance of this fixture that can be used to activate / select them for programming.",
        default = 0
            )

    display_beams: BoolProperty(
        name = "Display beams",
        description="Display beam projection and cone",
        default = True)

    add_target: BoolProperty(
        name = "Add Target",
        description="Add target for beam to follow",
        default = True)

    dmx_cache_dirty: BoolProperty(
        name = "DMX cache dirty",
        description="if dmx data has changed but keyframe has not been saved yet",
        default = False)

    gel_color_rgb: IntVectorProperty(
        name = "Gel Color",
        subtype = "COLOR",
        size = 3,
        min = 0,
        max = 255,
        default = (255,255,255))

    gel_color: FloatVectorProperty(
        name = "Unused",
        subtype = "COLOR",
        size = 4,
        min = 0.0,
        max = 1.0,
        default = (1.0,1.0,1.0,1.0))

    ignore_movement_dmx: BoolProperty(
        name = "Ignore movement DMX",
        description="Stay in position set by Target",
        default = False)

    classing: StringProperty(
        name = "Classing UUID",
        description = "Classing - logical grouping across different layers",
        default = ""
            )

    lock_pan_rotation: BoolProperty(
        name = "Lock Pan Rotation",
        description="Lock Pan Rotation",
        default = False)

    lock_tilt_rotation: BoolProperty(
        name = "Lock Tilt Rotation",
        description="Lock Tilt Rotation",
        default = False)

    def build(self, name, profile, mode, universe, address, gel_color, display_beams, add_target, mvr_position = None,
              focus_point = None, uuid = None, fixture_id="", custom_id=0, fixture_id_numeric=0, unit_number=0, classing=""):
        # (Edit) Store objects positions
        old_pos = {obj.name:obj.object.location.copy() for obj in self.objects}
        old_rot = {obj.name:obj.object.rotation_euler.copy() for obj in self.objects}

        # (Edit) Collection with this name already exists, delete it
        if (self.name in bpy.data.collections):
            for obj in bpy.data.collections[self.name].objects:
                bpy.data.objects.remove(obj)
            bpy.data.collections.remove(bpy.data.collections[self.name])

        # Data Properties
        self.name = name
        self.profile = profile
        self.mode = mode
        if fixture_id is not None:
            self.fixture_id = fixture_id
        if custom_id is not None:
            self.custom_id = custom_id
        if fixture_id_numeric is not None:
            self.fixture_id_numeric = fixture_id_numeric
        if unit_number is not None:
            self.unit_number = unit_number
        if uuid is not None:
            self.uuid = uuid
        if classing is not None:
            self.classing = classing

        # DMX Properties
        self.universe = universe
        self.address = address
        self.gel_color_rgb = list(int((255/1)*i) for i in gel_color[:3])
        self.display_beams = display_beams
        self.add_target = add_target

        # (Edit) Clear links and channel cache
        self.lights.clear()
        self.images.clear()
        self.objects.clear()
        self.channels.clear()
        self.virtual_channels.clear()
        self.emitter_materials.clear()
        self.geometry_nodes.clear()
        self.gobo_materials.clear()
        self.ies_data.clear()
        self.dmx_cache_dirty = False

        # Custom python data storage, outside of bpy.props. So called ID props
        self["dmx_values"] = []

        # Create clean Collection
        # (Blender creates the collection with selected objects/collections)
        bpy.ops.collection.create(name=name)
        self.collection = bpy.data.collections[name]

        for c in self.collection.objects:
            self.collection.objects.unlink(c)
        for c in self.collection.children:
            self.collection.children.unlink(c)

        # Import and deep copy Fixture Model Collection
        gdtf_profile = DMX_GDTF.loadProfile(profile)
        self.gdtf_long_name = gdtf_profile.long_name
        self.gdtf_manufacturer = gdtf_profile.manufacturer

        # Handle if dmx mode doesn't exist (maybe this is MVR import and GDTF files were replaced)
        # use mode[0] as default
        if not any(self.mode == mode.name for mode in gdtf_profile.dmx_modes):
            self.mode = gdtf_profile.dmx_modes[0].name

        model_collection = DMX_Model.getFixtureModelCollection(gdtf_profile, self.mode, self.display_beams, self.add_target)

        # Build DMX channels cache
        dmx_channels = pygdtf.utils.get_dmx_channels(gdtf_profile, self.mode)
        # Merge all DMX breaks together
        dmx_channels_flattened = [channel for break_channels in dmx_channels for channel in break_channels]

        has_gobos = False
        for ch in dmx_channels_flattened:
            channel = self.channels.add()
            channel.id = ch['id']
            channel.geometry = ch['geometry']

            # Set shutter to 0, we don't want strobing by default
            # and are not reading real world values yet
            if "shutter" in ch['id'].lower():
                channel.default = 0
            else:
                channel.default = ch['default']

            if "Gobo" in ch["id"]:
                has_gobos = True

        # Build cache of virtual channels
        _virtual_channels = pygdtf.utils.get_virtual_channels(gdtf_profile, self.mode)
        for ch in _virtual_channels:
            virtual_channel = self.virtual_channels.add()
            virtual_channel.id = ch['id']
            virtual_channel.geometry = ch['geometry']
            virtual_channel.default = ch['default']
            if "Gobo" in ch["id"]:
                has_gobos = True

        # Get all gobos
        if has_gobos:
            gobo_seq = DMX_GDTF.extract_gobos_as_sequence(gdtf_profile)
            if gobo_seq is not None:
                gobo1 = self.images.add()
                gobo1.name = "gobos1"
                gobo1.image = gobo_seq[0]
                gobo1.count = gobo_seq[0]["count"]
                gobo1.image.pack()
                gobo2 = self.images.add()
                gobo2.name = "gobos2"
                gobo2.image = gobo_seq[1]
                gobo2.count = gobo_seq[1]["count"]
                gobo2.image.pack()

        if "gobos1" not in self.images:
            has_gobos = False # faulty GDTF might have channels but no images

        self["slot_colors"] = []
        slot_colors = DMX_GDTF.get_wheel_slot_colors(gdtf_profile)
        if len(slot_colors)>1:
            self["slot_colors"]=slot_colors[:255] # limit number of colors to an 8bit control channel

        links = {}
        base = self.get_root(model_collection)
        head = self.get_tilt(model_collection)
        DMX_Log.log.info(f"Head: {head}, Base: {base}")

        for obj in model_collection.objects:
            # Copy object
            links[obj.name] = obj.copy()
            # If light, copy object data,
            # Cache access to base (root) and head for faster rendering.
            # Fixtures with multiple pan/tilts will still have issues
            # but that would anyway require geometry → attribute approach

            if obj.type == 'LIGHT':
                links[obj.name].data = obj.data.copy()
                self.lights.add()
                light_name=f'Light{len(self.lights)}'
                self.lights[-1].name = light_name
                self.lights[light_name].object = links[obj.name]
                if has_gobos:
                    self.lights[light_name].object.data.shadow_soft_size = 0.001 # larger spot diameter causes gobos to be blurry in Cycles
                    self.lights[light_name].object.data.shadow_buffer_clip_start = 0.002
            elif 'Target' in obj.name:
                self.objects.add()
                self.objects[-1].name = 'Target'
                self.objects['Target'].object = links[obj.name]
                self.objects['Target'].object["uuid"] = str(py_uuid.uuid4())
            elif base.name == obj.name:
                self.objects.add()
                self.objects[-1].name = "Root"
                self.objects["Root"].object = links[obj.name]
            elif head is not None and head.name == obj.name:
                self.objects.add()
                self.objects[-1].name = "Head"
                self.objects["Head"].object = links[obj.name]
            elif obj.get("2d_symbol", None) == "all":
                self.objects.add().name = "2D Symbol"
                self.objects["2D Symbol"].object = links[obj.name]

            # Link all other object to collection
            self.collection.objects.link(links[obj.name])

        # Reparent children
        for obj in model_collection.objects:
            for child in obj.children:
                if child.name in links:
                    links[child.name].parent=links[obj.name]
        # Relink constraints
        for obj in self.collection.objects:
            for constraint in obj.constraints:
                constraint.target = links[constraint.target.name]

        # (Edit) Reload old positions and rotations
        bpy.context.view_layer.update()
        for obj in self.objects:
            if obj.object.get("geometry_root", False):
                if obj.name in old_pos:
                    obj.object.location = old_pos[obj.name]
                if obj.name in old_rot:
                    obj.object.rotation_mode = 'XYZ'
                    obj.object.rotation_euler = old_rot[obj.name]

        # Set position from MVR
        if mvr_position is not None:
            for obj in self.objects:
                if obj.object.get("geometry_root", False):
                    obj.object.matrix_world=mvr_position

        # Set target's position from MVR
        if focus_point is not None:
            for obj in self.objects:
                if 'Target' in obj.name:
                    obj.object.matrix_world=focus_point

        # Setup emitter
        for obj in self.collection.objects:
            if "beam" in obj.get("geometry_type", ""):
                emitter = obj
                self.emitter_materials.add()
                self.emitter_materials[-1].name = obj.name

                emitter_material = getEmitterMaterial(obj.name)
                emitter.active_material = emitter_material
                emitter.material_slots[0].link = 'OBJECT'
                emitter.material_slots[0].material = emitter_material
                emitter.material_slots[0].material.shadow_method = 'NONE' # eevee
                self.emitter_materials[-1].material = emitter_material

            if "gobo" in obj.get("geometry_type", ""):
                material = self.gobo_materials.add()
                material.name = obj.name

                gobo_material = get_gobo_material(obj.name)
                obj.active_material = gobo_material
                obj.active_material.shadow_method = "CLIP"
                obj.active_material.blend_method = "BLEND"
                obj.material_slots[0].link = 'OBJECT' # ensure that each fixture has it's own material
                obj.material_slots[0].material = gobo_material
                material.material = gobo_material

                gobo_radius = obj.get("gobo_radius", 0)
                if gobo_radius:
                    obj.dimensions = (gobo_radius, gobo_radius, 0)

            # Setup laser geometry nodes
            if "laser" in obj.get("geometry_type", ""):
                #emitter
                emitter = obj
                self.emitter_materials.add()
                self.emitter_materials[-1].name = obj.name
                emitter_material = getEmitterMaterial(obj.name)
                emitter_material.shadow_method = "NONE" # laser beam should not cast shadows
                self.emitter_materials[-1].material = emitter_material
                #laser beam
                geo_node = obj
                node = self.geometry_nodes.add()
                node.name = obj.name
                modifier = geo_node.modifiers.new(type="NODES", name="base_object")
                node_group = getGeometryNodes(obj)
                modifier.node_group = node_group
                node.node = node_group


        # setup light for gobo in cycles
        for light in self.lights:
            set_light_nodes(light)

        # Link collection to DMX collection
        bpy.context.scene.dmx.collection.children.link(self.collection)

        # Set Pigtail visibility and Beam selection
        for obj in self.collection.objects:
            if "pigtail" in obj.get("geometry_type", ""):
                obj.hide_set(not bpy.context.scene.dmx.display_pigtails)
                obj.hide_viewport = not bpy.context.scene.dmx.display_pigtails # keyframing
                obj.hide_render = not bpy.context.scene.dmx.display_pigtails
            if obj.get("geometry_root", False):
                continue
            if "Target" in obj.name:
                continue
            if obj.get("2d_symbol", None) == "all":
                obj.hide_set(not bpy.context.scene.dmx.display_2D)
                obj.hide_viewport = not bpy.context.scene.dmx.display_2D #keyframing
                obj.hide_render = not bpy.context.scene.dmx.display_2D
                continue

            obj.hide_select = not bpy.context.scene.dmx.select_geometries

        self.clear()
        self.hide_gobo()
        d=DMX_OT_ArrangeSelected()
        for item in self.gobo_materials:
                ntree = item.material.node_tree
                d.process_tree(ntree)
        for item in self.geometry_nodes:
                ntree = item.node
                d.process_tree(ntree)

        for light in self.lights: #CYCLES
            light_obj = light.object
            ntree  = light_obj.data.node_tree
            d.process_tree(ntree)

        self.render()

    # Interface Methods #

    def setDMX(self, pvalues):

        temp_data = bpy.context.window_manager.dmx

        #channels = [c.id for c in self.channels]
        #virtuals = [c.id for c in self.virtual_channels]

        for attribute, value in pvalues.items():
            for idx, channel in enumerate(self.channels):
                if channel.id == attribute:
                    if len(temp_data.active_subfixtures)>0:
                        if any(channel.geometry == g.name for g in temp_data.active_subfixtures):
                            DMX_Log.log.info(("Set DMX data", channel.id, value))
                            DMX_Data.set(self.universe, self.address+idx, value)
                    else:
                        DMX_Log.log.info(("Set DMX data", channel, value))
                        DMX_Data.set(self.universe, self.address+idx, value)
            for vchannel in self.virtual_channels:
                if vchannel.id == attribute:
                    if len(temp_data.active_subfixtures)>0:
                        if any(vchannel.geometry == g.name for g in temp_data.active_subfixtures):
                            DMX_Log.log.info(("Set Virtual data", attribute, value))
                            geometry = next(vchannel.geometry == g.name for g in temp_data.active_subfixtures)
                            DMX_Data.set_virtual(self.name, attribute, geometry, value)
                    else:
                        DMX_Log.log.info(("Set Virtual data", attribute, value))
                        DMX_Data.set_virtual(self.name, attribute, None, value)

    def render(self, skip_cache = False, current_frame = None):

        if bpy.context.window_manager.dmx.pause_render:
        # do not run render loop when paused
            return

        channels = [c.id for c in self.channels]
        #virtual_channels = [c.id for c in self.virtual_channels]

        data = DMX_Data.get(self.universe, self.address, len(channels))
        data_virtual = DMX_Data.get_virtual(self.name)

        s_data = [int(b) for b in data] + [int(b["value"]) for b in data_virtual.values()] # create cache
        if list(self["dmx_values"]) == s_data: # this helps to eliminate flicker with Ethernet DMX signal when the data for this particular device is not changing
            if skip_cache is False: # allow to save a keyframe when using the programmer in Blender
                DMX_Log.log.debug("caching DMX")
                return
            if self.dmx_cache_dirty is False: # we care about keyframe saving only if there is data to be saved
                DMX_Log.log.debug("caching DMX")
                return
        else: # we have new dmx data, mark the cache as dirty, so we know we can save a keyframe when needed
            self.dmx_cache_dirty = True

        DMX_Log.log.debug(f"{current_frame=}, {self.dmx_cache_dirty=}")

        self["dmx_values"]  = s_data
        panTilt = [None,None, 1, 1] # pan, tilt, 1 = 8bit, 256 = 16bit
        cmy = [None,None,None]
        zoom = None
        color1 = None
        ctc = None
        iris = None
        rgb_mixing_geometries={}
        xyz_moving_geometries={}
        xyz_rotating_geometries={}
        shutter_dimmer_geometries={} # item: shutter, dimmer, unused, dimmer bits
        pan_rotating_geometries={}
        tilt_rotating_geometries={}

        pan_cont_rotating_geometries={}
        tilt_cont_rotating_geometries={}

        gobo1 = [None, None] #gobo selection (Gobo1), gobo indexing/rotation (Gobo1Pos)
        gobo2 = [None, None] #gobo selection (Gobo2), gobo indexing/rotation (Gobo2Pos)

        for vchannel in self.virtual_channels:
            geometry = vchannel.geometry # for now. But, no way to know, as BlenderDMX controls are universal
            if geometry not in rgb_mixing_geometries.keys():
                rgb_mixing_geometries[geometry] = [None] * 12 # R, G, B, White, WW, CW, Amber, Lime, UV, cyan, magenta, yellow
            if geometry not in xyz_moving_geometries.keys():
                xyz_moving_geometries[geometry]=[None, None, None]
            if geometry not in xyz_rotating_geometries.keys():
                xyz_rotating_geometries[geometry]=[None, None, None]
            if geometry not in shutter_dimmer_geometries.keys():
                shutter_dimmer_geometries[geometry]=[None, None, None, 1] # + bits
            if geometry not in pan_rotating_geometries.keys():
                pan_rotating_geometries[geometry]=[None, 1]
            if geometry not in tilt_rotating_geometries.keys():
                tilt_rotating_geometries[geometry]=[None, 1]
            if geometry not in pan_cont_rotating_geometries.keys():
                pan_cont_rotating_geometries[geometry]=[None, 1]
            if geometry not in tilt_cont_rotating_geometries.keys():
                tilt_cont_rotating_geometries[geometry]=[None, 1]
            if vchannel.id in data_virtual:
                if vchannel.id == "Shutter1": shutter_dimmer_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "Dimmer": shutter_dimmer_geometries[geometry][1] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "+Dimmer":
                    shutter_dimmer_geometries[geometry][1] = shutter_dimmer_geometries[geometry][1] * 256 + data_virtual[vchannel.id]["value"]
                    shutter_dimmer_geometries[geometry][3] = 256

                elif (vchannel.id == "ColorAdd_R" or vchannel.id == "ColorRGB_Red"): rgb_mixing_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif (vchannel.id == "ColorAdd_G" or vchannel.id == "ColorRGB_Green"): rgb_mixing_geometries[geometry][1] = data_virtual[vchannel.id]["value"]
                elif (vchannel.id == "ColorAdd_B" or vchannel.id == "ColorRGB_Blue"): rgb_mixing_geometries[geometry][2] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "ColorSub_C": cmy[0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "ColorSub_M": cmy[1] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "ColorSub_Y": cmy[2] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "Pan":
                    panTilt[0] = data_virtual[vchannel.id]["value"]
                    pan_rotating_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "+Pan":
                    panTilt[0]  = panTilt[0] * 256 + data_virtual[vchannel.id]["value"]
                    panTilt[2] = 256 # 16bit
                    pan_rotating_geometries[geometry][0] = pan_rotating_geometries[geometry][0] * 256 + data_virtual[vchannel.id]["value"]
                    pan_rotating_geometries[geometry][2] = 256

                elif vchannel.id == "Tilt":
                    panTilt[1] = data_virtual[vchannel.id]["value"]
                    tilt_rotating_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "+Tilt":
                    panTilt[1]  = panTilt[1] * 256 + data_virtual[vchannel.id]["value"]
                    panTilt[3] = 256 # 16bit
                    tilt_rotating_geometries[geometry][0] = tilt_rotating_geometries[geometry][0] * 256 + data_virtual[vchannel.id]["value"]
                    tilt_rotating_geometries[geometry][2] = 256

                elif vchannel.id == "PanRotate":
                    pan_cont_rotating_geometries[geometry][0] = data_virtual[vchannel.id]["value"]

                elif vchannel.id == "TiltRotate":
                    tilt_cont_rotating_geometries[geometry][0] = data_virtual[vchannel.id]["value"]

                elif vchannel.id == "Zoom": zoom = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "XYZ_X": xyz_moving_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "XYZ_Y": xyz_moving_geometries[geometry][1] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "XYZ_Z": xyz_moving_geometries[geometry][2] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "Rot_X": xyz_rotating_geometries[geometry][0] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "Rot_Y": xyz_rotating_geometries[geometry][1] = data_virtual[vchannel.id]["value"]
                elif vchannel.id == "Rot_Z": xyz_rotating_geometries[geometry][2] = data_virtual[vchannel.id]["value"]

        for c in range(len(channels)):
            geometry=self.channels[c].geometry
            if geometry not in rgb_mixing_geometries.keys():
                rgb_mixing_geometries[geometry] = [None] * 12
            if geometry not in xyz_moving_geometries.keys():
                xyz_moving_geometries[geometry]=[None, None, None]
            if geometry not in xyz_rotating_geometries.keys():
                xyz_rotating_geometries[geometry]=[None, None, None]
            if geometry not in shutter_dimmer_geometries.keys():
                shutter_dimmer_geometries[geometry]=[None, None, None, 1] # + bits
            if geometry not in pan_rotating_geometries.keys():
                pan_rotating_geometries[geometry]=[None, 1]
            if geometry not in tilt_rotating_geometries.keys():
                tilt_rotating_geometries[geometry]=[None, 1]
            if geometry not in pan_cont_rotating_geometries.keys():
                pan_cont_rotating_geometries[geometry]=[None, 1]
            if geometry not in tilt_cont_rotating_geometries.keys():
                tilt_cont_rotating_geometries[geometry]=[None, 1]

            if (channels[c] == 'Dimmer'): shutter_dimmer_geometries[geometry][1] = data[c]
            if (channels[c] == '+Dimmer'):
                shutter_dimmer_geometries[geometry][1] = shutter_dimmer_geometries[geometry][1] * 256 + data[c]
                shutter_dimmer_geometries[geometry][3] = 256
            elif (channels[c] == 'Shutter1'): shutter_dimmer_geometries[geometry][0] = data[c]
            elif (channels[c] == 'ColorAdd_R' or channels[c] == 'ColorRGB_Red'): rgb_mixing_geometries[geometry][0] = data[c]
            elif (channels[c] == 'ColorAdd_G' or channels[c] == 'ColorRGB_Green'): rgb_mixing_geometries[geometry][1] = data[c]
            elif (channels[c] == 'ColorAdd_B' or channels[c] == 'ColorRGB_Blue'): rgb_mixing_geometries[geometry][2] = data[c]
            elif channels[c] == 'ColorAdd_W': rgb_mixing_geometries[geometry][3] = data[c]
            elif channels[c] == 'ColorAdd_WW': rgb_mixing_geometries[geometry][4] = data[c]
            elif channels[c] == 'ColorAdd_CW': rgb_mixing_geometries[geometry][5] = data[c]
            elif channels[c] == 'ColorAdd_RY': rgb_mixing_geometries[geometry][6] = data[c]
            elif channels[c] == 'ColorAdd_GY': rgb_mixing_geometries[geometry][7] = data[c]
            elif channels[c] == 'ColorAdd_UV': rgb_mixing_geometries[geometry][8] = data[c]
            elif channels[c] == 'ColorAdd_C': rgb_mixing_geometries[geometry][9] = data[c]
            elif channels[c] == 'ColorAdd_M': rgb_mixing_geometries[geometry][10] = data[c]
            elif channels[c] == 'ColorAdd_Y': rgb_mixing_geometries[geometry][11] = data[c]
            elif channels[c] == 'ColorSub_C': cmy[0] = data[c]
            elif channels[c] == 'ColorSub_M': cmy[1] = data[c]
            elif channels[c] == 'ColorSub_Y': cmy[2] = data[c]
            elif (channels[c] == 'Pan'):
                panTilt[0]   = data[c]
                pan_rotating_geometries[geometry][0] = data[c]
            elif (channels[c] == '+Pan'):
                panTilt[0]  = panTilt[0] * 256 + data[c]
                panTilt[2] = 256 # 16bit
                pan_rotating_geometries[geometry][0] = pan_rotating_geometries[geometry][0] * 256 + data[c]
                pan_rotating_geometries[geometry][1] = 256
            elif (channels[c] == 'Tilt'):
                panTilt[1]  = data[c]
                tilt_rotating_geometries[geometry][0] = data[c]
            elif (channels[c] == '+Tilt'):
                panTilt[1] = panTilt[1] * 256 + data[c]
                panTilt[3] = 256 # 16bit
                tilt_rotating_geometries[geometry][0] = tilt_rotating_geometries[geometry][0] * 256 + data[c]
                tilt_rotating_geometries[geometry][1] = 256

            elif (channels[c] == 'PanRotate'):
                pan_cont_rotating_geometries[geometry][0] = data[c]
            elif (channels[c] == 'TiltRotate'):
                tilt_cont_rotating_geometries[geometry][0] = data[c]
            elif (channels[c] == 'Zoom'): zoom = data[c]
            elif (channels[c] == 'Color1'): color1 = data[c]
            elif (channels[c] == 'Color2'): color1 = data[c]
            elif (channels[c] == 'CTC'): ctc = data[c]
            elif (channels[c] == 'CTO'): ctc = data[c]
            elif (channels[c] == 'CTB'): ctc = data[c]
            elif (channels[c] == 'Iris'): iris = data[c]
            elif (channels[c] == 'ColorMacro1'): color1 = data[c]
            elif (channels[c] == 'Gobo1'): gobo1[0] = data[c]
            elif (channels[c] == 'Gobo1Pos' or channels[c] == 'Gobo1PosRotate'): gobo1[1] = data[c]
            elif (channels[c] == 'Gobo2'): gobo2[0] = data[c]
            elif (channels[c] == 'Gobo2Pos' or channels[c] == 'Gobo2PosRotate'): gobo2[1] = data[c]
            elif (channels[c] == 'XYZ_X'): xyz_moving_geometries[geometry][0] = data[c]
            elif (channels[c] == 'XYZ_Y'): xyz_moving_geometries[geometry][1] = data[c]
            elif (channels[c] == 'XYZ_Z'): xyz_moving_geometries[geometry][2] = data[c]
            elif (channels[c] == 'Rot_X'): xyz_rotating_geometries[geometry][0] = data[c]
            elif (channels[c] == 'Rot_Y'): xyz_rotating_geometries[geometry][1] = data[c]
            elif (channels[c] == 'Rot_Z'): xyz_rotating_geometries[geometry][2] = data[c]

        self.remove_unset_geometries_from_multigeometry_attributes_all(rgb_mixing_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_all(xyz_moving_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_all(xyz_rotating_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_3(shutter_dimmer_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_1(pan_rotating_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_1(tilt_rotating_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_1(pan_cont_rotating_geometries)
        self.remove_unset_geometries_from_multigeometry_attributes_1(tilt_cont_rotating_geometries)



        colorwheel_color = None
        if (color1 is not None):
            colorwheel_color = self.get_colorwheel_color(color1)
        color_temperature = None
        if (ctc is not None):
            color_temperature = self.get_color_temperature(ctc)


        for geometry, colors in rgb_mixing_geometries.items():
            if len(rgb_mixing_geometries)==1:
                geometry = None
            self.updateRGB(colors, geometry, colorwheel_color, color_temperature, current_frame)

        if not len(rgb_mixing_geometries):# handle units without mixing
            if not all([c == 255 for c in self.gel_color_rgb]) or colorwheel_color is not None or color_temperature is not None: #gel color is set and has priority or there is a color wheel or color_temperature
                self.updateRGB([255] * 12, None, colorwheel_color, color_temperature, current_frame)

        if (cmy[0] is not None and cmy[1] is not None and cmy[2] is not None):
            self.updateCMY(cmy, colorwheel_color, color_temperature, current_frame)


        if "Target" in self.objects:
            if self.ignore_movement_dmx:
                # programming by target, dmx for p/t locked
                if "Target" in self.objects:
                    target = self.objects['Target'].object
                    if current_frame and self.dmx_cache_dirty:
                        target.keyframe_insert(data_path="location", frame=current_frame)
                        target.keyframe_insert(data_path="rotation_euler", frame=current_frame)
            else:
                if panTilt[0] is None:
                    panTilt[0] = 0 * panTilt[2] # if the device doesn't have pan, align head with base
                if panTilt[1] is None:
                    panTilt[1] = 0 * panTilt[3]
                pan = (panTilt[0]/(panTilt[2]*127.0)-1)*540*(math.pi/360)
                tilt = (panTilt[1]/(panTilt[3]*127.0)-1)*270*(math.pi/360)
                self.updatePanTiltViaTarget(pan, tilt, current_frame)

        else:# no Target
            for geometry, pan_vals in pan_rotating_geometries.items():
                pan = (pan_vals[0]/(pan_vals[1]*127.0)-1)*540*(math.pi/360)
                self.updatePTDirectly(geometry, "pan", pan, current_frame)
            for geometry, tilt_vals in tilt_rotating_geometries.items():
                tilt = (tilt_vals[0]/(tilt_vals[1]*127.0)-1)*270*(math.pi/360)
                self.updatePTDirectly(geometry, "tilt", tilt, current_frame)


        for geometry, pan_rotate in pan_cont_rotating_geometries.items():
            self.set_pan_tilt_rotation(geometry=geometry, axis = "pan", rotation = pan_rotate[0], current_frame=current_frame)

        for geometry, tilt_rotate in tilt_cont_rotating_geometries.items():
            self.set_pan_tilt_rotation(geometry=geometry, axis = "tilt", rotation = tilt_rotate[0], current_frame=current_frame)


        if (zoom is not None):
            self.updateZoom(zoom, current_frame)

        self.hide_gobo_geometry(gobo1, gobo2, iris, current_frame)

        if gobo1[0] is not None:
            self.updateGobo(gobo1, 1, current_frame)

        if gobo2[0] is not None:
            self.updateGobo(gobo2, 2, current_frame)

        if iris is not None:
            if 0 <= iris <= 255:
                iris = iris  * 12/255
                self.update_iris(iris, current_frame)

        for geometry, xyz in xyz_moving_geometries.items():
            self.updatePosition(geometry=geometry, x=xyz[0], y=xyz[1], z=xyz[2], current_frame=current_frame)

        for geometry, xyz in xyz_rotating_geometries.items():
            self.updateRotation(geometry=geometry, x=xyz[0], y=xyz[1], z=xyz[2], current_frame=current_frame)

        for geometry, shutter_dimmer in shutter_dimmer_geometries.items():
            if len(shutter_dimmer_geometries)==1:
                geometry = None
            if shutter_dimmer[0] is not None or shutter_dimmer[1] is not None:
                if shutter_dimmer[0] is None:
                    shutter_dimmer[0] = 0 # if device doesn't have shutter, set default value
                if shutter_dimmer[1] is None:
                    shutter_dimmer[1] = 100 # if device doesn't have dimmer, set default value
                self.updateShutterDimmer(shutter_dimmer[0], shutter_dimmer[1], geometry, shutter_dimmer[3], current_frame)

        if current_frame:
            self.dmx_cache_dirty = False
        # end of render block


    def set_pan_tilt_rotation(self, geometry, axis, rotation, current_frame):
        if axis == "pan":
            mobile_type = "yoke"
            offset = 2
            lock_rotation = self.lock_pan_rotation

        else: # tilt
            mobile_type = "head"
            offset = 0
            lock_rotation = self.lock_tilt_rotation

        if geometry is None:
            geometry = self.get_mobile_type(mobile_type)
        else:
            geometry = self.get_object_by_geometry_name(geometry)
        if geometry:
            geometry.rotation_mode = "XYZ"
            geometry.driver_remove("rotation_euler", offset)

            if lock_rotation:
                rotation = rotation/128 * 360 *(math.pi/360)
                geometry.rotation_euler[offset] = rotation # just some value, not very precise
            else:
                if rotation != 0:
                    driver = geometry.driver_add("rotation_euler", offset)
                    value = rotation-128 # rotating in both direction, slowest in the middle
                    driver.driver.expression=f"frame*{value*0.005}"

            if current_frame and self.dmx_cache_dirty:
                geometry.keyframe_insert(data_path="location", frame=current_frame)
                geometry.keyframe_insert(data_path="rotation_euler", frame=current_frame)


    def remove_unset_geometries_from_multigeometry_attributes_all(self, dictionary):
        """Remove items with values of all None"""

        remove_empty_items = []
        for geometry, items in dictionary.items():
            if all([i == None for i in items]):
                remove_empty_items.append(geometry)
        for geo in remove_empty_items:
            del(dictionary[geo])

    def remove_unset_geometries_from_multigeometry_attributes_1(self, dictionary):
        """Remove items with 3 values of None"""

        remove_empty_items = []
        for geometry, items in dictionary.items():
            if items[0] is None:
                remove_empty_items.append(geometry)
        for geo in remove_empty_items:
            del(dictionary[geo])

    def remove_unset_geometries_from_multigeometry_attributes_3(self, dictionary):
        """Remove items with 1 value of None"""

        remove_empty_items = []
        for geometry, items in dictionary.items():
            if (items[0] is None and items[1] is None and items[2] is None):
                remove_empty_items.append(geometry)
        for geo in remove_empty_items:
            del(dictionary[geo])

    def light_object_for_geometry_exists(self, geometry):
        """Check if there is any light or emitter matching geometry name of a color attribute"""
        for light in self.lights:
            if geometry in light.object.data.name:
                return True
        for emitter_material in self.emitter_materials:
            if geometry in emitter_material.name:
                return True
        return False

    def get_channel_by_attribute(self, attribute):
        for channel in self.channels:
            if channel.id == attribute:
                return channel

    def updateShutterDimmer(self, shutter, dimmer, geometry, bits, current_frame):
        DMX_Log.log.info(("set shutter, dimmer", shutter, dimmer, geometry))
        dmx = bpy.context.scene.dmx
        if geometry is not None:
            geometry = geometry.replace(" ", "_")
        last_shutter_value = 0
        last_dimmer_value = 0
        try:
            for emitter_material in self.emitter_materials:
                if (shutter > 0 and shutter != 255):
                    break # no need to do the expensive value settings if we do this anyway in shutter timer
                if geometry is not None:
                    if f"{geometry}" in emitter_material.name:
                        DMX_Log.log.info("matched emitter")
                        emitter_material.material.node_tree.nodes[1].inputs[STRENGTH].default_value = 1*(dimmer/(255.0 * bits))
                else:
                    emitter_material.material.node_tree.nodes[1].inputs[STRENGTH].default_value = 1*(dimmer/(255.0 * bits))
                if current_frame and self.dmx_cache_dirty:
                    emitter_material.material.node_tree.nodes[1].inputs[STRENGTH].keyframe_insert(data_path='default_value', frame=current_frame)

            for light in self.lights:
                last_shutter_value = light.object.data['shutter_value']
                last_dimmer_value = light.object.data['shutter_dimmer_value']
                light.object.data['shutter_value']=shutter
                light.object.data['shutter_dimmer_value']=dimmer
                light.object.data['shutter_dimmer_bits']=bits
                flux = light.object.data["flux"] * dmx.beam_intensity_multiplier
                # we should improve this to get more Cycles/Eevee compatibility... add a driver which would adjust the intensity
                # depending on the IES linking or not, adding drivers: https://blender.stackexchange.com/a/314329/176407
                # plus, we would still need to calculate correct energy, so they match between Cycles/Eevee
                # here are some ideas: https://blender.stackexchange.com/a/180533/176407
                if (shutter > 0 and shutter != 255):
                    break # no need to do the expensive value settings if we do this anyway in shutter timer

                if geometry is not None:
                    if f"{geometry}" in  light.object.data.name:
                        DMX_Log.log.info("matched emitter")
                        light.object.data.energy = (dimmer/(255.0 * bits)) * flux

                else:
                    light.object.data.energy = (dimmer/(255.0 * bits)) * flux

                if current_frame and self.dmx_cache_dirty:
                    light.object.data.keyframe_insert(data_path='energy', frame=current_frame)

            for nodes in self.geometry_nodes:
                vector = nodes.node.nodes["Vector"]
                if dimmer > 0:
                    vector.vector = (0,0,-1)
                else:
                    vector.vector = (0,0,0)
                if current_frame and self.dmx_cache_dirty:
                    vector.keyframe_insert(data_path='vector', frame=current_frame)

        except Exception as e:
            DMX_Log.log.error(f"Error updating dimmer {e}")

        if (last_shutter_value == 0 or last_shutter_value == 255 or last_dimmer_value == 0) and (shutter > 0 and shutter != 255):
            bpy.app.timers.register(self.runStrobe)
            DMX_Log.log.info("Register shutter timer")

        return dimmer

    def runStrobe(self):
        #TODO: try to convert strobe to a blender driver, less resources and keyframable
        try:

            exit_timer = False
            dimmer_value = 0 # reused also for emitter
            dimmer_bits = 1

            for light in self.lights:
                if light.object.data['shutter_value'] == 0:
                    exit_timer= True
                if light.object.data['shutter_value'] == 255:
                    exit_timer= True
                if light.object.data['shutter_dimmer_value'] == 0:
                    exit_timer = True
                dimmer_value = 0
                flux = light.object.data["flux"]
                if light.object.data['shutter_counter'] == 1:
                    dimmer_value = light.object.data['shutter_dimmer_value']
                    dimmer_bits = light.object.data['shutter_dimmer_bits']
                if light.object.data['shutter_counter'] > light.object.data['shutter_value']:
                    light.object.data['shutter_counter'] = 0

                light.object.data.energy = (dimmer_value/(255.0 * dimmer_bits)) * flux
                light.object.data['shutter_counter'] +=1

            # Here we can reuse data we got from the light object...
            for emitter_material in self.emitter_materials:
                emitter_material.material.node_tree.nodes[1].inputs[STRENGTH].default_value = 1*(dimmer_value/(255.0 * dimmer_bits))

            if exit_timer:
                DMX_Log.log.info("Killing shutter timer")
                return None # exit the timer

        except Exception as e:
            DMX_Log.log.error(f"Error updating lights and emitters {e}")
            DMX_Log.log.info("Killing shutter timer")
            return None # kills the timer
        return 1.0/24.0

    def updateRGB(self, colors, geometry, colorwheel_color, color_temperature, current_frame):
        if geometry is not None:
            geometry = geometry.replace(" ", "_")
        DMX_Log.log.info(("color change for geometry", geometry))
        colors = [c if c is not None else 0 for c in colors] # replace None with 0, can happen if someone maps colors across geometries...
        rgb = colors_to_rgb(colors)
        if colorwheel_color is not None:
            rgb = add_rgb(rgb, colorwheel_color[:3])
        if color_temperature is not None:
            rgb = add_rgb(rgb, color_temperature[:3])
        rgb = add_rgb(self.gel_color_rgb, rgb)
        rgb = [c/255.0 for c in rgb]

        try:
            for emitter_material in self.emitter_materials:
                DMX_Log.log.info(("emitter:", emitter_material.name))
                if geometry is not None:
                    if f"{geometry}" in emitter_material.name:
                        DMX_Log.log.info("matched emitter")
                        emitter_material.material.node_tree.nodes[1].inputs[COLOR].default_value = rgb + [1]
                else:
                    emitter_material.material.node_tree.nodes[1].inputs[COLOR].default_value = rgb + [1]

                if current_frame and self.dmx_cache_dirty:
                    emitter_material.material.node_tree.nodes[1].inputs[COLOR].keyframe_insert(data_path='default_value', frame=current_frame)

            for light in self.lights:
                if geometry is not None:
                    DMX_Log.log.info(("light:", light.object.data.name))
                    if f"{geometry}" in  light.object.data.name:
                        DMX_Log.log.info("matched light")
                        light.object.data.color = rgb
                else:
                    light.object.data.color = rgb

                if current_frame and self.dmx_cache_dirty:
                    light.object.data.keyframe_insert(data_path='color', frame=current_frame)
        except Exception as e:
            DMX_Log.log.error(f"Error updating RGB {e}")
            traceback.print_exception(e)
        return rgb


    def updateCMY(self, cmy, colorwheel_color, color_temperature, current_frame):
        rgb=[0,0,0]
        rgb=cmy_to_rgb(cmy)
        if all([c == 255 for c in rgb]) and (colorwheel_color is not None or color_temperature is not None):
            rgb=[0,0,0] # without this, default white would always be overwriting ctc

        if colorwheel_color is not None:
            rgb = add_rgb(rgb, colorwheel_color)
        if color_temperature is not None:
            rgb = add_rgb(rgb, color_temperature[:3])
        if not all([c == 255 for c in self.gel_color_rgb]):
            rgb = add_rgb(self.gel_color_rgb, rgb)

        rgb = [c/255.0 for c in rgb]

        for emitter_material in self.emitter_materials:
            emitter_material.material.node_tree.nodes[1].inputs[COLOR].default_value = rgb + [1]
            if current_frame and self.dmx_cache_dirty:
                emitter_material.material.node_tree.nodes[1].inputs[COLOR].keyframe_insert(data_path='default_value', frame=current_frame)
        for light in self.lights:
            light.object.data.color = rgb
            if current_frame and self.dmx_cache_dirty:
                light.object.data.keyframe_insert(data_path='color', frame=current_frame)
        return cmy

    def updateZoom(self, zoom, current_frame):
        try:
            spot_size = math.radians(zoom)
            gobo_diameter = 2.2 * 0.01 * math.tan(math.radians(zoom/2))
            # 2x because result is 1/2 of diameter
            # .2 because there was a bit of a spill
            # 0.01 is distance from the beam
            # zoom/2 because we need 1/2 of the beam angle

            for obj in self.collection.objects:
                if "gobo" in obj.get("geometry_type", ""):
                    beam_diameter = obj.get("beam_radius", 0) * 2
                    if beam_diameter:
                        if gobo_diameter > beam_diameter:
                            gobo_diameter = beam_diameter
                    obj.dimensions = (gobo_diameter, gobo_diameter, 0)
                    if current_frame and self.dmx_cache_dirty:
                        obj.keyframe_insert(data_path='scale', frame=current_frame)

                if "laser" in obj.get("geometry_type", ""):
                    # multiplication makes this easy to only apply on used axis
                    # but we could also re-calculate this to proper angle

                    obj.rotation_euler[0] = obj.get("rot_x", 0) * zoom * 0.1
                    obj.rotation_euler[1] = obj.get("rot_y", 0) * zoom * 0.1
                    obj.rotation_euler[2] = obj.get("rot_z", 0) * zoom * 0.1
                    if current_frame and self.dmx_cache_dirty:
                        obj.keyframe_insert(data_path="rotation_euler", frame=current_frame)

            for light in self.lights:
                light.object.data.spot_size=spot_size

                if current_frame and self.dmx_cache_dirty:
                    light.object.data.keyframe_insert(data_path='spot_size', frame=current_frame)

        except Exception as e:
            DMX_Log.log.error(f"Error updating zoom {e}")
        return zoom


    def get_colorwheel_color(self, color1):
        if not len(self["slot_colors"]) or color1 == 0:
            return

        colors = self["slot_colors"]
        index = int(color1/int(255/(len(colors)-1)))

        if len(colors) > index:
            return list(colors[index])

    def get_color_temperature(self, ctc):
        if ctc == 0:
            return
        if 1 <= ctc <= 255:
            ctc = 1000 + (ctc - 1) * (12000 - 1000) / (255 - 1)
            ctc -= ctc % -100 # round to full 100s
            return kelvin_table[ctc]
        else:
            return

    def update_iris(self, iris, current_frame):

        for obj in self.collection.objects: #EEVEE
            if "gobo" in obj.get("geometry_type", ""):
                material = self.gobo_materials[obj.name].material
                mix = material.node_tree.nodes.get("Iris Size")
                DMX_Log.log.debug(("found iris", material, mix))
                iris_size = mix.inputs[3]
                iris_size.default_value = iris

                if current_frame and self.dmx_cache_dirty:
                    #light_obj.data.keyframe_insert(data_path="shadow_soft_size", frame=current_frame)
                    iris_size.keyframe_insert(data_path="default_value", frame=current_frame)

        for light in self.lights: # CYCLES
            light_obj = light.object
            mix = light_obj.data.node_tree.nodes.get("Iris Size")
            iris_size = mix.inputs[3]
            iris_size.default_value = iris

            if current_frame and self.dmx_cache_dirty:
                #light_obj.data.keyframe_insert(data_path="shadow_soft_size", frame=current_frame)
                iris_size.keyframe_insert(data_path="default_value", frame=current_frame)

    def updateGobo(self, gobo, n, current_frame):
        if "gobos1" not in self.images:
            self.hide_gobo([1,2], current_frame=current_frame)
            return

        if gobo is None:
            self.hide_gobo([n], current_frame=current_frame)
            return

        if gobo[0] == 0:
            self.hide_gobo([n], current_frame=current_frame)
            return

        gobos = self.images["gobos1"]
        if not gobos.count:
            self.hide_gobo([1,2], current_frame=current_frame)
            return

        DMX_Log.log.debug(("update gobo", gobo, n))
        self.hide_gobo([n], False, current_frame=current_frame)
        index = int(gobo[0]/int(255/(gobos.count-1)))
        self.set_gobo_slot(n, index, current_frame=current_frame)
        if gobo[1] is not None:
            self.set_gobo_rotation(gobo, n, current_frame=current_frame)

    def set_gobo_rotation(self, gobo, n, current_frame):
        for obj in self.collection.objects: #EEVEE
            if "gobo" in obj.get("geometry_type", ""):
                material = self.gobo_materials[obj.name].material
                gobo_rotation = material.node_tree.nodes.get(f"Gobo{n}Rotation")
                if gobo[1]<128: # half for indexing
                    gobo_rotation.inputs[3].driver_remove("default_value")
                    gobo_rotation.inputs[3].default_value = (gobo[1]/62.0-1)*360*(math.pi/360)
                else: # half for rotation
                    driver = gobo_rotation.inputs[3].driver_add("default_value")
                    value = gobo[1]-128-62 # rotating in both direction, slowest in the middle
                    driver.driver.expression=f"frame*{value*0.005}"

                if current_frame and self.dmx_cache_dirty:
                    gobo_rotation.inputs[3].keyframe_insert(data_path="default_value", frame=current_frame)

        for light in self.lights: #CYCLES
            light_obj = light.object
            gobo_rotation = light_obj.data.node_tree.nodes.get(f"Gobo{n}Rotation")
            if gobo[1]<128: # half for indexing
                gobo_rotation.inputs[3].driver_remove("default_value")
                gobo_rotation.inputs[3].default_value = (gobo[1]/62.0-1)*360*(math.pi/360)
            else: # half for rotation
                driver = gobo_rotation.inputs[3].driver_add("default_value")
                value = gobo[1]-128-62 # rotating in both direction, slowest in the middle
                driver.driver.expression=f"frame*{value*0.005}"

            if current_frame and self.dmx_cache_dirty:
                gobo_rotation.inputs[3].keyframe_insert(data_path="default_value", frame=current_frame)

    def updatePosition(self, geometry = None, x=None, y=None, z=None, current_frame=None):
        if geometry is None:
            geometry = self.objects["Root"].object
        else:
            geometry = self.get_object_by_geometry_name(geometry)

        if x is not None:
            geometry.location.x = (128-x) * 0.1
        if y is not None:
            geometry.location.y = (128-y) * 0.1
        if z is not None:
            geometry.location.z = (128-z) * 0.1
        if geometry is not None:
            if current_frame and self.dmx_cache_dirty:
                geometry.keyframe_insert(data_path="location", frame=current_frame)

    def updateRotation(self, geometry = None, x=None, y=None, z=None, current_frame=None):
        if geometry is None:
            geometry = self.objects["Root"].object
        else:
            geometry = self.get_object_by_geometry_name(geometry)

        geometry.rotation_mode = 'XYZ'
        if x is not None:
            geometry.rotation_euler[0] = (x/127.0-1)*360*(math.pi/360)
        if y is not None:
            geometry.rotation_euler[1] = (y/127.0-1)*360*(math.pi/360)
        if z is not None:
            geometry.rotation_euler[2] = (z/127.0-1)*360*(math.pi/360)
        if geometry is not None:
            if current_frame and self.dmx_cache_dirty:
                geometry.keyframe_insert(data_path="rotation_euler", frame=current_frame)

    def updatePanTiltViaTarget(self, pan, tilt, current_frame):

        DMX_Log.log.info("Updating pan tilt")

        base = self.objects["Root"].object
        pan = pan + base.rotation_euler[2] # take base z rotation into consideration
        tilt = tilt + base.rotation_euler[0] # take base x rotation into consideration

        # calculate target position, head will follow
        try:
            head = self.objects["Head"].object
        except Exception as e:
            self.updatePTDirectly(None, "pan", pan, current_frame)
            self.updatePTDirectly(None, "tilt", tilt, current_frame)
            DMX_Log.log.info("Updating pan/tilt directly via geometries, not via Target due to not located Head")
            return

        head_location = head.matrix_world.translation

        target = self.objects['Target'].object

        eul = mathutils.Euler((0.0,base.rotation_euler[1]+tilt,base.rotation_euler[0]+pan), 'XYZ')
        vec = mathutils.Vector((0.0,0.0,-(target.location-head_location).length))
        vec.rotate(eul)

        target.location = vec + head_location

        if current_frame and self.dmx_cache_dirty:
            target.keyframe_insert(data_path="location", frame=current_frame)
            target.keyframe_insert(data_path="rotation_euler", frame=current_frame)

    def updatePTDirectly(self, geometry, axis_type, value, current_frame):
        if axis_type == "pan":
            mobile_type = "yoke"
            offset = 2
        else: # tilt
            mobile_type = "head"
            offset = 0
        if geometry is None:
            geometry = self.get_mobile_type(mobile_type)
        else:
            geometry = self.get_object_by_geometry_name(geometry)
        if geometry:
            geometry.rotation_mode = "XYZ"
            geometry.rotation_euler[offset] = value
            if current_frame and self.dmx_cache_dirty:
                geometry.keyframe_insert(data_path="location", frame=current_frame)
                geometry.keyframe_insert(data_path="rotation_euler", frame=current_frame)

    def get_object_by_geometry_name(self, geometry):
        for obj in self.collection.objects:
            if "original_name" not in obj:
                continue
            if obj["original_name"] == geometry:
                return obj

    def get_mobile_type(self, mobile_type):
        for obj in self.collection.objects:
            if obj.get("mobile_type", None) == mobile_type:
                return obj


    def get_root(self, model_collection):
        if model_collection.objects is None:
            return None
        for obj in model_collection.objects:
            if obj.get("geometry_root", False):
                return obj

    def get_tilt(self, model_collection):
        for obj in model_collection.objects:
            for channel in self.channels:
                if "Tilt" == channel.id and channel.geometry == obj.get("original_name", "None"):
                    return obj
            for channel in self.virtual_channels:
                if "Tilt" == channel.id and channel.geometry == obj.get("original_name", "None"):
                    return obj


    def getProgrammerData(self):
        channels = [c.id for c in self.channels]
        data = DMX_Data.get(self.universe, self.address, len(channels))
        params = {}
        for c in range(len(channels)):
            params[channels[c]] = data[c]
        return params


    def select(self, select_target = False):
        dmx = bpy.context.scene.dmx
        if dmx.display_2D:
            # in 2D view deselect the 2D symbol, unhide the fixture and select base,
            # to allow movement and rotation
            self.objects["2D Symbol"].object.select_set(False)
            targets = []

            for obj in self.collection.objects:
                if ('Target' in self.objects):
                    targets.append(self.objects['Target'].object)
                if "pigtail" in obj.get("geometry_type", ""):
                    obj.hide_set(not bpy.context.scene.dmx.display_pigtails)
                    obj.hide_viewport = not bpy.context.scene.dmx.display_pigtails # keyframing
                    obj.hide_render = not bpy.context.scene.dmx.display_pigtails
                if obj.get("2d_symbol", None):
                    continue
                obj.hide_set(False)
                obj.hide_viewport = False #keyframing
                obj.hide_render = False

            if not select_target:
                if "Root" in self.objects:
                    try:
                        self.objects["Root"].object.select_set(True)
                    except Exception as e:
                        DMX_Log.log.error(f"Fixture doesn't exist, remove it via Fixture list → Edit → X")
            else:
                if (len(targets)):
                    for target in targets:
                        target.select_set(True)

        else:

            if not select_target:
                if "Root" in self.objects:
                    try:
                        self.objects["Root"].object.select_set(True)
                    except Exception as e:
                        DMX_Log.log.error(f"Fixture doesn't exist, remove it via Fixture list → Edit → X")
            else:
                targets = []
                for obj in self.collection.objects:
                    if ('Target' in self.objects):
                        targets.append(self.objects['Target'].object)

                if (len(targets)):
                    for target in targets:
                        target.select_set(True)

        DMX_OSC_Handlers.fixture_selection(self)
        dmx.updatePreviewVolume()
        self.sync_fixture_selection()

    def sync_fixture_selection(self):
        """This sets the active selection in the Fixtures list, as
        we may select by shortcuts, mouse or an operator """

        dmx = bpy.context.scene.dmx
        for idx, fixture in enumerate(dmx.fixtures):
            if fixture == self:
                dmx.selected_fixture_index = idx
                return

    def unselect(self):
        dmx = bpy.context.scene.dmx
        if "Root" in self.objects:
            try:
                self.objects["Root"].object.select_set(False)
            except Exception as e:
                DMX_Log.log.error(f"Fixture doesn't exist, remove it via Fixture list → Edit → X")
        if ('Target' in self.objects):
            self.objects['Target'].object.select_set(False)
        if "2D Symbol" in self.objects:
            try:
                self.objects["2D Symbol"].object.select_set(False)
            except Exception as e:
                DMX_Log.log.error(f"Fixture doesn't exist, remove it via Fixture list → Edit → X")
        if dmx.display_2D:
            for obj in self.collection.objects:
                if obj.get("2d_symbol", None):
                    continue
                obj.hide_set(True)
                obj.hide_viewport = True #need for keyframing
                obj.hide_render = True
        dmx.updatePreviewVolume()
        self.sync_fixture_selection()


    def toggleSelect(self):
        selected = False
        for obj in self.objects:
            if (obj.object in bpy.context.selected_objects):
                selected = True
                break
        if (selected): self.unselect()
        else: self.select()

    def is_selected(self):
        selected = False
        for obj in self.objects:
            if (obj.object in bpy.context.selected_objects):
                selected = True
                break
        return selected

    def clear(self):
        for i, ch in enumerate(self.channels):
            DMX_Data.set(self.universe, self.address+i, ch.default)
        self.render()

    def set_gobo_slot(self, n, index=-1, current_frame=None):
        gobos = self.images[f"gobos{n}"]
        for obj in self.collection.objects: #EEVEE
            if "gobo" in obj.get("geometry_type", ""):
                material = self.gobo_materials[obj.name].material
                texture = material.node_tree.nodes.get(f"Gobo{n}Texture")
                DMX_Log.log.debug(("Found gobo nodes:", n, material, texture))
                if texture.image is None:
                    texture.image = gobos.image
                    texture.image.source = "SEQUENCE"
                    texture.image_user.frame_duration = 1
                    texture.image_user.use_auto_refresh = True
                texture.image_user.frame_offset = index

                if current_frame and self.dmx_cache_dirty:
                    texture.image_user.keyframe_insert(data_path="frame_offset", frame=current_frame)
                break

        for light in self.lights: # CYCLES
            light_obj = light.object
            texture = light_obj.data.node_tree.nodes.get(f"Gobo{n}Texture")
            if texture.image is None:
                texture.image = gobos.image
                texture.image.source = "SEQUENCE"
                texture.image_user.frame_duration = 1
                texture.image_user.use_auto_refresh = True
            texture.image_user.frame_offset = index

            if current_frame and self.dmx_cache_dirty:
                texture.image_user.keyframe_insert(data_path="frame_offset", frame=current_frame)

    def set_spot_diameter_to_point(self, light_obj):
        if bpy.context.scene.dmx.reduced_beam_diameter_in_cycles == "REDUCED":
            light_obj.data.shadow_soft_size = 0.01
        elif bpy.context.scene.dmx.reduced_beam_diameter_in_cycles == "CUSTOM":
            if light_obj.data.get("beam_radius_pin_sized_for_gobos", True):
                light_obj.data.shadow_soft_size = 0.01
        elif bpy.context.scene.dmx.reduced_beam_diameter_in_cycles == "FULL":
            size = light_obj.data.get("beam_radius", 0.01)
            light_obj.data.shadow_soft_size = size

    def set_spot_diameter_to_normal(self, light_obj):
        size = light_obj.data.get("beam_radius", 0.01)
        light_obj.data.shadow_soft_size = size

    def hide_gobo_geometry(self, gobo1, gobo2, iris, current_frame = None):

        hide = True

        if gobo1[0] is not None:
            if gobo1[0] != 0:
                hide = False

        if gobo2[0] is not None:
            if gobo2[0] != 0:
                hide = False

        if iris is not None:
            if iris != 0:
                hide = False
        for obj in self.collection.objects:
            if "gobo" in obj.get("geometry_type", ""):
                obj.hide_viewport = hide
                obj.hide_render = hide
                if current_frame and self.dmx_cache_dirty:
                    obj.keyframe_insert("hide_viewport", frame = current_frame)
                    obj.keyframe_insert("hide_render", frame = current_frame)

        for light in self.lights: # CYCLES
            light_obj = light.object
            if hide:
                self.set_spot_diameter_to_normal(light_obj) # make the beam large if no gobo is used
            else:
                self.set_spot_diameter_to_point(light_obj)
            if current_frame and self.dmx_cache_dirty:
                light_obj.data.keyframe_insert(data_path="shadow_soft_size", frame=current_frame)


    def hide_gobo(self, n=[1,2], hide = True, current_frame = None):
        for obj in self.collection.objects:
            if "gobo" in obj.get("geometry_type", ""):
                material = self.gobo_materials[obj.name].material
                for i in n:
                    mix_factor = material.node_tree.nodes.get(f"Gobo{i}Mix").inputs["Factor"]
                    mix_factor.default_value = 1 if hide else 0
                    if current_frame and self.dmx_cache_dirty:
                        DMX_Log.log.debug(("hide gobo", hide, i))
                        mix_factor.keyframe_insert(data_path="default_value", frame=current_frame)

        for light in self.lights: # CYCLES
            light_obj = light.object
            for i in n:
                mix_factor = light_obj.data.node_tree.nodes.get(f"Gobo{i}Mix").inputs["Factor"]
                mix_factor.default_value = 1 if hide else 0
                if current_frame and self.dmx_cache_dirty:
                    mix_factor.keyframe_insert(data_path="default_value", frame=current_frame)

    def has_attributes(self, attributes, lower = False):

        temp_data = bpy.context.window_manager.dmx
        def low(id):
            if lower:
                return id.lower()
            else:
                return id
        if len(temp_data.active_subfixtures) > 0:
            in_fixture_real = [low(channel.id) for channel in self.channels if any(channel.geometry == g.name for g in temp_data.active_subfixtures)]
            in_fixture_virtual = [low(channel.id) for channel in self.virtual_channels if any(channel.geometry == g.name for g in temp_data.active_subfixtures)]

            real =    any(any(attribute == item for item in in_fixture_real) for attribute in attributes)
            virtual = any(any(attribute == item for item in in_fixture_virtual) for attribute in attributes)
        else:
            in_fixture_real = [low(channel.id) for channel in self.channels]
            in_fixture_virtual = [low(channel.id) for channel in self.virtual_channels]

            real =    any(any(attribute == item for item in in_fixture_real) for attribute in attributes)
            virtual = any(any(attribute == item for item in in_fixture_virtual) for attribute in attributes)

        return (real or virtual)

    def add_ies(self, ies_file_path):
        if os.path.isfile(ies_file_path):
            with open(ies_file_path, "r", encoding="cp1252") as f:
                ies_file = f.read()
        else:
            return

        unique_name = f"{self.uuid}-255"
        if unique_name in bpy.data.texts:
            bpy.data.texts.remove(bpy.data.texts[unique_name])

        if "255" in self.ies_data:
            ies_data = self.ies_data["255"]
        else:
            ies_data = self.ies_data.add()
            ies_data.name = "255"

        ies_data.ies = bpy.data.texts.new(unique_name)
        ies_data.ies.from_string(ies_file)
        for light in self.lights:
            light_obj = light.object
            ies = light_obj.data.node_tree.nodes.get("IES Texture")
            if ies is None:
                ies = get_ies_node(light_obj)
            ies.ies = ies_data.ies

    def remove_ies(self):
        self.ies_data.clear()
        zoom_ranges = ["255"]
        for zoom_range in zoom_ranges:
            unique_name = f"{self.uuid}-{zoom_range}"
            if unique_name in bpy.data.texts:
                bpy.data.texts.remove(bpy.data.texts[unique_name])
        for light in self.lights:
            light_obj = light.object
            ies = light_obj.data.node_tree.nodes.get("IES Texture")
            if ies is not None:
                light_obj.data.node_tree.nodes.remove(ies)


    def to_mvr_fixture(self):
        matrix = 0
        uuid_focus_point = None
        for obj in self.objects:
            if obj.object.get("geometry_root", False):
                m=obj.object.matrix_world
                matrix = [list(col) for col in m.col]
            if 'Target' in obj.name:
                uuid_focus_point = obj.object.get("uuid", None)

        r, g, b = list(self.gel_color_rgb)[:3]
        x, y, z = rgb2xyY(r, g, b)
        color = f"{x},{y},{z}"

        return pymvr.Fixture(name = self.name, uuid = self.uuid, gdtf_spec = self.profile, gdtf_mode = self.mode, fixture_id = self.fixture_id, addresses = [pymvr.Address(dmx_break= 0, universe=self.universe, address=self.address)], matrix = pymvr.Matrix(matrix), focus = uuid_focus_point, color = color, classing = self.classing)

    def focus_to_mvr_focus_point(self):
        for obj in self.objects:
            if 'Target' in obj.name:
                matrix = None
                uuid_ = None
                m=obj.object.matrix_world
                matrix = [list(col) for col in m.col]
                uuid_ = obj.object.get("uuid", None)
                if matrix is None or uuid_ is None:
                    DMX_Log.log.error(f"Matrix or uuid of a Target not defined")
                    return
                return pymvr.FocusPoint(matrix = pymvr.Matrix(matrix), uuid=uuid_, name=f"Target for {self.name}")


    def onDepsgraphUpdate(self):
        # TODO: rename this and hook again somewhere.
        # After not touching depsgraph (was causing slowdowns and crashes),
        # we do not have this functionality
        # Check if any object was deleted
        for obj in self.objects:
            if (not len(obj.object.users_collection)):
                bpy.context.scene.dmx.removeFixture(self)
                break

        # check if target is moving and the rest of objects is not selected
        # (programming by target)
        if "Target" in self.objects:
            target = self.objects['Target'].object
            update_by_target = False
            for obj in self.objects:
                if obj.object in bpy.context.selected_objects:
                    if obj.object != target:
                        # exit early if body (any part) and target were selected and moved
                        return
                    if obj.object == target:
                        update_by_target = True
            if update_by_target:
                self.ignore_movement_dmx = True
                return