add_advanced_objects_menu: unsupported: removed from repo: T63750
authormeta-androcto <meta.androcto1@gmail.com>
Wed, 12 Jun 2019 01:51:15 +0000 (11:51 +1000)
committermeta-androcto <meta.androcto1@gmail.com>
Wed, 12 Jun 2019 01:51:15 +0000 (11:51 +1000)
18 files changed:
add_advanced_objects_menu/__init__.py [deleted file]
add_advanced_objects_menu/add_light_template.py [deleted file]
add_advanced_objects_menu/add_mesh_aggregate.py [deleted file]
add_advanced_objects_menu/arrange_on_curve.py [deleted file]
add_advanced_objects_menu/circle_array.py [deleted file]
add_advanced_objects_menu/copy2.py [deleted file]
add_advanced_objects_menu/cubester.py [deleted file]
add_advanced_objects_menu/make_struts.py [deleted file]
add_advanced_objects_menu/mesh_easylattice.py [deleted file]
add_advanced_objects_menu/object_add_chain.py [deleted file]
add_advanced_objects_menu/oscurart_chain_maker.py [deleted file]
add_advanced_objects_menu/pixelate_3d.py [deleted file]
add_advanced_objects_menu/random_box_structure.py [deleted file]
add_advanced_objects_menu/rope_alpha.py [deleted file]
add_advanced_objects_menu/scene_objects_bi.py [deleted file]
add_advanced_objects_menu/scene_objects_cycles.py [deleted file]
add_advanced_objects_menu/scene_texture_render.py [deleted file]
add_advanced_objects_menu/trilighting.py [deleted file]

diff --git a/add_advanced_objects_menu/__init__.py b/add_advanced_objects_menu/__init__.py
deleted file mode 100644 (file)
index 91ddcb1..0000000
+++ /dev/null
@@ -1,547 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# Contributed to by:
-# meta-androcto, Bill Currie, Jorge Hernandez - Melenedez  Jacob Morris, Oscurart  #
-# Rebellion, Antonis Karvelas, Eleanor Howick, lijenstina, Daniel Schalla, Domlysz #
-# Unnikrishnan(kodemax), Florian Meyer, Omar ahmed, Brian Hinton (Nichod), liero   #
-# Atom, Dannyboy, Mano-Wii, Kursad Karatas, teldredge, Phil Cote #
-
-bl_info = {
-    "name": "Add Advanced Objects",
-    "author": "Meta Androcto",
-    "version": (0, 1, 6),
-    "blender": (2, 78, 0),
-    "location": "View3D > Add ",
-    "description": "Add Object & Camera extras",
-    "warning": "",
-    "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6"
-                "/Py/Scripts/Object/Add_Advanced",
-    "category": "Object"}
-
-if "bpy" in locals():
-    import importlib
-
-    importlib.reload(add_light_template)
-    importlib.reload(scene_objects_bi)
-    importlib.reload(scene_objects_cycles)
-    importlib.reload(scene_texture_render)
-    importlib.reload(trilighting)
-    importlib.reload(pixelate_3d)
-    importlib.reload(object_add_chain)
-    importlib.reload(oscurart_chain_maker)
-    importlib.reload(circle_array)
-    importlib.reload(copy2)
-    importlib.reload(make_struts)
-    importlib.reload(random_box_structure)
-    importlib.reload(cubester)
-    importlib.reload(rope_alpha)
-    importlib.reload(add_mesh_aggregate)
-    importlib.reload(arrange_on_curve)
-    importlib.reload(mesh_easylattice)
-
-else:
-    from . import add_light_template
-    from . import scene_objects_bi
-    from . import scene_objects_cycles
-    from . import scene_texture_render
-    from . import trilighting
-    from . import pixelate_3d
-    from . import object_add_chain
-    from . import oscurart_chain_maker
-    from . import circle_array
-    from . import copy2
-    from . import make_struts
-    from . import random_box_structure
-    from . import cubester
-    from . import rope_alpha
-    from . import add_mesh_aggregate
-    from . import arrange_on_curve
-    from . import mesh_easylattice
-
-
-import bpy
-from bpy.types import (
-    AddonPreferences,
-    Menu,
-    PropertyGroup,
-)
-from bpy.props import (
-    BoolProperty,
-    EnumProperty,
-    FloatProperty,
-    IntProperty,
-    StringProperty,
-    PointerProperty,
-)
-
-
-# Define the "Scenes" menu
-class VIEW3D_MT_scene_elements_add(Menu):
-    bl_idname = "VIEW3D_MT_scene_elements"
-    bl_label = "Test Scenes"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("bi.add_scene",
-                        text="Scene_Objects_BI")
-        layout.operator("objects_cycles.add_scene",
-                        text="Scene_Objects_Cycles")
-        layout.operator("objects_texture.add_scene",
-                        text="Scene_Textures_Cycles")
-
-
-# Define the "Lights" menu
-class VIEW3D_MT_mesh_lights_add(Menu):
-    bl_idname = "VIEW3D_MT_scene_lights"
-    bl_label = "Lighting Sets"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.add_light_template",
-                        text="Add Light Template")
-        layout.operator("object.trilighting",
-                        text="Add Tri Lighting")
-
-
-# Define the "Chains" menu
-class VIEW3D_MT_mesh_chain_add(Menu):
-    bl_idname = "VIEW3D_MT_mesh_chain"
-    bl_label = "Chains"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("mesh.primitive_chain_add", icon="LINKED")
-        layout.operator("mesh.primitive_oscurart_chain_add", icon="LINKED")
-
-
-# Define the "Array" Menu
-class VIEW3D_MT_array_mods_add(Menu):
-    bl_idname = "VIEW3D_MT_array_mods"
-    bl_label = "Array Mods"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-
-        layout.menu("VIEW3D_MT_mesh_chain", icon="LINKED")
-
-        layout.operator("objects.circle_array_operator",
-                        text="Circle Array", icon="MOD_ARRAY")
-        layout.operator("object.agregate_mesh",
-                        text="Aggregate Mesh", icon="MOD_ARRAY")
-        layout.operator("mesh.copy2",
-                text="Copy To Vert/Edge", icon="MOD_ARRAY")
-
-
-# Define the "Blocks" Menu
-class VIEW3D_MT_quick_blocks_add(Menu):
-    bl_idname = "VIEW3D_MT_quick_tools"
-    bl_label = "Block Tools"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-
-        layout.operator("object.pixelate", icon="MESH_GRID")
-        layout.operator("mesh.generate_struts",
-                    text="Struts", icon="GRID")
-        layout.operator("object.make_structure",
-                    text="Random Boxes", icon="SEQ_SEQUENCER")
-        layout.operator("object.easy_lattice",
-                    text="Easy Lattice", icon="MOD_LATTICE")
-
-
-# Define the "Phsysics Tools" Menu
-class VIEW3D_MT_Physics_tools_add(Menu):
-    bl_idname = "VIEW3D_MT_physics_tools"
-    bl_label = "Physics Tools"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator_context = 'INVOKE_REGION_WIN'
-
-        layout.operator("ball.rope",
-                        text="Wrecking Ball", icon='PHYSICS')
-        layout.operator("clot.rope",
-                        text="Cloth Rope", icon='PHYSICS')
-
-
-# Define "Extras" menu
-def menu(self, context):
-    layout = self.layout
-    layout.operator_context = 'INVOKE_REGION_WIN'
-    self.layout.separator()
-    self.layout.menu("VIEW3D_MT_scene_elements", icon="SCENE_DATA")
-    self.layout.menu("VIEW3D_MT_scene_lights", icon="LIGHT_SPOT")
-    self.layout.separator()
-    self.layout.menu("VIEW3D_MT_array_mods", icon="MOD_ARRAY")
-    self.layout.menu("VIEW3D_MT_quick_tools", icon="MOD_BUILD")
-    self.layout.menu("VIEW3D_MT_physics_tools", icon="PHYSICS")
-
-
-# Addons Preferences
-class AdvancedObjPreferences(AddonPreferences):
-    bl_idname = __name__
-
-    show_menu_list: BoolProperty(
-        name="Menu List",
-        description="Show/Hide the Add Menu items",
-        default=False
-    )
-    show_panel_list: BoolProperty(
-        name="Panels List",
-        description="Show/Hide the Panel items",
-        default=False
-    )
-
-    def draw(self, context):
-        layout = self.layout
-
-        icon_1 = "TRIA_RIGHT" if not self.show_menu_list else "TRIA_DOWN"
-        box = layout.box()
-        box.prop(self, "show_menu_list", emboss=False, icon=icon_1)
-
-        if self.show_menu_list:
-            box.label(text="Items located in the Add Menu (default shortcut Ctrl + A):",
-                      icon="LAYER_USED")
-            box.label(text="Test Scenes:", icon="LAYER_ACTIVE")
-            box.label(text="Scene Objects BI, Scene Objects Cycles, Scene Textures Cycles",
-                      icon="LAYER_USED")
-            box.label(text="Lighting Sets:", icon="LAYER_ACTIVE")
-            box.label(text="Add Light Template, Add Tri Lighting", icon="LAYER_USED")
-            box.label(text="Array Mods:", icon="LAYER_ACTIVE")
-            box.label(text="Circle Array, Chains submenu, Copy Vert/Edge and Aggregate Mesh",
-                         icon="LAYER_ACTIVE")
-            box.label(text="Chains Submenu - Add Chain, Chain to Bones",
-                      icon="LAYER_ACTIVE")
-            box.label(text="Block Tools:", icon="LAYER_ACTIVE")
-            box.label(text="Pixelate Object, Struts, Random Boxes, Easy Lattice",
-                      icon="LAYER_USED")
-            box.label(text="Physics Tools:", icon="LAYER_ACTIVE")
-            box.label(text="Wrecking Ball and Cloth Rope", icon="LAYER_USED")
-
-        icon_2 = "TRIA_RIGHT" if not self.show_panel_list else "TRIA_DOWN"
-        box = layout.box()
-        box.prop(self, "show_panel_list", emboss=False, icon=icon_2)
-
-        if self.show_panel_list:
-            box.label(text="Panels located in 3D View Tools Region > Create",
-                      icon="LAYER_ACTIVE")
-            box.label(text="CubeSter", icon="LAYER_USED")
-            box.label(text="Arrange on Curve  (Shown if an Active Curve Object is it the 3D View)",
-                      icon="LAYER_USED")
-
-
-# Cubester update functions
-def find_audio_length(self, context):
-    adv_obj = context.scene.advanced_objects
-    audio_file = adv_obj.cubester_audio_path
-    length = 0
-
-    if audio_file != "":
-        # confirm that strip hasn't been loaded yet
-        get_sequence = getattr(context.scene.sequence_editor, "sequences_all", [])
-        for strip in get_sequence:
-            if type(strip) == bpy.types.SoundSequence and strip.sound.filepath == audio_file:
-                length = strip.frame_final_duration
-
-        if length == 0:
-            area = context.area
-            old_type = area.type
-            area.type = "SEQUENCE_EDITOR"
-            try:
-                bpy.ops.sequencer.sound_strip_add(filepath=audio_file)
-                adv_obj.cubester_check_audio = True
-            except Exception as e:
-                print("\n[Add Advanced Objects]\n Function: "
-                      "find_audio_length\n {}\n".format(e))
-                adv_obj.cubester_check_audio = False
-                pass
-
-            area.type = old_type
-
-        # find audio file
-        for strip in context.scene.sequence_editor.sequences_all:
-            if type(strip) == bpy.types.SoundSequence and strip.sound.filepath == audio_file:
-                adv_obj.cubester_check_audio = True
-                length = strip.frame_final_duration
-
-    adv_obj.cubester_audio_file_length = length
-
-
-# load image if possible
-def adjust_selected_image(self, context):
-    scene = context.scene.advanced_objects
-    try:
-        image = bpy.data.images.load(scene.cubester_load_image)
-        scene.cubester_image = image.name
-    except Exception as e:
-        print("\n[Add Advanced Objects]\n Function: "
-              "adjust_selected_image\n {}\n".format(e))
-
-
-# load color image if possible
-def adjust_selected_color_image(self, context):
-    scene = context.scene.advanced_objects
-    try:
-        image = bpy.data.images.load(scene.cubester_load_color_image)
-        scene.cubester_color_image = image.name
-    except Exception as e:
-        print("\nAdd Advanced Objects]\n Function: "
-              "adjust_selected_color_image\n {}\n".format(e))
-
-
-class AdvancedObjProperties(PropertyGroup):
-    # cubester
-    # main properties
-    cubester_check_audio: BoolProperty(
-        name="",
-        default=False
-    )
-    cubester_audio_image: EnumProperty(
-        name="Input Type",
-        items=(("image", "Image",
-                "Use an Image as input for generating Geometry", "IMAGE_COL", 0),
-               ("audio", "Audio",
-                "Use a Sound Strip as input for generating Geometry", "FILE_SOUND", 1))
-    )
-    cubester_audio_file_length: IntProperty(
-        default=0
-    )
-    # audio
-    cubester_audio_path: StringProperty(
-        default="",
-        name="Audio File",
-        subtype="FILE_PATH",
-        update=find_audio_length
-    )
-    cubester_audio_min_freq: IntProperty(
-        name="Minimum Frequency",
-        min=20, max=100000,
-        default=20
-    )
-    cubester_audio_max_freq: IntProperty(
-        name="Maximum Frequency",
-        min=21, max=999999,
-        default=5000
-    )
-    cubester_audio_offset_type: EnumProperty(
-        name="Offset Type",
-        items=(("freq", "Frequency Offset", ""),
-               ("frame", "Frame Offset", "")),
-        description="Type of offset per row of mesh"
-    )
-    cubester_audio_frame_offset: IntProperty(
-        name="Frame Offset",
-        min=0, max=10,
-        default=2
-    )
-    cubester_audio_block_layout: EnumProperty(
-        name="Block Layout",
-        items=(("rectangle", "Rectangular", ""),
-              ("radial", "Radial", ""))
-    )
-    cubester_audio_width_blocks: IntProperty(
-        name="Width Block Count",
-        min=1, max=10000,
-        default=5
-    )
-    cubester_audio_length_blocks: IntProperty(
-        name="Length Block Count",
-        min=1, max=10000,
-        default=50
-    )
-    # image
-    cubester_load_type: EnumProperty(
-        name="Image Input Type",
-        items=(("single", "Single Image", ""),
-              ("multiple", "Image Sequence", ""))
-    )
-    cubester_image: StringProperty(
-        default="",
-        name=""
-    )
-    cubester_load_image: StringProperty(
-        default="",
-        name="Load Image",
-        subtype="FILE_PATH",
-        update=adjust_selected_image
-    )
-    cubester_skip_images: IntProperty(
-        name="Image Step",
-        min=1, max=30,
-        default=1,
-        description="Step from image to image by this number"
-    )
-    cubester_max_images: IntProperty(
-        name="Max Number Of Images",
-        min=2, max=1000,
-        default=10,
-        description="Maximum number of images to be used"
-    )
-    cubester_frame_step: IntProperty(
-        name="Frame Step Size",
-        min=1, max=10,
-        default=4,
-        description="The number of frames each picture is used"
-    )
-    cubester_skip_pixels: IntProperty(
-        name="Skip # Pixels",
-        min=0, max=256,
-        default=64,
-        description="Skip this number of pixels before placing the next"
-    )
-    cubester_mesh_style: EnumProperty(
-        name="Mesh Type",
-        items=(("blocks", "Blocks", ""),
-               ("plane", "Plane", "")),
-        description="Compose mesh of multiple blocks or of a single plane"
-    )
-    cubester_block_style: EnumProperty(
-        name="Block Style",
-        items=(("size", "Vary Size", ""),
-               ("position", "Vary Position", "")),
-        description="Vary Z-size of block, or vary Z-position"
-    )
-    cubester_height_scale: FloatProperty(
-        name="Height Scale",
-        subtype="DISTANCE",
-        min=0.1, max=2,
-        default=0.2
-    )
-    cubester_invert: BoolProperty(
-        name="Invert Height",
-        default=False
-    )
-    # general adjustments
-    cubester_size_per_hundred_pixels: FloatProperty(
-        name="Size Per 100 Blocks/Points",
-        subtype="DISTANCE",
-        min=0.001, max=5,
-        default=1
-    )
-    # material based stuff
-    cubester_materials: EnumProperty(
-        name="Material",
-        items=(("vertex", "Vertex Colors", ""),
-               ("image", "Image", "")),
-        description="Color with vertex colors, or uv unwrap and use an image"
-    )
-    cubester_use_image_color: BoolProperty(
-        name="Use Original Image Colors'?",
-        default=True,
-        description="Use original image colors, or replace with an another one"
-    )
-    cubester_color_image: StringProperty(
-        default="",
-        name=""
-    )
-    cubester_load_color_image: StringProperty(
-        default="",
-        name="Load Color Image",
-        subtype="FILE_PATH",
-        update=adjust_selected_color_image
-    )
-    cubester_vertex_colors = {}
-    # advanced
-    cubester_advanced: BoolProperty(
-        name="Advanced Options",
-        default=False
-    )
-    cubester_random_weights: BoolProperty(
-        name="Random Weights",
-        default=False
-    )
-    cubester_weight_r: FloatProperty(
-        name="Red",
-        subtype="FACTOR",
-        min=0.01, max=1.0,
-        default=0.25
-    )
-    cubester_weight_g: FloatProperty(
-        name="Green",
-        subtype="FACTOR",
-        min=0.01, max=1.0,
-        default=0.25
-    )
-    cubester_weight_b: FloatProperty(
-        name="Blue",
-        subtype="FACTOR",
-        min=0.01, max=1.0,
-        default=0.25
-    )
-    cubester_weight_a: FloatProperty(
-        name="Alpha",
-        subtype="FACTOR",
-        min=0.01, max=1.0,
-        default=0.25
-    )
-
-    # arrange_on_curve
-    arrange_c_use_selected: BoolProperty(
-        name="Use Selected",
-        description="Use the selected objects to duplicate",
-        default=True,
-    )
-    arrange_c_obj_arranjar: StringProperty(
-        name=""
-    )
-    arrange_c_select_type: EnumProperty(
-        name="Type",
-        description="Select object or group",
-        items=[
-            ('O', "Object", "Make duplicates of a specific object"),
-            ('G', "Group", "Make duplicates of the objects in a group"),
-        ],
-        default='O',
-    )
-
-
-def register():
-    bpy.utils.register_module(__name__)
-
-    bpy.types.Scene.advanced_objects = PointerProperty(
-        type=AdvancedObjProperties
-    )
-
-    # Add "Extras" menu to the "Add" menu
-    bpy.types.VIEW3D_MT_add.append(menu)
-    try:
-        bpy.types.VIEW3D_MT_AddMenu.append(menu)
-    except:
-        pass
-
-
-def unregister():
-    # Remove "Extras" menu from the "Add" menu.
-    bpy.types.VIEW3D_MT_add.remove(menu)
-    try:
-        bpy.types.VIEW3D_MT_AddMenu.remove(menu)
-    except:
-        pass
-
-    bpy.utils.unregister_module(__name__)
-    del bpy.types.Scene.advanced_objects
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/add_light_template.py b/add_advanced_objects_menu/add_light_template.py
deleted file mode 100644 (file)
index 3d6d880..0000000
+++ /dev/null
@@ -1,145 +0,0 @@
-# gpl: author Rebellion
-
-import bpy
-from bpy.types import Operator
-from bpy.props import BoolProperty
-
-
-def add_lights(self, context):
-
-    if self.bKeyLight:
-        keyLight = bpy.data.lights.new(name="Key_Light", type="SPOT")
-        ob = bpy.data.objects.new("Key_Light", keyLight)
-        constraint = ob.constraints.new(type='COPY_LOCATION')
-        constraint.use_offset = True
-        constraint.owner_space = 'LOCAL'
-        constraint.target = self.camera
-        constraint = ob.constraints.new(type='TRACK_TO')
-        constraint.target = self.target
-        constraint.track_axis = 'TRACK_NEGATIVE_Z'
-        constraint.up_axis = 'UP_X'
-        constraint.owner_space = 'LOCAL'
-        bpy.context.collection.objects.link(ob)
-        ob.rotation_euler[2] = -0.785398
-
-    if self.bFillLight:
-        fillLight = bpy.data.lights.new(name="Fill_Light", type="SPOT")
-        ob = bpy.data.objects.new("Fill_Light", fillLight)
-        constraint = ob.constraints.new(type='COPY_LOCATION')
-        constraint.use_offset = True
-        constraint.owner_space = 'LOCAL'
-        constraint.target = self.camera
-        constraint = ob.constraints.new(type='TRACK_TO')
-        constraint.target = self.target
-        constraint.track_axis = 'TRACK_NEGATIVE_Z'
-        constraint.up_axis = 'UP_X'
-        constraint.owner_space = 'LOCAL'
-        bpy.context.collection.objects.link(ob)
-        ob.rotation_euler[2] = 0.785398
-        ob.data.energy = 0.3
-
-    if self.bBackLight:
-        backLight = bpy.data.lights.new(name="Back_Light", type="SPOT")
-        ob = bpy.data.objects.new("Back_Light", backLight)
-        constraint = ob.constraints.new(type='COPY_LOCATION')
-        constraint.use_offset = True
-        constraint.owner_space = 'LOCAL'
-        constraint.target = self.camera
-        constraint = ob.constraints.new(type='TRACK_TO')
-        constraint.target = self.target
-        constraint.track_axis = 'TRACK_NEGATIVE_Z'
-        constraint.up_axis = 'UP_X'
-        constraint.owner_space = 'LOCAL'
-        bpy.context.collection.objects.link(ob)
-        ob.rotation_euler[2] = 3.14159
-        ob.data.energy = 0.2
-
-    if self.camera_constraint and self.camera is not None and \
-       self.camera.type == "CAMERA":
-
-        constraint = self.camera.constraints.new(type='TRACK_TO')
-        constraint.target = self.target
-        constraint.track_axis = 'TRACK_NEGATIVE_Z'
-        constraint.up_axis = 'UP_Y'
-
-
-class OBJECT_OT_add_light_template(Operator):
-    bl_idname = "object.add_light_template"
-    bl_label = "Add Light Template"
-    bl_description = ("Add Key, Fill and Back Lights to the Scene\n"
-                      "Needs an existing Active Object")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    camera = None
-    target = None
-
-    bKeyLight: BoolProperty(
-            name="Key Light",
-            description="Enable Key Light in the Scene",
-            default=True
-            )
-    bFillLight: BoolProperty(
-            name="Fill Light",
-            description="Enable Fill Light in the Scene",
-            default=True
-            )
-    bBackLight: BoolProperty(
-            name="Back Light",
-            description="Enable Back Light in the Scene",
-            default=True
-            )
-    camera_constraint: BoolProperty(
-            name="Camera Constraint",
-            description="Add a Constraint to the Camera Object",
-            default=False
-            )
-
-    @classmethod
-    def poll(cls, context):
-        return context.active_object is not None
-
-    def execute(self, context):
-        try:
-            objects = context.selected_objects
-
-            if len(objects) == 2:
-                for ob in objects:
-                    if ob.type == 'CAMERA':
-                        self.camera = ob
-                    else:
-                        self.target = ob
-            elif len(objects) == 1:
-                if objects[0].type == 'CAMERA':
-                    self.camera = objects[0]
-                    bpy.ops.object.empty_add()
-                    self.target = context.active_object
-                else:
-                    self.camera = context.scene.camera
-                    self.target = context.active_object
-            elif len(objects) == 0:
-                bpy.ops.object.empty_add()
-                self.target = context.active_object
-                self.camera = context.scene.camera
-
-            add_lights(self, context)
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "object.add_light_template\nError: {}".format(e))
-
-        return {'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(OBJECT_OT_add_light_template)
-
-
-def unregister():
-    bpy.utils.unregister_class(OBJECT_OT_add_light_template)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/add_mesh_aggregate.py b/add_advanced_objects_menu/add_mesh_aggregate.py
deleted file mode 100644 (file)
index 2665df1..0000000
+++ /dev/null
@@ -1,338 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# Simple aggregate of particles / meshes
-# Copy the selected objects on the active object
-# Based on the position of the cursor and a defined volume
-# Allows to control growth by using a Build modifier
-
-bl_info = {
-    "name": "Aggregate Mesh",
-    "author": "liero",
-    "version": (0, 0, 5),
-    "blender": (2, 70, 0),
-    "location": "View3D > Tool Shelf",
-    "description": "Adds geometry to a mesh like in DLA aggregators",
-    "category": "Object"}
-
-
-import bpy
-import bmesh
-from random import (
-        choice,
-        gauss,
-        seed,
-        )
-from mathutils import Matrix
-from bpy.props import (
-        BoolProperty,
-        FloatProperty,
-        IntProperty,
-        )
-from bpy.types import Operator
-
-
-def use_random_seed(self):
-    seed(self.rSeed)
-    return
-
-
-def rg(n):
-    return (round(gauss(0, n), 2))
-
-
-def remover(sel=False):
-    bpy.ops.object.editmode_toggle()
-    if sel:
-        bpy.ops.mesh.select_all(action='SELECT')
-    bpy.ops.mesh.remove_doubles(threshold=0.0001)
-    bpy.ops.object.mode_set()
-
-
-class OBJECT_OT_agregate_mesh(Operator):
-    bl_idname = "object.agregate_mesh"
-    bl_label = "Aggregate"
-    bl_description = ("Adds geometry to a mesh like in DLA aggregators\n"
-                      "Needs at least two selected Mesh objects")
-    bl_options = {'REGISTER', 'UNDO', 'PRESET'}
-
-    volX: FloatProperty(
-            name="Volume X",
-            min=0.1, max=25,
-            default=3,
-            description="The cloud around cursor"
-            )
-    volY: FloatProperty(
-            name="Volume Y",
-            min=0.1, max=25,
-            default=3,
-            description="The cloud around cursor"
-            )
-    volZ: FloatProperty(
-            name="Volume Z",
-            min=0.1, max=25,
-            default=3,
-            description="The cloud around cursor"
-            )
-    baseSca: FloatProperty(
-            name="Scale",
-            min=0.01, max=5,
-            default=.25,
-            description="Particle Scale"
-            )
-    varSca: FloatProperty(
-            name="Var",
-            min=0, max=1,
-            default=0,
-            description="Particle Scale Variation"
-            )
-    rotX: FloatProperty(
-            name="Rot Var X",
-            min=0, max=2,
-            default=0,
-            description="X Rotation Variation"
-            )
-    rotY: FloatProperty(
-            name="Rot Var Y",
-            min=0, max=2,
-            default=0,
-            description="Y Rotation Variation"
-            )
-    rotZ: FloatProperty(
-            name="Rot Var Z",
-            min=0, max=2,
-            default=1,
-            description="Z Rotation Variation"
-            )
-    rSeed: IntProperty(
-            name="Random seed",
-            min=0, max=999999,
-            default=1,
-            description="Seed to feed random values"
-            )
-    numP: IntProperty(
-            name="Number",
-            min=1,
-            max=9999, soft_max=500,
-            default=50,
-            description="Number of particles"
-            )
-    nor: BoolProperty(
-            name="Normal Oriented",
-            default=False,
-            description="Align Z axis with Faces normals"
-            )
-    cent: BoolProperty(
-            name="Use Face Center",
-            default=False,
-            description="Center on Faces"
-            )
-    track: BoolProperty(
-            name="Cursor Follows",
-            default=False,
-            description="Cursor moves as structure grows / more compact results"
-            )
-    anim: BoolProperty(
-            name="Animatable",
-            default=False,
-            description="Sort faces so you can regrow with Build Modifier, materials are lost"
-            )
-    refresh: BoolProperty(
-            name="Update",
-            default=False
-            )
-    auto_refresh: BoolProperty(
-            name="Auto",
-            description="Auto update spline",
-            default=False
-            )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column(align=True)
-        row = col.row(align=True)
-
-        if self.auto_refresh is False:
-            self.refresh = False
-        elif self.auto_refresh is True:
-            self.refresh = True
-
-        row.prop(self, "auto_refresh", toggle=True, icon="AUTO")
-        row.prop(self, "refresh", toggle=True, icon="FILE_REFRESH")
-
-        col = layout.column(align=True)
-        col.separator()
-
-        col = layout.column(align=True)
-        col.prop(self, "volX", slider=True)
-        col.prop(self, "volY", slider=True)
-        col.prop(self, "volZ", slider=True)
-
-        layout.label(text="Particles:")
-        col = layout.column(align=True)
-        col.prop(self, "baseSca", slider=True)
-        col.prop(self, "varSca", slider=True)
-
-        col = layout.column(align=True)
-        col.prop(self, "rotX", slider=True)
-        col.prop(self, "rotY", slider=True)
-        col.prop(self, "rotZ", slider=True)
-
-        col = layout.column(align=True)
-        col.prop(self, "rSeed", slider=False)
-        col.prop(self, "numP")
-
-        row = layout.row(align=True)
-        row.prop(self, "nor")
-        row.prop(self, "cent")
-
-        row = layout.row(align=True)
-        row.prop(self, "track")
-        row.prop(self, "anim")
-
-    @classmethod
-    def poll(cls, context):
-        return (len(bpy.context.selected_objects) > 1 and
-                bpy.context.object.type == 'MESH')
-
-    def invoke(self, context, event):
-        self.refresh = True
-        return self.execute(context)
-
-    def execute(self, context):
-        if not self.refresh:
-            return {'PASS_THROUGH'}
-
-        scn = bpy.context.scene
-        obj = bpy.context.active_object
-
-        use_random_seed(self)
-
-        mat = Matrix((
-                (1, 0, 0, 0),
-                (0, 1, 0, 0),
-                (0, 0, 1, 0),
-                (0, 0, 0, 1))
-                )
-        if obj.matrix_world != mat:
-            self.report({'WARNING'},
-                         "Please, Apply transformations to Active Object first")
-            return{'FINISHED'}
-
-        par = [o for o in bpy.context.selected_objects if o.type == 'MESH' and o != obj]
-        if not par:
-            return{'FINISHED'}
-
-        bpy.ops.object.mode_set()
-        bpy.ops.object.select_all(action='DESELECT')
-        obj.select_set(True)
-        msv = []
-
-        for i in range(len(obj.modifiers)):
-            msv.append(obj.modifiers[i].show_viewport)
-            obj.modifiers[i].show_viewport = False
-
-        cur = scn.cursor.location
-        for i in range(self.numP):
-
-            mes = choice(par).data
-            newobj = bpy.data.objects.new('nuevo', mes)
-            scn.objects.link(newobj)
-            origen = (rg(self.volX) + cur[0], rg(self.volY) + cur[1], rg(self.volZ) + cur[2])
-
-            cpom = obj.closest_point_on_mesh(origen)
-
-            if self.cent:
-                bm = bmesh.new()
-                bm.from_mesh(obj.data)
-                if hasattr(bm.verts, "ensure_lookup_table"):
-                    bm.verts.ensure_lookup_table()
-                    bm.faces.ensure_lookup_table()
-
-                newobj.location = bm.faces[cpom[3]].calc_center_median()
-
-                bm.free()
-            else:
-                newobj.location = cpom[1]
-
-            if self.nor:
-                newobj.rotation_mode = 'QUATERNION'
-                newobj.rotation_quaternion = cpom[1].to_track_quat('Z', 'Y')
-                newobj.rotation_mode = 'XYZ'
-                newobj.rotation_euler[0] += rg(self.rotX)
-                newobj.rotation_euler[1] += rg(self.rotY)
-                newobj.rotation_euler[2] += rg(self.rotZ)
-            else:
-                newobj.rotation_euler = (rg(self.rotX), rg(self.rotY), rg(self.rotZ))
-
-            newobj.scale = [self.baseSca + self.baseSca * rg(self.varSca)] * 3
-
-            if self.anim:
-                newobj.select_set(True)
-                bpy.ops.object.make_single_user(type='SELECTED_OBJECTS', obdata=True)
-                bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
-
-                bme = bmesh.new()
-                bme.from_mesh(obj.data)
-
-                tmp = bmesh.new()
-                tmp.from_mesh(newobj.data)
-
-                for f in tmp.faces:
-                    # z = len(bme.verts)
-                    for v in f.verts:
-                        bme.verts.new(list(v.co))
-                    bme.faces.new(bme.verts[-len(f.verts):])
-
-                bme.to_mesh(obj.data)
-                remover(True)
-                # Note: foo.user_clear() is deprecated use do_unlink=True instead
-                bpy.data.meshes.remove(newobj.data, do_unlink=True)
-
-            else:
-                scn.objects.active = obj
-                newobj.select_set(True)
-                bpy.ops.object.join()
-
-            if self.track:
-                cur = scn.cursor.location = cpom[1]
-
-        for i in range(len(msv)):
-            obj.modifiers[i].show_viewport = msv[i]
-
-        for o in par:
-            o.select_set(True)
-
-        obj.select_set(True)
-
-        if self.auto_refresh is False:
-            self.refresh = False
-
-        return{'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(OBJECT_OT_agregate_mesh)
-
-
-def unregister():
-    bpy.utils.unregister_class(OBJECT_OT_agregate_mesh)
-
-
-if __name__ == '__main__':
-    register()
diff --git a/add_advanced_objects_menu/arrange_on_curve.py b/add_advanced_objects_menu/arrange_on_curve.py
deleted file mode 100644 (file)
index 38fbb92..0000000
+++ /dev/null
@@ -1,356 +0,0 @@
-# gpl author: Mano-Wii
-
-bl_info = {
-    "name": "Arrange on Curve",
-    "author": "Mano-Wii",
-    "version": (6, 3, 0),
-    "blender": (2, 77, 0),
-    "location": "3D View > Toolshelf > Create > Arrange on Curve",
-    "description": "Arrange objects along a curve",
-    "warning": "Select curve",
-    "wiki_url": "",
-    "category": "3D View"
-    }
-
-# Note: scene properties are moved into __init__
-# search for patterns advanced_objects and adv_obj
-
-import bpy
-import mathutils
-from bpy.types import (
-        Operator,
-        Panel,
-        )
-from bpy.props import (
-        EnumProperty,
-        FloatProperty,
-        IntProperty,
-        )
-
-FLT_MIN = 0.004
-
-
-class PanelDupliCurve(Panel):
-    bl_idname = "VIEW3D_PT_arranjar_numa_curva"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_context = "objectmode"
-    bl_category = "Create"
-    bl_label = "Arrange on Curve"
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.mode == 'OBJECT' and context.object.type == 'CURVE'
-
-    def draw(self, context):
-        layout = self.layout
-        adv_obj = context.scene.advanced_objects
-
-        layout.prop(adv_obj, "arrange_c_use_selected")
-
-        if not adv_obj.arrange_c_use_selected:
-            layout.prop(adv_obj, "arrange_c_select_type", expand=True)
-            if adv_obj.arrange_c_select_type == 'O':
-                layout.column(align=True).prop_search(
-                              adv_obj, "arrange_c_obj_arranjar",
-                              bpy.data, "objects"
-                              )
-            elif adv_obj.arrange_c_select_type == 'G':
-                layout.column(align=True).prop_search(
-                              adv_obj, "arrange_c_obj_arranjar",
-                              bpy.data, "collections"
-                              )
-        if context.object.type == 'CURVE':
-            layout.operator("object.arranjar_numa_curva", text="Arrange Objects")
-
-
-class DupliCurve(Operator):
-    bl_idname = "object.arranjar_numa_curva"
-    bl_label = "Arrange Objects along a Curve"
-    bl_description = "Arange chosen / selected objects along the Active Curve"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    use_distance: EnumProperty(
-            name="Arrangement",
-            items=[
-                ("D", "Distance", "Objects are arranged depending on the distance", 0),
-                ("Q", "Quantity", "Objects are arranged depending on the quantity", 1),
-                ("R", "Range", "Objects are arranged uniformly between the corners", 2)
-                ]
-            )
-    distance: FloatProperty(
-            name="Distance",
-            description="Distance between Objects",
-            default=1.0,
-            min=FLT_MIN,
-            soft_min=0.1,
-            unit='LENGTH',
-            )
-    object_qt: IntProperty(
-            name="Quantity",
-            description="Object amount",
-            default=2,
-            min=0,
-            )
-    scale: FloatProperty(
-            name="Scale",
-            description="Object Scale",
-            default=1.0,
-            min=FLT_MIN,
-            unit='LENGTH',
-                )
-    Yaw: FloatProperty(
-            name="X",
-            description="Rotate around the X axis (Yaw)",
-            default=0.0,
-            unit='ROTATION'
-            )
-    Pitch: FloatProperty(
-            default=0.0,
-            description="Rotate around the Y axis (Pitch)",
-            name="Y",
-            unit='ROTATION'
-            )
-    Roll: FloatProperty(
-            default=0.0,
-            description="Rotate around the Z axis (Roll)",
-            name="Z",
-            unit='ROTATION'
-            )
-    max_angle: FloatProperty(
-            default=1.57079,
-            max=3.141592,
-            name="Angle",
-            unit='ROTATION'
-            )
-    offset: FloatProperty(
-            default=0.0,
-            name="Offset",
-            unit='LENGTH'
-            )
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode == 'OBJECT'
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "use_distance", text="")
-        col = layout.column(align=True)
-        if self.use_distance == "D":
-            col.prop(self, "distance")
-        elif self.use_distance == "Q":
-            col.prop(self, "object_qt")
-        else:
-            col.prop(self, "distance")
-            col.prop(self, "max_angle")
-            col.prop(self, "offset")
-
-        col = layout.column(align=True)
-        col.prop(self, "scale")
-        col.prop(self, "Yaw")
-        col.prop(self, "Pitch")
-        col.prop(self, "Roll")
-
-    def Glpoints(self, curve):
-        Gpoints = []
-        for i, spline in enumerate(curve.data.splines):
-            segments = len(spline.bezier_points)
-            if segments >= 2:
-                r = spline.resolution_u + 1
-
-                points = []
-                for j in range(segments):
-                    bp1 = spline.bezier_points[j]
-                    inext = (j + 1)
-                    if inext == segments:
-                        if not spline.use_cyclic_u:
-                            break
-                        inext = 0
-                    bp2 = spline.bezier_points[inext]
-                    if bp1.handle_right_type == bp2.handle_left_type == 'VECTOR':
-                        _points = (bp1.co, bp2.co) if j == 0 else (bp2.co,)
-                    else:
-                        knot1 = bp1.co
-                        handle1 = bp1.handle_right
-                        handle2 = bp2.handle_left
-                        knot2 = bp2.co
-                        _points = mathutils.geometry.interpolate_bezier(knot1, handle1, handle2, knot2, r)
-                    points.extend(_points)
-                Gpoints.append(tuple((curve.matrix_world * p for p in points)))
-            elif len(spline.points) >= 2:
-                l = [curve.matrix_world * p.co.xyz for p in spline.points]
-                if spline.use_cyclic_u:
-                    l.append(l[0])
-                Gpoints.append(tuple(l))
-
-            if self.use_distance == "R":
-                max_angle = self.max_angle
-                tmp_Gpoints = []
-                sp = Gpoints[i]
-                sp2 = [sp[0], sp[1]]
-                lp = sp[1]
-                v1 = lp - sp[0]
-                for p in sp[2:]:
-                    v2 = p - lp
-                    try:
-                        if (3.14158 - v1.angle(v2)) < max_angle:
-                            tmp_Gpoints.append(tuple(sp2))
-                            sp2 = [lp]
-                    except Exception as e:
-                        print("\n[Add Advanced  Objects]\nOperator: "
-                              "object.arranjar_numa_curva\nError: {}".format(e))
-                        pass
-                    sp2.append(p)
-                    v1 = v2
-                    lp = p
-                tmp_Gpoints.append(tuple(sp2))
-                Gpoints = Gpoints[:i] + tmp_Gpoints
-
-        lengths = []
-        if self.use_distance != "D":
-            for sp in Gpoints:
-                lp = sp[1]
-                leng = (lp - sp[0]).length
-                for p in sp[2:]:
-                    leng += (p - lp).length
-                    lp = p
-                lengths.append(leng)
-        return Gpoints, lengths
-
-    def execute(self, context):
-        if context.object.type != 'CURVE':
-            return {'CANCELLED'}
-
-        curve = context.active_object
-        Gpoints, lengs = self.Glpoints(curve)
-        adv_obj = context.scene.advanced_objects
-
-        if adv_obj.arrange_c_use_selected:
-            G_Objeto = context.selected_objects
-            G_Objeto.remove(curve)
-
-            if not G_Objeto:
-                return {'CANCELLED'}
-
-        elif adv_obj.arrange_c_select_type == 'O':
-            G_Objeto = bpy.data.objects[adv_obj.arrange_c_obj_arranjar],
-        elif adv_obj.arrange_c_select_type == 'G':
-            G_Objeto = bpy.data.collections[adv_obj.arrange_c_obj_arranjar].objects
-
-        yawMatrix = mathutils.Matrix.Rotation(self.Yaw, 4, 'X')
-        pitchMatrix = mathutils.Matrix.Rotation(self.Pitch, 4, 'Y')
-        rollMatrix = mathutils.Matrix.Rotation(self.Roll, 4, 'Z')
-
-        max_angle = self.max_angle  # max_angle is called in Glpoints
-
-        if self.use_distance == "D":
-            dist = self.distance
-            for sp_points in Gpoints:
-                dx = 0.0  # Length of initial calculation of section
-                last_point = sp_points[0]
-                j = 0
-                for point in sp_points[1:]:
-                    vetorx = point - last_point  # Vector spline section
-                    quat = mathutils.Vector.to_track_quat(vetorx, 'X', 'Z')  # Tracking the selected objects
-                    quat = quat.to_matrix().to_4x4()
-
-                    v_len = vetorx.length
-                    if v_len > 0.0:
-                        dx += v_len  # Defined length calculation equal total length of the spline section
-                        v_norm = vetorx / v_len
-                        while dx > dist:
-                            object = G_Objeto[j % len(G_Objeto)]
-                            j += 1
-                            dx -= dist  # Calculating the remaining length of the section
-                            obj = object.copy()
-                            context.collection.objects.link(obj)
-                            obj.matrix_world = quat * yawMatrix * pitchMatrix * rollMatrix
-                            # Placing in the correct position
-                            obj.matrix_world.translation = point - v_norm * dx
-                            obj.scale *= self.scale
-                        last_point = point
-
-        elif self.use_distance == "Q":
-            object_qt = self.object_qt + 1
-            for i, sp_points in enumerate(Gpoints):
-                dx = 0.0  # Length of initial calculation of section
-                dist = lengs[i] / object_qt
-                last_point = sp_points[0]
-                j = 0
-                for point in sp_points[1:]:
-                    vetorx = point - last_point  # Vector spline section
-                    # Tracking the selected objects
-                    quat = mathutils.Vector.to_track_quat(vetorx, 'X', 'Z')
-                    quat = quat.to_matrix().to_4x4()
-
-                    v_len = vetorx.length
-                    if v_len > 0.0:
-                        # Defined length calculation equal total length of the spline section
-                        dx += v_len
-                        v_norm = vetorx / v_len
-                        while dx > dist:
-                            object = G_Objeto[j % len(G_Objeto)]
-                            j += 1
-                            dx -= dist  # Calculating the remaining length of the section
-                            obj = object.copy()
-                            context.collection.objects.link(obj)
-                            obj.matrix_world = quat * yawMatrix * pitchMatrix * rollMatrix
-                            # Placing in the correct position
-                            obj.matrix_world.translation = point - v_norm * dx
-                            obj.scale *= self.scale
-                        last_point = point
-
-        else:
-            dist = self.distance
-            offset2 = 2 * self.offset
-            for i, sp_points in enumerate(Gpoints):
-                leng = lengs[i] - offset2
-                rest = leng % dist
-                offset = offset2 + rest
-                leng -= rest
-                offset /= 2
-                last_point = sp_points[0]
-
-                dx = dist - offset  # Length of initial calculation of section
-                j = 0
-                for point in sp_points[1:]:
-                    vetorx = point - last_point  # Vector spline section
-                    # Tracking the selected objects
-                    quat = mathutils.Vector.to_track_quat(vetorx, 'X', 'Z')
-                    quat = quat.to_matrix().to_4x4()
-
-                    v_len = vetorx.length
-                    if v_len > 0.0:
-                        dx += v_len
-                        v_norm = vetorx / v_len
-                        while dx >= dist and leng >= 0.0:
-                            leng -= dist
-                            dx -= dist  # Calculating the remaining length of the section
-                            object = G_Objeto[j % len(G_Objeto)]
-                            j += 1
-                            obj = object.copy()
-                            context.collection.objects.link(obj)
-                            obj.matrix_world = quat * yawMatrix * pitchMatrix * rollMatrix
-                            # Placing in the correct position
-                            obj.matrix_world.translation = point - v_norm * dx
-                            obj.scale *= self.scale
-                        last_point = point
-
-        return {"FINISHED"}
-
-
-def register():
-    bpy.utils.register_class(PanelDupliCurve)
-    bpy.utils.register_class(DupliCurve)
-
-
-def unregister():
-    bpy.utils.unregister_class(PanelDupliCurve)
-    bpy.utils.unregister_class(DupliCurve)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/circle_array.py b/add_advanced_objects_menu/circle_array.py
deleted file mode 100644 (file)
index 6d4a945..0000000
+++ /dev/null
@@ -1,166 +0,0 @@
-# gpl author: Antonis Karvelas
-
-# -*- coding: utf-8 -*-
-
-bl_info = {
-    "name": "Circle Array",
-    "author": "Antonis Karvelas",
-    "version": (1, 0, 1),
-    "blender": (2, 67, 0),
-    "location": "View3D > Object > Circle_Array",
-    "description": "Uses an existing array and creates an empty, "
-                   "rotates it properly and makes a Circle Array",
-    "warning": "",
-    "wiki_url": "",
-    "category": "Mesh"
-    }
-
-
-import bpy
-from bpy.types import Operator
-from math import radians
-
-
-class Circle_Array(Operator):
-    bl_label = "Circle Array"
-    bl_idname = "objects.circle_array_operator"
-    bl_description = ("Creates an Array Modifier with offset empty object\n"
-                      "Works with Mesh, Curve, Text and Surface\n"
-                      "Use an object with an existing Array modifier\n"
-                      "or rotate the newly created Empty with the name pattern\n"
-                      "EMPTY_C_Array_ if the Array doesn't exist (angle: 360/Count)")
-
-    @classmethod
-    def poll(cls, context):
-        return context.active_object is not None
-
-    def check_empty_name(self, context):
-        new_name, def_name = "", "EMPTY_C_Array"
-        suffix = 1
-        try:
-            # first slap a simple linear count + 1 for numeric suffix, if it fails
-            # harvest for the rightmost numbers and append the max value
-            list_obj = []
-            obj_all = context.scene.objects
-            list_obj = [obj.name for obj in obj_all if obj.name.startswith(def_name)]
-            new_name = "{}_{}".format(def_name, len(list_obj) + 1)
-
-            if new_name in list_obj:
-                from re import findall
-                test_num = [findall("\d+", words) for words in list_obj]
-                suffix += max([int(l[-1]) for l in test_num])
-                new_name = "{}_{}".format(def_name, suffix)
-            return new_name
-        except:
-            return None
-
-    def execute(self, context):
-        is_allowed = True
-        try:
-            allowed_obj = ['MESH', 'CURVE', 'SURFACE', 'FONT']
-            for obj in context.selected_objects:
-                if obj.type not in allowed_obj:
-                    is_allowed = False
-                    break
-
-            if not is_allowed:
-                self.report(
-                    {"WARNING"},
-                    "The Active/Selected objects are not of "
-                    "Mesh, Curve, Surface or Font type. Operation Cancelled"
-                    )
-                return {'CANCELLED'}
-
-            default_name = self.check_empty_name(context) or "EMPTY_C_Array"
-            bpy.ops.object.modifier_add(type='ARRAY')
-
-            if len(context.selected_objects) == 2:
-                selected = context.selected_objects
-                lists = [obj for obj in selected if obj != context.active_object]
-                active = lists[0]
-                # check if the list object has a modifier
-                check_mod = None
-                for mod in active.modifiers[:]:
-                    if mod.type == "ARRAY":
-                        check_mod = mod
-                        break
-
-                if check_mod:
-                    check_mod.use_object_offset = True
-                    check_mod.use_relative_offset = False
-                else:
-                    # fallback
-                    bpy.context.view_layer.objects.active = active
-                    bpy.ops.object.modifier_add(type='ARRAY')
-                    active.modifiers[0].use_object_offset = True
-                    active.modifiers[0].use_relative_offset = False
-
-                active.modifiers[0].use_object_offset = True
-                active.modifiers[0].use_relative_offset = False
-                active.select_set(False)
-                bpy.context.view_layer.objects.active = context.active_object
-                bpy.ops.view3d.snap_cursor_to_selected()
-
-                if active.modifiers[0].offset_object is None:
-                    bpy.ops.object.add(type='EMPTY')
-                    empty_name = bpy.context.active_object
-                    empty_name.name = default_name
-                    active.modifiers[0].offset_object = empty_name
-                else:
-                    empty_name = active.modifiers[0].offset_object
-
-                bpy.context.view_layer.objects.active = active
-                num = active.modifiers["Array"].count
-                rotate_num = 360 / num
-                active.select_set(True)
-                bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
-                empty_name.rotation_euler = (0, 0, radians(rotate_num))
-                empty_name.select_set(False)
-                active.select_set(True)
-                bpy.ops.object.origin_set(type="ORIGIN_CURSOR")
-
-                return {'FINISHED'}
-            else:
-                active = context.active_object
-                active.modifiers[0].use_object_offset = True
-                active.modifiers[0].use_relative_offset = False
-                bpy.ops.view3d.snap_cursor_to_selected()
-
-                if active.modifiers[0].offset_object is None:
-                    bpy.ops.object.add(type='EMPTY')
-                    empty_name = bpy.context.active_object
-                    empty_name.name = default_name
-                    active.modifiers[0].offset_object = empty_name
-                else:
-                    empty_name = active.modifiers[0].offset_object
-
-                bpy.context.view_layer.objects.active = active
-                num = active.modifiers["Array"].count
-                rotate_num = 360 / num
-                active.select_set(True)
-                bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
-                empty_name.rotation_euler = (0, 0, radians(rotate_num))
-                empty_name.select_set(False)
-                active.select_set(True)
-
-                return {'FINISHED'}
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Circle Array operator could not be executed (See the console for more info)")
-            print("\n[objects.circle_array_operator]\nError: {}\n".format(e))
-
-            return {'CANCELLED'}
-
-
-# Register
-def register():
-    bpy.utils.register_class(Circle_Array)
-
-
-def unregister():
-    bpy.utils.unregister_class(Circle_Array)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/copy2.py b/add_advanced_objects_menu/copy2.py
deleted file mode 100644 (file)
index 5b1bceb..0000000
+++ /dev/null
@@ -1,339 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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, see http://www.gnu.org/licenses/
-#  or write to the Free Software Foundation, Inc., 51 Franklin Street,
-#  Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-bl_info = {
-    "name": "Copy2 Vertices, Edges or Faces",
-    "author": "Eleanor Howick (elfnor.com)",
-    "version": (0, 1, 1),
-    "blender": (2, 71, 0),
-    "location": "3D View > Object > Copy 2",
-    "description": "Copy one object to the selected vertices, edges or faces of another object",
-    "warning": "",
-    "category": "Object"
-}
-
-import bpy
-from bpy.types import Operator
-from bpy.props import (
-        BoolProperty,
-        EnumProperty,
-        FloatProperty,
-        )
-from mathutils import (
-        Vector,
-        Matrix,
-        )
-
-
-class Copy2(Operator):
-    bl_idname = "mesh.copy2"
-    bl_label = "Copy 2"
-    bl_description = ("Copy Vertices, Edges or Faces to the Selected object\n"
-                      "Needs an existing Active Mesh Object")
-    bl_options = {"REGISTER", "UNDO"}
-
-    obj_list = None
-
-    def obj_list_cb(self, context):
-        return Copy2.obj_list
-
-    def sec_axes_list_cb(self, context):
-        if self.priaxes == 'X':
-            sec_list = [('Y', "Y", "Secondary axis Y"),
-                        ('Z', "Z", "Secondary axis Z")]
-
-        if self.priaxes == 'Y':
-            sec_list = [('X', "X", "Secondary axis X"),
-                        ('Z', "Z", "Secondary axis Z")]
-
-        if self.priaxes == 'Z':
-            sec_list = [('X', "X", "Secondary axis X"),
-                        ('Y', "Y", "Secondary axis Y")]
-        return sec_list
-
-    copytype: EnumProperty(
-            items=(('V', "Vertex",
-                    "Paste the Copied Geometry to Vertices of the Active Object", 'VERTEXSEL', 0),
-                   ('E', "Edge",
-                    "Paste the Copied Geometry to Edges of the Active Object", 'EDGESEL', 1),
-                   ('F', "Face",
-                    "Paste the Copied Geometry to Faces of the Active Object", 'FACESEL', 2)),
-            )
-    copyfromobject: EnumProperty(
-            name="Copy from",
-            description="Copy an Object from the list",
-            items=obj_list_cb
-            )
-    priaxes: EnumProperty(
-            description="Primary axes used for Copied Object orientation",
-            items=(('X', "X", "Along X"),
-                   ('Y', "Y", "Along Y"),
-                   ('Z', "Z", "Along Z")),
-            )
-    edgescale: BoolProperty(
-            name="Scale to fill edge",
-            default=False
-            )
-    secaxes: EnumProperty(
-            name="Secondary Axis",
-            description="Secondary axis used for Copied Object orientation",
-            items=sec_axes_list_cb
-            )
-    scale: FloatProperty(
-            name="Scale",
-            default=1.0,
-            min=0.0,
-            )
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return obj and obj.type == "MESH"
-
-    def draw(self, context):
-        layout = self.layout
-
-        layout.prop(self, "copyfromobject")
-        layout.label(text="to:")
-        layout.prop(self, "copytype", expand=True)
-        layout.label(text="Primary axis:")
-        layout.prop(self, "priaxes", expand=True)
-        layout.label(text="Secondary axis:")
-        layout.prop(self, "secaxes", expand=True)
-        if self.copytype == "E":
-            layout.prop(self, "edgescale")
-            if self.edgescale:
-                layout.prop(self, "scale")
-        return
-
-    def execute(self, context):
-        copytoobject = context.active_object.name
-        axes = self.priaxes + self.secaxes
-
-        # check if there is a problem with the strings related to some chars
-        copy_to_object = bpy.data.objects[copytoobject] if \
-                         copytoobject in bpy.data.objects else None
-
-        copy_from_object = bpy.data.objects[self.copyfromobject] if \
-                           self.copyfromobject in bpy.data.objects else None
-
-        if copy_to_object is None or copy_from_object is None:
-            self.report({"WARNING"},
-                        "There was a problem with retrieving Object data. Operation Cancelled")
-            return {"CANCELLED"}
-        try:
-            copy_to_from(
-                    context.collection,
-                    copy_to_object,
-                    copy_from_object,
-                    self.copytype,
-                    axes,
-                    self.edgescale,
-                    self.scale
-                    )
-        except Exception as e:
-            self.report({"WARNING"},
-                        "Copy2 could not be completed (Check the Console for more info)")
-            print("\n[Add Advanced Objects]\nOperator: mesh.copy2\n{}\n".format(e))
-
-            return {"CANCELLED"}
-
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        Copy2.obj_list = [(obj.name, obj.name, obj.name) for obj in bpy.data.objects]
-
-        return {"FINISHED"}
-
-
-def copy_to_from(collection, to_obj, from_obj, copymode, axes, edgescale, scale):
-    if copymode == 'V':
-        vertex_copy(collection, to_obj, from_obj, axes)
-
-    if copymode == 'E':
-        # don't pass edgescalling to object types that cannot be scaled
-        if from_obj.type in ["CAMERA", "LIGHT", "EMPTY", "ARMATURE", "SPEAKER", "META"]:
-            edgescale = False
-        edge_copy(collection, to_obj, from_obj, axes, edgescale, scale)
-
-    if copymode == 'F':
-        face_copy(collection, to_obj, from_obj, axes)
-
-
-axes_dict = {'XY': (1, 2, 0),
-             'XZ': (2, 1, 0),
-             'YX': (0, 2, 1),
-             'YZ': (2, 0, 1),
-             'ZX': (0, 1, 2),
-             'ZY': (1, 0, 2)}
-
-
-def copyto(collection, source_obj, pos, xdir, zdir, axes, scale=None):
-    """
-    copy the source_obj to pos, so its primary axis points in zdir and its
-    secondary axis points in xdir
-    """
-    copy_obj = source_obj.copy()
-    collection.objects.link(copy_obj)
-
-    xdir = xdir.normalized()
-    zdir = zdir.normalized()
-    # rotation first
-    z_axis = zdir
-    x_axis = xdir
-    y_axis = z_axis.cross(x_axis)
-    # use axes_dict to assign the axis as chosen in panel
-    A, B, C = axes_dict[axes]
-    rot_mat = Matrix()
-    rot_mat[A].xyz = x_axis
-    rot_mat[B].xyz = y_axis
-    rot_mat[C].xyz = z_axis
-    rot_mat.transpose()
-
-    # rotate object
-    copy_obj.matrix_world = rot_mat
-
-    # move object into position
-    copy_obj.location = pos
-
-    # scale object
-    if scale is not None:
-        copy_obj.scale = scale
-
-    return copy_obj
-
-
-def vertex_copy(collection, obj, source_obj, axes):
-    # vertex select mode
-    sel_verts = []
-    copy_list = []
-
-    for v in obj.data.vertices:
-        if v.select is True:
-            sel_verts.append(v)
-
-    # make a set for each vertex. The set contains all the connected vertices
-    # use sets so the list is unique
-    vert_con = [set() for i in range(len(obj.data.vertices))]
-    for e in obj.data.edges:
-        vert_con[e.vertices[0]].add(e.vertices[1])
-        vert_con[e.vertices[1]].add(e.vertices[0])
-
-    for v in sel_verts:
-        pos = v.co * obj.matrix_world.transposed()
-        xco = obj.data.vertices[list(vert_con[v.index])[0]].co * obj.matrix_world.transposed()
-
-        zdir = (v.co + v.normal) * obj.matrix_world.transposed() - pos
-        zdir = zdir.normalized()
-
-        edir = pos - xco
-
-        # edir is nor perpendicular to z dir
-        # want xdir to be projection of edir onto plane through pos with direction zdir
-        xdir = edir - edir.dot(zdir) * zdir
-        xdir = -xdir.normalized()
-
-        copy = copyto(collection, source_obj, pos, xdir, zdir, axes)
-        copy_list.append(copy)
-
-    # select all copied objects
-    for copy in copy_list:
-        copy.select_set(True)
-    obj.select_set(False)
-
-
-def edge_copy(collection, obj, source_obj, axes, es, scale):
-    # edge select mode
-    sel_edges = []
-    copy_list = []
-
-    for e in obj.data.edges:
-        if e.select is True:
-            sel_edges.append(e)
-
-    for e in sel_edges:
-        # pos is average of two edge vertexs
-        v0 = obj.data.vertices[e.vertices[0]].co * obj.matrix_world.transposed()
-        v1 = obj.data.vertices[e.vertices[1]].co * obj.matrix_world.transposed()
-        pos = (v0 + v1) / 2
-        # xdir is along edge
-        xdir = v0 - v1
-        xlen = xdir.magnitude
-        xdir = xdir.normalized()
-        # project each edge vertex normal onto plane normal to xdir
-        vn0 = (obj.data.vertices[e.vertices[0]].co * obj.matrix_world.transposed() +
-               obj.data.vertices[e.vertices[0]].normal) - v0
-        vn1 = (obj.data.vertices[e.vertices[1]].co * obj.matrix_world.transposed() +
-               obj.data.vertices[e.vertices[1]].normal) - v1
-        vn0p = vn0 - vn0.dot(xdir) * xdir
-        vn1p = vn1 - vn1.dot(xdir) * xdir
-        # the mean of the two projected normals is the zdir
-        zdir = vn0p + vn1p
-        zdir = zdir.normalized()
-        escale = None
-        if es:
-            escale = Vector([1.0, 1.0, 1.0])
-            i = list('XYZ').index(axes[1])
-            escale[i] = scale * xlen / source_obj.dimensions[i]
-
-        copy = copyto(collection, source_obj, pos, xdir, zdir, axes, scale=escale)
-        copy_list.append(copy)
-
-    # select all copied objects
-    for copy in copy_list:
-        copy.select_set(True)
-    obj.select_set(False)
-
-
-def face_copy(collection, obj, source_obj, axes):
-    # face select mode
-    sel_faces = []
-    copy_list = []
-
-    for f in obj.data.polygons:
-        if f.select is True:
-            sel_faces.append(f)
-
-    for f in sel_faces:
-        fco = f.center * obj.matrix_world.transposed()
-        # get first vertex corner of transformed object
-        vco = obj.data.vertices[f.vertices[0]].co * obj.matrix_world.transposed()
-        # get face normal of transformed object
-        fn = (f.center + f.normal) * obj.matrix_world.transposed() - fco
-        fn = fn.normalized()
-
-        copy = copyto(collection, source_obj, fco, vco - fco, fn, axes)
-        copy_list.append(copy)
-
-    # select all copied objects
-    for copy in copy_list:
-        copy.select_set(True)
-    obj.select_set(False)
-
-
-def register():
-    bpy.utils.register_class(Copy2)
-
-
-def unregister():
-    bpy.utils.unregister_class(Copy2)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/cubester.py b/add_advanced_objects_menu/cubester.py
deleted file mode 100644 (file)
index 8925171..0000000
+++ /dev/null
@@ -1,957 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# Original Author = Jacob Morris
-# URL = blendingjacob.blogspot.com
-
-# Note: scene properties are moved into __init__ together with the 3 update functions
-#       for properties search for the name patterns adv_obj and advanced_objects
-
-bl_info = {
-    "name": "CubeSter",
-    "author": "Jacob Morris",
-    "version": (0, 7, 2),
-    "blender": (2, 78, 0),
-    "location": "View 3D > Toolbar > CubeSter",
-    "description": "Takes image, image sequence, or audio file and converts it "
-                   "into a height map based on pixel color and alpha values",
-    "category": "Add Mesh"
-}
-
-import bpy
-import bmesh
-from bpy.types import (
-    Operator,
-    Panel,
-)
-
-import timeit
-from random import uniform
-from math import radians
-from os import (
-    path,
-    listdir,
-)
-
-
-# create block at center position x, y with block width 2 * hx and 2 * hy and height of h
-def create_block(x, y, hw, h, verts: list, faces: list):
-    if bpy.context.scene.advanced_objects.cubester_block_style == "size":
-        z = 0.0
-    else:
-        z = h
-        h = 2 * hw
-
-    p = len(verts)
-    verts += [(x - hw, y - hw, z), (x + hw, y - hw, z), (x + hw, y + hw, z), (x - hw, y + hw, z)]
-    verts += [(x - hw, y - hw, z + h), (x + hw, y - hw, z + h),
-              (x + hw, y + hw, z + h), (x - hw, y + hw, z + h)]
-
-    faces += [(p, p + 1, p + 5, p + 4), (p + 1, p + 2, p + 6, p + 5),
-              (p + 2, p + 3, p + 7, p + 6), (p, p + 4, p + 7, p + 3),
-              (p + 4, p + 5, p + 6, p + 7), (p, p + 3, p + 2, p + 1)]
-
-
-# go through all frames in len(frames), adjusting values at frames[x][y]
-def create_f_curves(mesh, frames, frame_step_size, style):
-    # use data to animate mesh
-    action = bpy.data.actions.new("CubeSterAnimation")
-
-    mesh.animation_data_create()
-    mesh.animation_data.action = action
-
-    data_path = "vertices[%d].co"
-
-    vert_index = 4 if style == "blocks" else 0  # index of first vertex
-
-    # loop for every face height value
-    for frame_start_vert in range(len(frames[0])):
-        # only go once if plane, otherwise do all four vertices that are in top plane if blocks
-        end_point = frame_start_vert + 4 if style == "blocks" else frame_start_vert + 1
-
-        # loop through to get the four vertices that compose the face
-        for frame_vert in range(frame_start_vert, end_point):
-            # fcurves for x, y, z
-            fcurves = [action.fcurves.new(data_path % vert_index, i) for i in range(3)]
-            frame_counter = 0  # go through each frame and add position
-            temp_v = mesh.vertices[vert_index].co
-
-            # loop through frames
-            for frame in frames:
-                # new x, y, z positions
-                vals = [temp_v[0], temp_v[1], frame[frame_start_vert]]
-                for i in range(3):  # for each x, y, z set each corresponding fcurve
-                    fcurves[i].keyframe_points.insert(frame_counter, vals[i], {'FAST'})
-
-                frame_counter += frame_step_size  # skip frames for smoother animation
-
-            vert_index += 1
-
-        # only skip vertices if made of blocks
-        if style == "blocks":
-            vert_index += 4
-
-
-# create material with given name, apply to object
-def create_material(scene, ob, name):
-    mat = bpy.data.materials.new("CubeSter_" + name)
-    adv_obj = scene.advanced_objects
-    image = None
-
-    # image
-    if not adv_obj.cubester_use_image_color and adv_obj.cubester_color_image in bpy.data.images:
-        try:
-            image = bpy.data.images[adv_obj.cubester_color_image]
-        except:
-            pass
-    else:
-        try:
-            image = bpy.data.images[adv_obj.cubester_image]
-        except:
-            pass
-
-    if scene.render.engine == "CYCLES":
-        mat.use_nodes = True
-        nodes = mat.node_tree.nodes
-
-        att = nodes.new("ShaderNodeAttribute")
-        att.attribute_name = "Col"
-        att.location = (-200, 300)
-
-        att = nodes.new("ShaderNodeTexImage")
-        if image:
-            att.image = image
-
-        if adv_obj.cubester_load_type == "multiple":
-            att.image.source = "SEQUENCE"
-        att.location = (-200, 700)
-
-        att = nodes.new("ShaderNodeTexCoord")
-        att.location = (-450, 600)
-
-        if adv_obj.cubester_materials == "image":
-            mat.node_tree.links.new(
-                nodes["Image Texture"].outputs[0],
-                nodes["Diffuse BSDF"].inputs[0]
-            )
-            mat.node_tree.links.new(
-                nodes["Texture Coordinate"].outputs[2],
-                nodes["Image Texture"].inputs[0]
-            )
-        else:
-            mat.node_tree.links.new(
-                nodes["Attribute"].outputs[0],
-                nodes["Diffuse BSDF"].inputs[0]
-            )
-    else:
-        if adv_obj.cubester_materials == "image" or scene.render.engine != "BLENDER_RENDER":
-            tex = bpy.data.textures.new("CubeSter_" + name, "IMAGE")
-            if image:
-                tex.image = image
-            slot = mat.texture_slots.add()
-            slot.texture = tex
-        else:
-            mat.use_vertex_color_paint = True
-
-    ob.data.materials.append(mat)
-
-
-# generate mesh from audio
-def create_mesh_from_audio(self, context, verts, faces):
-    scene = context.scene
-    view_layer = context.view_layer
-    adv_obj = scene.advanced_objects
-    audio_filepath = adv_obj.cubester_audio_path
-    width = adv_obj.cubester_audio_width_blocks
-    length = adv_obj.cubester_audio_length_blocks
-
-    size_per_hundred = adv_obj.cubester_size_per_hundred_pixels
-    size = size_per_hundred / 100
-    # Note: used for compatibility with vertex colors changes
-    bl_version = bool(bpy.app.version >= (2, 79, 1))
-
-    # create all blocks
-    y = -(width / 2) * size + (size / 2)
-    for r in range(width):
-        x = -(length / 2) * size + (size / 2)
-        for c in range(length):
-            create_block(x, y, size / 2, 1, verts, faces)
-
-            x += size
-        y += size
-
-    # create object
-    mesh = bpy.data.meshes.new("cubed")
-    mesh.from_pydata(verts, [], faces)
-    ob = bpy.data.objects.new("cubed", mesh)
-    bpy.context.collection.objects.link(ob)
-    bpy.context.view_layer.objects.active = ob
-    ob.select_set(True)
-
-    # initial vertex colors
-    if adv_obj.cubester_materials == "image" and adv_obj.cubester_color_image != "":
-        picture = bpy.data.images[adv_obj.cubester_color_image]
-        pixels = list(picture.pixels)
-        vert_colors = []
-
-        skip_y = int(picture.size[1] / width)
-        skip_x = int(picture.size[0] / length)
-
-        for row in range(0, picture.size[1], skip_y + 1):
-            # go through each column, step by appropriate amount
-            for column in range(0, picture.size[0] * 4, 4 + skip_x * 4):
-                r, g, b, a = get_pixel_values(picture, pixels, row, column)
-                get_colors = (r, g, b, a) if bl_version else (r, g, b)
-                vert_colors += [get_colors for i in range(24)]
-
-        bpy.ops.mesh.vertex_color_add()
-
-        i = 0
-        vert_colors_size = len(vert_colors)
-        for c in ob.data.vertex_colors[0].data:
-            if i < vert_colors_size:
-                c.color = vert_colors[i]
-                i += 1
-
-        # image sequence handling
-        if adv_obj.cubester_load_type == "multiple":
-            images = find_sequence_images(self, bpy.context)
-
-            frames_vert_colors = []
-
-            max_images = adv_obj.cubester_max_images + 1 if \
-                        len(images[0]) > adv_obj.cubester_max_images else len(images[0])
-
-            # goes through and for each image for each block finds new height
-            for image_index in range(0, max_images, adv_obj.cubester_skip_images):
-                filepath = images[0][image_index]
-                name = images[1][image_index]
-                picture = fetch_image(self, name, filepath)
-                pixels = list(picture.pixels)
-
-                frame_colors = []
-
-                for row in range(0, picture.size[1], skip_y + 1):
-                    for column in range(0, picture.size[0] * 4, 4 + skip_x * 4):
-                        r, g, b, a = get_pixel_values(picture, pixels, row, column)
-                        get_colors = (r, g, b, a) if bl_version else (r, g, b)
-                        frame_colors += [get_colors for i in range(24)]
-
-                frames_vert_colors.append(frame_colors)
-
-            adv_obj.cubester_vertex_colors[ob.name] = \
-                                    {"type": "vertex", "frames": frames_vert_colors,
-                                    "frame_skip": adv_obj.cubester_frame_step,
-                                    "total_images": max_images}
-
-        # either add material or create
-        if ("CubeSter_" + "Vertex") in bpy.data.materials:
-            ob.data.materials.append(bpy.data.materials["CubeSter_" + "Vertex"])
-        else:
-            create_material(scene, ob, "Vertex")
-
-    # set keyframe for each object as initial point
-    frame = [1 for i in range(int(len(verts) / 8))]
-    frames = [frame]
-
-    area = bpy.context.area
-    old_type = area.type
-    area.type = "GRAPH_EDITOR"
-
-    scene.frame_current = 0
-
-    create_f_curves(mesh, frames, 1, "blocks")
-
-    # deselect all fcurves
-    fcurves = ob.data.animation_data.action.fcurves.data.fcurves
-    for i in fcurves:
-        i.select = False
-
-    max_images = adv_obj.cubester_audio_max_freq
-    min_freq = adv_obj.cubester_audio_min_freq
-    freq_frame = adv_obj.cubester_audio_offset_type
-
-    freq_step = (max_images - min_freq) / length
-    freq_sub_step = freq_step / width
-
-    frame_step = adv_obj.cubester_audio_frame_offset
-
-    # animate each block with a portion of the frequency
-    for c in range(length):
-        frame_off = 0
-        for r in range(width):
-            if freq_frame == "frame":
-                scene.frame_current = frame_off
-                l = c * freq_step
-                h = (c + 1) * freq_step
-                frame_off += frame_step
-            else:
-                l = c * freq_step + (r * freq_sub_step)
-                h = c * freq_step + ((r + 1) * freq_sub_step)
-
-            pos = c + (r * length)  # block number
-            index = pos * 4  # first index for vertex
-
-            # select curves
-            for i in range(index, index + 4):
-                curve = i * 3 + 2  # fcurve location
-                fcurves[curve].select = True
-            try:
-                bpy.ops.graph.sound_bake(filepath=bpy.path.abspath(audio_filepath), low=l, high=h)
-            except:
-                pass
-
-            # deselect curves
-            for i in range(index, index + 4):
-                curve = i * 3 + 2  # fcurve location
-                fcurves[curve].select = False
-
-    area.type = old_type
-
-    # UV unwrap
-    create_uv_map(bpy.context, width, length)
-
-    # if radial apply needed modifiers
-    if adv_obj.cubester_audio_block_layout == "radial":
-        # add bezier curve of correct width
-        bpy.ops.curve.primitive_bezier_circle_add()
-        curve = bpy.context.object
-        # slope determined off of collected data
-        curve_size = (0.319 * (width * (size * 100)) - 0.0169) / 100
-        curve.dimensions = (curve_size, curve_size, 0.0)
-        # correct for z height
-        curve.scale = (curve.scale[0], curve.scale[0], curve.scale[0])
-
-        ob.select_set(True)
-        curve.select_set(False)
-        view_layer.objects.active = ob
-
-        # data was collected and then multi-variable regression was done in Excel
-        # influence of width and length
-        width_infl, length_infl, intercept = -0.159125, 0.49996, 0.007637
-        x_offset = ((width * (size * 100) * width_infl) +
-                   (length * (size * 100) * length_infl) + intercept) / 100
-        ob.location = (ob.location[0] + x_offset, ob.location[1], ob.location[2])
-
-        ob.rotation_euler = (radians(-90), 0.0, 0.0)
-        bpy.ops.object.modifier_add(type="CURVE")
-        ob.modifiers["Curve"].object = curve
-        ob.modifiers["Curve"].deform_axis = "POS_Z"
-
-
-# generate mesh from image(s)
-def create_mesh_from_image(self, scene, verts, faces):
-    context = bpy.context
-    adv_obj = scene.advanced_objects
-    picture = bpy.data.images[adv_obj.cubester_image]
-    pixels = list(picture.pixels)
-    # Note: used for compatibility with vertex colors changes
-    bl_version = bool(bpy.app.version >= (2, 79, 1))
-
-    x_pixels = picture.size[0] / (adv_obj.cubester_skip_pixels + 1)
-    y_pixels = picture.size[1] / (adv_obj.cubester_skip_pixels + 1)
-
-    width = x_pixels / 100 * adv_obj.cubester_size_per_hundred_pixels
-    height = y_pixels / 100 * adv_obj.cubester_size_per_hundred_pixels
-
-    step = width / x_pixels
-    half_width = step / 2
-
-    y = -height / 2 + half_width
-
-    vert_colors = []
-    rows = 0
-
-    # go through each row of pixels stepping by adv_obj.cubester_skip_pixels + 1
-    for row in range(0, picture.size[1], adv_obj.cubester_skip_pixels + 1):
-        rows += 1
-        x = -width / 2 + half_width  # reset to left edge of mesh
-        # go through each column, step by appropriate amount
-        for column in range(0, picture.size[0] * 4, 4 + adv_obj.cubester_skip_pixels * 4):
-            r, g, b, a = get_pixel_values(picture, pixels, row, column)
-            get_colors = (r, g, b, a) if bl_version else (r, g, b)
-            h = find_point_height(r, g, b, a, scene)
-
-            # if not transparent
-            if h != -1:
-                if adv_obj.cubester_mesh_style == "blocks":
-                    create_block(x, y, half_width, h, verts, faces)
-                    vert_colors += [get_colors for i in range(24)]
-                else:
-                    verts += [(x, y, h)]
-                    vert_colors += [get_colors for i in range(4)]
-
-            x += step
-        y += step
-
-        # if plane not blocks, then remove last 4 items from vertex_colors
-        # as the faces have already wrapped around
-        if adv_obj.cubester_mesh_style == "plane":
-            del vert_colors[len(vert_colors) - 4:len(vert_colors)]
-
-    # create faces if plane based and not block based
-    if adv_obj.cubester_mesh_style == "plane":
-        off = int(len(verts) / rows)
-        for r in range(rows - 1):
-            for c in range(off - 1):
-                faces += [(r * off + c, r * off + c + 1, (r + 1) * off + c + 1, (r + 1) * off + c)]
-
-    mesh = bpy.data.meshes.new("cubed")
-    mesh.from_pydata(verts, [], faces)
-    ob = bpy.data.objects.new("cubed", mesh)
-    context.collection.objects.link(ob)
-    context.view_layer.objects.active = ob
-    ob.select_set(True)
-
-    # uv unwrap
-    if adv_obj.cubester_mesh_style == "blocks":
-        create_uv_map(context, rows, int(len(faces) / 6 / rows))
-    else:
-        create_uv_map(context, rows - 1, int(len(faces) / (rows - 1)))
-
-    # material
-    # determine name and if already created
-    if adv_obj.cubester_materials == "vertex":  # vertex color
-        image_name = "Vertex"
-    elif not adv_obj.cubester_use_image_color and \
-       adv_obj.cubester_color_image in bpy.data.images and \
-       adv_obj.cubester_materials == "image":  # replaced image
-        image_name = adv_obj.cubester_color_image
-    else:  # normal image
-        image_name = adv_obj.cubester_image
-
-    # either add material or create
-    if ("CubeSter_" + image_name) in bpy.data.materials:
-        ob.data.materials.append(bpy.data.materials["CubeSter_" + image_name])
-
-    # create material
-    else:
-        create_material(scene, ob, image_name)
-
-    # vertex colors
-    bpy.ops.mesh.vertex_color_add()
-    i = 0
-    for c in ob.data.vertex_colors[0].data:
-        c.color = vert_colors[i]
-        i += 1
-
-    frames = []
-    # image sequence handling
-    if adv_obj.cubester_load_type == "multiple":
-        images = find_sequence_images(self, context)
-        frames_vert_colors = []
-
-        max_images = adv_obj.cubester_max_images + 1 if \
-                    len(images[0]) > adv_obj.cubester_max_images else len(images[0])
-
-        # goes through and for each image for each block finds new height
-        for image_index in range(0, max_images, adv_obj.cubester_skip_images):
-            filepath = images[0][image_index]
-            name = images[1][image_index]
-            picture = fetch_image(self, name, filepath)
-            pixels = list(picture.pixels)
-
-            frame_heights = []
-            frame_colors = []
-
-            for row in range(0, picture.size[1], adv_obj.cubester_skip_pixels + 1):
-                for column in range(0, picture.size[0] * 4, 4 + adv_obj.cubester_skip_pixels * 4):
-                    r, g, b, a = get_pixel_values(picture, pixels, row, column)
-                    get_colors = (r, g, b, a) if bl_version else (r, g, b)
-                    h = find_point_height(r, g, b, a, scene)
-
-                    if h != -1:
-                        frame_heights.append(h)
-                        if adv_obj.cubester_mesh_style == "blocks":
-                            frame_colors += [get_colors for i in range(24)]
-                        else:
-                            frame_colors += [get_colors for i in range(4)]
-
-            if adv_obj.cubester_mesh_style == "plane":
-                del vert_colors[len(vert_colors) - 4:len(vert_colors)]
-
-            frames.append(frame_heights)
-            frames_vert_colors.append(frame_colors)
-
-        # determine what data to use
-        if adv_obj.cubester_materials == "vertex" or scene.render.engine == "BLENDER_ENGINE":
-            adv_obj.cubester_vertex_colors[ob.name] = {
-                "type": "vertex", "frames": frames_vert_colors,
-                "frame_skip": adv_obj.cubester_frame_step,
-                "total_images": max_images
-            }
-        else:
-            adv_obj.cubester_vertex_colors[ob.name] = {
-                "type": "image", "frame_skip": adv_obj.cubester_frame_step,
-                "total_images": max_images
-            }
-            att = get_image_node(ob.data.materials[0])
-            att.image_user.frame_duration = len(frames) * adv_obj.cubester_frame_step
-
-        # animate mesh
-        create_f_curves(
-            mesh, frames,
-            adv_obj.cubester_frame_step,
-            adv_obj.cubester_mesh_style
-        )
-
-
-# generate uv map for object
-def create_uv_map(context, rows, columns):
-    adv_obj = context.scene.advanced_objects
-    mesh = context.object.data
-    mesh.uv_textures.new("cubester")
-    bm = bmesh.new()
-    bm.from_mesh(mesh)
-
-    uv_layer = bm.loops.layers.uv[0]
-    bm.faces.ensure_lookup_table()
-
-    x_scale = 1 / columns
-    y_scale = 1 / rows
-
-    y_pos = 0.0
-    x_pos = 0.0
-    count = columns - 1  # hold current count to compare to if need to go to next row
-
-    # if blocks
-    if adv_obj.cubester_mesh_style == "blocks":
-        for fa in range(int(len(bm.faces) / 6)):
-            for i in range(6):
-                pos = (fa * 6) + i
-                bm.faces[pos].loops[0][uv_layer].uv = (x_pos, y_pos)
-                bm.faces[pos].loops[1][uv_layer].uv = (x_pos + x_scale, y_pos)
-                bm.faces[pos].loops[2][uv_layer].uv = (x_pos + x_scale, y_pos + y_scale)
-                bm.faces[pos].loops[3][uv_layer].uv = (x_pos, y_pos + y_scale)
-
-            x_pos += x_scale
-
-            if fa >= count:
-                y_pos += y_scale
-                x_pos = 0.0
-                count += columns
-
-    # if planes
-    else:
-        for fa in range(len(bm.faces)):
-            bm.faces[fa].loops[0][uv_layer].uv = (x_pos, y_pos)
-            bm.faces[fa].loops[1][uv_layer].uv = (x_pos + x_scale, y_pos)
-            bm.faces[fa].loops[2][uv_layer].uv = (x_pos + x_scale, y_pos + y_scale)
-            bm.faces[fa].loops[3][uv_layer].uv = (x_pos, y_pos + y_scale)
-
-            x_pos += x_scale
-
-            if fa >= count:
-                y_pos += y_scale
-                x_pos = 0.0
-                count += columns
-
-    bm.to_mesh(mesh)
-
-
-# if already loaded return image, else load and return
-def fetch_image(self, name, load_path):
-    if name in bpy.data.images:
-        return bpy.data.images[name]
-    else:
-        try:
-            image = bpy.data.images.load(load_path)
-            return image
-        except RuntimeError:
-            self.report({"ERROR"}, "CubeSter: '{}' could not be loaded".format(load_path))
-            return None
-
-
-# find height for point
-def find_point_height(r, g, b, a, scene):
-    adv_obj = scene.advanced_objects
-    if a:  # if not completely transparent
-        normalize = 1
-
-        # channel weighting
-        if not adv_obj.cubester_advanced:
-            composed = 0.25 * r + 0.25 * g + 0.25 * b + 0.25 * a
-        else:
-            # user defined weighting
-            if not adv_obj.cubester_random_weights:
-                composed = adv_obj.cubester_weight_r * r + adv_obj.cubester_weight_g * g + \
-                        adv_obj.cubester_weight_b * b + adv_obj.cubester_weight_a * a
-                total = adv_obj.cubester_weight_r + adv_obj.cubester_weight_g + adv_obj.cubester_weight_b + \
-                        adv_obj.cubester_weight_a
-
-                normalize = 1 / total
-            # random weighting
-            else:
-                weights = [uniform(0.0, 1.0) for i in range(4)]
-                composed = weights[0] * r + weights[1] * g + weights[2] * b + weights[3] * a
-                total = weights[0] + weights[1] + weights[2] + weights[3]
-                normalize = 1 / total
-
-        if adv_obj.cubester_invert:
-            h = (1 - composed) * adv_obj.cubester_height_scale * normalize
-        else:
-            h = composed * adv_obj.cubester_height_scale * normalize
-
-        return h
-    else:
-        return -1
-
-
-# find all images that would belong to sequence
-def find_sequence_images(self, context):
-    scene = context.scene
-    images = [[], []]
-
-    if scene.advanced_objects.cubester_image in bpy.data.images:
-        image = bpy.data.images[scene.advanced_objects.cubester_image]
-        main = image.name.split(".")[0]
-
-        # first part of name to check against other files
-        length = len(main)
-        keep_going = True
-        for i in range(length - 1, -1, -1):
-            if main[i].isdigit() and keep_going:
-                length -= 1
-            else:
-                keep_going = not keep_going
-        name = main[0:length]
-
-        dir_name = path.dirname(bpy.path.abspath(image.filepath))
-
-        try:
-            for file in listdir(dir_name):
-                if path.isfile(path.join(dir_name, file)) and file.startswith(name):
-                    images[0].append(path.join(dir_name, file))
-                    images[1].append(file)
-        except FileNotFoundError:
-            self.report({"ERROR"}, "CubeSter: '{}' directory not found".format(dir_name))
-
-    return images
-
-
-# get image node
-def get_image_node(mat):
-    nodes = mat.node_tree.nodes
-    att = nodes["Image Texture"]
-
-    return att
-
-
-# get the RGBA values from pixel
-def get_pixel_values(picture, pixels, row, column):
-    # determine i position to start at based on row and column position
-    i = (row * picture.size[0] * 4) + column
-    pixs = pixels[i: i + 4]
-    r = pixs[0]
-    g = pixs[1]
-    b = pixs[2]
-    a = pixs[3]
-
-    return r, g, b, a
-
-
-# frame change handler for materials
-def material_frame_handler(scene):
-    frame = scene.frame_current
-    adv_obj = scene.advanced_objects
-
-    keys = list(adv_obj.cubester_vertex_colors.keys())
-
-    # get keys and see if object is still in scene
-    for i in keys:
-        # if object is in scene then update information
-        if i in bpy.data.objects:
-            ob = bpy.data.objects[i]
-            data = adv_obj.advanced_objects.cubester_vertex_colors[ob.name]
-            skip_frames = data["frame_skip"]
-
-            # update materials using vertex colors
-            if data['type'] == "vertex":
-                colors = data["frames"]
-
-                if frame % skip_frames == 0 and 0 <= frame < (data['total_images'] - 1) * skip_frames:
-                    use_frame = int(frame / skip_frames)
-                    color = colors[use_frame]
-
-                    i = 0
-                    for c in ob.data.vertex_colors[0].data:
-                        c.color = color[i]
-                        i += 1
-
-            else:
-                att = get_image_node(ob.data.materials[0])
-                offset = frame - int(frame / skip_frames)
-                att.image_user.frame_offset = -offset
-
-        # if the object is no longer in the scene then delete then entry
-        else:
-            del adv_obj.advanced_objects.cubester_vertex_colors[i]
-
-
-class CubeSterPanel(Panel):
-    bl_idname = "OBJECT_PT_cubester"
-    bl_label = "CubeSter"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_category = "Create"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_context = "objectmode"
-
-    def draw(self, context):
-        layout = self.layout.box()
-        scene = bpy.context.scene
-        adv_obj = scene.advanced_objects
-        images_found = 0
-        rows = 0
-        columns = 0
-
-        layout.prop(adv_obj, "cubester_audio_image")
-
-        if adv_obj.cubester_audio_image == "image":
-            box = layout.box()
-            box.prop(adv_obj, "cubester_load_type")
-            box.label(text="Image To Convert:")
-            box.prop_search(adv_obj, "cubester_image", bpy.data, "images")
-            box.prop(adv_obj, "cubester_load_image")
-
-            # find number of appropriate images if sequence
-            if adv_obj.cubester_load_type == "multiple":
-                box = layout.box()
-                # display number of images found there
-                images = find_sequence_images(self, context)
-                images_found = len(images[0]) if len(images[0]) <= adv_obj.cubester_max_images \
-                               else adv_obj.cubester_max_images
-
-                if len(images[0]):
-                    box.label(str(len(images[0])) + " Images Found", icon="PACKAGE")
-
-                box.prop(adv_obj, "cubester_max_images")
-                box.prop(adv_obj, "cubester_skip_images")
-                box.prop(adv_obj, "cubester_frame_step")
-
-            box = layout.box()
-            col = box.column(align=True)
-            col.prop(adv_obj, "cubester_skip_pixels")
-            col.prop(adv_obj, "cubester_size_per_hundred_pixels")
-            col.prop(adv_obj, "cubester_height_scale")
-            box.prop(adv_obj, "cubester_invert", icon="FILE_REFRESH")
-
-            box = layout.box()
-            box.prop(adv_obj, "cubester_mesh_style", icon="MESH_GRID")
-
-            if adv_obj.cubester_mesh_style == "blocks":
-                box.prop(adv_obj, "cubester_block_style")
-        else:
-            # audio file
-            layout.prop(adv_obj, "cubester_audio_path")
-
-            box = layout.box()
-            col = box.column(align=True)
-            col.prop(adv_obj, "cubester_audio_min_freq")
-            col.prop(adv_obj, "cubester_audio_max_freq")
-
-            box.separator()
-            box.prop(adv_obj, "cubester_audio_offset_type")
-
-            if adv_obj.cubester_audio_offset_type == "frame":
-                box.prop(adv_obj, "cubester_audio_frame_offset")
-            box.prop(adv_obj, "cubester_audio_block_layout")
-            box.separator()
-
-            col = box.column(align=True)
-            col.prop(adv_obj, "cubester_audio_width_blocks")
-            col.prop(adv_obj, "cubester_audio_length_blocks")
-
-            rows = adv_obj.cubester_audio_width_blocks
-            columns = adv_obj.cubester_audio_length_blocks
-
-            col.prop(adv_obj, "cubester_size_per_hundred_pixels")
-
-        # materials
-        box = layout.box()
-        box.prop(adv_obj, "cubester_materials", icon="MATERIAL")
-
-        if adv_obj.cubester_materials == "image":
-            box.prop(adv_obj, "cubester_load_type")
-
-            # find number of appropriate images if sequence
-            if adv_obj.cubester_load_type == "multiple":
-                # display number of images found there
-                images = find_sequence_images(self, context)
-                images_found = len(images[0]) if len(images[0]) <= adv_obj.cubester_max_images \
-                    else adv_obj.cubester_max_images
-
-                if len(images[0]):
-                    box.label(str(len(images[0])) + " Images Found", icon="PACKAGE")
-                box.prop(adv_obj, "cubester_max_images")
-                box.prop(adv_obj, "cubester_skip_images")
-                box.prop(adv_obj, "cubester_frame_step")
-
-            box.separator()
-
-            if adv_obj.cubester_audio_image == "image":
-                box.prop(adv_obj, "cubester_use_image_color", icon="COLOR")
-
-            if not adv_obj.cubester_use_image_color or adv_obj.cubester_audio_image == "audio":
-                box.label(text="Image To Use For Colors:")
-                box.prop_search(adv_obj, "cubester_color_image", bpy.data, "images")
-                box.prop(adv_obj, "cubester_load_color_image")
-
-            if adv_obj.cubester_image in bpy.data.images:
-                rows = int(bpy.data.images[adv_obj.cubester_image].size[1] /
-                          (adv_obj.cubester_skip_pixels + 1))
-                columns = int(bpy.data.images[adv_obj.cubester_image].size[0] /
-                             (adv_obj.cubester_skip_pixels + 1))
-
-        box = layout.box()
-
-        if adv_obj.cubester_mesh_style == "blocks":
-            box.label(text="Approximate Cube Count: " + str(rows * columns))
-            box.label(text="Expected Verts/Faces: " + str(rows * columns * 8) + " / " + str(rows * columns * 6))
-        else:
-            box.label(text="Approximate Point Count: " + str(rows * columns))
-            box.label(text="Expected Verts/Faces: " + str(rows * columns) + " / " + str(rows * (columns - 1)))
-
-        # blocks and plane generation time values
-        if adv_obj.cubester_mesh_style == "blocks":
-            slope = 0.0000876958
-            intercept = 0.02501
-            block_infl, frame_infl, intercept2 = 0.0025934, 0.38507, -0.5840189
-        else:
-            slope = 0.000017753
-            intercept = 0.04201
-            block_infl, frame_infl, intercept2 = 0.000619, 0.344636, -0.272759
-
-        # if creating image based mesh
-        points = rows * columns
-        if adv_obj.cubester_audio_image == "image":
-            if adv_obj.cubester_load_type == "single":
-                time = rows * columns * slope + intercept  # approximate time count for mesh
-            else:
-                time = (points * slope) + intercept + (points * block_infl) + \
-                       (images_found / adv_obj.cubester_skip_images * frame_infl) + intercept2
-
-                box.label(text="Images To Be Used: " + str(int(images_found / adv_obj.cubester_skip_images)))
-        else:
-            # audio based mesh
-            box.label(text="Audio Track Length: " + str(adv_obj.cubester_audio_file_length) + " frames")
-
-            block_infl, frame_infl, intercept = 0.0948, 0.0687566, -25.85985
-            time = (points * block_infl) + (adv_obj.cubester_audio_file_length * frame_infl) + intercept
-            if time < 0.0:  # usually no audio loaded
-                time = 0.0
-
-        time_mod = "s"
-        if time > 60:  # convert to minutes if needed
-            time /= 60
-            time_mod = "min"
-        time = round(time, 3)
-
-        box.label(text="Expected Time: " + str(time) + " " + time_mod)
-
-        # advanced
-        if adv_obj.cubester_audio_image == "image":
-            icon_1 = "TRIA_DOWN" if adv_obj.cubester_advanced else "TRIA_RIGHT"
-            # layout.separator()
-            box = layout.box()
-            box.prop(adv_obj, "cubester_advanced", icon=icon_1)
-
-            if adv_obj.cubester_advanced:
-                box.prop(adv_obj, "cubester_random_weights", icon="RNDCURVE")
-
-                if not adv_obj.cubester_random_weights:
-                    box.label(text="RGBA Channel Weights", icon="COLOR")
-                    col = box.column(align=True)
-                    col.prop(adv_obj, "cubester_weight_r")
-                    col.prop(adv_obj, "cubester_weight_g")
-                    col.prop(adv_obj, "cubester_weight_b")
-                    col.prop(adv_obj, "cubester_weight_a")
-
-        # generate mesh
-        layout.operator("mesh.cubester", icon="OBJECT_DATA")
-
-
-class CubeSter(Operator):
-    bl_idname = "mesh.cubester"
-    bl_label = "Generate CubeSter Mesh"
-    bl_description = "Generate a mesh from an Image or Sound File"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        verts, faces = [], []
-
-        start = timeit.default_timer()
-        scene = bpy.context.scene
-        adv_obj = scene.advanced_objects
-
-        if adv_obj.cubester_audio_image == "image":
-            if adv_obj.cubester_image != "":
-                create_mesh_from_image(self, scene, verts, faces)
-                frames = find_sequence_images(self, context)
-                created = len(frames[0])
-            else:
-                self.report({'WARNING'},
-                            "Please add an Image for Object generation. Operation Cancelled")
-                return {"CANCELLED"}
-        else:
-            if (adv_obj.cubester_audio_path != "" and
-                    path.isfile(adv_obj.cubester_audio_path) and
-                    adv_obj.cubester_check_audio is True):
-
-                create_mesh_from_audio(self, context, verts, faces)
-                created = adv_obj.cubester_audio_file_length
-            else:
-                self.report({'WARNING'},
-                            "Please add an Sound File for Object generation. Operation Cancelled")
-                return {"CANCELLED"}
-
-        stop = timeit.default_timer()
-
-        if adv_obj.cubester_mesh_style == "blocks" or adv_obj.cubester_audio_image == "audio":
-            self.report(
-                {"INFO"},
-                "CubeSter: {} blocks and {} frame(s) "
-                "in {}s".format(str(int(len(verts) / 8)),
-                                str(created),
-                                str(round(stop - start, 4)))
-            )
-        else:
-            self.report(
-                {"INFO"},
-                "CubeSter: {} points and {} frame(s) "
-                "in {}s" .format(str(len(verts)),
-                                 str(created),
-                                 str(round(stop - start, 4)))
-            )
-
-        return {"FINISHED"}
-
-
-def register():
-    bpy.utils.register_module(__name__)
-    bpy.app.handlers.frame_change_pre.append(material_frame_handler)
-
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-    bpy.app.handlers.frame_change_pre.remove(material_frame_handler)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/make_struts.py b/add_advanced_objects_menu/make_struts.py
deleted file mode 100644 (file)
index f9eda05..0000000
+++ /dev/null
@@ -1,588 +0,0 @@
-#  Copyright (C) 2012 Bill Currie <bill@taniwha.org>
-#  Date: 2012/2/20
-
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# <pep8 compliant>
-
-import bpy
-import bmesh
-from bpy.types import Operator
-from bpy.props import (
-        FloatProperty,
-        IntProperty,
-        BoolProperty,
-        )
-from mathutils import (
-        Vector,
-        Matrix,
-        Quaternion,
-        )
-from math import (
-        pi, cos,
-        sin,
-        )
-
-cossin = []
-
-# Initialize the cossin table based on the number of segments.
-#
-#   @param n  The number of segments into which the circle will be
-#             divided.
-#   @return   None
-
-
-def build_cossin(n):
-    global cossin
-    cossin = []
-    for i in range(n):
-        a = 2 * pi * i / n
-        cossin.append((cos(a), sin(a)))
-
-
-def select_up(axis):
-    # if axis.length != 0 and (abs(axis[0] / axis.length) < 1e-5 and abs(axis[1] / axis.length) < 1e-5):
-    if (abs(axis[0] / axis.length) < 1e-5 and abs(axis[1] / axis.length) < 1e-5):
-        up = Vector((-1, 0, 0))
-    else:
-        up = Vector((0, 0, 1))
-    return up
-
-# Make a single strut in non-manifold mode.
-#
-#   The strut will be a "cylinder" with @a n sides. The vertices of the
-#   cylinder will be @a od / 2 from the center of the cylinder. Optionally,
-#   extra loops will be placed (@a od - @a id) / 2 from either end. The
-#   strut will be either a simple, open-ended single-surface "cylinder", or a
-#   double walled "pipe" with the outer wall vertices @a od / 2 from the center
-#   and the inner wall vertices @a id / 2 from the center. The two walls will
-#   be joined together at the ends with a face ring such that the entire strut
-#   is a manifold object. All faces of the strut will be quads.
-#
-#   @param v1       Vertex representing one end of the strut's center-line.
-#   @param v2       Vertex representing the other end of the strut's
-#                   center-line.
-#   @param id       The diameter of the inner wall of a solid strut. Used for
-#                   calculating the position of the extra loops irrespective
-#                   of the solidity of the strut.
-#   @param od       The diameter of the outer wall of a solid strut, or the
-#                   diameter of a non-solid strut.
-#   @param solid    If true, the strut will be made solid such that it has an
-#                   inner wall (diameter @a id), an outer wall (diameter
-#                   @a od), and face rings at either end of the strut such
-#                   the strut is a manifold object. If false, the strut is
-#                   a simple, open-ended "cylinder".
-#   @param loops    If true, edge loops will be placed at either end of the
-#                   strut, (@a od - @a id) / 2 from the end of the strut. The
-#                   loops make subsurfed solid struts work nicely.
-#   @return         A tuple containing a list of vertices and a list of faces.
-#                   The face vertex indices are accurate only for the list of
-#                   vertices for the created strut.
-
-
-def make_strut(v1, v2, ind, od, n, solid, loops):
-    v1 = Vector(v1)
-    v2 = Vector(v2)
-    axis = v2 - v1
-    pos = [(0, od / 2)]
-    if loops:
-        pos += [((od - ind) / 2, od / 2),
-                (axis.length - (od - ind) / 2, od / 2)]
-    pos += [(axis.length, od / 2)]
-    if solid:
-        pos += [(axis.length, ind / 2)]
-        if loops:
-            pos += [(axis.length - (od - ind) / 2, ind / 2),
-                    ((od - ind) / 2, ind / 2)]
-        pos += [(0, ind / 2)]
-    vps = len(pos)
-    fps = vps
-    if not solid:
-        fps -= 1
-    fw = axis.copy()
-    fw.normalize()
-    up = select_up(axis)
-    lf = up.cross(fw)
-    lf.normalize()
-    up = fw.cross(lf)
-    mat = Matrix((fw, lf, up))
-    mat.transpose()
-    verts = [None] * n * vps
-    faces = [None] * n * fps
-    for i in range(n):
-        base = (i - 1) * vps
-        x = cossin[i][0]
-        y = cossin[i][1]
-        for j in range(vps):
-            p = Vector((pos[j][0], pos[j][1] * x, pos[j][1] * y))
-            p = mat * p
-            verts[i * vps + j] = p + v1
-        if i:
-            for j in range(fps):
-                f = (i - 1) * fps + j
-                faces[f] = [base + j, base + vps + j,
-                            base + vps + (j + 1) % vps, base + (j + 1) % vps]
-    base = len(verts) - vps
-    i = n
-    for j in range(fps):
-        f = (i - 1) * fps + j
-        faces[f] = [base + j, j, (j + 1) % vps, base + (j + 1) % vps]
-
-    return verts, faces
-
-
-# Project a point along a vector onto a plane.
-#
-#   Really, just find the intersection of the line represented by @a point
-#   and @a dir with the plane represented by @a norm and @a p. However, if
-#   the point is on or in front of the plane, or the line is parallel to
-#   the plane, the original point will be returned.
-#
-#   @param point    The point to be projected onto the plane.
-#   @param dir      The vector along which the point will be projected.
-#   @param norm     The normal of the plane onto which the point will be
-#                   projected.
-#   @param p        A point through which the plane passes.
-#   @return         A vector representing the projected point, or the
-#                   original point.
-
-def project_point(point, dir, norm, p):
-    d = (point - p).dot(norm)
-    if d >= 0:
-        # the point is already on or in front of the plane
-        return point
-    v = dir.dot(norm)
-    if v * v < 1e-8:
-        # the plane is unreachable
-        return point
-    return point - dir * d / v
-
-
-# Make a simple strut for debugging.
-#
-#   The strut is just a single quad representing the Z axis of the edge.
-#
-#   @param mesh     The base mesh. Used for finding the edge vertices.
-#   @param edge_num The number of the current edge. For the face vertex
-#                   indices.
-#   @param edge     The edge for which the strut will be built.
-#   @param od       Twice the width of the strut.
-#   @return         A tuple containing a list of vertices and a list of faces.
-#                   The face vertex indices are pre-adjusted by the edge
-#                   number.
-#   @fixme          The face vertex indices should be accurate for the local
-#                   vertices (consistency)
-
-def make_debug_strut(mesh, edge_num, edge, od):
-    v = [mesh.verts[edge.verts[0].index].co,
-         mesh.verts[edge.verts[1].index].co,
-         None, None]
-    v[2] = v[1] + edge.z * od / 2
-    v[3] = v[0] + edge.z * od / 2
-    f = [[edge_num * 4 + 0, edge_num * 4 + 1,
-          edge_num * 4 + 2, edge_num * 4 + 3]]
-    return v, f
-
-
-# Make a cylinder with ends clipped to the end-planes of the edge.
-#
-#   The strut is just a single quad representing the Z axis of the edge.
-#
-#   @param mesh     The base mesh. Used for finding the edge vertices.
-#   @param edge_num The number of the current edge. For the face vertex
-#                   indices.
-#   @param edge     The edge for which the strut will be built.
-#   @param od       The diameter of the strut.
-#   @return         A tuple containing a list of vertices and a list of faces.
-#                   The face vertex indices are pre-adjusted by the edge
-#                   number.
-#   @fixme          The face vertex indices should be accurate for the local
-#                   vertices (consistency)
-
-def make_clipped_cylinder(mesh, edge_num, edge, od):
-    n = len(cossin)
-    cyl = [None] * n
-    v0 = mesh.verts[edge.verts[0].index].co
-    c0 = v0 + od * edge.y
-    v1 = mesh.verts[edge.verts[1].index].co
-    c1 = v1 - od * edge.y
-    for i in range(n):
-        x = cossin[i][0]
-        y = cossin[i][1]
-        r = (edge.z * x - edge.x * y) * od / 2
-        cyl[i] = [c0 + r, c1 + r]
-        for p in edge.verts[0].planes:
-            cyl[i][0] = project_point(cyl[i][0], edge.y, p, v0)
-        for p in edge.verts[1].planes:
-            cyl[i][1] = project_point(cyl[i][1], -edge.y, p, v1)
-    v = [None] * n * 2
-    f = [None] * n
-    base = edge_num * n * 2
-    for i in range(n):
-        v[i * 2 + 0] = cyl[i][1]
-        v[i * 2 + 1] = cyl[i][0]
-        f[i] = [None] * 4
-        f[i][0] = base + i * 2 + 0
-        f[i][1] = base + i * 2 + 1
-        f[i][2] = base + (i * 2 + 3) % (n * 2)
-        f[i][3] = base + (i * 2 + 2) % (n * 2)
-    return v, f
-
-
-# Represent a vertex in the base mesh, with additional information.
-#
-#   These vertices are @b not shared between edges.
-#
-#   @var index  The index of the vert in the base mesh
-#   @var edge   The edge to which this vertex is attached.
-#   @var edges  A tuple of indicess of edges attached to this vert, not
-#               including the edge to which this vertex is attached.
-#   @var planes List of vectors representing the normals of the planes that
-#               bisect the angle between this vert's edge and each other
-#               adjacant edge.
-
-class SVert:
-    # Create a vertex holding additional information about the bmesh vertex.
-    #   @param bmvert   The bmesh vertex for which additional information is
-    #                   to be stored.
-    #   @param bmedge   The edge to which this vertex is attached.
-
-    def __init__(self, bmvert, bmedge, edge):
-        self.index = bmvert.index
-        self.edge = edge
-        edges = bmvert.link_edges[:]
-        edges.remove(bmedge)
-        self.edges = tuple(map(lambda e: e.index, edges))
-        self.planes = []
-
-    def calc_planes(self, edges):
-        for ed in self.edges:
-            self.planes.append(calc_plane_normal(self.edge, edges[ed]))
-
-
-# Represent an edge in the base mesh, with additional information.
-#
-#   Edges do not share vertices so that the edge is always on the front (back?
-#   must verify) side of all the planes attached to its vertices. If the
-#   vertices were shared, the edge could be on either side of the planes, and
-#   there would be planes attached to the vertex that are irrelevant to the
-#   edge.
-#
-#   @var index      The index of the edge in the base mesh.
-#   @var bmedge     Cached reference to this edge's bmedge
-#   @var verts      A tuple of 2 SVert vertices, one for each end of the
-#                   edge. The vertices are @b not shared between edges.
-#                   However, if two edges are connected via a vertex in the
-#                   bmesh, their corresponding SVert vertices will have the
-#                   the same index value.
-#   @var x          The x axis of the edges local frame of reference.
-#                   Initially invalid.
-#   @var y          The y axis of the edges local frame of reference.
-#                   Initialized such that the edge runs from verts[0] to
-#                   verts[1] along the negative y axis.
-#   @var z          The z axis of the edges local frame of reference.
-#                   Initially invalid.
-
-
-class SEdge:
-
-    def __init__(self, bmesh, bmedge):
-
-        self.index = bmedge.index
-        self.bmedge = bmedge
-        bmesh.verts.ensure_lookup_table()
-        self.verts = (SVert(bmedge.verts[0], bmedge, self),
-                      SVert(bmedge.verts[1], bmedge, self))
-        self.y = (bmesh.verts[self.verts[0].index].co -
-                  bmesh.verts[self.verts[1].index].co)
-        self.y.normalize()
-        self.x = self.z = None
-
-    def set_frame(self, up):
-        self.x = self.y.cross(up)
-        self.x.normalize()
-        self.z = self.x.cross(self.y)
-
-    def calc_frame(self, base_edge):
-        baxis = base_edge.y
-        if (self.verts[0].index == base_edge.verts[0].index or
-              self.verts[1].index == base_edge.verts[1].index):
-            axis = -self.y
-        elif (self.verts[0].index == base_edge.verts[1].index or
-                self.verts[1].index == base_edge.verts[0].index):
-            axis = self.y
-        else:
-            raise ValueError("edges not connected")
-        if baxis.dot(axis) in (-1, 1):
-            # aligned axis have their up/z aligned
-            up = base_edge.z
-        else:
-            # Get the unit vector dividing the angle (theta) between baxis and
-            # axis in two equal parts
-            h = (baxis + axis)
-            h.normalize()
-            # (cos(theta/2), sin(theta/2) * n) where n is the unit vector of the
-            # axis rotating baxis onto axis
-            q = Quaternion([baxis.dot(h)] + list(baxis.cross(h)))
-            # rotate the base edge's up around the rotation axis (blender
-            # quaternion shortcut:)
-            up = q * base_edge.z
-        self.set_frame(up)
-
-    def calc_vert_planes(self, edges):
-        for v in self.verts:
-            v.calc_planes(edges)
-
-    def bisect_faces(self):
-        n1 = self.bmedge.link_faces[0].normal
-        if len(self.bmedge.link_faces) > 1:
-            n2 = self.bmedge.link_faces[1].normal
-            return (n1 + n2).normalized()
-        return n1
-
-    def calc_simple_frame(self):
-        return self.y.cross(select_up(self.y)).normalized()
-
-    def find_edge_frame(self, sedges):
-        if self.bmedge.link_faces:
-            return self.bisect_faces()
-        if self.verts[0].edges or self.verts[1].edges:
-            edges = list(self.verts[0].edges + self.verts[1].edges)
-            for i in range(len(edges)):
-                edges[i] = sedges[edges[i]]
-            while edges and edges[-1].y.cross(self.y).length < 1e-3:
-                edges.pop()
-            if not edges:
-                return self.calc_simple_frame()
-            n1 = edges[-1].y.cross(self.y).normalized()
-            edges.pop()
-            while edges and edges[-1].y.cross(self.y).cross(n1).length < 1e-3:
-                edges.pop()
-            if not edges:
-                return n1
-            n2 = edges[-1].y.cross(self.y).normalized()
-            return (n1 + n2).normalized()
-        return self.calc_simple_frame()
-
-
-def calc_plane_normal(edge1, edge2):
-    if edge1.verts[0].index == edge2.verts[0].index:
-        axis1 = -edge1.y
-        axis2 = edge2.y
-    elif edge1.verts[1].index == edge2.verts[1].index:
-        axis1 = edge1.y
-        axis2 = -edge2.y
-    elif edge1.verts[0].index == edge2.verts[1].index:
-        axis1 = -edge1.y
-        axis2 = -edge2.y
-    elif edge1.verts[1].index == edge2.verts[0].index:
-        axis1 = edge1.y
-        axis2 = edge2.y
-    else:
-        raise ValueError("edges not connected")
-    # Both axis1 and axis2 are unit vectors, so this will produce a vector
-    # bisects the two, so long as they are not 180 degrees apart (in which
-    # there are infinite solutions).
-    return (axis1 + axis2).normalized()
-
-
-def build_edge_frames(edges):
-    edge_set = set(edges)
-    while edge_set:
-        edge_queue = [edge_set.pop()]
-        edge_queue[0].set_frame(edge_queue[0].find_edge_frame(edges))
-        while edge_queue:
-            current_edge = edge_queue.pop()
-            for i in (0, 1):
-                for e in current_edge.verts[i].edges:
-                    edge = edges[e]
-                    if edge.x is not None:  # edge already processed
-                        continue
-                    edge_set.remove(edge)
-                    edge_queue.append(edge)
-                    edge.calc_frame(current_edge)
-
-
-def make_manifold_struts(truss_obj, od, segments):
-    bpy.context.view_layer.objects.active = truss_obj
-    bpy.ops.object.editmode_toggle()
-    truss_mesh = bmesh.from_edit_mesh(truss_obj.data).copy()
-    bpy.ops.object.editmode_toggle()
-    edges = [None] * len(truss_mesh.edges)
-    for i, e in enumerate(truss_mesh.edges):
-        edges[i] = SEdge(truss_mesh, e)
-    build_edge_frames(edges)
-    verts = []
-    faces = []
-    for e, edge in enumerate(edges):
-        # v, f = make_debug_strut(truss_mesh, e, edge, od)
-        edge.calc_vert_planes(edges)
-        v, f = make_clipped_cylinder(truss_mesh, e, edge, od)
-        verts += v
-        faces += f
-    return verts, faces
-
-
-def make_simple_struts(truss_mesh, ind, od, segments, solid, loops):
-    vps = 2
-    if solid:
-        vps *= 2
-    if loops:
-        vps *= 2
-    fps = vps
-    if not solid:
-        fps -= 1
-
-    verts = [None] * len(truss_mesh.edges) * segments * vps
-    faces = [None] * len(truss_mesh.edges) * segments * fps
-    vbase = 0
-    fbase = 0
-
-    for e in truss_mesh.edges:
-        v1 = truss_mesh.vertices[e.vertices[0]]
-        v2 = truss_mesh.vertices[e.vertices[1]]
-        v, f = make_strut(v1.co, v2.co, ind, od, segments, solid, loops)
-        for fv in f:
-            for i in range(len(fv)):
-                fv[i] += vbase
-        for i in range(len(v)):
-            verts[vbase + i] = v[i]
-        for i in range(len(f)):
-            faces[fbase + i] = f[i]
-        # if not base % 12800:
-        #    print (base * 100 / len(verts))
-        vbase += vps * segments
-        fbase += fps * segments
-
-    return verts, faces
-
-
-def create_struts(self, context, ind, od, segments, solid, loops, manifold):
-    build_cossin(segments)
-
-    for truss_obj in bpy.context.scene.objects:
-        if not truss_obj.select_get():
-            continue
-        truss_obj.select_set(False)
-        truss_mesh = truss_obj.to_mesh(context.scene, True, 'PREVIEW')
-        if not truss_mesh.edges:
-            continue
-        if manifold:
-            verts, faces = make_manifold_struts(truss_obj, od, segments)
-        else:
-            verts, faces = make_simple_struts(truss_mesh, ind, od, segments,
-                                              solid, loops)
-        mesh = bpy.data.meshes.new("Struts")
-        mesh.from_pydata(verts, [], faces)
-        obj = bpy.data.objects.new("Struts", mesh)
-        bpy.context.collection.objects.link(obj)
-        obj.select_set(True)
-        obj.location = truss_obj.location
-        bpy.context.view_layer.objects.active = obj
-        mesh.update()
-
-
-class Struts(Operator):
-    bl_idname = "mesh.generate_struts"
-    bl_label = "Struts"
-    bl_description = ("Add one or more struts meshes based on selected truss meshes \n"
-                      "Note: can get very high poly\n"
-                      "Needs an existing Active Mesh Object")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    ind: FloatProperty(
-            name="Inside Diameter",
-            description="Diameter of inner surface",
-            min=0.0, soft_min=0.0,
-            max=100, soft_max=100,
-            default=0.04
-            )
-    od: FloatProperty(
-            name="Outside Diameter",
-            description="Diameter of outer surface",
-            min=0.001, soft_min=0.001,
-            max=100, soft_max=100,
-            default=0.05
-            )
-    manifold: BoolProperty(
-            name="Manifold",
-            description="Connect struts to form a single solid",
-            default=False
-            )
-    solid: BoolProperty(
-            name="Solid",
-            description="Create inner surface",
-            default=False
-            )
-    loops: BoolProperty(
-            name="Loops",
-            description="Create sub-surf friendly loops",
-            default=False
-            )
-    segments: IntProperty(
-            name="Segments",
-            description="Number of segments around strut",
-            min=3, soft_min=3,
-            max=64, soft_max=64,
-            default=12
-            )
-
-    def draw(self, context):
-        layout = self.layout
-
-        col = layout.column(align=True)
-        col.prop(self, "ind")
-        col.prop(self, "od")
-        col.prop(self, "segments")
-        col.separator()
-
-        col.prop(self, "manifold")
-        col.prop(self, "solid")
-        col.prop(self, "loops")
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return obj is not None and obj.type == "MESH"
-
-    def execute(self, context):
-        keywords = self.as_keywords()
-
-        try:
-            create_struts(self, context, **keywords)
-
-            return {"FINISHED"}
-
-        except Exception as e:
-            self.report({"WARNING"},
-                        "Make Struts could not be performed. Operation Cancelled")
-            print("\n[mesh.generate_struts]\n{}".format(e))
-            return {"CANCELLED"}
-
-
-def register():
-    bpy.utils.register_module(__name__)
-
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/mesh_easylattice.py b/add_advanced_objects_menu/mesh_easylattice.py
deleted file mode 100644 (file)
index a1e4f70..0000000
+++ /dev/null
@@ -1,361 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-bl_info = {
-    "name": "Easy Lattice Object",
-    "author": "Kursad Karatas",
-    "version": (0, 6, 0),
-    "blender": (2, 66, 0),
-    "location": "View3D > Easy Lattice",
-    "description": "Create a lattice for shape editing",
-    "warning": "",
-    "wiki_url": "https://wiki.blender.org/index.php/Easy_Lattice_Editing_Addon",
-    "tracker_url": "https://bitbucket.org/kursad/blender_addons_easylattice/src",
-    "category": "Mesh",
-}
-
-
-import bpy
-from mathutils import (
-    Matrix,
-    Vector,
-)
-from bpy.types import Operator
-from bpy.props import (
-    EnumProperty,
-    FloatProperty,
-    IntProperty,
-)
-
-
-def createLattice(context, obj, props):
-    # Create lattice and object
-    lat = bpy.data.lattices.new('EasyLattice')
-    ob = bpy.data.objects.new('EasyLattice', lat)
-
-    # Take into consideration any selected vertices (default: all vertices)
-    selectedVertices = createVertexGroup(obj)
-
-    size, pos = findBBox(obj, selectedVertices)
-    loc, rot = getTransformations(obj)
-
-    # the position comes from the bbox
-    ob.location = pos
-
-    # the size from bbox * the incoming scale factor
-    ob.scale = size * props[3]
-
-    # the rotation comes from the combined obj world
-    # matrix which was converted to euler pairs
-    ob.rotation_euler = buildRot_World(obj)
-    ob.show_in_front = True
-
-    # Link object to scene
-    scn = context.scene
-
-    # Take care of the local view
-    base = scn.objects.link(ob)
-    scn.objects.active = ob
-
-    v3d = None
-    if context.space_data and context.space_data.type == 'VIEW_3D':
-        v3d = context.space_data
-
-    if v3d and v3d.local_view:
-        base.layers_from_view(v3d)
-
-    scn.update()
-
-    # Set lattice attributes
-    lat.points_u = props[0]
-    lat.points_v = props[1]
-    lat.points_w = props[2]
-
-    lat.interpolation_type_u = props[4]
-    lat.interpolation_type_v = props[4]
-    lat.interpolation_type_w = props[4]
-
-    lat.use_outside = False
-
-    return ob
-
-
-def createVertexGroup(obj):
-    vertices = obj.data.vertices
-    selverts = []
-
-    if obj.mode == "EDIT":
-        bpy.ops.object.editmode_toggle()
-
-    group = obj.vertex_groups.new(name="easy_lattice_group")
-
-    for vert in vertices:
-        if vert.select is True:
-            selverts.append(vert)
-            group.add([vert.index], 1.0, "REPLACE")
-
-    # Default: use all vertices
-    if not selverts:
-        for vert in vertices:
-            selverts.append(vert)
-            group.add([vert.index], 1.0, "REPLACE")
-
-    return selverts
-
-
-def getTransformations(obj):
-    rot = obj.rotation_euler
-    loc = obj.location
-
-    return [loc, rot]
-
-
-def findBBox(obj, selvertsarray):
-
-    mat = buildTrnScl_WorldMat(obj)
-    mat_world = obj.matrix_world
-
-    minx, miny, minz = selvertsarray[0].co
-    maxx, maxy, maxz = selvertsarray[0].co
-
-    c = 1
-
-    for c in range(len(selvertsarray)):
-        co = selvertsarray[c].co
-
-        if co.x < minx:
-            minx = co.x
-        if co.y < miny:
-            miny = co.y
-        if co.z < minz:
-            minz = co.z
-
-        if co.x > maxx:
-            maxx = co.x
-        if co.y > maxy:
-            maxy = co.y
-        if co.z > maxz:
-            maxz = co.z
-        c += 1
-
-    minpoint = Vector((minx, miny, minz))
-    maxpoint = Vector((maxx, maxy, maxz))
-
-    # The middle position has to be calculated based on the real world matrix
-    pos = ((minpoint + maxpoint) / 2)
-
-    minpoint = mat * minpoint    # Calculate only based on loc/scale
-    maxpoint = mat * maxpoint    # Calculate only based on loc/scale
-    pos = mat_world * pos        # the middle position has to be calculated based on the real world matrix
-
-    size = maxpoint - minpoint
-    size = Vector((max(0.1, abs(size.x)), max(0.1, abs(size.y)), max(0.1, abs(size.z)))) # Prevent zero size dimensions
-
-    return [size, pos]
-
-
-def buildTrnSclMat(obj):
-    # This function builds a local matrix that encodes translation
-    # and scale and it leaves out the rotation matrix
-    # The rotation is applied at object level if there is any
-    mat_trans = Matrix.Translation(obj.location)
-    mat_scale = Matrix.Scale(obj.scale[0], 4, (1, 0, 0))
-    mat_scale *= Matrix.Scale(obj.scale[1], 4, (0, 1, 0))
-    mat_scale *= Matrix.Scale(obj.scale[2], 4, (0, 0, 1))
-
-    mat_final = mat_trans * mat_scale
-
-    return mat_final
-
-
-def buildTrnScl_WorldMat(obj):
-    # This function builds a real world matrix that encodes translation
-    # and scale and it leaves out the rotation matrix
-    # The rotation is applied at object level if there is any
-    loc, rot, scl = obj.matrix_world.decompose()
-    mat_trans = Matrix.Translation(loc)
-
-    mat_scale = Matrix.Scale(scl[0], 4, (1, 0, 0))
-    mat_scale *= Matrix.Scale(scl[1], 4, (0, 1, 0))
-    mat_scale *= Matrix.Scale(scl[2], 4, (0, 0, 1))
-
-    mat_final = mat_trans * mat_scale
-
-    return mat_final
-
-
-# Feature use
-def buildRot_WorldMat(obj):
-    # This function builds a real world matrix that encodes rotation
-    # and it leaves out translation and scale matrices
-    loc, rot, scl = obj.matrix_world.decompose()
-    rot = rot.to_euler()
-
-    mat_rot = Matrix.Rotation(rot[0], 4, 'X')
-    mat_rot *= Matrix.Rotation(rot[1], 4, 'Z')
-    mat_rot *= Matrix.Rotation(rot[2], 4, 'Y')
-    return mat_rot
-
-
-def buildTrn_WorldMat(obj):
-    # This function builds a real world matrix that encodes translation
-    # and scale and it leaves out the rotation matrix
-    # The rotation is applied at object level if there is any
-    loc, rot, scl = obj.matrix_world.decompose()
-    mat_trans = Matrix.Translation(loc)
-
-    return mat_trans
-
-
-def buildScl_WorldMat(obj):
-    # This function builds a real world matrix that encodes translation
-    # and scale and it leaves out the rotation matrix
-    # The rotation is applied at object level if there is any
-    loc, rot, scl = obj.matrix_world.decompose()
-
-    mat_scale = Matrix.Scale(scl[0], 4, (1, 0, 0))
-    mat_scale *= Matrix.Scale(scl[1], 4, (0, 1, 0))
-    mat_scale *= Matrix.Scale(scl[2], 4, (0, 0, 1))
-
-    return mat_scale
-
-
-def buildRot_World(obj):
-    # This function builds a real world rotation values
-    loc, rot, scl = obj.matrix_world.decompose()
-    rot = rot.to_euler()
-
-    return rot
-
-
-def main(context, lat_props):
-    obj = context.object
-
-    if obj.type == "MESH":
-        lat = createLattice(context, obj, lat_props)
-
-        modif = obj.modifiers.new("EasyLattice", "LATTICE")
-        modif.object = lat
-        modif.vertex_group = "easy_lattice_group"
-
-        bpy.ops.object.select_all(action='DESELECT')
-        bpy.ops.object.select_pattern(pattern=lat.name, extend=False)
-        context.view_layer.objects.active = lat
-
-        context.view_layer.update()
-
-    return
-
-
-class EasyLattice(Operator):
-    bl_idname = "object.easy_lattice"
-    bl_label = "Easy Lattice Creator"
-    bl_description = ("Create a Lattice modifier ready to edit\n"
-                      "Needs an existing Active Mesh Object\n")
-
-    lat_u: IntProperty(
-            name="Lattice u",
-            description="Points in u direction",
-            default=3
-            )
-    lat_v: IntProperty(
-            name="Lattice v",
-            description="Points in v direction",
-            default=3
-            )
-    lat_w: IntProperty(
-            name="Lattice w",
-            description="Points in w direction",
-            default=3
-            )
-    lat_scale_factor: FloatProperty(
-            name="Lattice scale factor",
-            description="Adjustment to the lattice scale",
-            default=1,
-            min=0.1,
-            step=1,
-            precision=2
-            )
-    lat_types = (('KEY_LINEAR', "Linear", "Linear Interpolation type"),
-                 ('KEY_CARDINAL', "Cardinal", "Cardinal Interpolation type"),
-                 ('KEY_CATMULL_ROM', "Catmull-Rom", "Catmull-Rom Interpolation type"),
-                 ('KEY_BSPLINE', "BSpline", "Key BSpline Interpolation Type")
-                )
-    lat_type: EnumProperty(
-            name="Lattice Type",
-            description="Choose Lattice Type",
-            items=lat_types,
-            default='KEY_BSPLINE'
-            )
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return obj is not None and obj.type == "MESH"
-
-    def draw(self, context):
-        layout = self.layout
-
-        col = layout.column(align=True)
-        col.prop(self, "lat_u")
-        col.prop(self, "lat_v")
-        col.prop(self, "lat_w")
-
-        layout.prop(self, "lat_scale_factor")
-
-        layout.prop(self, "lat_type")
-
-    def execute(self, context):
-        lat_u = self.lat_u
-        lat_v = self.lat_v
-        lat_w = self.lat_w
-
-        lat_scale_factor = self.lat_scale_factor
-
-        # enum property no need to complicate things
-        lat_type = self.lat_type
-        # XXX, should use keyword args
-        lat_props = [lat_u, lat_v, lat_w, lat_scale_factor, lat_type]
-        try:
-            main(context, lat_props)
-
-        except Exception as ex:
-            print("\n[Add Advanced Objects]\nOperator:object.easy_lattice\n{}\n".format(ex))
-            self.report(
-                {'WARNING'},
-                "Easy Lattice Creator could not be completed (See Console for more info)"
-            )
-            return {"CANCELLED"}
-
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-
-def register():
-    bpy.utils.register_class(EasyLattice)
-
-
-def unregister():
-    bpy.utils.unregister_class(EasyLattice)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/object_add_chain.py b/add_advanced_objects_menu/object_add_chain.py
deleted file mode 100644 (file)
index f02a125..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-bl_info = {
-    "name": "Add Chain",
-    "author": "Brian Hinton (Nichod)",
-    "version": (0, 1, 2),
-    "blender": (2, 71, 0),
-    "location": "Toolshelf > Create Tab",
-    "description": "Adds Chain with curve guide for easy creation",
-    "warning": "",
-    "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
-                "Scripts/Object/Add_Chain",
-    "category": "Object",
-}
-
-import bpy
-from bpy.types import Operator
-
-
-def Add_Chain():
-    # Adds Empty to scene
-    bpy.ops.object.add(
-            type='EMPTY',
-            align='WORLD',
-            enter_editmode=False,
-            location=(0, 0, 0),
-            rotation=(0, 0, 0),
-            )
-
-    # Changes name of Empty to rot_link adds variable emp
-    emp = bpy.context.object
-    emp.name = "rot_link"
-
-    # Rotate emp ~ 90 degrees
-    emp.rotation_euler = [1.570796, 0, 0]
-
-    # Adds Curve Path to scene
-    bpy.ops.curve.primitive_nurbs_path_add(
-            align='WORLD',
-            enter_editmode=False,
-            location=(0, 0, 0),
-            rotation=(0, 0, 0),
-            )
-
-    # Change Curve name to deform adds variable curv
-    curv = bpy.context.object
-    curv.name = "deform"
-
-    # Inserts Torus primitive
-    bpy.ops.mesh.primitive_torus_add(
-            major_radius=1,
-            minor_radius=0.25,
-            major_segments=12,
-            minor_segments=4,
-            abso_major_rad=1,
-            abso_minor_rad=0.5,
-            )
-
-    # Positions Torus primitive to center of scene
-    bpy.context.active_object.location = 0.0, 0.0, 0.0
-
-    # Resetting Torus rotation in case of 'Align to view' option enabled
-    bpy.context.active_object.rotation_euler = 0.0, 0.0, 0.0
-
-    # Changes Torus name to chain adds variable tor
-    tor = bpy.context.object
-    tor.name = "chain"
-
-    # Adds Array Modifier to tor
-    bpy.ops.object.modifier_add(type='ARRAY')
-
-    # Adds subsurf modifier tor
-    bpy.ops.object.modifier_add(type='SUBSURF')
-
-    # Smooths tor
-    bpy.ops.object.shade_smooth()
-
-    # Select curv
-    sce = bpy.context.scene
-    sce.objects.active = curv
-
-    # Toggle into editmode
-    bpy.ops.object.editmode_toggle()
-
-    # TODO, may be better to move objects directly
-    # Translate curve object
-    bpy.ops.transform.translate(
-            value=(2, 0, 0),
-            constraint_axis=(True, False, False),
-            orient_type='GLOBAL',
-            mirror=False,
-            proportional='DISABLED',
-            proportional_edit_falloff='SMOOTH',
-            proportional_size=1,
-            snap=False,
-            snap_target='CLOSEST',
-            snap_point=(0, 0, 0),
-            snap_align=False,
-            snap_normal=(0, 0, 0),
-            release_confirm=False,
-            )
-
-    # Toggle into objectmode
-    bpy.ops.object.editmode_toggle()
-
-    # Select tor or chain
-    sce.objects.active = tor
-
-    # Selects Array Modifier for editing
-    array = tor.modifiers['Array']
-
-    # Change Array Modifier Parameters
-    array.fit_type = 'FIT_CURVE'
-    array.curve = curv
-    array.offset_object = emp
-    array.use_object_offset = True
-    array.relative_offset_displace = 0.549, 0.0, 0.0
-
-    # Add curve modifier
-    bpy.ops.object.modifier_add(type='CURVE')
-
-    # Selects Curve Modifier for editing
-    cur = tor.modifiers['Curve']
-
-    # Change Curve Modifier Parameters
-    cur.object = curv
-
-
-class AddChain(Operator):
-    bl_idname = "mesh.primitive_chain_add"
-    bl_label = "Add Chain"
-    bl_description = ("Create a Chain segment with helper objects controlling modifiers:\n"
-                      "1) A Curve Modifier Object (deform) for the length and shape,\n"
-                      "Edit the Path to extend Chain Length\n"
-                      "2) An Empty (rot_link) as an Array Offset for rotation")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self, context):
-        try:
-            Add_Chain()
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "mesh.primitive_chain_add\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(AddChain)
-
-
-def unregister():
-    bpy.utils.unregister_class(AddChain)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/oscurart_chain_maker.py b/add_advanced_objects_menu/oscurart_chain_maker.py
deleted file mode 100644 (file)
index a553ae4..0000000
+++ /dev/null
@@ -1,288 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# TODO: find English versions of created object names
-
-bl_info = {
-    "name": "Oscurart Chain Maker",
-    "author": "Oscurart",
-    "version": (1, 1),
-    "blender": (2, 56, 0),
-    "location": "Add > Mesh > Oscurart Chain",
-    "description": "Create chain links from armatures",
-    "warning": "",
-    "wiki_url": "oscurart.blogspot.com",
-    "category": "Object"}
-
-
-import bpy
-from bpy.props import (
-        BoolProperty,
-        FloatProperty,
-        )
-from bpy.types import Operator
-
-
-def makeChain(self, context, mult, curverig):
-
-    if not context.active_object.type == 'ARMATURE':
-        self.report({'WARNING'}, "Active Object must be an Armature")
-        return False
-
-    bpy.ops.object.mode_set(mode='OBJECT')
-    VAR_SWITCH = abs(1)
-    ARMATURE = bpy.context.active_object
-
-    def creahuesocero(hueso):
-        # create data to link
-        mesh = bpy.data.meshes.new("objectData" + str(hueso.name))
-        object = bpy.data.objects.new("HardLink" + str(hueso.name), mesh)
-        mesh.from_pydata(
-            [(-0.04986128956079483, -0.6918092370033264, -0.17846597731113434),
-             (-0.04986128956079483, -0.6918091773986816, 0.17846640944480896),
-             (-0.049861326813697815, -0.154555082321167, 0.17846627533435822),
-             (-0.049861326813697815, -0.15455523133277893, -0.17846614122390747),
-             (-0.04986133798956871, -0.03475356101989746, 0.25805795192718506),
-             (-0.04986133798956871, -0.03475397825241089, -0.25805795192718506),
-             (-0.049861278384923935, -0.8116106986999512, -0.2580576539039612),
-             (-0.049861278384923935, -0.8116104602813721, 0.25805822014808655),
-             (-0.04986128211021423, -0.7692053318023682, 2.6668965347198537e-07),
-             (-0.04986127093434334, -0.923523485660553, 2.7834033744511544e-07),
-             (-0.04986133426427841, -0.0771591067314148, 3.5627678585115063e-08),
-             (-0.04986134544014931, 0.0771591067314148, -3.5627678585115063e-08),
-             (0.04986133798956871, -0.03475397825241089, -0.25805795192718506),
-             (0.04986133053898811, 0.0771591067314148, -3.5627678585115063e-08),
-             (0.04986133798956871, -0.03475356101989746, 0.25805795192718506),
-             (0.04986134544014931, -0.15455523133277893, -0.17846614122390747),
-             (0.04986134544014931, -0.0771591067314148, 3.5627678585115063e-08),
-             (0.04986134544014931, -0.154555082321167, 0.17846627533435822),
-             (0.049861397594213486, -0.8116106986999512, -0.2580576539039612),
-             (0.04986140504479408, -0.923523485660553, 2.7834033744511544e-07),
-             (0.049861397594213486, -0.8116104602813721, 0.25805822014808655),
-             (0.04986139014363289, -0.6918091773986816, 0.17846640944480896),
-             (0.04986139014363289, -0.7692053318023682, 2.6668965347198537e-07),
-             (0.04986139014363289, -0.6918092370033264, -0.17846597731113434)],
-            [(1, 2), (0, 3), (3, 5), (2, 4), (0, 6), (5, 6), (1, 7), (4, 7), (0, 8), (1, 8),
-            (7, 9), (6, 9), (8, 9), (2, 10), (3, 10), (4, 11), (5, 11), (10, 11), (5, 12),
-            (12, 13), (11, 13), (13, 14), (4, 14), (10, 16), (15, 16), (3, 15), (2, 17),
-            (16, 17), (9, 19), (18, 19), (6, 18), (7, 20), (19, 20), (8, 22), (21, 22),
-            (1, 21), (0, 23), (22, 23), (14, 20), (12, 18), (15, 23), (17, 21), (12, 15),
-            (13, 16), (14, 17), (20, 21), (19, 22), (18, 23)],
-            [(6, 0, 3, 5), (1, 7, 4, 2), (0, 6, 9, 8), (8, 9, 7, 1), (2, 4, 11, 10), (10, 11, 5, 3),
-            (11, 13, 12, 5), (4, 14, 13, 11), (3, 15, 16, 10), (10, 16, 17, 2), (6, 18, 19, 9),
-            (9, 19, 20, 7), (1, 21, 22, 8), (23, 0, 8, 22), (7, 20, 14, 4), (5, 12, 18, 6),
-            (0, 23, 15, 3), (2, 17, 21, 1), (16, 15, 12, 13), (17, 16, 13, 14), (22, 21, 20, 19),
-            (23, 22, 19, 18), (21, 17, 14, 20), (15, 23, 18, 12)]
-            )
-        mesh.validate()
-        bpy.context.collection.objects.link(object)
-        # scale to the bone
-        bpy.data.objects["HardLink" + str(hueso.name)].scale = (hueso.length * mult,
-                                                                hueso.length * mult,
-                                                                hueso.length * mult)
-        # Parent Objects
-        bpy.data.objects["HardLink" + str(hueso.name)].parent = ARMATURE
-        bpy.data.objects["HardLink" + str(hueso.name)].parent_type = 'BONE'
-        bpy.data.objects["HardLink" + str(hueso.name)].parent_bone = hueso.name
-
-    def creahuesonoventa(hueso):
-        # create data to link
-        mesh = bpy.data.meshes.new("objectData" + str(hueso.name))
-        object = bpy.data.objects.new("NewLink" + str(hueso.name), mesh)
-        mesh.from_pydata(
-            [(0.1784660965204239, -0.6918091773986816, -0.049861203879117966),
-            (-0.1784662902355194, -0.6918091773986816, -0.04986126348376274),
-            (-0.17846627533435822, -0.1545550525188446, -0.04986134544014931),
-            (0.17846617102622986, -0.15455520153045654, -0.04986128583550453),
-            (-0.25805795192718506, -0.03475359082221985, -0.049861375242471695),
-            (0.25805795192718506, -0.034753888845443726, -0.04986129328608513),
-            (0.2580578327178955, -0.8116105794906616, -0.04986117407679558),
-            (-0.2580580413341522, -0.8116105198860168, -0.049861256033182144),
-            (-9.672299938756623e-08, -0.7692052721977234, -0.04986122250556946),
-            (-8.99775329799013e-08, -0.923523485660553, -0.04986120015382767),
-            (-7.764004550381287e-09, -0.07715904712677002, -0.049861326813697815),
-            (4.509517737005808e-08, 0.0771591067314148, -0.049861349165439606),
-            (0.25805795192718506, -0.034753888845443726, 0.049861375242471695),
-            (-2.2038317837314025e-08, 0.0771591067314148, 0.049861326813697815),
-            (-0.25805795192718506, -0.03475359082221985, 0.04986129328608513),
-            (0.17846617102622986, -0.15455520153045654, 0.04986138269305229),
-            (-1.529285498236277e-08, -0.07715907692909241, 0.049861352890729904),
-            (-0.17846627533435822, -0.1545550525188446, 0.049861323088407516),
-            (0.2580578029155731, -0.8116105794906616, 0.049861494451761246),
-            (-1.5711103173998708e-07, -0.923523485660553, 0.04986147582530975),
-            (-0.2580580711364746, -0.8116105198860168, 0.04986141249537468),
-            (-0.1784663051366806, -0.6918091773986816, 0.049861419945955276),
-            (-1.340541757599567e-07, -0.7692052721977234, 0.049861449748277664),
-            (0.1784660816192627, -0.6918091773986816, 0.04986146464943886)],
-            [(1, 2), (0, 3), (3, 5), (2, 4), (0, 6), (5, 6), (1, 7), (4, 7), (0, 8),
-            (1, 8), (7, 9), (6, 9), (8, 9), (2, 10), (3, 10), (4, 11), (5, 11), (10, 11),
-            (5, 12), (12, 13), (11, 13), (13, 14), (4, 14), (10, 16), (15, 16), (3, 15),
-            (2, 17), (16, 17), (9, 19), (18, 19), (6, 18), (7, 20), (19, 20), (8, 22),
-            (21, 22), (1, 21), (0, 23), (22, 23), (14, 20), (12, 18), (15, 23), (17, 21),
-            (12, 15), (13, 16), (14, 17), (20, 21), (19, 22), (18, 23)],
-            [(6, 0, 3, 5), (1, 7, 4, 2), (0, 6, 9, 8), (8, 9, 7, 1), (2, 4, 11, 10),
-            (10, 11, 5, 3), (11, 13, 12, 5), (4, 14, 13, 11), (3, 15, 16, 10), (10, 16, 17, 2),
-            (6, 18, 19, 9), (9, 19, 20, 7), (1, 21, 22, 8), (23, 0, 8, 22), (7, 20, 14, 4),
-            (5, 12, 18, 6), (0, 23, 15, 3), (2, 17, 21, 1), (16, 15, 12, 13), (17, 16, 13, 14),
-            (22, 21, 20, 19), (23, 22, 19, 18), (21, 17, 14, 20), (15, 23, 18, 12)]
-            )
-        mesh.validate()
-        bpy.context.collection.objects.link(object)
-        # scale to the bone
-        bpy.data.objects["NewLink" + str(hueso.name)].scale = (hueso.length * mult,
-                                                                  hueso.length * mult,
-                                                                  hueso.length * mult)
-        # Parent objects
-        bpy.data.objects["NewLink" + str(hueso.name)].parent = ARMATURE
-        bpy.data.objects["NewLink" + str(hueso.name)].parent_type = 'BONE'
-        bpy.data.objects["NewLink" + str(hueso.name)].parent_bone = hueso.name
-
-    for hueso in bpy.context.active_object.pose.bones:
-        if VAR_SWITCH == 1:
-            creahuesocero(hueso)
-        else:
-            creahuesonoventa(hueso)
-        if VAR_SWITCH == 1:
-            VAR_SWITCH = 0
-        else:
-            VAR_SWITCH = 1
-
-    # if curve rig is activated
-    if curverig is True:
-        # variables
-        LISTA_POINTC = []
-        ACTARM = bpy.context.active_object
-
-        # create data and link the object to the scene
-        crv = bpy.data.curves.new("CurvaCable", "CURVE")
-        obCable = bpy.data.objects.new("Cable", crv)
-        bpy.context.collection.objects.link(obCable)
-
-        # set the attributes
-        crv.dimensions = "3D"
-        crv.resolution_u = 10
-        crv.resolution_v = 10
-        crv.twist_mode = "MINIMUM"
-
-        # create the list of tail and head coordinates
-        LISTA_POINTC.append((
-                ACTARM.data.bones[0].head_local[0],
-                ACTARM.data.bones[0].head_local[1],
-                ACTARM.data.bones[0].head_local[2], 1
-                ))
-
-        for hueso in ACTARM.data.bones:
-            LISTA_POINTC.append((
-                    hueso.tail_local[0],
-                    hueso.tail_local[1],
-                    hueso.tail_local[2], 1
-                    ))
-
-        # create the Spline
-        spline = crv.splines.new("NURBS")
-        lencoord = len(LISTA_POINTC)
-        rango = range(lencoord)
-        spline.points.add(lencoord - 1)
-
-        for punto in rango:
-            spline.points[punto].co = LISTA_POINTC[punto]
-
-        # set the endpoint
-        bpy.data.objects['Cable'].data.splines[0].use_endpoint_u = True
-        # select the curve
-        bpy.ops.object.select_all(action='DESELECT')
-        bpy.data.objects['Cable'].select = 1
-        bpy.context.view_layer.objects.active = bpy.data.objects['Cable']
-        # switch to Edit mode
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        # create hooks
-        POINTSTEP = 0
-        for POINT in bpy.data.objects['Cable'].data.splines[0].points:
-            bpy.ops.curve.select_all(action="DESELECT")
-            bpy.data.objects['Cable'].data.splines[0].points[POINTSTEP].select = 1
-            bpy.ops.object.hook_add_newob()
-            POINTSTEP += 1
-
-        # Objects selection step
-        bpy.ops.object.mode_set(mode='OBJECT')
-        bpy.ops.object.select_all(action='DESELECT')
-        ACTARM.select = 1
-        bpy.context.view_layer.objects.active = bpy.data.objects['Armature']
-        bpy.ops.object.mode_set(mode='POSE')
-        bpy.ops.pose.select_all(action='DESELECT')
-        ACTARM.data.bones[-1].select = 1
-        ACTARM.data.bones.active = ACTARM.data.bones[-1]
-
-        # set IK Spline
-        bpy.ops.pose.constraint_add_with_targets(type='SPLINE_IK')
-        ACTARM.pose.bones[-1].constraints['Spline IK'].target = bpy.data.objects['Cable']
-        ACTARM.pose.bones[-1].constraints['Spline IK'].chain_count = 100
-        bpy.context.active_object.pose.bones[-1].constraints['Spline IK'].use_y_stretch = False
-        # return to Object mode
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-
-class MESH_OT_primitive_oscurart_chain_add(Operator):
-    bl_idname = "mesh.primitive_oscurart_chain_add"
-    bl_label = "Chain to Bones"
-    bl_description = ("Add Chain Parented to an Existing Armature\n"
-                      "The Active/Last Selected Object must be an Armature")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    curverig: BoolProperty(
-            name="Curve Rig",
-            default=False
-            )
-    multiplier: FloatProperty(
-            name="Scale",
-            default=1,
-            min=0.01, max=100.0
-            )
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return (obj is not None and obj.type == "ARMATURE")
-
-    def execute(self, context):
-        try:
-            makeChain(self, context, self.multiplier, self.curverig)
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "mesh.primitive_oscurart_chain_add\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(MESH_OT_primitive_oscurart_chain_add)
-
-
-def unregister():
-    bpy.utils.unregister_class(MESH_OT_primitive_oscurart_chain_add)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/pixelate_3d.py b/add_advanced_objects_menu/pixelate_3d.py
deleted file mode 100644 (file)
index ea7c0e8..0000000
+++ /dev/null
@@ -1,137 +0,0 @@
-# gpl author: liero
-# very simple 'pixelization' or 'voxelization' engine #
-
-bl_info = {
-    "name": "3D Pixelate",
-    "author": "liero",
-    "version": (0, 5, 3),
-    "blender": (2, 74, 0),
-    "location": "View3D > Tool Shelf",
-    "description": "Creates a 3d pixelated version of the object",
-    "category": "Object"}
-
-# Note: winmgr properties are moved to the operator
-
-
-import bpy
-from bpy.types import Operator
-from bpy.props import (
-        FloatProperty,
-        IntProperty,
-        )
-
-
-def pix(self, obj):
-    sce = bpy.context.scene
-    obj.hide = obj.hide_render = True
-    mes = obj.to_mesh(sce, True, 'RENDER')
-    mes.transform(obj.matrix_world)
-    dup = bpy.data.objects.new('dup', mes)
-    sce.objects.link(dup)
-    dup.instance_type = 'VERTS'
-    sce.objects.active = dup
-    bpy.ops.object.mode_set()
-    ver = mes.vertices
-
-    for i in range(250):
-        fin = True
-        for i in dup.data.edges:
-            d = ver[i.vertices[0]].co - ver[i.vertices[1]].co
-            if d.length > self.size:
-                ver[i.vertices[0]].select = True
-                ver[i.vertices[1]].select = True
-                fin = False
-        bpy.ops.object.editmode_toggle()
-        bpy.ops.mesh.subdivide(number_cuts=1, smoothness=self.smooth)
-        bpy.ops.mesh.select_all(action='DESELECT')
-        bpy.ops.object.editmode_toggle()
-        if fin:
-            break
-
-    for i in ver:
-        for n in range(3):
-            i.co[n] -= (.001 + i.co[n]) % self.size
-
-    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
-    bpy.ops.mesh.select_all(action='SELECT')
-    bpy.ops.mesh.remove_doubles(threshold=0.0001)
-    bpy.ops.mesh.delete(type='EDGE_FACE')
-    bpy.ops.object.mode_set()
-    sca = self.size * (100 - self.gap) * .005
-    bpy.ops.mesh.primitive_cube_add(layers=[True] + [False] * 19)
-    bpy.ops.transform.resize(value=[sca] * 3)
-    bpy.context.view_layer.objects.active = dup
-    bpy.ops.object.parent_set(type='OBJECT')
-
-
-class Pixelate(Operator):
-    bl_idname = "object.pixelate"
-    bl_label = "Pixelate Object"
-    bl_description = ("Create a 3d pixelated version of the object\n"
-                      "using a Duplivert Box around each copied vertex\n"
-                      "With high poly objects, it can take some time\n"
-                      "Needs an existing Active Mesh Object")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    size: FloatProperty(
-            name="Size",
-            min=.05, max=5,
-            default=.25,
-            description="Size of the cube / grid \n"
-                        "Small values (below 0.1) can create a high polygon count"
-            )
-    gap: IntProperty(
-            name="Gap",
-            min=0, max=90,
-            default=10,
-            subtype='PERCENTAGE',
-            description="Separation - percent of size"
-            )
-    smooth: FloatProperty(
-            name="Smooth",
-            min=0, max=1,
-            default=.0,
-            description="Smooth factor when subdividing mesh"
-            )
-
-    @classmethod
-    def poll(cls, context):
-        return (context.active_object and
-                context.active_object.type == 'MESH' and
-                context.mode == 'OBJECT')
-
-    def draw(self, context):
-        layout = self.layout
-
-        col = layout.column(align=True)
-        col.prop(self, "size")
-        col.prop(self, "gap")
-        layout.prop(self, "smooth")
-
-    def execute(self, context):
-        objeto = bpy.context.object
-        try:
-            pix(self, objeto)
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "object.pixelate\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(Pixelate)
-
-
-def unregister():
-    bpy.utils.unregister_class(Pixelate)
-
-
-if __name__ == '__main__':
-    register()
diff --git a/add_advanced_objects_menu/random_box_structure.py b/add_advanced_objects_menu/random_box_structure.py
deleted file mode 100644 (file)
index 819dd5e..0000000
+++ /dev/null
@@ -1,201 +0,0 @@
-# gpl: author Dannyboy
-
-bl_info = {
-    "name": "Add Random Box Structure",
-    "author": "Dannyboy",
-    "version": (1, 0, 1),
-    "location": "View3D > Add > Make Box Structure",
-    "description": "Fill selected box shaped meshes with randomly sized cubes",
-    "warning": "",
-    "wiki_url": "",
-    "tracker_url": "dannyboypython.blogspot.com",
-    "category": "Object"}
-
-import bpy
-import random
-from bpy.types import Operator
-from bpy.props import (
-        BoolProperty,
-        FloatProperty,
-        FloatVectorProperty,
-        IntProperty,
-        )
-
-
-class makestructure(Operator):
-    bl_idname = "object.make_structure"
-    bl_label = "Add Random Box Structure"
-    bl_description = ("Create a randomized structure made of boxes\n"
-                      "with various control parameters\n"
-                      "Needs an existing Active Mesh Object")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    dc: BoolProperty(
-            name="Delete Base Mesh(es)",
-            default=True
-            )
-    wh: BoolProperty(
-            name="Stay Within Bounds",
-            description="Keeps cubes from exceeding base mesh bounds",
-            default=True
-            )
-    uf: BoolProperty(
-            name="Uniform Cube Quantity",
-            default=False
-            )
-    qn: IntProperty(
-            name="Cube Quantity",
-            default=10,
-            min=1, max=1500
-            )
-    mn: FloatVectorProperty(
-            name="Min Scales",
-            default=(0.1, 0.1, 0.1),
-            subtype='XYZ'
-            )
-    mx: FloatVectorProperty(
-            name="Max Scales",
-            default=(2.0, 2.0, 2.0),
-            subtype='XYZ'
-            )
-    lo: FloatVectorProperty(
-            name="XYZ Offset",
-            default=(0.0, 0.0, 0.0),
-            subtype='XYZ'
-            )
-    rsd: FloatProperty(
-            name="Random Seed",
-            default=1
-            )
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return obj is not None and obj.type == "MESH" and obj.mode == "OBJECT"
-
-    def draw(self, context):
-        layout = self.layout
-
-        box = layout.box()
-        box.label(text="Options:")
-        box.prop(self, "dc")
-        box.prop(self, "wh")
-        box.prop(self, "uf")
-
-        box = layout.box()
-        box.label(text="Parameters:")
-        box.prop(self, "qn")
-        box.prop(self, "mn")
-        box.prop(self, "mx")
-        box.prop(self, "lo")
-        box.prop(self, "rsd")
-
-    def execute(self, context):
-        rsdchange = self.rsd
-        oblst = []
-        uvyes = 0
-        bpy.ops.collection.create(name='Cubagrouper')
-        bpy.ops.collection.objects_remove()
-
-        for ob in bpy.context.selected_objects:
-            oblst.append(ob)
-
-        for obj in oblst:
-            bpy.ops.object.select_pattern(pattern=obj.name)  # Select base mesh
-            bpy.context.view_layer.objects.active = obj
-            if obj.data.uv_layers[:] != []:
-                uvyes = 1
-            else:
-                uvyes = 0
-            bpy.ops.object.collection_link(group='Cubagrouper')
-            dim = obj.dimensions
-            rot = obj.rotation_euler
-            if self.uf is True:
-                area = dim.x * dim.y * dim.z
-            else:
-                area = 75
-
-            for cube in range(round((area / 75) * self.qn)):
-                random.seed(rsdchange)
-                pmn = self.mn  # Proxy values
-                pmx = self.mx
-                if self.wh is True:
-                    if dim.x < pmx.x:  # Keeping things from exceeding proper size
-                        pmx.x = dim.x
-                    if dim.y < pmx.y:
-                        pmx.y = dim.y
-                    if dim.z < pmx.z:
-                        pmx.z = dim.z
-                if 0.0 > pmn.x:  # Keeping things from going under zero
-                    pmn.x = 0.0
-                if 0.0 > pmn.y:
-                    pmn.y = 0.0
-                if 0.0 > pmn.z:
-                    pmn.z = 0.0
-                sx = (random.random() * (pmx.x - pmn.x)) + pmn.x  # Just changed self.mx and .mn to pmx.
-                sy = (random.random() * (pmx.y - pmn.y)) + pmn.y
-                sz = (random.random() * (pmx.z - pmn.z)) + pmn.z
-                if self.wh is True:  # This keeps the cubes within the base mesh
-                    ex = (random.random() * (dim.x - sx)) - ((dim.x - sx) / 2) + obj.location.x
-                    wy = (random.random() * (dim.y - sy)) - ((dim.y - sy) / 2) + obj.location.y
-                    ze = (random.random() * (dim.z - sz)) - ((dim.z - sz) / 2) + obj.location.z
-                elif self.wh is False:
-                    ex = (random.random() * dim.x) - (dim.x / 2) + obj.location.x
-                    wy = (random.random() * dim.y) - (dim.y / 2) + obj.location.y
-                    ze = (random.random() * dim.z) - (dim.z / 2) + obj.location.z
-                bpy.ops.mesh.primitive_cube_add(
-                            radius=0.5, location=(ex + self.lo.x, wy + self.lo.y, ze + self.lo.z)
-                            )
-                bpy.ops.object.mode_set(mode='EDIT')
-                bpy.ops.mesh.select_all(action='SELECT')
-                bpy.ops.transform.resize(
-                    value=(sx, sy, sz), constraint_axis=(True, True, True),
-                    orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                    proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=True
-                    )
-                bpy.ops.object.mode_set(mode='OBJECT')
-                select = bpy.context.object  # This is used to keep something selected for poll()
-                bpy.ops.object.collection_link(group='Cubagrouper')
-                rsdchange += 3
-            bpy.ops.object.select_grouped(type='GROUP')
-            bpy.ops.transform.rotate(
-                    value=rot[0], axis=(1, 0, 0), constraint_axis=(False, False, False),
-                    orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                    proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=True
-                    )
-            bpy.ops.transform.rotate(
-                    value=rot[1], axis=(0, 1, 0), constraint_axis=(False, False, False),
-                    orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                    proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=True
-                    )
-            bpy.ops.transform.rotate(
-                    value=rot[2], axis=(0, 0, 1), constraint_axis=(False, False, False),
-                    orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                    proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=True
-                    )
-            bpy.context.view_layer.objects.active = obj  # Again needed to avoid poll() taking me down
-            bpy.ops.object.make_links_data(type='MODIFIERS')
-            bpy.ops.object.make_links_data(type='MATERIAL')
-
-            if uvyes == 1:
-                bpy.ops.object.join_uvs()
-
-            bpy.ops.collection.objects_remove()
-            bpy.context.view_layer.objects.active = select
-
-            if self.dc is True:
-                bpy.context.collection.objects.unlink(obj)
-
-        return {'FINISHED'}
-
-
-def register():
-    bpy.utils.register_class(makestructure)
-
-
-def unregister():
-    bpy.utils.unregister_class(makestructure)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/rope_alpha.py b/add_advanced_objects_menu/rope_alpha.py
deleted file mode 100644 (file)
index 4c90ee2..0000000
+++ /dev/null
@@ -1,832 +0,0 @@
-# Copyright (c) 2012 Jorge Hernandez - Melendez
-
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  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 2
-#  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.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# TODO : prop names into English, add missing tooltips
-
-bl_info = {
-    "name": "Rope Creator",
-    "description": "Dynamic rope (with cloth) creator",
-    "author": "Jorge Hernandez - Melenedez",
-    "version": (0, 2, 2),
-    "blender": (2, 73, 0),
-    "location": "Left Toolbar > ClothRope",
-    "warning": "",
-    "wiki_url": "",
-    "category": "Add Mesh"
-}
-
-
-import bpy
-from bpy.types import Operator
-from bpy.props import (
-        BoolProperty,
-        FloatProperty,
-        IntProperty,
-        )
-
-
-def desocultar(quien):
-    if quien == "todo":
-        for ob in bpy.data.objects:
-            ob.hide = False
-    else:
-        bpy.data.objects[quien].hide = False
-
-
-def deseleccionar_todo():
-    bpy.ops.object.select_all(action='DESELECT')
-
-
-def seleccionar_todo():
-    bpy.ops.object.select_all(action='SELECT')
-
-
-def salir_de_editmode():
-    if bpy.context.mode in ["EDIT", "EDIT_MESH", "EDIT_CURVE"]:
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-
-# Clear scene:
-def reset_scene():
-    desocultar("todo")
-    # playback to the start
-    bpy.ops.screen.frame_jump(end=False)
-    try:
-        salir_de_editmode()
-    except:
-        pass
-    try:
-        area = bpy.context.area
-        # expand everything in the outliner to be able to select children
-        old_type = area.type
-        area.type = 'OUTLINER'
-        bpy.ops.outliner.expanded_toggle()
-
-        # restore the original context
-        area.type = old_type
-
-        seleccionar_todo()
-        bpy.ops.object.delete(use_global=False)
-
-    except Exception as e:
-        print("\n[rope_alpha]\nfunction: reset_scene\nError: %s" % e)
-
-
-def entrar_en_editmode():
-    if bpy.context.mode == "OBJECT":
-        bpy.ops.object.mode_set(mode='EDIT')
-
-
-def select_all_in_edit_mode(ob):
-    if ob.mode != 'EDIT':
-        entrar_en_editmode()
-    bpy.ops.mesh.select_all(action="DESELECT")
-    bpy.context.tool_settings.mesh_select_mode = (True, False, False)
-    salir_de_editmode()
-    for v in ob.data.vertices:
-        if not v.select:
-            v.select = True
-    entrar_en_editmode()
-
-
-def deselect_all_in_edit_mode(ob):
-    if ob.mode != 'EDIT':
-        entrar_en_editmode()
-    bpy.ops.mesh.select_all(action="DESELECT")
-    bpy.context.tool_settings.mesh_select_mode = (True, False, False)
-    salir_de_editmode()
-    for v in ob.data.vertices:
-        if not v.select:
-            v.select = False
-    entrar_en_editmode()
-
-
-def which_vertex_are_selected(ob):
-    for v in ob.data.vertices:
-        if v.select:
-            print(str(v.index))
-            print("Vertex " + str(v.index) + " is selected")
-
-
-def seleccionar_por_nombre(nombre):
-    scn = bpy.context.scene
-    bpy.data.objects[nombre].select_set(True)
-
-    scn.objects.active = bpy.data.objects[nombre]
-
-
-def deseleccionar_por_nombre(nombre):
-    bpy.data.objects[nombre].select_set(False)
-
-
-def crear_vertices(ob):
-    ob.data.vertices.add(1)
-    ob.data.update
-
-
-def borrar_elementos_seleccionados(tipo):
-    if tipo == "vertices":
-        bpy.ops.mesh.delete(type='VERT')
-
-
-def obtener_coords_vertex_seleccionados():
-    coordenadas_de_vertices = []
-    for ob in bpy.context.selected_objects:
-        if ob.type == 'MESH':
-            for v in ob.data.vertices:
-                if v.select:
-                    coordenadas_de_vertices.append([v.co[0], v.co[1], v.co[2]])
-            return coordenadas_de_vertices[0]
-
-
-def crear_locator(pos):
-    bpy.ops.object.empty_add(
-            type='PLAIN_AXES', radius=1, align='WORLD',
-            location=(pos[0], pos[1], pos[2]),
-            layers=(True, False, False, False, False, False, False,
-                    False, False, False, False, False, False, False,
-                    False, False, False, False, False, False)
-            )
-
-
-def extruir_vertices(longitud, cuantos_segmentos):
-    bpy.ops.mesh.extrude_region_move(
-            MESH_OT_extrude_region={"mirror": False},
-            TRANSFORM_OT_translate={
-                    "value": (longitud / cuantos_segmentos, 0, 0),
-                    "constraint_axis": (True, False, False),
-                    "orient_type": 'GLOBAL', "mirror": False,
-                    "proportional": 'DISABLED', "proportional_edit_falloff": 'SMOOTH',
-                    "proportional_size": 1, "snap": False, "snap_target": 'CLOSEST',
-                    "snap_point": (0, 0, 0), "snap_align": False, "snap_normal": (0, 0, 0),
-                    "gpencil_strokes": False, "texture_space": False,
-                    "remove_on_cancel": False, "release_confirm": False
-                    }
-            )
-
-
-def select_all_vertex_in_curve_bezier(bc):
-    for i in range(len(bc.data.splines[0].points)):
-        bc.data.splines[0].points[i].select = True
-
-
-def deselect_all_vertex_in_curve_bezier(bc):
-    for i in range(len(bc.data.splines[0].points)):
-        bc.data.splines[0].points[i].select = False
-
-
-def ocultar_relationships():
-    for area in bpy.context.screen.areas:
-        if area.type == 'VIEW_3D':
-            area.spaces[0].show_relationship_lines = False
-
-
-class ClothRope(Operator):
-    bl_idname = "clot.rope"
-    bl_label = "Rope Cloth"
-    bl_description = ("Create a new Scene with a Cloth modifier\n"
-                      "Rope Simulation with hooked Helper Objects")
-
-    ropelength: IntProperty(
-            name="Rope Length",
-            description="Length of the generated Rope",
-            default=5
-            )
-    ropesegments: IntProperty(
-            name="Rope Segments",
-            description="Number of the Rope Segments",
-            default=5
-            )
-    qcr: IntProperty(
-            name="Collision Quality",
-            description="Rope's Cloth modifier collsion quality",
-            min=1, max=20,
-            default=20
-            )
-    substeps: IntProperty(
-            name="Rope Substeps",
-            description="Rope's Cloth modifier quality",
-            min=4, max=80,
-            default=50
-            )
-    resrope: IntProperty(
-            name="Rope Resolution",
-            description="Rope's Bevel resolution",
-            default=5
-            )
-    radiusrope: FloatProperty(
-            name="Radius",
-            description="Rope's Radius",
-            min=0.04, max=1,
-            default=0.04
-            )
-    hide_emptys: BoolProperty(
-            name="Hide Empties",
-            description="Hide Helper Objects",
-            default=False
-            )
-
-    def execute(self, context):
-        # add a new scene
-        bpy.ops.scene.new(type="NEW")
-        scene = bpy.context.scene
-        scene.name = "Test Rope"
-        seleccionar_todo()
-        longitud = self.ropelength
-
-        # For the middle to have x segments between the first and
-        # last point, must add 1 to the quantity:
-        cuantos_segmentos = self.ropesegments + 1
-        calidad_de_colision = self.qcr
-        substeps = self.substeps
-        deseleccionar_todo()
-        # collect the possible empties that already exist in the data
-        empties_prev = [obj.name for obj in bpy.data.objects if obj.type == "EMPTY"]
-
-        # create an empty that will be the parent of everything
-        bpy.ops.object.empty_add(
-                type='SPHERE', radius=1, align='WORLD', location=(0, 0, 0),
-                layers=(True, False, False, False, False, False, False, False,
-                        False, False, False, False, False, False, False, False,
-                        False, False, False, False)
-                )
-        ob = bpy.context.selected_objects[0]
-        ob.name = "Rope"
-        # .001 and friends
-        rope_name = ob.name
-        deseleccionar_todo()
-
-        # create a plane and delete it
-        bpy.ops.mesh.primitive_plane_add(
-                radius=1, align='WORLD', enter_editmode=False, location=(0, 0, 0),
-                layers=(True, False, False, False, False, False, False, False, False,
-                        False, False, False, False, False, False, False, False,
-                        False, False, False)
-                )
-        ob = bpy.context.selected_objects[0]
-        # rename:
-        ob.name = "cuerda"
-        # .001 and friends
-        cuerda_1_name = ob.name
-
-        entrar_en_editmode()  # enter edit mode
-        select_all_in_edit_mode(ob)
-
-        borrar_elementos_seleccionados("vertices")
-        salir_de_editmode()  # leave edit mode
-        crear_vertices(ob)  # create a vertex
-
-        # Creating a Group for the PIN
-        # Group contains the vertices of the pin and the Group.001 contains the single main line
-        entrar_en_editmode()  # enter edit mode
-        bpy.ops.object.vertex_group_add()  # create a group
-        select_all_in_edit_mode(ob)
-        bpy.ops.object.vertex_group_assign()  # assign it
-
-        salir_de_editmode()  # leave edit mode
-        ob.vertex_groups[0].name = "Pin"
-        deseleccionar_todo()
-        seleccionar_por_nombre(cuerda_1_name)
-
-        # extrude vertices:
-        for i in range(cuantos_segmentos):
-            entrar_en_editmode()
-            extruir_vertices(longitud, cuantos_segmentos)
-            # delete the PIN group
-            bpy.ops.object.vertex_group_remove_from()
-            # get the direction to create the locator on it's position
-            pos = obtener_coords_vertex_seleccionados()
-
-            salir_de_editmode()  # leave edit mode
-            # create locator at position
-            crear_locator(pos)
-            deseleccionar_todo()
-            seleccionar_por_nombre(cuerda_1_name)
-        deseleccionar_todo()
-
-        seleccionar_por_nombre(cuerda_1_name)  # select the rope
-        entrar_en_editmode()
-
-        pos = obtener_coords_vertex_seleccionados()  # get their positions
-        salir_de_editmode()
-        # create the last locator
-        crear_locator(pos)
-        deseleccionar_todo()
-        seleccionar_por_nombre(cuerda_1_name)
-        entrar_en_editmode()  # enter edit mode
-        bpy.ops.object.vertex_group_add()  # Creating Master guide group
-        select_all_in_edit_mode(ob)
-        bpy.ops.object.vertex_group_assign()  # and assign it
-        ob.vertex_groups[1].name = "Guide_rope"
-
-        # extrude the Curve so it has a minimum thickness for collide
-        bpy.ops.mesh.extrude_region_move(
-                MESH_OT_extrude_region={"mirror": False},
-                TRANSFORM_OT_translate={
-                        "value": (0, 0.005, 0), "constraint_axis": (False, True, False),
-                        "orient_type": 'GLOBAL', "mirror": False,
-                        "proportional": 'DISABLED', "proportional_edit_falloff": 'SMOOTH',
-                        "proportional_size": 1, "snap": False, "snap_target": 'CLOSEST',
-                        "snap_point": (0, 0, 0), "snap_align": False, "snap_normal": (0, 0, 0),
-                        "gpencil_strokes": False, "texture_space": False,
-                        "remove_on_cancel": False, "release_confirm": False
-                        }
-                )
-        bpy.ops.object.vertex_group_remove_from()
-        deselect_all_in_edit_mode(ob)
-        salir_de_editmode()
-        bpy.ops.object.modifier_add(type='CLOTH')
-        bpy.context.object.modifiers["Cloth"].settings.use_pin_cloth = True
-        bpy.context.object.modifiers["Cloth"].settings.vertex_group_mass = "Pin"
-        bpy.context.object.modifiers["Cloth"].collision_settings.collision_quality = calidad_de_colision
-        bpy.context.object.modifiers["Cloth"].settings.quality = substeps
-
-        # Duplicate to convert into Curve:
-        # select the vertices that are the part of the Group.001
-        seleccionar_por_nombre(cuerda_1_name)
-        entrar_en_editmode()
-        bpy.ops.mesh.select_all(action="DESELECT")
-        bpy.context.tool_settings.mesh_select_mode = (True, False, False)
-        salir_de_editmode()
-        gi = ob.vertex_groups["Guide_rope"].index  # get group index
-
-        for v in ob.data.vertices:
-            for g in v.groups:
-                if g.group == gi:  # compare with index in VertexGroupElement
-                    v.select = True
-
-        # now we have to make a table of names of cuerdas to see which one will be new
-        cuerda_names = [obj.name for obj in bpy.data.objects if "cuerda" in obj.name]
-
-        entrar_en_editmode()
-
-        # we already have the selected guide:
-        # duplicate it:
-        bpy.ops.mesh.duplicate_move(
-                MESH_OT_duplicate={"mode": 1},
-                TRANSFORM_OT_translate={
-                        "value": (0, 0, 0), "constraint_axis": (False, False, False),
-                        "orient_type": 'GLOBAL', "mirror": False,
-                        "proportional": 'DISABLED', "proportional_edit_falloff": 'SMOOTH',
-                        "proportional_size": 1, "snap": False, "snap_target": 'CLOSEST',
-                        "snap_point": (0, 0, 0), "snap_align": False, "snap_normal": (0, 0, 0),
-                        "gpencil_strokes": False, "texture_space": False,
-                        "remove_on_cancel": False, "release_confirm": False
-                        }
-                )
-        # separate the selections:
-        bpy.ops.mesh.separate(type='SELECTED')
-        salir_de_editmode()
-        deseleccionar_todo()
-
-        cuerda_2_name = "cuerda.001"
-        test = []
-        for obj in bpy.data.objects:
-            if "cuerda" in obj.name and obj.name not in cuerda_names:
-                cuerda_2_name = obj.name
-                test.append(obj.name)
-
-        seleccionar_por_nombre(cuerda_2_name)
-
-        # from the newly created curve remove the Cloth:
-        bpy.ops.object.modifier_remove(modifier="Cloth")
-        # convert the Curve:
-        bpy.ops.object.convert(target='CURVE')
-
-        # all Empties that are not previously present
-        emptys = []
-        for eo in bpy.data.objects:
-            if eo.type == 'EMPTY' and eo.name not in empties_prev:
-                if eo.name != rope_name:
-                    emptys.append(eo)
-
-        # select and deselect:
-        bc = bpy.data.objects[cuerda_2_name]
-        n = 0
-
-        for e in emptys:
-            deseleccionar_todo()
-            seleccionar_por_nombre(e.name)
-            seleccionar_por_nombre(bc.name)
-            entrar_en_editmode()
-            deselect_all_vertex_in_curve_bezier(bc)
-            bc.data.splines[0].points[n].select = True
-            bpy.ops.object.hook_add_selob(use_bone=False)
-            salir_de_editmode()
-            n = n + 1
-
-        ob = bpy.data.objects[cuerda_1_name]
-        n = 0
-
-        for e in emptys:
-            deseleccionar_todo()
-            seleccionar_por_nombre(e.name)
-            seleccionar_por_nombre(ob.name)
-            entrar_en_editmode()
-            bpy.ops.mesh.select_all(action="DESELECT")
-            bpy.context.tool_settings.mesh_select_mode = (True, False, False)
-            salir_de_editmode()
-
-            for v in ob.data.vertices:
-                if v.select:
-                    v.select = False
-            ob.data.vertices[n].select = True
-            entrar_en_editmode()
-            bpy.ops.object.vertex_parent_set()
-
-            salir_de_editmode()
-            n = n + 1
-
-            # hide the Empties:
-            deseleccionar_todo()
-
-        # all parented to the spherical empty:
-        seleccionar_por_nombre(cuerda_2_name)
-        seleccionar_por_nombre(cuerda_1_name)
-        seleccionar_por_nombre(rope_name)
-        bpy.ops.object.parent_set(type='OBJECT', keep_transform=True)
-        deseleccionar_todo()
-
-        # do not display the relations
-        ocultar_relationships()
-        seleccionar_por_nombre(cuerda_2_name)
-
-        # curved rope settings:
-        bpy.context.object.data.fill_mode = 'FULL'
-        bpy.context.object.data.bevel_depth = self.radiusrope
-        bpy.context.object.data.bevel_resolution = self.resrope
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=350)
-
-    def draw(self, context):
-        layout = self.layout
-        box = layout.box()
-        col = box.column(align=True)
-
-        col.label(text="Rope settings:")
-        rowsub0 = col.row()
-        rowsub0.prop(self, "ropelength", text="Length")
-        rowsub0.prop(self, "ropesegments", text="Segments")
-        rowsub0.prop(self, "radiusrope", text="Radius")
-
-        col.label(text="Quality Settings:")
-        col.prop(self, "resrope", text="Resolution curve")
-        col.prop(self, "qcr", text="Quality Collision")
-        col.prop(self, "substeps", text="Substeps")
-
-
-class BallRope(Operator):
-    bl_idname = "ball.rope"
-    bl_label = "Wrecking Ball"
-    bl_description = ("Create a new Scene with a Rigid Body simulation of\n"
-                      "Wrecking Ball on a rope")
-
-    # defaults rope ball
-    ropelength2: IntProperty(
-            name="Rope Length",
-            description="Length of the Wrecking Ball rope",
-            default=10
-            )
-    ropesegments2: IntProperty(
-            name="Rope Segments",
-            description="Number of the Wrecking Ball rope segments",
-            min=0, max=999,
-            default=6
-            )
-    radiuscubes: FloatProperty(
-            name="Cube Radius",
-            description="Size of the Linked Cubes helpers",
-            default=0.5
-            )
-    radiusrope: FloatProperty(
-            name="Rope Radius",
-            description="Radius of the Rope",
-            default=0.4
-            )
-    worldsteps: IntProperty(
-            name="World Steps",
-            description="Rigid Body Solver world steps per second (update)",
-            min=60, max=1000,
-            default=250
-            )
-    solveriterations: IntProperty(
-            name="Solver Iterations",
-            description="How many times the Rigid Body Solver should run",
-            min=10, max=100,
-            default=50
-            )
-    massball: IntProperty(
-            name="Ball Mass",
-            description="Mass of the Wrecking Ball",
-            default=1
-            )
-    resrope: IntProperty(
-            name="Resolution",
-            description="Rope resolution",
-            default=4
-            )
-    grados: FloatProperty(
-            name="Degrees",
-            description="Angle of the Wrecking Ball compared to the Ground Plane",
-            default=45
-            )
-    separacion: FloatProperty(
-            name="Link Cubes Gap",
-            description="Space between the Rope's Linked Cubes",
-            default=0.1
-            )
-    hidecubes: BoolProperty(
-            name="Hide Link Cubes",
-            description="Hide helper geometry for the Rope",
-            default=False
-            )
-
-    def execute(self, context):
-        world_steps = self.worldsteps
-        solver_iterations = self.solveriterations
-        longitud = self.ropelength2
-
-        # make a + 2, so the segments will be between the two end points...
-        segmentos = self.ropesegments2 + 2
-        offset_del_suelo = 1
-        offset_del_suelo_real = (longitud / 2) + (segmentos / 2)
-        radio = self.radiuscubes
-        radiorope = self.radiusrope
-        masa = self.massball
-        resolucion = self.resrope
-        rotrope = self.grados
-        separation = self.separacion
-        hidecubeslinks = self.hidecubes
-
-        # add new scene
-        bpy.ops.scene.new(type="NEW")
-        scene = bpy.context.scene
-        scene.name = "Test Ball"
-
-        # collect the possible constraint empties that already exist in the data
-        constraint_prev = [obj.name for obj in bpy.data.objects if
-                           obj.type == "EMPTY" and "Constraint" in obj.name]
-        # floor:
-        bpy.ops.mesh.primitive_cube_add(
-                radius=1, align='WORLD', enter_editmode=False, location=(0, 0, 0),
-                layers=(True, False, False, False, False, False, False, False, False,
-                        False, False, False, False, False, False, False, False,
-                        False, False, False)
-                )
-        bpy.context.object.scale.x = 10 + longitud
-        bpy.context.object.scale.y = 10 + longitud
-        bpy.context.object.scale.z = 0.05
-        bpy.context.object.name = "groundplane"
-        # The secret agents .001, 002 etc.
-        groundplane_name = bpy.context.object.name
-
-        bpy.ops.rigidbody.objects_add(type='PASSIVE')
-
-        # create the first cube:
-        cuboslink = []
-        n = 0
-        for i in range(segmentos):
-            # if 0 start from 1
-            if i == 0:
-                i = offset_del_suelo
-            else:  # if it is not 0, add one so it doesn't step on the first one starting from 1
-                i = i + offset_del_suelo
-            separacion = longitud * 2 / segmentos  # distance between linked cubes
-            bpy.ops.mesh.primitive_cube_add(
-                    radius=1, align='WORLD', enter_editmode=False,
-                    location=(0, 0, i * separacion),
-                    layers=(True, False, False, False, False, False, False, False,
-                            False, False, False, False, False, False, False, False,
-                            False, False, False, False)
-                    )
-            bpy.ops.rigidbody.objects_add(type='ACTIVE')
-            bpy.context.object.name = "CubeLink"
-            if n != 0:
-                bpy.context.object.display_type = 'WIRE'
-                bpy.context.object.hide_render = True
-            n += 1
-            bpy.context.object.scale.z = (longitud * 2) / (segmentos * 2) - separation
-            bpy.context.object.scale.x = radio
-            bpy.context.object.scale.y = radio
-            cuboslink.append(bpy.context.object)
-
-        for i in range(len(cuboslink)):
-            deseleccionar_todo()
-            if i != len(cuboslink) - 1:
-                nombre1 = cuboslink[i]
-                nombre2 = cuboslink[i + 1]
-                seleccionar_por_nombre(nombre1.name)
-                seleccionar_por_nombre(nombre2.name)
-                bpy.ops.rigidbody.connect()
-
-        # select by name
-        constraint_new = [
-                    obj.name for obj in bpy.data.objects if
-                    obj.type == "EMPTY" and "Constraint" in obj.name and
-                    obj.name not in constraint_prev
-                    ]
-
-        for names in constraint_new:
-            seleccionar_por_nombre(names)
-
-        for c in bpy.context.selected_objects:
-            c.rigid_body_constraint.type = 'POINT'
-        deseleccionar_todo()
-
-        # create a Bezier curve:
-        bpy.ops.curve.primitive_bezier_curve_add(
-                radius=1, align='WORLD', enter_editmode=False, location=(0, 0, 0),
-                layers=(True, False, False, False, False, False, False, False, False,
-                False, False, False, False, False, False, False, False, False, False, False)
-                )
-        bpy.context.object.name = "Cuerda"
-        # Blender will automatically append the .001
-        # if it is already in data
-        real_name = bpy.context.object.name
-
-        for i in range(len(cuboslink)):
-            cubonombre = cuboslink[i].name
-            seleccionar_por_nombre(cubonombre)
-            seleccionar_por_nombre(real_name)
-            x = cuboslink[i].location[0]
-            y = cuboslink[i].location[1]
-            z = cuboslink[i].location[2]
-
-            # if it is 0 make it start from 1 as the offset from the ground...
-            if i == 0:
-                i = offset_del_suelo
-            else:  # if it is not 0, add one so it doesn't step on the first one starting from 1
-                i = i + offset_del_suelo
-
-            salir_de_editmode()
-            entrar_en_editmode()
-
-            if i == 1:
-                # select all the vertices and delete them
-                select_all_vertex_in_curve_bezier(bpy.data.objects[real_name])
-                bpy.ops.curve.delete(type='VERT')
-                # create the first vertex:
-                bpy.ops.curve.vertex_add(location=(x, y, z))
-            else:
-                # extrude the rest:
-                bpy.ops.curve.extrude_move(
-                        CURVE_OT_extrude={"mode": 'TRANSLATION'},
-                        TRANSFORM_OT_translate={
-                            "value": (0, 0, z / i),
-                            "constraint_axis": (False, False, True),
-                            "orient_type": 'GLOBAL', "mirror": False,
-                            "proportional": 'DISABLED', "proportional_edit_falloff": 'SMOOTH',
-                            "proportional_size": 1, "snap": False, "snap_target": 'CLOSEST',
-                            "snap_point": (0, 0, 0), "snap_align": False, "snap_normal": (0, 0, 0),
-                            "gpencil_strokes": False, "texture_space": False,
-                            "remove_on_cancel": False, "release_confirm": False
-                            }
-                        )
-            bpy.ops.object.hook_add_selob(use_bone=False)
-            salir_de_editmode()
-            bpy.context.object.data.bevel_resolution = resolucion
-            deseleccionar_todo()
-
-        # create a sphere ball:
-        deseleccionar_todo()
-        seleccionar_por_nombre(cuboslink[0].name)
-        entrar_en_editmode()
-        z = cuboslink[0].scale.z + longitud / 2
-        bpy.ops.view3d.snap_cursor_to_selected()
-        bpy.ops.mesh.primitive_uv_sphere_add(
-                align='WORLD', enter_editmode=False,
-                layers=(True, False, False, False, False, False, False,
-                        False, False, False, False, False, False, False,
-                        False, False, False, False, False, False)
-                )
-        bpy.ops.transform.translate(
-                value=(0, 0, -z + 2), constraint_axis=(False, False, True),
-                orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                proportional_edit_falloff='SMOOTH', proportional_size=1
-                )
-        bpy.ops.transform.resize(
-                value=(longitud / 2, longitud / 2, longitud / 2),
-                constraint_axis=(False, False, False),
-                orient_type='GLOBAL',
-                mirror=False, proportional='DISABLED',
-                proportional_edit_falloff='SMOOTH', proportional_size=1
-                )
-        deselect_all_in_edit_mode(cuboslink[0])
-        salir_de_editmode()
-        bpy.ops.object.shade_smooth()
-        bpy.context.object.rigid_body.mass = masa
-        bpy.ops.object.origin_set(type='ORIGIN_CENTER_OF_MASS')
-
-        # move it all up a bit more:
-        seleccionar_todo()
-        deseleccionar_por_nombre(groundplane_name)
-        bpy.ops.transform.translate(
-                value=(0, 0, offset_del_suelo_real),
-                constraint_axis=(False, False, True),
-                orient_type='GLOBAL', mirror=False,
-                proportional='DISABLED', proportional_edit_falloff='SMOOTH',
-                proportional_size=1
-                )
-
-        deseleccionar_todo()
-        seleccionar_por_nombre(cuboslink[-1].name)
-        bpy.ops.rigidbody.objects_add(type='PASSIVE')
-
-        bpy.context.scene.rigidbody_world.steps_per_second = world_steps
-        bpy.context.scene.rigidbody_world.solver_iterations = solver_iterations
-
-        # move everything from the top one:
-        seleccionar_por_nombre(cuboslink[-1].name)
-        bpy.ops.view3d.snap_cursor_to_selected()
-        seleccionar_todo()
-        deseleccionar_por_nombre(groundplane_name)
-        deseleccionar_por_nombre(cuboslink[-1].name)
-        bpy.context.space_data.pivot_point = 'CURSOR'
-        bpy.ops.transform.rotate(
-                value=rotrope, axis=(1, 0, 0),
-                constraint_axis=(True, False, False),
-                orient_type='GLOBAL',
-                mirror=False, proportional='DISABLED',
-                proportional_edit_falloff='SMOOTH',
-                proportional_size=1
-                )
-        bpy.context.space_data.pivot_point = 'MEDIAN_POINT'
-        deseleccionar_todo()
-
-        seleccionar_por_nombre(real_name)
-        bpy.context.object.data.fill_mode = 'FULL'
-        bpy.context.object.data.bevel_depth = radiorope
-        for ob in bpy.data.objects:
-            if ob.name != cuboslink[0].name:
-                if ob.name.find("CubeLink") >= 0:
-                    deseleccionar_todo()
-                    seleccionar_por_nombre(ob.name)
-                    if hidecubeslinks:
-                        bpy.context.object.hide = True
-        ocultar_relationships()
-        deseleccionar_todo()
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=350)
-
-    def draw(self, context):
-        layout = self.layout
-        box = layout.box()
-        col = box.column(align=True)
-
-        col.label(text="Rope settings:")
-        rowsub0 = col.row()
-        rowsub0.prop(self, "hidecubes", text="Hide Link Cubes")
-
-        rowsub1 = col.row(align=True)
-        rowsub1.prop(self, "ropelength2", text="Length")
-        rowsub1.prop(self, "ropesegments2", text="Segments")
-
-        rowsub2 = col.row(align=True)
-        rowsub2.prop(self, "radiuscubes", text="Radius Link Cubes")
-        rowsub2.prop(self, "radiusrope", text="Radius Rope")
-
-        rowsub3 = col.row(align=True)
-        rowsub3.prop(self, "grados", text="Degrees")
-        rowsub3.prop(self, "separacion", text="Separation Link Cubes")
-
-        col.label(text="Quality Settings:")
-        col.prop(self, "resrope", text="Resolution Rope")
-        col.prop(self, "massball", text="Ball Mass")
-        col.prop(self, "worldsteps", text="World Steps")
-        col.prop(self, "solveriterations", text="Solver Iterarions")
-
-
-# Register
-
-def register():
-    bpy.utils.register_module(__name__)
-
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-
-
-if __name__ == "__main__":
-    register()
diff --git a/add_advanced_objects_menu/scene_objects_bi.py b/add_advanced_objects_menu/scene_objects_bi.py
deleted file mode 100644 (file)
index f9ef53f..0000000
+++ /dev/null
@@ -1,195 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-from bpy.types import Operator
-
-
-class add_BI_scene(Operator):
-    bl_idname = "bi.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Blender Internal renderer Scene with Objects"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self, context):
-        try:
-            blend_data = context.blend_data
-            # ob = bpy.context.active_object
-
-            # add new scene
-            bpy.ops.scene.new(type="NEW")
-            scene = bpy.context.scene
-            scene.name = "scene_materials"
-
-            # render settings
-            render = scene.render
-            render.resolution_x = 1920
-            render.resolution_y = 1080
-            render.resolution_percentage = 50
-
-            # add new world
-            world = bpy.data.worlds.new("Materials_World")
-            scene.world = world
-            world.use_sky_blend = True
-            world.use_sky_paper = True
-            world.horizon_color = (0.004393, 0.02121, 0.050)
-            world.zenith_color = (0.03335, 0.227, 0.359)
-            world.light_settings.use_ambient_occlusion = True
-            world.light_settings.ao_factor = 0.25
-
-            # add camera
-            bpy.ops.object.camera_add(
-                    location=(7.48113, -6.50764, 5.34367),
-                    rotation=(1.109319, 0.010817, 0.814928)
-                    )
-            cam = bpy.context.active_object.data
-            cam.lens = 35
-            cam.display_size = 0.1
-            bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-            # add point lamp
-            bpy.ops.object.light_add(
-                    type="POINT", location=(4.07625, 1.00545, 5.90386),
-                    rotation=(0.650328, 0.055217, 1.866391)
-                    )
-            lamp1 = bpy.context.active_object.data
-            lamp1.name = "Point_Right"
-            lamp1.energy = 1.0
-            lamp1.distance = 30.0
-            lamp1.shadow_method = "RAY_SHADOW"
-            lamp1.use_sphere = True
-
-            # add point lamp2
-            bpy.ops.object.light_add(
-                    type="POINT", location=(-0.57101, -4.24586, 5.53674),
-                    rotation=(1.571, 0, 0.785)
-                    )
-            lamp2 = bpy.context.active_object.data
-            lamp2.name = "Point_Left"
-            lamp2.energy = 1.0
-            lamp2.distance = 30.0
-
-            # Add cube
-            bpy.ops.mesh.primitive_cube_add()
-            bpy.ops.object.editmode_toggle()
-            bpy.ops.mesh.subdivide(number_cuts=2)
-            bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
-            bpy.ops.object.editmode_toggle()
-
-            cube = bpy.context.active_object
-            # add new material
-            cubeMaterial = blend_data.materials.new("Cube_Material")
-            bpy.ops.object.material_slot_add()
-            cube.material_slots[0].material = cubeMaterial
-            # Diffuse
-            cubeMaterial.preview_render_type = "CUBE"
-            cubeMaterial.diffuse_color = (1.000, 0.373, 0.00)
-            cubeMaterial.diffuse_shader = 'OREN_NAYAR'
-            cubeMaterial.diffuse_intensity = 1.0
-            cubeMaterial.roughness = 0.09002
-            # Specular
-            cubeMaterial.specular_color = (1.000, 0.800, 0.136)
-            cubeMaterial.specular_shader = "PHONG"
-            cubeMaterial.specular_intensity = 1.0
-            cubeMaterial.specular_hardness = 511.0
-            # Shading
-            cubeMaterial.ambient = 1.00
-            cubeMaterial.use_cubic = False
-            # Transparency
-            cubeMaterial.use_transparency = False
-            cubeMaterial.alpha = 0
-            # Mirror
-            cubeMaterial.raytrace_mirror.use = True
-            cubeMaterial.mirror_color = (1.000, 0.793, 0.0)
-            cubeMaterial.raytrace_mirror.reflect_factor = 0.394
-            cubeMaterial.raytrace_mirror.fresnel = 2.0
-            cubeMaterial.raytrace_mirror.fresnel_factor = 1.641
-            cubeMaterial.raytrace_mirror.fade_to = "FADE_TO_SKY"
-            cubeMaterial.raytrace_mirror.gloss_anisotropic = 1.0
-            # Shadow
-            cubeMaterial.use_transparent_shadows = True
-
-            # Add a texture
-            cubetex = blend_data.textures.new("CloudTex", type='CLOUDS')
-            cubetex.noise_type = 'SOFT_NOISE'
-            cubetex.noise_scale = 0.25
-            mtex = cubeMaterial.texture_slots.add()
-            mtex.texture = cubetex
-            mtex.texture_coords = 'ORCO'
-            mtex.scale = (0.800, 0.800, 0.800)
-            mtex.use_map_mirror = True
-            mtex.mirror_factor = 0.156
-            mtex.use_map_color_diffuse = True
-            mtex.diffuse_color_factor = 0.156
-            mtex.use_map_normal = True
-            mtex.normal_factor = 0.010
-            mtex.blend_type = "ADD"
-            mtex.use_rgb_to_intensity = True
-            mtex.color = (1.000, 0.207, 0.000)
-
-            # Add monkey
-            bpy.ops.mesh.primitive_monkey_add(location=(-0.1, 0.08901, 1.505))
-            bpy.ops.transform.rotate(value=(1.15019), axis=(0, 0, 1))
-            bpy.ops.transform.rotate(value=(-0.673882), axis=(0, 1, 0))
-            bpy.ops.transform.rotate(value=-0.055, axis=(1, 0, 0))
-            bpy.ops.object.modifier_add(type='SUBSURF')
-            bpy.ops.object.shade_smooth()
-            monkey = bpy.context.active_object
-            # add new material
-            monkeyMaterial = blend_data.materials.new("Monkey_Material")
-            bpy.ops.object.material_slot_add()
-            monkey.material_slots[0].material = monkeyMaterial
-            # Material settings
-            monkeyMaterial.preview_render_type = "MONKEY"
-            monkeyMaterial.diffuse_color = (0.239, 0.288, 0.288)
-            monkeyMaterial.specular_color = (0.604, 0.465, 0.136)
-            monkeyMaterial.diffuse_shader = 'LAMBERT'
-            monkeyMaterial.diffuse_intensity = 1.0
-            monkeyMaterial.specular_intensity = 0.3
-            monkeyMaterial.ambient = 0
-            monkeyMaterial.type = 'SURFACE'
-            monkeyMaterial.use_cubic = True
-            monkeyMaterial.use_transparency = False
-            monkeyMaterial.alpha = 0
-            monkeyMaterial.use_transparent_shadows = True
-            monkeyMaterial.raytrace_mirror.use = True
-            monkeyMaterial.raytrace_mirror.reflect_factor = 0.65
-            monkeyMaterial.raytrace_mirror.fade_to = "FADE_TO_MATERIAL"
-
-            # Add plane
-            bpy.ops.mesh.primitive_plane_add(
-                            radius=50, align='WORLD', enter_editmode=False, location=(0, 0, -1)
-                            )
-            bpy.ops.object.editmode_toggle()
-            bpy.ops.transform.rotate(
-                    value=-0.8, axis=(0, 0, 1), constraint_axis=(False, False, True),
-                    orient_type='GLOBAL', mirror=False, proportional='DISABLED',
-                    proportional_edit_falloff='SMOOTH', proportional_size=1
-                    )
-            bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
-            bpy.ops.object.editmode_toggle()
-            plane = bpy.context.active_object
-            # add new material
-            planeMaterial = blend_data.materials.new("Plane_Material")
-            bpy.ops.object.material_slot_add()
-            plane.material_slots[0].material = planeMaterial
-            # Material settings
-            planeMaterial.preview_render_type = "CUBE"
-            planeMaterial.diffuse_color = (0.2, 0.2, 0.2)
-            planeMaterial.specular_color = (0.604, 0.465, 0.136)
-            planeMaterial.specular_intensity = 0.3
-            planeMaterial.ambient = 0
-            planeMaterial.use_cubic = True
-            planeMaterial.use_transparency = False
-            planeMaterial.alpha = 0
-            planeMaterial.use_transparent_shadows = True
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "bi.add_scene\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {"FINISHED"}
diff --git a/add_advanced_objects_menu/scene_objects_cycles.py b/add_advanced_objects_menu/scene_objects_cycles.py
deleted file mode 100644 (file)
index 7e13ce1..0000000
+++ /dev/null
@@ -1,142 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-from bpy.types import Operator
-
-
-class add_cycles_scene(Operator):
-    bl_idname = "objects_cycles.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Cycles renderer Scene with Objects"
-    bl_options = {'REGISTER'}
-
-    def execute(self, context):
-        try:
-            blend_data = context.blend_data
-
-            # add new scene
-            bpy.ops.scene.new(type="NEW")
-            scene = bpy.context.scene
-            bpy.context.scene.render.engine = 'CYCLES'
-            scene.name = "scene_object_cycles"
-
-            # render settings
-            render = scene.render
-            render.resolution_x = 1920
-            render.resolution_y = 1080
-            render.resolution_percentage = 50
-
-            # add new world
-            world = bpy.data.worlds.new("Cycles_Object_World")
-            scene.world = world
-            world.use_sky_blend = True
-            world.use_sky_paper = True
-            world.horizon_color = (0.004393, 0.02121, 0.050)
-            world.zenith_color = (0.03335, 0.227, 0.359)
-            world.light_settings.use_ambient_occlusion = True
-            world.light_settings.ao_factor = 0.25
-
-            # add camera
-            bpy.ops.object.camera_add(
-                    location=(7.48113, -6.50764, 5.34367),
-                    rotation=(1.109319, 0.010817, 0.814928)
-                    )
-            cam = bpy.context.active_object.data
-            cam.lens = 35
-            cam.display_size = 0.1
-            bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-            # add point lamp
-            bpy.ops.object.light_add(
-                    type="POINT", location=(4.07625, 1.00545, 5.90386),
-                    rotation=(0.650328, 0.055217, 1.866391)
-                    )
-            lamp1 = bpy.context.active_object.data
-            lamp1.name = "Point_Right"
-            lamp1.energy = 1.0
-            lamp1.distance = 30.0
-            lamp1.shadow_method = "RAY_SHADOW"
-            lamp1.use_sphere = True
-
-            # add point lamp2
-            bpy.ops.object.light_add(
-                    type="POINT", location=(-0.57101, -4.24586, 5.53674),
-                    rotation=(1.571, 0, 0.785)
-                    )
-            lamp2 = bpy.context.active_object.data
-            lamp2.name = "Point_Left"
-            lamp2.energy = 1.0
-            lamp2.distance = 30.0
-
-            # Add cube
-            bpy.ops.mesh.primitive_cube_add()
-            bpy.ops.object.editmode_toggle()
-            bpy.ops.mesh.subdivide(number_cuts=2)
-            bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
-            bpy.ops.object.editmode_toggle()
-            cube = bpy.context.active_object
-
-            # add cube material
-            cubeMaterial = blend_data.materials.new("Cycles_Cube_Material")
-            bpy.ops.object.material_slot_add()
-            cube.material_slots[0].material = cubeMaterial
-            # Diffuse
-            cubeMaterial.preview_render_type = "CUBE"
-            cubeMaterial.diffuse_color = (1.000, 0.373, 0.00)
-            # Cycles
-            cubeMaterial.use_nodes = True
-
-            # Add monkey
-            bpy.ops.mesh.primitive_monkey_add(location=(-0.1, 0.08901, 1.505))
-            bpy.ops.transform.rotate(value=(1.15019), axis=(0, 0, 1))
-            bpy.ops.transform.rotate(value=(-0.673882), axis=(0, 1, 0))
-            bpy.ops.transform.rotate(value=-0.055, axis=(1, 0, 0))
-
-            bpy.ops.object.modifier_add(type='SUBSURF')
-            bpy.ops.object.shade_smooth()
-            monkey = bpy.context.active_object
-
-            # add monkey material
-            monkeyMaterial = blend_data.materials.new("Cycles_Monkey_Material")
-            bpy.ops.object.material_slot_add()
-            monkey.material_slots[0].material = monkeyMaterial
-            # Diffuse
-            monkeyMaterial.preview_render_type = "MONKEY"
-            monkeyMaterial.diffuse_color = (0.239, 0.288, 0.288)
-            # Cycles
-            monkeyMaterial.use_nodes = True
-
-            # Add plane
-            bpy.ops.mesh.primitive_plane_add(
-                    radius=50, align='WORLD',
-                    enter_editmode=False, location=(0, 0, -1)
-                    )
-            bpy.ops.object.editmode_toggle()
-            bpy.ops.transform.rotate(
-                    value=-0.8, axis=(0, 0, 1),
-                    constraint_axis=(False, False, True)
-                    )
-            bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
-            bpy.ops.object.editmode_toggle()
-            plane = bpy.context.active_object
-
-            # add plane material
-            planeMaterial = blend_data.materials.new("Cycles_Plane_Material")
-            bpy.ops.object.material_slot_add()
-            plane.material_slots[0].material = planeMaterial
-            # Diffuse
-            planeMaterial.preview_render_type = "FLAT"
-            planeMaterial.diffuse_color = (0.2, 0.2, 0.2)
-            # Cycles
-            planeMaterial.use_nodes = True
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "objects_cycles.add_scene\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
diff --git a/add_advanced_objects_menu/scene_texture_render.py b/add_advanced_objects_menu/scene_texture_render.py
deleted file mode 100644 (file)
index d9b81a0..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-# gpl: author meta-androcto
-
-import bpy
-from bpy.types import Operator
-
-
-class add_texture_scene(Operator):
-    bl_idname = "objects_texture.add_scene"
-    bl_label = "Create test scene"
-    bl_description = "Cycles renderer Scene: Camera aligned to a plane"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self, context):
-        try:
-            blend_data = context.blend_data
-
-            # add new scene
-            bpy.ops.scene.new(type="NEW")
-            scene = bpy.context.scene
-            bpy.context.scene.render.engine = 'CYCLES'
-            scene.name = "scene_texture_cycles"
-
-            # render settings
-            render = scene.render
-            render.resolution_x = 1080
-            render.resolution_y = 1080
-            render.resolution_percentage = 100
-
-            # add new world
-            world = bpy.data.worlds.new("Cycles_Textures_World")
-            scene.world = world
-            world.use_sky_blend = True
-            world.use_sky_paper = True
-            world.horizon_color = (0.004393, 0.02121, 0.050)
-            world.zenith_color = (0.03335, 0.227, 0.359)
-            world.light_settings.use_ambient_occlusion = True
-            world.light_settings.ao_factor = 0.5
-
-            # add camera
-            bpy.ops.view3d.viewnumpad(type='TOP')
-            bpy.ops.object.camera_add(
-                    location=(0, 0, 2.1850), rotation=(0, 0, 0), align='VIEW'
-                    )
-            cam = bpy.context.active_object.data
-            cam.lens = 35
-            cam.display_size = 0.1
-
-            # add plane
-            bpy.ops.mesh.primitive_plane_add(enter_editmode=True, location=(0, 0, 0))
-            bpy.ops.mesh.subdivide(number_cuts=10, smoothness=0)
-            bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
-            bpy.ops.object.editmode_toggle()
-            plane = bpy.context.active_object
-
-            # add plane material
-            planeMaterial = blend_data.materials.new("Cycles_Plane_Material")
-            bpy.ops.object.material_slot_add()
-            plane.material_slots[0].material = planeMaterial
-            # Diffuse
-            planeMaterial.preview_render_type = "FLAT"
-            planeMaterial.diffuse_color = (0.2, 0.2, 0.2)
-            # Cycles
-            planeMaterial.use_nodes = True
-
-            # Back to Scene
-            sc = bpy.context.scene
-            bpy.ops.view3d.viewnumpad(type='CAMERA')
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "objects_texture.add_scene\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
diff --git a/add_advanced_objects_menu/trilighting.py b/add_advanced_objects_menu/trilighting.py
deleted file mode 100644 (file)
index 8fee580..0000000
+++ /dev/null
@@ -1,239 +0,0 @@
-# gpl: author Daniel Schalla
-
-import bpy
-from bpy.types import Operator
-from bpy.props import (
-        EnumProperty,
-        FloatProperty,
-        IntProperty,
-        )
-from math import (
-        sin, cos,
-        radians,
-        sqrt,
-        )
-
-
-class TriLighting(Operator):
-    bl_idname = "object.trilighting"
-    bl_label = "Tri-Lighting Creator"
-    bl_description = ("Add 3 Point Lighting to Selected / Active Object\n"
-                      "Needs an existing Active Object")
-    bl_options = {'REGISTER', 'UNDO'}
-
-    height: FloatProperty(
-            name="Height",
-            default=5
-            )
-    distance: FloatProperty(
-            name="Distance",
-            default=5,
-            min=0.1,
-            subtype="DISTANCE"
-            )
-    energy: IntProperty(
-            name="Base Energy",
-            default=3,
-            min=1
-            )
-    contrast: IntProperty(
-            name="Contrast",
-            default=50,
-            min=-100, max=100,
-            subtype="PERCENTAGE"
-            )
-    leftangle: IntProperty(
-            name="Left Angle",
-            default=26,
-            min=1, max=90,
-            subtype="ANGLE"
-            )
-    rightangle: IntProperty(
-            name="Right Angle",
-            default=45,
-            min=1, max=90,
-            subtype="ANGLE"
-            )
-    backangle: IntProperty(
-            name="Back Angle",
-            default=235,
-            min=90, max=270,
-            subtype="ANGLE"
-            )
-    Light_Type_List = [
-            ('POINT', "Point", "Point Light"),
-            ('SUN', "Sun", "Sun Light"),
-            ('SPOT', "Spot", "Spot Light"),
-            ('HEMI', "Hemi", "Hemi Light"),
-            ('AREA', "Area", "Area Light")
-            ]
-    primarytype: EnumProperty(
-            attr='tl_type',
-            name="Key Type",
-            description="Choose the types of Key Lights you would like",
-            items=Light_Type_List,
-            default='HEMI'
-            )
-    secondarytype: EnumProperty(
-            attr='tl_type',
-            name="Fill + Back Type",
-            description="Choose the types of secondary Lights you would like",
-            items=Light_Type_List,
-            default="POINT"
-            )
-
-    @classmethod
-    def poll(cls, context):
-        return context.active_object is not None
-
-    def draw(self, context):
-        layout = self.layout
-
-        layout.label(text="Position:")
-        col = layout.column(align=True)
-        col.prop(self, "height")
-        col.prop(self, "distance")
-
-        layout.label(text="Light:")
-        col = layout.column(align=True)
-        col.prop(self, "energy")
-        col.prop(self, "contrast")
-
-        layout.label(text="Orientation:")
-        col = layout.column(align=True)
-        col.prop(self, "leftangle")
-        col.prop(self, "rightangle")
-        col.prop(self, "backangle")
-
-        col = layout.column()
-        col.label(text="Key Light Type:")
-        col.prop(self, "primarytype", text="")
-        col.label(text="Fill + Back Type:")
-        col.prop(self, "secondarytype", text="")
-
-    def execute(self, context):
-        try:
-            collection = context.collection
-            scene = context.scene
-            view = context.space_data
-            if view.type == 'VIEW_3D' and not view.lock_camera_and_layers:
-                camera = view.camera
-            else:
-                camera = scene.camera
-
-            if (camera is None):
-                cam_data = bpy.data.cameras.new(name='Camera')
-                cam_obj = bpy.data.objects.new(name='Camera', object_data=cam_data)
-                collection.objects.link(cam_obj)
-                scene.camera = cam_obj
-                bpy.ops.view3d.camera_to_view()
-                camera = cam_obj
-                bpy.ops.view3d.viewnumpad(type='TOP')
-
-            obj = bpy.context.view_layer.objects.active
-
-            # Calculate Energy for each Lamp
-            if(self.contrast > 0):
-                keyEnergy = self.energy
-                backEnergy = (self.energy / 100) * abs(self.contrast)
-                fillEnergy = (self.energy / 100) * abs(self.contrast)
-            else:
-                keyEnergy = (self.energy / 100) * abs(self.contrast)
-                backEnergy = self.energy
-                fillEnergy = self.energy
-
-            # Calculate Direction for each Lamp
-
-            # Calculate current Distance and get Delta
-            obj_position = obj.location
-            cam_position = camera.location
-
-            delta_position = cam_position - obj_position
-            vector_length = sqrt(
-                            (pow(delta_position.x, 2) +
-                             pow(delta_position.y, 2) +
-                             pow(delta_position.z, 2))
-                            )
-            if not vector_length:
-                # division by zero most likely
-                self.report({'WARNING'},
-                            "Operation Cancelled. No viable object in the scene")
-
-                return {'CANCELLED'}
-
-            single_vector = (1 / vector_length) * delta_position
-
-            # Calc back position
-            singleback_vector = single_vector.copy()
-            singleback_vector.x = cos(radians(self.backangle)) * single_vector.x + \
-                                  (-sin(radians(self.backangle)) * single_vector.y)
-
-            singleback_vector.y = sin(radians(self.backangle)) * single_vector.x + \
-                                 (cos(radians(self.backangle)) * single_vector.y)
-
-            backx = obj_position.x + self.distance * singleback_vector.x
-            backy = obj_position.y + self.distance * singleback_vector.y
-
-            backData = bpy.data.lights.new(name="TriLamp-Back", type=self.secondarytype)
-            backData.energy = backEnergy
-
-            backLamp = bpy.data.objects.new(name="TriLamp-Back", object_data=backData)
-            collection.objects.link(backLamp)
-            backLamp.location = (backx, backy, self.height)
-
-            trackToBack = backLamp.constraints.new(type="TRACK_TO")
-            trackToBack.target = obj
-            trackToBack.track_axis = "TRACK_NEGATIVE_Z"
-            trackToBack.up_axis = "UP_Y"
-
-            # Calc right position
-            singleright_vector = single_vector.copy()
-            singleright_vector.x = cos(radians(self.rightangle)) * single_vector.x + \
-                                  (-sin(radians(self.rightangle)) * single_vector.y)
-
-            singleright_vector.y = sin(radians(self.rightangle)) * single_vector.x + \
-                                  (cos(radians(self.rightangle)) * single_vector.y)
-
-            rightx = obj_position.x + self.distance * singleright_vector.x
-            righty = obj_position.y + self.distance * singleright_vector.y
-
-            rightData = bpy.data.lights.new(name="TriLamp-Fill", type=self.secondarytype)
-            rightData.energy = fillEnergy
-            rightLamp = bpy.data.objects.new(name="TriLamp-Fill", object_data=rightData)
-            collection.objects.link(rightLamp)
-            rightLamp.location = (rightx, righty, self.height)
-            trackToRight = rightLamp.constraints.new(type="TRACK_TO")
-            trackToRight.target = obj
-            trackToRight.track_axis = "TRACK_NEGATIVE_Z"
-            trackToRight.up_axis = "UP_Y"
-
-            # Calc left position
-            singleleft_vector = single_vector.copy()
-            singleleft_vector.x = cos(radians(-self.leftangle)) * single_vector.x + \
-                                (-sin(radians(-self.leftangle)) * single_vector.y)
-            singleleft_vector.y = sin(radians(-self.leftangle)) * single_vector.x + \
-                                (cos(radians(-self.leftangle)) * single_vector.y)
-            leftx = obj_position.x + self.distance * singleleft_vector.x
-            lefty = obj_position.y + self.distance * singleleft_vector.y
-
-            leftData = bpy.data.lights.new(name="TriLamp-Key", type=self.primarytype)
-            leftData.energy = keyEnergy
-
-            leftLamp = bpy.data.objects.new(name="TriLamp-Key", object_data=leftData)
-            collection.objects.link(leftLamp)
-            leftLamp.location = (leftx, lefty, self.height)
-            trackToLeft = leftLamp.constraints.new(type="TRACK_TO")
-            trackToLeft.target = obj
-            trackToLeft.track_axis = "TRACK_NEGATIVE_Z"
-            trackToLeft.up_axis = "UP_Y"
-
-        except Exception as e:
-            self.report({'WARNING'},
-                        "Some operations could not be performed (See Console for more info)")
-
-            print("\n[Add Advanced  Objects]\nOperator: "
-                  "object.trilighting\nError: {}".format(e))
-
-            return {'CANCELLED'}
-
-        return {'FINISHED'}